发现优秀的 MCP 服务器

strava-mcp

There are a few ways to interpret "MCP server for Strava," depending on what you're trying to achieve. Here are a few possibilities and their translations: **1. If you're looking for a server that *manages* or *processes* Strava data (like a custom application that interacts with the Strava API):** * **Chinese Translation:** 用于 Strava 的 MCP 服务器 (Yòng yú Strava de MCP fúwùqì) * **Explanation:** This translates to "MCP server for Strava." It's a general translation that implies the server is designed to work with Strava data. You'd need to specify *what* the server does to be more precise. **2. If "MCP" refers to a specific technology or protocol (which is less likely in the context of Strava):** * You'd need to provide more context about what "MCP" means. Without knowing what MCP stands for, I can't provide an accurate translation. **3. If you're looking for a server to *host* a Strava-related application:** * **Chinese Translation:** 用于托管 Strava 相关应用的服务器 (Yòng yú tuōguǎn Strava xiāngguān yìngyòng de fúwùqì) * **Explanation:** This translates to "Server for hosting Strava-related applications." This implies you want a server to run a website or application that uses Strava data. **4. If you're looking for a server to *store* Strava data:** * **Chinese Translation:** 用于存储 Strava 数据的服务器 (Yòng yú chǔcún Strava shùjù de fúwùqì) * **Explanation:** This translates to "Server for storing Strava data." **In summary, the best translation depends on the specific function of the "MCP server." Please provide more details about what you want the server to *do* with Strava data, and I can give you a more accurate and helpful translation.**

local-command-server MCP Server

一个基于 TypeScript 的 MCP 服务器，用于执行命令并返回结构化输出。

MCPHub

用于人工智能服务的可嵌入模型上下文协议（MCP）解决方案。通过统一的界面，将 MCP 服务器与 OpenAI Agents、LangChain 和 Autogen 框架无缝集成。简化了不同人工智能应用中 MCP 工具的配置、设置和管理。

die-mcp

Detect-It-Easy MCP 服务器 (Detect-It-Easy MCP fúwùqì)

Mcp Server

