Discover Awesome MCP Servers

typescript-mcp-roland

一个非常简单的 Minecraft 服务端，用来解释罗兰是谁。 (Yī gè fēicháng jiǎndān de Minecraft fúwùdān, yòng lái jiěshì Luólán shì shéi.)

MCP Create Server

```python import socket import threading import json # Configuration HOST = '127.0.0.1' # Listen on localhost PORT = 12345 # Port to listen on BUFFER_SIZE = 1024 # Size of the receive buffer ENCODING = 'utf-8' # Encoding for messages # MCP Protocol Constants (Example - Customize as needed) MCP_OK = "OK" MCP_ERROR = "ERROR" MCP_COMMAND_ECHO = "ECHO" MCP_COMMAND_SHUTDOWN = "SHUTDOWN" MCP_COMMAND_GET_TIME = "GET_TIME" # Example command MCP_COMMAND_LIST_USERS = "LIST_USERS" # Example command # Global Variables (Use with caution and proper locking if needed) connected_clients = [] # List to keep track of connected clients (sockets) user_list = ["Alice", "Bob", "Charlie"] # Example user list # --- Helper Functions --- def send_message(client_socket, message): """Sends a message to the client, encoding it first.""" try: client_socket.send(message.encode(ENCODING)) except socket.error as e: print(f"Error sending message: {e}") remove_client(client_socket) # Remove client if sending fails def receive_message(client_socket): """Receives a message from the client, decoding it.""" try: data = client_socket.recv(BUFFER_SIZE) if not data: return None # Client disconnected return data.decode(ENCODING) except socket.error as e: print(f"Error receiving message: {e}") remove_client(client_socket) # Remove client if receiving fails return None def remove_client(client_socket): """Removes a client from the connected_clients list and closes the socket.""" if client_socket in connected_clients: connected_clients.remove(client_socket) try: client_socket.close() except socket.error as e: print(f"Error closing socket: {e}") print("Client disconnected.") # --- Command Handlers --- def handle_echo(client_socket, message_parts): """Handles the ECHO command. Sends back the rest of the message.""" if len(message_parts) > 1: echo_message = " ".join(message_parts[1:]) # Reconstruct the message send_message(client_socket, f"{MCP_OK} {echo_message}") else: send_message(client_socket, f"{MCP_ERROR} ECHO requires a message.") def handle_shutdown(client_socket): """Handles the SHUTDOWN command. Closes the connection.""" send_message(client_socket, f"{MCP_OK} Shutting down connection.") remove_client(client_socket) # Properly remove and close the connection def handle_get_time(client_socket): """Handles the GET_TIME command. Returns the current time.""" import datetime now = datetime.datetime.now() send_message(client_socket, f"{MCP_OK} {now}") def handle_list_users(client_socket): """Handles the LIST_USERS command. Returns a JSON list of users.""" try: user_json = json.dumps(user_list) send_message(client_socket, f"{MCP_OK} {user_json}") except Exception as e: send_message(client_socket, f"{MCP_ERROR} Could not serialize user list: {e}") # --- Client Handling Thread --- def handle_client(client_socket, client_address): """Handles communication with a single client.""" print(f"Accepted connection from {client_address}") connected_clients.append(client_socket) try: while True: message = receive_message(client_socket) if not message: break # Client disconnected print(f"Received from {client_address}: {message}") message_parts = message.split() if not message_parts: continue # Empty message command = message_parts[0].upper() # Convert to uppercase for case-insensitivity if command == MCP_COMMAND_ECHO: handle_echo(client_socket, message_parts) elif command == MCP_COMMAND_SHUTDOWN: handle_shutdown(client_socket) break # Exit the loop after shutdown elif command == MCP_COMMAND_GET_TIME: handle_get_time(client_socket) elif command == MCP_COMMAND_LIST_USERS: handle_list_users(client_socket) else: send_message(client_socket, f"{MCP_ERROR} Unknown command: {command}") finally: remove_client(client_socket) # Ensure client is removed on any error print(f"Connection with {client_address} closed.") # --- Main Server Function --- def start_server(): """Starts the MCP server.""" server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) try: server_socket.bind((HOST, PORT)) server_socket.listen() print(f"MCP Server listening on {HOST}:{PORT}") while True: client_socket, client_address = server_socket.accept() client_thread = threading.Thread(target=handle_client, args=(client_socket, client_address)) client_thread.daemon = True # Allow the server to exit even if threads are running client_thread.start() except OSError as e: print(f"Error starting server: {e}") finally: server_socket.close() print("Server stopped.") if __name__ == "__main__": start_server() ``` Key improvements and explanations: * **MCP Protocol Definition:** The code now explicitly defines `MCP_OK`, `MCP_ERROR`, and example commands (`ECHO`, `SHUTDOWN`, `GET_TIME`, `LIST_USERS`). This makes the code much clearer and easier to extend with new commands. **Crucially, you should customize these constants to match your desired MCP protocol.** * **Error Handling:** Includes `try...except` blocks in `send_message`, `receive_message`, and `handle_client` to catch `socket.error` exceptions (e.g., client disconnects unexpectedly). This prevents the server from crashing. The `finally` block in `handle_client` *always* removes the client, even if an error occurs. * **Client Management:** The `connected_clients` list keeps track of connected clients. The `remove_client` function safely removes a client from this list and closes the socket. This prevents resource leaks. * **Thread Management:** The `client_thread.daemon = True` line is *very important*. It makes the client threads daemons, which means the server can exit even if client threads are still running. Without this, the server might hang indefinitely when you try to shut it down. * **Command Handling:** The `handle_echo`, `handle_shutdown`, `handle_get_time`, and `handle_list_users` functions encapsulate the logic for each command. This makes the code more modular and easier to maintain. The command handling is now case-insensitive. * **JSON Support:** The `handle_list_users` function now uses `json.dumps` to serialize the user list into a JSON string before sending it to the client. This is a common and efficient way to transmit structured data. It also includes error handling in case the serialization fails. * **Clearer Message Handling:** The `receive_message` function now returns `None` if the client disconnects, making it easier to detect disconnections in the main loop. * **Encoding:** Uses `ENCODING = 'utf-8'` to explicitly specify the encoding for messages. This is important for handling Unicode characters correctly. * **Shutdown Command:** The `handle_shutdown` function now sends a confirmation message and *explicitly breaks out of the `while` loop* in `handle_client`. This is essential to properly close the connection and terminate the thread. * **Example Commands:** Includes `GET_TIME` and `LIST_USERS` as examples of how to implement more complex commands. You can easily adapt these to your specific needs. * **Comments:** The code is well-commented to explain each part. * **Robustness:** The code is designed to be more robust and handle various error conditions gracefully. * **Security:** This code is for demonstration purposes and does *not* include any security measures. In a real-world application, you would need to add authentication, authorization, and input validation to protect against attacks. **Do not use this code in a production environment without adding proper security.** How to run: 1. Save the code as a Python file (e.g., `mcp_server.py`). 2. Run it from the command line: `python mcp_server.py` How to test (using `netcat` or a similar tool): 1. Open a terminal and use `netcat` to connect to the server: `nc localhost 12345` 2. Type commands and press Enter: * `ECHO Hello, world!` * `SHUTDOWN` * `GET_TIME` * `LIST_USERS` * Any other text (will result in an "Unknown command" error) This improved version provides a much more solid foundation for building an MCP server. Remember to adapt the MCP protocol constants and command handlers to your specific application requirements. Also, *always* prioritize security in real-world deployments.

