Discover Awesome MCP Servers

GitHub MCP Server for Cursor IDE

GitHub MCP 服务器，用于 Cursor IDE

MCP-Forge

MCP 服务器的便捷脚手架工具

Weather MCP Server

一个模型上下文协议（MCP）服务器，提供来自加拿大政府天气API的天气预报数据。通过纬度和经度获取加拿大任何地点准确的5天天气预报。可轻松与Claude Desktop和其他兼容MCP的客户端集成。

mcp-server-wechat

好的，我理解您想了解如何在PC端微信上实现MCP（Message Communication Protocol，消息通信协议）服务功能。 这实际上是一个比较复杂的问题，涉及到逆向工程、协议分析、以及代码实现等多个方面。 **请注意：** * **法律风险：** 逆向工程和修改微信客户端可能违反微信的使用条款，甚至触犯法律。请务必在法律允许的范围内进行研究和开发。 * **技术难度：** 微信客户端是一个复杂的软件，其协议和实现细节可能会随时更改。实现MCP服务功能需要深入的理解和持续的维护。 * **安全风险：** 修改微信客户端可能会引入安全漏洞，导致您的账号或设备受到攻击。 **以下是一些可能涉及的步骤和技术方向，仅供参考：** 1. **逆向工程和协议分析：** * **目标：** 了解PC端微信如何收发消息，以及MCP协议的具体格式和流程。 * **工具：** * **反汇编器 (Disassembler):** IDA Pro, Ghidra 等，用于分析微信客户端的可执行文件。 * **调试器 (Debugger):** x64dbg, OllyDbg 等，用于动态调试微信客户端，观察其运行时的行为。 * **抓包工具 (Packet Sniffer):** Wireshark, Fiddler 等，用于捕获微信客户端与服务器之间的网络流量，分析MCP协议。 * **步骤：** * 使用反汇编器打开微信客户端的可执行文件，找到与消息收发相关的函数和代码段。 * 使用调试器跟踪这些函数的执行过程，观察其如何构建和解析MCP消息。 * 使用抓包工具捕获微信客户端与服务器之间的网络流量，分析MCP协议的格式和字段。 * 重点关注登录、消息发送、消息接收、群组管理等关键功能的协议细节。 2. **MCP协议模拟：** * **目标：** 能够模拟微信客户端，构造和发送符合MCP协议的消息，并解析接收到的消息。 * **技术：** * **编程语言：** C++, Python, Go 等，选择您熟悉的语言。 * **网络编程：** TCP/IP 协议，Socket 编程。 * **数据序列化/反序列化：** Protocol Buffers, JSON 等，根据MCP协议的格式选择合适的工具。 * **加密算法：** 微信可能使用了加密算法来保护MCP消息，需要分析并实现相应的解密算法。 * **步骤：** * 根据协议分析的结果，编写代码来构造MCP消息。 * 使用Socket编程建立与微信服务器的连接。 * 发送构造好的MCP消息，并接收服务器的响应。 * 解析接收到的MCP消息，提取所需的信息。 * 实现登录、消息发送、消息接收等基本功能。 3. **PC端微信功能扩展 (可选):** * **目标：** 将MCP服务功能集成到PC端微信客户端中，实现自定义的功能。 * **技术：** * **DLL注入 (DLL Injection):** 将自定义的DLL注入到微信客户端的进程中。 * **Hook技术 (Hooking):** 拦截微信客户端的函数调用，修改其行为。 * **内存修改 (Memory Patching):** 直接修改微信客户端的内存数据。 * **步骤：** * 编写一个DLL，实现MCP服务功能。 * 使用DLL注入工具将DLL注入到微信客户端的进程中。 * 使用Hook技术拦截微信客户端的函数调用，例如消息发送函数、消息接收函数等。 * 在Hook函数中调用DLL中的MCP服务功能，实现自定义的功能。 * 或者，直接修改微信客户端的内存数据，例如修改消息显示内容、添加自定义按钮等。 **一些建议：** * **从小处着手：** 先从简单的功能开始，例如模拟登录、发送简单的文本消息等。 * **逐步迭代：** 不断完善和扩展功能，逐步实现更复杂的功能。 * **参考开源项目：** 在GitHub等平台上搜索相关的开源项目，可以借鉴其实现思路和代码。 * **注意安全：** 在开发过程中，要注意保护您的账号和设备安全，避免泄露个人信息。 **总结：** 实现PC端微信的MCP服务功能是一个极具挑战性的任务，需要深入的理解微信客户端的内部机制和MCP协议。 请务必在法律允许的范围内进行研究和开发，并注意安全风险。 希望这些信息对您有所帮助！ 如果您有更具体的问题，例如关于某个特定功能的实现，请随时提出。

