发现优秀的 MCP 服务器

Clockify MCP Server

一个 MCP 服务器，用于管理你在 Clockify 中的时间记录。

HubSpot MCP Server

镜子 (jìng zi)

MCP Lambda Server

一个 Lambda 层，允许 Lambda 函数作为 MCP 服务器运行。 (Yī gè Lambda céng, yǔnxǔ Lambda hánshù zuòwéi MCP fúwùqì yùnxíng.)

@madisonbullard/mcp-servers

一个包含用于各种用例的模型上下文协议服务器的单体仓库。

spring-ai-mcp-client

使用 Spring AI 和 Anthropic Claude 模型的 MCP 客户端应用程序。它与支持 MCP 协议的服务器集成，以实现 AI 驱动的聊天互动。

QuickBooks Time MCP Server (Combined)

镜子 (jìng zi)

Model Context Protocol for Unreal Engine

使像 Cursor、Windsurf 和 Claude Desktop 这样的 AI 助手客户端能够使用模型上下文协议 (MCP) 通过自然语言控制 Unreal Engine。

WindTools MCP Server

Okay, I understand. You want me to translate the following English text into Chinese: "Your own codebase tools like code semantic search" Here are a few possible translations, depending on the nuance you want to convey: **Option 1 (Most literal and general):** * **你自己的代码库工具，例如代码语义搜索 (Nǐ zìjǐ de dàimǎ kù gōngjù, lìrú dàimǎ yǔyì sōusuǒ)** * This is a direct translation. "你自己的代码库" means "your own codebase," "工具" means "tools," "例如" means "for example," and "代码语义搜索" means "code semantic search." **Option 2 (Slightly more natural flow):** * **像代码语义搜索这样的，你自己的代码库工具 (Xiàng dàimǎ yǔyì sōusuǒ zhèyàng de, nǐ zìjǐ de dàimǎ kù gōngjù)** * This emphasizes the "like" part a bit more. "像...这样的" means "like... such as." **Option 3 (Focus on the benefit/purpose):** * **用于你自己的代码库的工具，比如代码语义搜索 (Yòng yú nǐ zìjǐ de dàimǎ kù de gōngjù, bǐrú dàimǎ yǔyì sōusuǒ)** * This emphasizes that these tools are *for* your codebase. "用于...的" means "used for..." and "比如" means "for example." **Which option is best depends on the context.** If you're simply listing examples, Option 1 or 2 is fine. If you're emphasizing the purpose of the tools, Option 3 might be better. Therefore, I recommend **Option 1 (你自己的代码库工具，例如代码语义搜索)** as a good general translation.

MCP Community Portal

一个现代的、社区驱动的 Docker 化模型上下文协议 (MCP) 服务器、工具和资源集合。

Super Windows CLI MCP Server

镜子 (jìng zi)

mcp_repo_4a01eabf

这是一个由 MCP 服务器的测试脚本为 GitHub 创建的测试仓库。

mcp_docs_server