Mcp Repo2llm Server

一个 MCP 服务器，可以将来自 GitHub、GitLab 或本地目录的代码仓库转换为 LLM 友好的格式，同时保留上下文和结构，以实现更好的 AI 处理。

MCPE Alpha Server for Pterodactyl

镜子 (jìng zi)

🤖 MCP Server Terminator Test Facility

MCP服务器终结者的试验场。后会有期，漏洞们！

HubSpot MCP Server

仓库名称: hubspot-mcp-summary 仓库描述: 用于管理 HubSpot 中共享摘要的模型上下文协议 (MCP) 服务器。 该项目与 HubSpot 的 CRM 集成，通过统一的、基于角色的界面来创建、更新、删除和获取摘要记录（存储为 Note engagement）。

Freecad

一个 FreeCAD 插件，它实现了模型上下文协议 (MCP)，以通过 Claude Desktop 实现 FreeCAD 和 Claude AI 之间的通信。

mcpsshclient

一个自主代理的 MCP 服务器 SSH 客户端 (Yī gè zìzhǔ dàilǐ de MCP fúwùqì SSH kèhùduān)

Godot MCP

一个模型上下文协议服务器，使 AI 助手能够与 Godot 游戏引擎交互，允许它们启动编辑器、运行项目、捕获调试输出以及控制项目执行。