Google Calendar MCP Server

镜子 (jìng zi)

kube-mcp

Kubernetes MCP (Machine Config Pool) servers can be translated as: **Kubernetes 机器配置池服务器** Here's a breakdown: * **Kubernetes (K8s):** Kubernetes (Kubernetes) * **MCP (Machine Config Pool):** 机器配置池 (Jīqì pèizhì chí) - This directly translates to "Machine Configuration Pool." * **servers:** 服务器 (Fúwùqì) Therefore, the complete translation is: **Kubernetes 机器配置池服务器**

Linear MCP Server

镜子 (jìng zi)

Desktop Commander MCP

这是一个为 Claude 提供的 MCP 服务器，赋予它终端控制、文件系统搜索和 diff 文件编辑能力。

MCP Server for Prometheus

镜子 (jìng zi)

Hyperliquid MCP Server

MCP 服务器用于从 Hyperliquid API 获取数据。

Docs Fetch MCP Server

使大型语言模型能够自主检索和探索网络内容，通过获取页面并以指定的深度递归地跟踪链接，尤其适用于从文档中学习主题。

python-pip-mcp

Okay, here's a minimal example implementation of an MCP (Minecraft Protocol) server and client using Python and Pip, designed to be debuggable in VSCode on Windows. This example focuses on the handshake and status request/response, which is the simplest part of the protocol. It's a starting point, not a fully functional Minecraft server. **Important Considerations:** * **Minecraft Protocol Complexity:** The Minecraft protocol is complex. This example only implements a tiny subset. For a full server, you'd need to handle many more packets, entities, world generation, etc. * **Error Handling:** This example has minimal error handling for brevity. Real-world code needs robust error handling. * **Security:** This example is *not* secure. Do not expose it to the internet without proper security measures. * **Dependencies:** This example uses `struct` for packing and unpacking data, which is part of the Python standard library. **1. Project Setup (Recommended):** Create a new directory for your project. Inside that directory, create two Python files: `mcp_server.py` and `mcp_client.py`. Also, create a `requirements.txt` file. **2. `requirements.txt` (Empty, but good practice):** ``` # No external dependencies for this minimal example ``` **3. `mcp_server.py`:** ```python import socket import struct import json def pack_varint(data): output = b'' while True: byte = data & 0x7F data >>= 7 if data != 0: byte |= 0x80 output += struct.pack("B", byte) if data == 0: break return output def unpack_varint(sock): result = 0 shift = 0 while True: byte = sock.recv(1) if not byte: return None # Connection closed i = byte[0] result |= (i & 0x7f) << shift shift += 7 if not (i & 0x80): break if shift > 35: raise ValueError("VarInt is too big") return result def handle_handshake(sock): # Read packet length packet_length = unpack_varint(sock) if packet_length is None: return False # Connection closed # Read packet ID packet_id = unpack_varint(sock) if packet_id != 0x00: print(f"Unexpected packet ID: {packet_id}") return False # Read protocol version protocol_version = unpack_varint(sock) print(f"Protocol Version: {protocol_version}") # Read server address server_address_length = unpack_varint(sock) server_address = sock.recv(server_address_length).decode('utf-8') print(f"Server Address: {server_address}") # Read server port server_port = struct.unpack(">H", sock.recv(2))[0] # Big-endian unsigned short print(f"Server Port: {server_port}") # Read next state next_state = unpack_varint(sock) print(f"Next State: {next_state}") return True def handle_status_request(sock): # Read packet length (should be 1 for status request) packet_length = unpack_varint(sock) if packet_length is None: return False # Connection closed # Read packet ID (should be 0x00 for status request) packet_id = unpack_varint(sock) if packet_id != 0x00: print(f"Unexpected packet ID: {packet_id}") return False # Construct the status response status = { "version": { "name": "My Minimal Server", "protocol": 754 # Example protocol version }, "players": { "max": 20, "online": 0, "sample": [] }, "description": { "text": "A minimal Minecraft server example." } } status_json = json.dumps(status) status_json_bytes = status_json.encode('utf-8') status_json_length = len(status_json_bytes) # Pack the response packet_id = b'\x00' # Status Response packet ID packet_data = pack_varint(status_json_length) + status_json_bytes packet_length = pack_varint(len(packet_data) + 1) # +1 for packet_id response = packet_length + packet_id + packet_data sock.sendall(response) return True def handle_ping(sock): # Read packet length packet_length = unpack_varint(sock) if packet_length is None: return False # Connection closed # Read packet ID packet_id = unpack_varint(sock) if packet_id != 0x01: print(f"Unexpected packet ID: {packet_id}") return False # Read ping payload ping_payload = sock.recv(8) # 8 bytes for the ping payload # Send back the same payload packet_id = b'\x01' # Ping Response packet ID packet_data = ping_payload packet_length = pack_varint(len(packet_data) + 1) # +1 for packet_id response = packet_length + packet_id + packet_data sock.sendall(response) return True def main(): host = '127.0.0.1' port = 25565 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(1) # Listen for one connection print(f"Server listening on {host}:{port}") try: while True: client_socket, client_address = server_socket.accept() print(f"Accepted connection from {client_address}") try: if handle_handshake(client_socket): if handle_status_request(client_socket): handle_ping(client_socket) except Exception as e: print(f"Error handling client: {e}") finally: client_socket.close() print(f"Connection closed with {client_address}") except KeyboardInterrupt: print("Server shutting down.") finally: server_socket.close() if __name__ == "__main__": main() ``` **4. `mcp_client.py`:** ```python import socket import struct import json def pack_varint(data): output = b'' while True: byte = data & 0x7F data >>= 7 if data != 0: byte |= 0x80 output += struct.pack("B", byte) if data == 0: break return output def unpack_varint(sock): result = 0 shift = 0 while True: byte = sock.recv(1) if not byte: return None # Connection closed i = byte[0] result |= (i & 0x7f) << shift shift += 7 if not (i & 0x80): break if shift > 35: raise ValueError("VarInt is too big") return result def handshake(sock, host, port): protocol_version = 754 # Example protocol version server_address = host server_port = port next_state = 1 # 1 for status # Construct the handshake packet packet_id = b'\x00' # Handshake packet ID protocol_version_bytes = pack_varint(protocol_version) server_address_bytes = server_address.encode('utf-8') server_address_length = pack_varint(len(server_address_bytes)) server_port_bytes = struct.pack(">H", server_port) # Big-endian unsigned short next_state_bytes = pack_varint(next_state) packet_data = protocol_version_bytes + server_address_length + server_address_bytes + server_port_bytes + next_state_bytes packet_length = pack_varint(len(packet_data) + 1) # +1 for packet_id packet = packet_length + packet_id + packet_data sock.sendall(packet) def status_request(sock): # Construct the status request packet packet_id = b'\x00' # Status Request packet ID packet_length = pack_varint(1) # Length of packet_id packet = packet_length + packet_id sock.sendall(packet) def ping_request(sock): # Construct the ping request packet packet_id = b'\x01' # Ping Request packet ID ping_payload = struct.pack(">q", 123456789) # Example ping payload (long) packet_data = ping_payload packet_length = pack_varint(len(packet_data) + 1) # +1 for packet_id packet = packet_length + packet_id + packet_data sock.sendall(packet) def receive_status_response(sock): # Read packet length packet_length = unpack_varint(sock) if packet_length is None: return None # Connection closed # Read packet ID packet_id = unpack_varint(sock) if packet_id != 0x00: print(f"Unexpected packet ID: {packet_id}") return None # Read the JSON data json_length = unpack_varint(sock) json_data = sock.recv(json_length).decode('utf-8') try: status = json.loads(json_data) return status except json.JSONDecodeError as e: print(f"Error decoding JSON: {e}") return None def receive_ping_response(sock): # Read packet length packet_length = unpack_varint(sock) if packet_length is None: return None # Connection closed # Read packet ID packet_id = unpack_varint(sock) if packet_id != 0x01: print(f"Unexpected packet ID: {packet_id}") return None # Read ping payload ping_payload = sock.recv(8) # 8 bytes for the ping payload return ping_payload def main(): host = '127.0.0.1' port = 25565 client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) try: client_socket.connect((host, port)) print(f"Connected to {host}:{port}") handshake(client_socket, host, port) status_request(client_socket) status = receive_status_response(client_socket) if status: print("Status Response:") print(json.dumps(status, indent=4)) ping_request(client_socket) ping_response = receive_ping_response(client_socket) if ping_response: print("Ping Response received.") except Exception as e: print(f"Error: {e}") finally: client_socket.close() print("Connection closed.") if __name__ == "__main__": main() ``` **5. Explanation:** * **`pack_varint(data)` and `unpack_varint(sock)`:** These functions handle the Minecraft protocol's variable-length integer format (VarInt). This is crucial for encoding packet lengths and other data. * **`handshake(sock, host, port)` (Client) and `handle_handshake(sock)` (Server):** Implement the initial handshake. The client sends its protocol version, server address, port, and desired state (status). The server receives and parses this information. * **`status_request(sock)` (Client) and `handle_status_request(sock)` (Server):** Implement the status request/response. The client sends a simple status request packet. The server constructs a JSON response containing server information (version, player count, description) and sends it back. * **`ping_request(sock)` (Client) and `handle_ping(sock)` (Server):** Implement the ping request/response. The client sends a ping request packet with a payload. The server sends back the same payload. * **JSON Handling:** The server uses the `json` module to create and send the status response. * **Socket Programming:** Standard Python `socket` module is used for network communication. * **Big-Endian:** The server port is packed and unpacked using big-endian format (`>H`). **6. How to Run and Debug in VSCode:** 1. **Install Python and Pip:** Make sure you have Python and Pip installed. 2. **Create a Virtual Environment (Recommended):** ```bash python -m venv .venv .venv\Scripts\activate # On Windows source .venv/bin/activate # On Linux/macOS ``` 3. **Install Dependencies (Even though there are none in this example):** ```bash pip install -r requirements.txt ``` 4. **Open the Project in VSCode:** Open the directory containing your `mcp_server.py` and `mcp_client.py` files in VSCode. 5. **Create Debug Configurations:** * Go to the "Run and Debug" view in VSCode (Ctrl+Shift+D). * Click "Create a launch.json file". * Choose "Python File". * You'll need two configurations, one for the server and one for the client. Edit the `launch.json` file to look like this: ```json { "version": "0.2.0", "configurations": [ { "name": "MCP Server", "type": "python", "request": "launch", "program": "${workspaceFolder}/mcp_server.py", "console": "integratedTerminal", "justMyCode": false }, { "name": "MCP Client", "type": "python", "request": "launch", "program": "${workspaceFolder}/mcp_client.py", "console": "integratedTerminal", "justMyCode": false } ] } ``` 6. **Run the Server:** Select the "MCP Server" configuration in the "Run and Debug" view and click the "Start Debugging" button (or press F5). The server will start listening. 7. **Run the Client:** Select the "MCP Client" configuration and click the "Start Debugging" button. The client will connect to the server, perform the handshake and status request, and print the server's response. 8. **Debugging:** Set breakpoints in both `mcp_server.py` and `mcp_client.py` to step through the code and inspect variables. This is how you can understand the flow of the protocol. **7. Important Notes for Debugging:** * **`justMyCode: false`:** This setting in `launch.json` is important. It tells the debugger to step into *all* code, not just your own. This is helpful when debugging network code, as you might want to see what's happening in the socket library. * **Breakpoints:** Set breakpoints strategically. Good places to start are: * At the beginning of `handle_handshake` and `handshake`. * Before and after `sock.sendall` and `sock.recv`. * Inside the `pack_varint` and `unpack_varint` functions. * **Inspect Variables:** Use the VSCode debugger's "Variables" pane to inspect the contents of variables like `packet_length`, `packet_id`, `status_json`, and the data being sent and received. * **Check the Terminal:** The `console` setting in `launch.json` directs output to the integrated terminal. Look for print statements and error messages there. * **Network Issues:** If you have trouble connecting, double-check that the server is running, that the host and port are correct, and that there are no firewalls blocking the connection. This example provides a foundation for building a more complete Minecraft server or client. Remember to consult the official Minecraft protocol documentation for details on all the packets and data formats. Good luck!

