发现优秀的 MCP 服务器

cutterMCP

针对 Cutter 的 MCP 服务器

MCP Test Repository

一个通过 GitHub MCP 服务器创建的测试仓库。

Notion MCP Server

一个简单的 Notion MCP 服务器 (Yī gè jiǎndān de Notion MCP fúwùqì)

Flow MCP Server

镜子 (jìng zi)

attio-mcp-server

镜子 (jìng zi)

Hyperliquid MCP for HL Coder

Hyperliquid MCP Server，供 HL 程序员使用 (Hyperliquid MCP Server, for HL Coders)

WordPress MCP Server

一个用于与 WordPress 站点交互的模型上下文协议 (MCP) 服务器。该服务器提供工具，可以从任何启用了 REST API 的 WordPress 安装中获取文章、页面、分类和站点信息。

MCP GitHub Reader

将 GitHub 仓库引入上下文，使用这个 MCP 服务器。

Todoist MCP Server (Python)

镜子 (jìng zi)

Integrate MCP with GitHub Copilot

了解如何将 MCP 服务器与 GitHub Copilot 结合使用

🔐 get-mcp-keys

一个轻量级的实用工具，可以安全地从您的主目录加载 Cursor MCP 服务器的 API 密钥，防止在代码仓库中意外暴露密钥。在保持与 AI 编码助手无缝集成的同时，确保您的凭据安全。

MCP Server