Okay, to help you build an MCP (Mod Coder Pack) server, I need to understand what you're trying to achieve. MCP itself isn't a server, but a toolset for decompiling, deobfuscating, and re-compiling Minecraft code to make modding easier. You likely want to set up a development environment that *uses* MCP to create mods, and then test those mods on a Minecraft server. Here's a breakdown of the process and the help I can provide, along with common scenarios: **Understanding the Goal:** * **Are you trying to create a Minecraft server to *test* your mods?** This is the most common scenario. You'll use MCP to develop the mods, and then run a standard Minecraft server (Vanilla, Forge, Fabric, etc.) to test them. * **Are you trying to *modify* the server code itself using MCP?** This is a much more advanced scenario. It involves decompiling the server, making changes, and recompiling. It's generally not recommended unless you have a very specific reason. * **Are you trying to create a *modded* server for others to play on?** This involves installing mods (that you or others have created) onto a standard Minecraft server. **I'll assume you want to create a Minecraft server to *test* your mods, which is the most common use case. Here's a general outline and how I can help:** **1. Setting up your Development Environment (using MCP):** * **Download and Install MCP:** * Find the correct MCP version for the Minecraft version you're targeting. MCP is version-specific. A good place to start is often the MinecraftForge forums or related modding communities. * Follow the MCP installation instructions. This usually involves extracting the MCP archive to a directory. * **Decompile Minecraft:** * Use the MCP scripts (usually `decompile.bat` or `decompile.sh`) to decompile the Minecraft client and server. This will extract the source code. This is a crucial step. * **Set up your IDE (Integrated Development Environment):** * **IntelliJ IDEA (Recommended):** IntelliJ IDEA is a popular and powerful IDE for Java development. It has excellent support for Minecraft modding. * **Eclipse:** Another popular IDE. * Configure your IDE to use the MCP environment. This usually involves importing the MCP project into your IDE. MCP provides scripts to generate IDE-specific project files (e.g., `eclipse.bat` or `idea.bat`). * **Create your Mod Project:** * Within your IDE, create a new Java project or module. * Configure your project to depend on the MCP libraries. This allows you to use Minecraft classes and methods in your mod. * **Write your Mod Code:** This is where you actually write the Java code for your mod. **2. Setting up the Minecraft Server:** * **Choose a Server Type:** * **Vanilla:** The standard, unmodified Minecraft server. You'll need to use a mod loader (Forge or Fabric) to run mods on it. * **Forge:** A popular mod loader that provides a framework for mods to interact with Minecraft. Download the Forge installer for the Minecraft version you're using. * **Fabric:** Another mod loader, known for being lightweight and fast. Download the Fabric installer. * **Install the Server:** * **Vanilla:** Download the Minecraft server JAR file from the official Minecraft website. * **Forge/Fabric:** Run the Forge/Fabric installer and choose the "Install server" option. This will create the necessary server files. * **Configure the Server:** * Edit the `server.properties` file to configure server settings (e.g., port, game mode, difficulty). * **Install your Mod (and any dependencies):** * Place your mod's JAR file (the one you built in your IDE) into the `mods` folder in your server directory. If your mod has dependencies (other mods it relies on), you'll need to install those as well. * **Run the Server:** * Start the server using the appropriate command (e.g., `java -jar server.jar` or `java -Xmx4G -Xms4G -jar forge-xxx.jar nogui`). Adjust the memory allocation (`-Xmx4G -Xms4G`) as needed. **3. Testing and Debugging:** * **Connect to the Server:** Launch your Minecraft client and connect to the server's IP address and port. * **Test your Mod:** Verify that your mod is working as expected. * **Debug:** If you encounter issues, use your IDE's debugger to step through your code and identify the problem. Server logs are also invaluable for debugging. **How I can help you *specifically*:** To give you the best help, please tell me: * **What Minecraft version are you targeting?** (e.g., 1.20.1, 1.19.2, 1.16.5) * **Which mod loader are you using?** (Forge or Fabric) If you're not sure, start with Forge. * **What IDE are you using?** (IntelliJ IDEA, Eclipse, etc.) * **What specific problems are you encountering?** (e.g., "I can't decompile Minecraft," "My mod isn't loading on the server," "I'm getting a NullPointerException") * **What have you tried so far?** **Example Questions you might ask me:** * "I'm using Minecraft 1.18.2 and Forge. How do I set up my IntelliJ IDEA project to use the MCP libraries?" * "I'm getting an error when I run `decompile.bat`. The error message is '...' What does this mean?" * "My mod is crashing the server with a NullPointerException. How can I use the debugger to find the problem?" * "How do I add a new block to the game using Forge?" **Translation of Key Terms:** * **MCP (Mod Coder Pack):** 模组编码包 (Mózǔ biānmǎ bāo) * **Minecraft Server:** 我的世界服务器 (Wǒ de shìjiè fúwùqì) * **Mod:** 模组 (Mózǔ) * **Forge:** Forge (usually kept in English) * **Fabric:** Fabric (usually kept in English) * **Decompile:** 反编译 (Fǎnbiānyì) * **IDE (Integrated Development Environment):** 集成开发环境 (Jíchéng kāifā huánjìng) * **IntelliJ IDEA:** IntelliJ IDEA (usually kept in English) * **Eclipse:** Eclipse (usually kept in English) * **Server.properties:** 服务器配置文件 (Fúwùqì pèizhì wénjiàn) * **Mods Folder:** 模组文件夹 (Mózǔ wénjiànjiā) I'm ready to help you with specific steps once you provide more information. Good luck!

MCPez - 微服务命令代理管理平台

微型统一 MCP 服务器 (Wēi xíng tǒngyī MCP fúwùqì)

MCP Server for ArangoDB

镜子 (jìng zi)

rust-mcp-tutorial

好的，这是 "rustでmcp serverのお試し" 的中文翻译： **使用 Rust 尝试 MCP 服务器** 更自然的说法可能是： **用 Rust 尝试搭建 MCP 服务器** 或者更口语化： **用 Rust 试试 MCP 服务器** 选择哪个翻译取决于你想要表达的细微差别。 "搭建" 更强调了建立服务器的过程。

Getting Started with Create React App

用于 MCP 服务器测试的 React 应用程序

marginfi-mcp-serverr

marginfi mcp 服务器

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!

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.**