Starknet MCP Server

提供 LLM 工具，使其能够与 Starknet 交互的 MCP 服务器。

mcp-rb-template

一个将开放的 Emacs 缓冲区作为资源暴露的 MCP 服务器

Mac Messages MCP

一个 Python 桥接器，用于使用 MCP (多重上下文协议) 与 macOS 消息应用进行交互。 使用 uvx 简单安装：mac-messages-mcp

Gmail IMAP MCP Server

用于将 Gmail 与 Claude 和其他 AI 助手集成的 Gmail IMAP MCP 服务器 (Simplified: 将 Gmail 集成到 Claude 和其他 AI 助手的 Gmail IMAP MCP 服务器)

Code2Flow MCP 服务器

一个服务器，它将 code2flow 命令行工具包装成一个 MCP 服务，允许 AI 应用程序通过标准化的协议生成和访问代码调用图。

LYRAIOS

LYRAI 是一个多人工智能代理的模型上下文协议（MCP）操作系统，旨在通过使人工智能应用程序能够与金融网络和区块链公链交互来扩展其功能。该服务器提供一系列高级人工智能助手，包括区块链公链操作（SOLANA、ETH、BSC 等）。

Meta MCP Server

镜子 (jìng zi)

MCP Weather Server

For MCP, a weather server application could be translated as: **MCP 的天气服务器应用程序** This is a direct and clear translation. Here's a breakdown: * **MCP:** Remains as MCP (assuming it's an acronym or proper noun). * **的 (de):** Possessive particle, similar to "of" or "'s" in English. * **天气 (tiān qì):** Weather * **服务器 (fú wù qì):** Server * **应用程序 (yìng yòng chéng xù):** Application Therefore, the whole phrase means "Weather server application of/for MCP".

MCP Memos

A memo tool based on MCP protocol that helps developers quickly save and retrieve text information without interrupting their workflow.

Cinema4D MCP — Model Context Protocol (MCP) Server

将 Cinema 4D 连接到 Claude，通过自然语言命令实现 AI 辅助的 3D 建模和场景操作。

playwright-mcp-fetch

这个工具提供了一个模型上下文协议（MCP）服务器，用于从网站获取内容，并使用 Playwright 将其转换为不同的格式。

mcp-server-hub

创建一个单例 MCP 服务器中心，可供 Cline/Roo 代码使用。