Okay, here are a few ways to translate "Server implementation for MCP" into Chinese, depending on the context and the specific meaning you want to convey: **1. Most General and Common Translation:** * **MCP 的服务器实现 (MCP de fúwùqì shíxiàn)** * This is a direct and straightforward translation. * `MCP` remains as is (assuming it's an acronym or proper noun). * `的 (de)` is a possessive particle (like "of" or "'s"). * `服务器 (fúwùqì)` means "server". * `实现 (shíxiàn)` means "implementation" or "realization". * **Suitable when you're talking about the general concept of implementing a server for MCP.** **2. Emphasis on the Process of Implementing:** * **为 MCP 实现服务器 (wèi MCP shíxiàn fúwùqì)** * This emphasizes the *action* of implementing. * `为 (wèi)` means "for" or "in order to". * `MCP` remains as is. * `实现 (shíxiàn)` means "to implement" or "to realize". * `服务器 (fúwùqì)` means "server". * **Suitable when you're talking about the *process* of building the server implementation.** **3. More Technical/Formal Translation:** * **MCP 服务器的实现方案 (MCP fúwùqì de shíxiàn fāng'àn)** * This is a more formal and technical translation, suggesting a specific plan or solution. * `MCP` remains as is. * `服务器 (fúwùqì)` means "server". * `的 (de)` is a possessive particle. * `实现方案 (shíxiàn fāng'àn)` means "implementation scheme" or "implementation plan". * **Suitable when discussing a specific design or architecture for the server implementation.** **4. If MCP is a well-known term in the Chinese-speaking community and has a standard Chinese translation, use that translation instead of "MCP".** For example, if MCP stands for "Master Control Program" and the Chinese translation for that is "主控程序 (zhǔkòng chéngxù)", then you would use: * **主控程序的服务器实现 (zhǔkòng chéngxù de fúwùqì shíxiàn)** **Which translation is best depends on the specific context. Consider these questions:** * **Who is your audience?** (Technical experts vs. general audience) * **What is the purpose of the translation?** (General information, technical documentation, marketing material) * **Is "MCP" a well-known term in the Chinese-speaking community, or does it need to be explained?** **In most cases, the first option, "MCP 的服务器实现 (MCP de fúwùqì shíxiàn)", is a safe and generally understandable translation.**

WhatsApp MCP Server

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

yapi-mcp-server

Yapi 的模型上下文协议 (MCP) 服务器。

VSC-MCP

这个项目提供的工具可以将语言服务器协议（LSP）的功能作为 MCP（模型上下文协议）工具公开。

powergentic/azd-mcp-ts

一个 AZD 模板，用于将使用 SSE 传输的 TypeScript 编写的 Model Context Protocol (MCP) 服务器部署到 Azure 容器应用。

mcp-http-proxy

一个 HTTP/SSE 代理服务器，用于使用 stdio 的模型上下文协议 (MCP) 应用程序。 支持通过 HTTP 发送原始 JSON-RPC 命令，并实现直接的 stdio 通信，无需 MCP SDK。

Memos MCP Server

一个用于 Memos API 的模型上下文协议 (MCP) 服务器，具备搜索、创建、检索和标签列表功能。

MCP Bridge API

MCP Bridge 是一个轻量级、快速且与 LLM 无关的代理，它通过统一的 REST API 连接到多个模型上下文协议 (MCP) 服务器。它支持在移动设备、Web 和边缘设备等不同环境中安全地执行工具。该桥梁设计灵活、可扩展，并且易于与任何 LLM 后端集成。

GitHub MCP Server

GitHub MCP 服务器，用于与 CI 流程集成。

Meta MCP Server

镜子 (jìng zi)

GitHub Configuration

TickTick 任务管理应用的 Model Context Protocol (MCP) 服务器

RobotFrameworkLibrary-to-MCP

Okay, here's a breakdown of how to turn a Robot Framework library into an MCP (Message Center Protocol) server, along with explanations and considerations: **Understanding the Goal** The core idea is to expose the functionality of your Robot Framework library as a service that can be accessed remotely via MCP. This allows other systems (potentially written in different languages or running on different machines) to trigger actions within your Robot Framework library. **Key Concepts** * **Robot Framework Library:** A collection of keywords (functions) that can be used in Robot Framework test cases. * **MCP (Message Center Protocol):** A lightweight protocol for inter-process communication. It's often used for sending commands and receiving responses between different applications or services. * **MCP Server:** A process that listens for MCP requests, processes them, and sends back responses. * **MCP Client:** A process that sends MCP requests to an MCP server. * **Serialization/Deserialization:** Converting data structures (like Python objects) into a format suitable for transmission over a network (e.g., JSON) and then converting them back on the receiving end. **General Approach** 1. **Choose an MCP Library/Framework:** You'll need a Python library that handles the MCP protocol. Some options include: * **`mcp` (Python Package):** A dedicated MCP library for Python. This is likely the most direct and appropriate choice. You can install it with `pip install mcp`. * **ZeroMQ (with MCP Implementation):** ZeroMQ is a powerful messaging library that can be used to implement MCP. This is a more general-purpose solution, but it might be overkill if you only need MCP. * **Other Messaging Libraries:** You *could* potentially use other messaging libraries (like RabbitMQ or Redis Pub/Sub), but you'd need to implement the MCP protocol on top of them, which is more complex. 2. **Create an MCP Server:** Write a Python script that: * Imports your Robot Framework library. * Uses the chosen MCP library to create a server that listens on a specific port. * Registers handlers for different MCP commands. Each handler will correspond to a keyword in your Robot Framework library. * When a command is received, the handler will: * Extract the arguments from the MCP message. * Call the corresponding Robot Framework keyword with those arguments. * Capture the return value (if any) from the keyword. * Serialize the return value (e.g., to JSON). * Send the serialized result back to the MCP client as an MCP response. 3. **Create an MCP Client (if needed for testing):** Write a Python script (or use a tool like `netcat`) that: * Uses the chosen MCP library to connect to the MCP server. * Sends MCP requests with the appropriate command name and arguments. * Receives and deserializes the MCP response. * Prints or processes the result. **Example using the `mcp` Python Package** ```python # server.py (MCP Server) import mcp import json from robot.libraries.BuiltIn import BuiltIn # Or import your custom library # Instantiate your Robot Framework library (or use BuiltIn for demonstration) # my_library = MyRobotLibrary() builtin = BuiltIn() def execute_keyword(keyword_name, *args): """Executes a Robot Framework keyword and returns the result.""" try: result = builtin.run_keyword(keyword_name, *args) return result except Exception as e: return {"error": str(e)} # Handle errors gracefully class MyMCPHandler(mcp.Handler): def handle_message(self, message): """Handles incoming MCP messages.""" try: command = message.command arguments = message.arguments if command == "log_message": # Example: Expose the 'Log' keyword result = execute_keyword("Log", arguments.get("message", "")) # Pass arguments as needed return mcp.Response(result=result) elif command == "get_variable_value": #Example: Expose the 'Get Variable Value' keyword variable_name = arguments.get("name") default_value = arguments.get("default", None) result = execute_keyword("Get Variable Value", variable_name, default_value) return mcp.Response(result=result) else: return mcp.Response(error="Unknown command: {}".format(command)) except Exception as e: return mcp.Response(error=str(e)) if __name__ == "__main__": server = mcp.Server(handler=MyMCPHandler()) server.start() # Defaults to port 7000 print("MCP server started on port 7000...") try: server.join() # Keep the server running except KeyboardInterrupt: print("Shutting down server...") server.stop() ``` ```python # client.py (MCP Client - for testing) import mcp import json def send_mcp_request(command, arguments): """Sends an MCP request and returns the response.""" try: client = mcp.Client() response = client.send_message(mcp.Message(command=command, arguments=arguments)) client.close() return response.result, response.error except Exception as e: return None, str(e) if __name__ == "__main__": # Example 1: Call the 'Log' keyword result, error = send_mcp_request("log_message", {"message": "Hello from MCP!"}) if error: print("Error:", error) else: print("Log Result:", result) # Example 2: Call the 'Get Variable Value' keyword result, error = send_mcp_request("get_variable_value", {"name": "${TEMPDIR}"}) if error: print("Error:", error) else: print("Variable Value:", result) ``` **Explanation of the Example** * **`server.py`:** * Imports the `mcp` library and `robot.libraries.BuiltIn`. Replace `robot.libraries.BuiltIn` with your actual Robot Framework library. * `execute_keyword` function: This is the crucial part. It takes a keyword name and arguments, and then uses `BuiltIn().run_keyword()` (or the equivalent for your library) to execute the keyword. Error handling is included. * `MyMCPHandler`: This class inherits from `mcp.Handler` and overrides the `handle_message` method. This method is called whenever the server receives an MCP message. * It extracts the command name and arguments from the message. * It uses a series of `if/elif/else` statements to determine which Robot Framework keyword to call based on the command name. * It calls `execute_keyword` to execute the keyword. * It creates an `mcp.Response` object with the result (or an error message) and returns it. * The `if __name__ == "__main__":` block creates an `mcp.Server` instance, starts it, and keeps it running until a `KeyboardInterrupt` (Ctrl+C) is received. * **`client.py`:** * Imports the `mcp` library. * `send_mcp_request` function: This function takes a command name and arguments, creates an `mcp.Message` object, sends it to the server, and returns the response. * The `if __name__ == "__main__":` block shows how to use the `send_mcp_request` function to call the `log_message` and `get_variable_value` commands. **How to Run the Example** 1. **Install `mcp`:** `pip install mcp` 2. **Save the code:** Save the server code as `server.py` and the client code as `client.py`. 3. **Run the server:** `python server.py` 4. **Run the client:** `python client.py` (in a separate terminal) You should see the "Hello from MCP!" message logged by the Robot Framework `Log` keyword, and the value of the `${TEMPDIR}` variable printed by the client. **Important Considerations and Enhancements** * **Error Handling:** The example includes basic error handling, but you should add more robust error handling to catch exceptions and return meaningful error messages to the client. * **Security:** MCP itself doesn't provide any security features. If you need to secure your MCP server, you'll need to implement your own security mechanisms (e.g., authentication, encryption). Consider using TLS/SSL for encryption. * **Argument Handling:** The example assumes that the arguments are passed as a dictionary. You might need to adjust the argument handling to match the specific requirements of your Robot Framework keywords. Consider using a more structured data format like JSON Schema to define the expected arguments for each command. * **Data Serialization:** The example uses JSON for serialization. You can use other serialization formats (e.g., Pickle, MessagePack) if needed. JSON is generally a good choice for interoperability. * **Asynchronous Operations:** If your Robot Framework keywords perform long-running operations, consider using asynchronous programming (e.g., `asyncio`) to prevent the MCP server from blocking. * **Configuration:** Use a configuration file (e.g., YAML, JSON) to store the server's port number, logging settings, and other configuration parameters. * **Logging:** Add logging to the server to track requests, responses, and errors. Use a logging library like `logging`. * **Command Discovery:** Implement a mechanism for the client to discover the available commands and their arguments. This could be done by adding a special "describe" command to the server. * **Robot Framework Listener:** You could potentially use a Robot Framework listener to automatically register keywords as MCP commands. This would reduce the amount of manual configuration required. * **Testing:** Write unit tests and integration tests to ensure that your MCP server is working correctly. **In summary, turning a Robot Framework library into an MCP server involves creating a Python script that listens for MCP requests, calls the appropriate Robot Framework keywords, and sends back the results as MCP responses. The `mcp` Python package provides a convenient way to implement the MCP protocol.** Remember to consider error handling, security, argument handling, and other important factors to create a robust and reliable service.