Okay, here's an example of how you might structure a simple MCP (Minecraft Protocol) server in Python, designed to interact with a client (like a Minecraft game client) and tailored for use with Claude (or any other LLM) for potential game logic or content generation. This is a simplified example and doesn't cover all the complexities of the Minecraft protocol. It focuses on the core concepts. **Important Considerations:** * **Minecraft Protocol Complexity:** The Minecraft protocol is complex and version-dependent. This example is highly simplified and likely won't work directly with a modern Minecraft client without significant modification. You'll need to research the specific protocol version you want to support. * **Libraries:** Using a library like `mcstatus` or `python-minecraft-nbt` can greatly simplify working with the Minecraft protocol. However, for this example, I'll try to keep it relatively library-free to illustrate the core concepts. * **Security:** This example is for demonstration purposes only and is not secure. Do not expose this to the internet without proper security measures. * **Claude Integration:** The Claude integration is represented by placeholder comments. You'll need to use a Claude API client (e.g., Anthropic's Python SDK) to actually interact with Claude. ```python import socket import struct import json import threading # Configuration HOST = '127.0.0.1' # Localhost PORT = 25565 # Default Minecraft port (can be changed) # --- Minecraft Protocol Helper Functions --- def read_varint(sock): """Reads a Minecraft VarInt from the socket.""" result = 0 shift = 0 while True: byte = sock.recv(1) if not byte: return None # Connection closed byte = byte[0] result |= (byte & 0x7F) << shift shift += 7 if not (byte & 0x80): break return result def write_varint(sock, value): """Writes a Minecraft VarInt to the socket.""" while True: byte = value & 0x7F value >>= 7 if value != 0: byte |= 0x80 sock.send(bytes([byte])) if value == 0: break def read_string(sock): """Reads a Minecraft string (prefixed with a VarInt length).""" length = read_varint(sock) if length is None: return None data = sock.recv(length) return data.decode('utf-8') def write_string(sock, string): """Writes a Minecraft string (prefixed with a VarInt length).""" encoded = string.encode('utf-8') write_varint(sock, len(encoded)) sock.send(encoded) def pack_data(data_type, data): """Packs data according to the Minecraft data type.""" if data_type == "varint": return write_varint(data) elif data_type == "string": return write_string(data) elif data_type == "byte": return struct.pack("!b", data) elif data_type == "ubyte": return struct.pack("!B", data) elif data_type == "short": return struct.pack("!h", data) elif data_type == "ushort": return struct.pack("!H", data) elif data_type == "int": return struct.pack("!i", data) elif data_type == "long": return struct.pack("!q", data) elif data_type == "float": return struct.pack("!f", data) elif data_type == "double": return struct.pack("!d", data) elif data_type == "bool": return struct.pack("!?", data) else: raise ValueError(f"Unknown data type: {data_type}") def create_packet(packet_id, data): """Creates a Minecraft packet.""" packet_data = b"" for data_type, value in data: if data_type == "varint": packet_data += value elif data_type == "string": packet_data += value else: packet_data += pack_data(data_type, value) packet = b"" write_varint(packet, packet_id) packet += packet_data length = len(packet) packet_length = b"" write_varint(packet_length, length) return packet_length + packet # --- Packet Handling Functions --- def handle_handshake(sock): """Handles the initial handshake packet.""" protocol_version = read_varint(sock) server_address = read_string(sock) server_port = struct.unpack("!H", sock.recv(2))[0] # Unpack unsigned short (2 bytes) next_state = read_varint(sock) print(f"Handshake: Protocol {protocol_version}, Address {server_address}:{server_port}, Next State {next_state}") return next_state def handle_status_request(sock): """Handles the status request (ping).""" print("Status Request received") # Example status response (replace with dynamic data if needed) status = { "version": { "name": "My Claude Server", "protocol": 757 # Example protocol version }, "players": { "max": 10, "online": 0, "sample": [] }, "description": { "text": "A Minecraft server powered by Claude!" } } status_json = json.dumps(status) write_string(sock, status_json) # Send the packet packet_id = 0x00 # Status Response packet ID packet_data = [("string", status_json)] packet = create_packet(packet_id, packet_data) write_varint(sock, len(packet)) sock.sendall(packet) def handle_ping(sock): """Handles the ping request.""" payload = sock.recv(8) # 8-byte payload print(f"Ping received with payload: {payload}") # Send back the same payload packet_id = 0x01 # Pong packet ID packet_data = [("long", struct.unpack("!q", payload)[0])] packet = create_packet(packet_id, packet_data) write_varint(sock, len(packet)) sock.sendall(packet) def handle_login_start(sock): """Handles the login start packet (username).""" username = read_string(sock) print(f"Login Start: Username {username}") # --- Claude Integration Point --- # Here, you would send the username (and potentially other data) to Claude. # Claude could then generate a response, such as a welcome message, # a custom world seed, or even modify the player's starting inventory. # # Example (replace with actual Claude API call): # claude_response = claude.generate_response(f"Minecraft player joined: {username}") # print(f"Claude response: {claude_response}") # For now, just send a simple login success packet. uuid = "00000000-0000-0000-0000-000000000000" # Dummy UUID packet_id = 0x02 # Login Success packet ID packet_data = [("string", uuid), ("string", username)] packet = create_packet(packet_id, packet_data) write_varint(sock, len(packet)) sock.sendall(packet) # Example: Send a chat message to the player (after login) chat_message = {"text": f"Welcome to the server, {username}!"} chat_json = json.dumps(chat_message) packet_id = 0x0F # Chat Message packet ID (example) packet_data = [("string", chat_json), ("byte", 0), ("string", "00000000-0000-0000-0000-000000000000")] packet = create_packet(packet_id, packet_data) write_varint(sock, len(packet)) sock.sendall(packet) def handle_client(sock, addr): """Handles a single client connection.""" print(f"Accepted connection from {addr}") try: state = handle_handshake(sock) if state == 1: # Status handle_status_request(sock) handle_ping(sock) elif state == 2: # Login handle_login_start(sock) # After login, you would enter the "play" state and handle game packets. # This is where you'd receive player actions (movement, chat, etc.) # and send world updates. This is a very complex part of the protocol. while True: # Example: Receive a packet and print its ID (for debugging) packet_length = read_varint(sock) if packet_length is None: break # Connection closed packet_id = read_varint(sock) print(f"Received packet with ID: 0x{packet_id:02X}") # --- Claude Integration Point --- # You could send the packet data to Claude for analysis or processing. # For example, Claude could analyze chat messages, detect suspicious # player behavior, or generate new game events. # # Example: # claude_analysis = claude.analyze_packet(packet_id, packet_data) # print(f"Claude analysis: {claude_analysis}") else: print(f"Unknown state: {state}") except Exception as e: print(f"Error handling client: {e}") finally: print(f"Closing connection from {addr}") sock.close() # --- Main Server Loop --- def main(): """Main server function.""" server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # Allow address reuse server_socket.bind((HOST, PORT)) server_socket.listen(5) # Listen for up to 5 connections print(f"Listening on {HOST}:{PORT}") try: while True: sock, addr = server_socket.accept() client_thread = threading.Thread(target=handle_client, args=(sock, addr)) client_thread.start() except KeyboardInterrupt: print("Shutting down server...") finally: server_socket.close() if __name__ == "__main__": main() ``` **Explanation and Key Points:** 1. **Socket Setup:** The code creates a basic TCP socket server. 2. **Minecraft Protocol Functions:** * `read_varint`, `write_varint`: Minecraft uses VarInts (variable-length integers) for packet lengths and IDs. These functions handle reading and writing them. * `read_string`, `write_string`: Handle reading and writing strings, which are prefixed with a VarInt length. * `pack_data`: Packs data into bytes according to the specified Minecraft data type. * `create_packet`: Creates a Minecraft packet by combining the packet ID and data. 3. **Packet Handling:** * `handle_handshake`: Handles the initial handshake packet, which determines the client's intended state (status or login). * `handle_status_request`, `handle_ping`: Handle the status request (used to get server information) and the ping (used to measure latency). * `handle_login_start`: Handles the login start packet, which contains the player's username. **This is a key integration point for Claude.** 4. **Claude Integration (Placeholders):** * The `handle_login_start` function contains comments indicating where you would integrate with the Claude API. You would: * Send the player's username (and potentially other data) to Claude. * Receive a response from Claude. * Use Claude's response to customize the player's experience (e.g., generate a welcome message, modify the world, etc.). * The `handle_client` function also has a placeholder for Claude integration during the "play" state, where you could analyze player actions and generate dynamic game events. 5. **Threading:** Each client connection is handled in a separate thread, allowing the server to handle multiple clients concurrently. 6. **Error Handling:** Includes basic `try...except` blocks to catch potential errors. 7. **Simplified Protocol:** This example only implements a very small subset of the Minecraft protocol. It's enough to get a basic connection and login working, but it doesn't handle the full game logic. **To use this code:** 1. **Install Python:** Make sure you have Python 3 installed. 2. **Install Anthropic's Python SDK (if using Claude):** ```bash pip install anthropic ``` 3. **Replace Placeholders:** Replace the Claude integration placeholders with your actual Claude API calls. You'll need to set up an Anthropic API key. 4. **Run the Server:** Run the Python script. 5. **Connect with a Minecraft Client:** You'll need to use a Minecraft client that supports the protocol version you're targeting. You might need to modify the client or use a proxy to connect to this simplified server. **This is the tricky part, as the protocol is complex.** **Chinese Translation of Key Concepts:** * **Minecraft Protocol:** Minecraft 协议 (Minecraft Xiéyì) * **Server:** 服务器 (Fúwùqì) * **Client:** 客户端 (Kèhùduān) * **Packet:** 数据包 (Shùjùbāo) * **Handshake:** 握手 (Wòshǒu) * **Status:** 状态 (Zhuàngtài) * **Login:** 登录 (Dēnglù) * **VarInt:** 变长整数 (Biàn cháng zhěngshù) * **Socket:** 套接字 (Tàojiēzì) * **Thread:** 线程 (Xiànchéng) * **Claude Integration:** Claude 集成 (Claude Jíchéng) * **Protocol Version:** 协议版本 (Xiéyì Bǎnběn) * **Username:** 用户名 (Yònghùmíng) * **UUID:** 通用唯一识别码 (Tōngyòng Wéiyī Shìbiémǎ) **Example Chinese Comments for the Code:** ```python # --- Minecraft 协议助手函数 --- (Minecraft Protocol Helper Functions) def read_varint(sock): """从套接字读取 Minecraft 变长整数。""" # Reads a Minecraft VarInt from the socket. # ... def handle_login_start(sock): """处理登录开始数据包（用户名）。""" # Handles the login start packet (username). username = read_string(sock) print(f"登录开始: 用户名 {username}") # Login Start: Username {username} # --- Claude 集成点 --- (Claude Integration Point) # 在这里，你可以将用户名（以及其他数据）发送给 Claude。 # Claude 可以生成一个响应，例如欢迎消息、自定义世界种子， # 甚至修改玩家的起始物品栏。 # ... ``` This provides a starting point. Building a fully functional Minecraft server is a significant undertaking, but this example gives you a basic framework and highlights the areas where you can integrate Claude to add AI-powered features to your Minecraft world. Remember to consult the Minecraft protocol documentation for the specific version you are targeting. Good luck!

Model Context Protocol .NET Template

这个仓库包含一个用于在 .NET 中创建模型上下文协议 (MCP) 应用程序的模板。

Claude Connect

一个符合 MCP 规范的外部连接器服务器，使 Claude 和其他 LLM 能够与 Web API、文件系统和自定义资源进行交互。

mcp-kagi-search

一个使用 npx 实现的 MCP 服务器，用于 Kagi 的 API，以便它可以轻松地在 n8n 中运行。

Mcp K8s Eye

用于 Kubernetes 管理和分析工作负载状态的 MCP 服务器

MCP Server for Spotify

一个 Spotify MCP 服务器 (Yī gè Spotify MCP fúwùqì)

isolated-commands-mcp-server MCP Server

镜子 (jìng zi)

ESA MCP Server

用于 Claude Desktop 的 ESA.io 模型上下文协议服务器

GDB MCP Server

用于 GDB 调试的 MCP 服务器。

MCP Server

MCP 服务器 (MCP fúwùqì)

AGE-MCP-Server

镜子 (jìng zi)

arduino-mcp-server

用 Go 编写的 Arduino MCP 服务器

🎯 Kubernetes AI Management System

AI驱动的Kubernetes管理系统：一个将自然语言处理与Kubernetes管理相结合的平台。用户可以进行实时诊断、资源监控和智能日志分析。它通过对话式AI简化了Kubernetes管理，提供了一种现代化的替代方案。

Vault Mcp Server

YZi Labs 黑客马拉松的 Vault MCP 服务器仓库

Polarion MCP Servers

Polarion 的 MCP 服务器

MCP-demo-blog-analyzer

好的，这是将 "A quickstart to test MCP blog analyzer client and a webpage visitor server" 翻译成中文的几种选择，根据不同的侧重点略有不同： **选项 1 (偏技术，简洁):** 快速开始：测试 MCP 博客分析客户端和网页访问者服务器 **选项 2 (更详细，更易理解):** 快速入门：测试 MCP 博客分析器客户端和网页访问者服务器 **选项 3 (更口语化):** 快速上手：测试 MCP 博客分析客户端和网页访问者服务器 **选项 4 (强调目的):** 快速开始：用于测试 MCP 博客分析客户端和网页访问者服务器的指南 **选择哪个取决于你的具体需求。** 如果面向技术人员，选项1或2更合适。 如果面向更广泛的受众，选项3或4可能更好。

McpRails

在你的 Rails 应用中使用 MCP 服务器

Linear Remote MCP server

Linear 的远程模型上下文协议 (MCP) 服务器。 (Linear de yuǎnchéng móxíng shàngxiàwén xiéyì (MCP) fúwùqì.)

Marimo Documenation MCP Server

一个模型上下文协议 (MCP) 服务器，它提供对 Marimo 文档的程序化访问。

vscode-mcp-server

用于管理 VSCode 设置、扩展、代码片段等的 VSCode MCP 服务器