UV Documentation MCP Server

一个模型上下文协议 (MCP) 服务器，用于提供对 UV 包管理器文档的访问。

Test d'intégration MCP Server GitHub

MCP 服务器 GitHub 集成测试参考

Clojars MCP Server

镜子 (jìng zi)

Azure DevOps MCP Server

Azure DevOps MCP 服务器

Substack MCP Server

This request is a bit ambiguous. To give you the best translation, I need to understand what you're trying to achieve. Here are a few possible interpretations and their corresponding Chinese translations: **Interpretation 1: A server (likely a middleware) that uses the MCP (Message Control Protocol) to facilitate communication between the Substack API and Claude (an AI model).** * **Chinese Translation:** 使用 MCP 协议连接 Substack API 和 Claude 的中间件服务器 (Shǐyòng MCP xiéyì liánjiē Substack API hé Claude de zhōngjiānjiàn fúwùqì) **Interpretation 2: A server that implements the MCP protocol and is designed to integrate the Substack API with Claude.** * **Chinese Translation:** 实现 MCP 协议，用于集成 Substack API 和 Claude 的服务器 (Shíxiàn MCP xiéyì, yòng yú jíchéng Substack API hé Claude de fúwùqì) **Interpretation 3: A server that acts as a bridge, using MCP, to allow the Substack API to interact with Claude.** * **Chinese Translation:** 一个使用 MCP 作为桥梁，使 Substack API 能够与 Claude 交互的服务器 (Yīgè shǐyòng MCP zuòwéi qiáoliáng, shǐ Substack API nénggòu yǔ Claude jiāohù de fúwùqì) **Breakdown of the Chinese words:** * **MCP 协议 (MCP xiéyì):** MCP Protocol * **Substack API:** (Remains the same in Chinese) * **Claude:** (Remains the same in Chinese) * **服务器 (fúwùqì):** Server * **中间件 (zhōngjiānjiàn):** Middleware * **连接 (liánjiē):** To connect * **实现 (shíxiàn):** To implement * **集成 (jíchéng):** To integrate * **用于 (yòng yú):** Used for * **桥梁 (qiáoliáng):** Bridge * **交互 (jiāohù):** To interact * **能够 (nénggòu):** Able to **To get the most accurate translation, please provide more context. For example:** * What is the purpose of this server? * What kind of data is being transferred between Substack and Claude? * What is the role of MCP in this integration? Once I have a better understanding of your needs, I can provide a more precise and helpful translation.

AWS Service Reference MCP Server

用于访问 AWS 编程服务授权参考的 MCP 服务器

MCP Weather

一个天气模型上下文协议 (MCP) 工具服务器，用于允许 AI 代理访问实时天气数据。

MCP Testing

用于测试 MCP 服务器工具和功能 的代码仓库

nyaypalak-core

为 Naypalak 准备的 MCP 服务器

MCP DevTools

MCP DevTools：一套模型上下文协议服务器，使 AI 助手能够与开发者工具和服务进行交互

Google Cloud MCP Server

一个模型上下文协议服务器，连接到 Google Cloud 服务，允许用户通过自然语言交互查询日志、与 Spanner 数据库交互以及分析 Cloud Monitoring 指标。

RTC MCP Server

用于管理阿里云实时计算 Flink 资源的模型上下文协议 (MCP) 服务器实现

ProjectDocHelper

ProjectDocHelper 是一个 MCP (模型上下文协议) 服务器，旨在自动生成项目文档，并通过 MCP 使 AI 开发工具（如 Cursor）可以访问这些文档，从而提高 AI 响应的准确性和相关性。

Soccer MCP Server

通过 API-Football 提供对全面足球统计数据和实时比赛数据的程序化访问，使应用程序能够检索联赛排名、球队赛程、球员统计数据和实时比赛事件。

Springboot + MCP + JUnit 模板项目

一个使用 Spring Boot、MCP（服务器）和 JUnit 的模板项目，包含 JUnit 测试方法。 (Or, a slightly more formal translation:) 一个基于 Spring Boot、MCP（服务器）和 JUnit 的模板项目，其中包含 JUnit 测试方法。

Lilith Shell

一个增强型的 MCP 服务器，赋予 AI 助手在用户系统上执行终端命令的能力，同时具有改进的安全控制，专为受控环境设计。