Discover Awesome MCP Servers

Apache Doris MCP Server

Apache Doris 和 VeloDB 的 MCP 服务器

Linear 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 机器配置池服务器**

Google Calendar MCP Server

镜子 (jìng zi)

VSCode MCP

启用像 Goose 或 Claude 这样的人工智能代理和助手，使其可以通过模型上下文协议与 VS Code 交互。

My MCP Servers 🛠

我的一些MCP服务器的集合。

mcp-tavily-search

MCP 服务器赋予客户端在互联网上搜索的能力。

Desktop Commander MCP

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

Twilio MCP Server

一个模型上下文协议（Model Context Protocol）服务器，它使 Claude 和其他 AI 助手能够使用 Twilio 发送 SMS 和 MMS 消息。

Starknet MCP Server

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

mcp-rb-template

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

MCP Server for Prometheus

镜子 (jìng zi)

LangGraph MCP Server

一个基于 Python 的模型上下文协议 (MCP) 服务器，它使 LLM 能够通过标准化接口访问外部工具和资源。

MCP-Server-TESS

一个模型上下文协议服务器，它能够与 TESS API 集成，允许用户通过自然语言界面列出和管理代理、使用自定义消息执行代理以及管理文件。

Mac Messages MCP

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

Illumio MCP Server

镜子 (jìng zi)

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!

Gmail IMAP MCP Server

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

Hyperliquid MCP Server

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

Code2Flow MCP 服务器

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

MCP-Server for command line

这是一个简单的命令行 MCP 服务器，主要思路来自 hdcola。

Axiom MCP Server

适用于 Axiom 的 MCP 服务器