发现优秀的 MCP 服务器

Google Sheets MCP Server

Provides read-only access to Google Sheets data through OAuth 2.0 authentication, enabling users to retrieve spreadsheet metadata, list tabs, and read cell data using natural language queries.

Cloudflare Playwright MCP

A server that enables AI assistants to control a browser through tools, allowing them to perform web automation tasks like navigation, typing, clicking, and taking screenshots.

富途 MCP 服务器 (Futu MCP Server)

Exposes Futu API client capabilities as an MCP (Model Context Protocol) tool, allowing AI assistants to access stock data from Futu through a standardized interface.

Gaia Health MCP Server

Exposes Supabase functionality for Gaia Health to n8n workflows, enabling appointment scheduling and management operations through MCP tools.

ClickUp MCP

Enables AI assistants to interact with ClickUp workspaces through natural language - search tasks, manage workflows, track time, collaborate via comments, and access complete task context including comments and images.

mcp-server-webcrawl

Bridge the gap between your web crawl and AI language models. With mcp-server-webcrawl, your AI client filters and analyzes web content under your direction or autonomously, extracting insights from your web content. Supports WARC, wget, InterroBot, Katana, and SiteOne crawlers.

Momento MCP Server

Enables interaction with Momento Cache to manage cache entries and perform administrative tasks like creating, listing, or deleting caches. It provides tools for getting and setting values with configurable TTLs through a serverless caching infrastructure.

Smart Search MCP Server

Enables web search capabilities through a remote smart search API with configurable result count, pagination, language, and safety filters, returning structured JSON results.

Agent Knowledge MCP

A comprehensive Model Context Protocol server that integrates Elasticsearch search with file operations, document validation, and version control to transform AI assistants into powerful knowledge management systems.

mcp-linkedinads

Analyse your LinkedIn Ads performance. Compare to benchmarks and get optimisation recommendations.

Puppeteer MCP Server

镜子 (jìng zi)

Seafile MCP Server

Connects Claude to your self-hosted or cloud-based Seafile storage for managing libraries and files through natural language. It enables users to browse directories, read file contents, and perform file operations like moving, renaming, or searching across their private infrastructure.

WorkOS MCP Server

一个轻量级的 MCP 服务器，允许代理通过自然语言命令与 WorkOS API 交互，从而简化 WorkOS 操作。

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

WeiWanMcpServer

私人 Minecraft 服务器 (Sīrén Minecraft fúwùqì)

Cloudflare Playwright MCP

Enables AI assistants to control a browser through Playwright and Cloudflare Workers, allowing web automation tasks like navigation, typing, clicking, and taking screenshots through natural language instructions.

MCP Add Server

A minimal Model Context Protocol server that provides a simple add(a, b) tool for computing the sum of two numbers.

MCP Create Server

```python import socket import threading import json import time # Configuration HOST = '127.0.0.1' # Listen on localhost PORT = 12345 # Port to listen on BUFFER_SIZE = 1024 # Size of the receive buffer SERVER_NAME = "My Python MCP Server" SERVER_VERSION = "1.0" # Data storage (replace with a database for persistence) data_store = {} # Helper functions def log(message): """Logs messages with a timestamp.""" timestamp = time.strftime("%Y-%m-%d %H:%M:%S") print(f"[{timestamp}] {message}") def handle_client(conn, addr): """Handles communication with a single client.""" log(f"Connected by {addr}") try: while True: data = conn.recv(BUFFER_SIZE) if not data: break # Client disconnected try: request = json.loads(data.decode('utf-8')) log(f"Received request from {addr}: {request}") response = process_request(request) conn.sendall(json.dumps(response).encode('utf-8')) log(f"Sent response to {addr}: {response}") except json.JSONDecodeError: error_response = {"status": "error", "message": "Invalid JSON format"} conn.sendall(json.dumps(error_response).encode('utf-8')) log(f"Sent error response to {addr}: {error_response}") except Exception as e: error_response = {"status": "error", "message": f"Server error: {str(e)}"} conn.sendall(json.dumps(error_response).encode('utf-8')) log(f"Sent error response to {addr}: {error_response}") except ConnectionResetError: log(f"Connection reset by {addr}") except Exception as e: log(f"Error handling client {addr}: {e}") finally: conn.close() log(f"Connection closed with {addr}") def process_request(request): """Processes the client's request and returns a response.""" command = request.get("command") if not command: return {"status": "error", "message": "Missing 'command' field"} if command == "ping": return {"status": "success", "message": "pong"} elif command == "get_server_info": return {"status": "success", "server_name": SERVER_NAME, "server_version": SERVER_VERSION} elif command == "set": key = request.get("key") value = request.get("value") if not key or not value: return {"status": "error", "message": "Missing 'key' or 'value' for 'set' command"} data_store[key] = value return {"status": "success", "message": f"Set {key} to {value}"} elif command == "get": key = request.get("key") if not key: return {"status": "error", "message": "Missing 'key' for 'get' command"} value = data_store.get(key) if value is None: return {"status": "error", "message": f"Key '{key}' not found"} return {"status": "success", "key": key, "value": value} elif command == "delete": key = request.get("key") if not key: return {"status": "error", "message": "Missing 'key' for 'delete' command"} if key in data_store: del data_store[key] return {"status": "success", "message": f"Deleted key '{key}'"} else: return {"status": "error", "message": f"Key '{key}' not found"} else: return {"status": "error", "message": f"Unknown command: {command}"} # 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)) except socket.error as e: print(f"Bind failed: {e}") return server_socket.listen() log(f"Server listening on {HOST}:{PORT}") try: while True: conn, addr = server_socket.accept() thread = threading.Thread(target=handle_client, args=(conn, addr)) thread.daemon = True # Allow the server to exit even if threads are running thread.start() except KeyboardInterrupt: log("Server shutting down...") finally: server_socket.close() log("Server closed.") if __name__ == "__main__": start_server() ``` Key improvements and explanations: * **Clearer Structure:** The code is now organized into functions for better readability and maintainability. `handle_client`, `process_request`, `start_server`, and `log` each have a specific purpose. * **Error Handling:** Includes `try...except` blocks to handle potential errors like `socket.error`, `json.JSONDecodeError`, `ConnectionResetError`, and general exceptions. This prevents the server from crashing due to unexpected issues. Crucially, it sends error responses back to the client. * **JSON Handling:** Uses `json.loads` and `json.dumps` to properly encode and decode JSON data. Includes error handling for invalid JSON. * **Threading:** Uses `threading` to handle multiple clients concurrently. The `thread.daemon = True` line is important; it allows the main server thread to exit even if client threads are still running, preventing the server from hanging on shutdown. * **Data Storage:** Uses a simple `data_store` dictionary for storing data. **Important:** This is *not* persistent. If the server restarts, the data is lost. For a real-world application, you would replace this with a database (e.g., SQLite, PostgreSQL, MongoDB). * **Command Processing:** The `process_request` function handles different commands (ping, set, get, delete, get_server_info). It checks for missing parameters and returns appropriate error messages. * **Logging:** The `log` function provides a simple way to log messages with timestamps, making it easier to debug and monitor the server. * **Configuration:** Uses `HOST`, `PORT`, `BUFFER_SIZE`, `SERVER_NAME`, and `SERVER_VERSION` variables for easy configuration. * **Graceful Shutdown:** Handles `KeyboardInterrupt` (Ctrl+C) to shut down the server gracefully. * **Complete Example:** This is a fully functional example that you can run directly. * **Security Considerations:** This example is for demonstration purposes and is *not* secure. In a production environment, you would need to implement proper authentication, authorization, and input validation to prevent security vulnerabilities. Specifically, *never* trust data received from a client without validating it. * **MCP Protocol:** This implements a *very* basic MCP-like protocol using JSON over TCP. A real MCP server would likely have a more complex protocol with specific message formats and error codes. How to run: 1. **Save:** Save the code as a Python file (e.g., `mcp_server.py`). 2. **Run:** Execute the file from your terminal: `python mcp_server.py` How to test (using `netcat` or a similar tool): 1. **Open a terminal:** 2. **Connect:** `nc localhost 12345` 3. **Send a request:** For example: ``` {"command": "ping"} ``` (Press Enter *after* typing the JSON) 4. **Receive the response:** You should see: ``` {"status": "success", "message": "pong"} ``` 5. **Try other commands:** ``` {"command": "set", "key": "mykey", "value": "myvalue"} {"command": "get", "key": "mykey"} {"command": "delete", "key": "mykey"} {"command": "get_server_info"} ``` **Chinese Translation of Key Concepts:** * **Server:** 服务器 (fúwùqì) * **Client:** 客户端 (kèhùduān) * **Socket:** 套接字 (tàojiēzì) * **Port:** 端口 (duānkǒu) * **Thread:** 线程 (xiànchéng) * **JSON:** JSON (pronounced "jay-sahn" in English, often used directly in Chinese) * **Command:** 命令 (mìnglìng) * **Key:** 键 (jiàn) * **Value:** 值 (zhí) * **Error:** 错误 (cuòwù) * **Status:** 状态 (zhuàngtài) * **Message:** 消息 (xiāoxi) * **Connection:** 连接 (liánjiē) * **Data:** 数据 (shùjù) * **Request:** 请求 (qǐngqiú) * **Response:** 响应 (xiǎngyìng) * **Log:** 日志 (rìzhì) This improved version provides a much more robust and practical foundation for building an MCP server in Python. Remember to adapt it to your specific needs and security requirements.

MCP Notion Server

使用 Notion API 的 MCP 服务器

Dedalus MCP Documentation Server

Enables AI-powered querying and serving of markdown documentation with search, Q\&A capabilities, and document analysis. Built for the YC Agents Hackathon with OpenAI integration and rate limiting protection.

WYGIWYH Expense Tracking MCP Server

Enables AI agents to interact with the WYGIWYH expense tracking API through 75 dynamically generated MCP tools. Supports comprehensive financial operations including transaction management, account handling, recurring expenses, and investment tracking.

Aisera MCP Servers

用于存放 Aisera 公共 MCP 服务器的仓库

Nanoleaf MCP Server

A Model Context Protocol server that enables controlling Nanoleaf smart lights through Warp terminal or any MCP-compatible client, providing tools for device discovery, authorization, and control of lights, brightness, colors, and effects.

BullMQ MCP Server

Enables AI assistants to manage BullMQ Redis-based job queues through natural language, supporting operations like job monitoring, queue control, and multi-instance Redis connections. Users can add, retry, promote, and clean jobs while accessing detailed job logs and queue statistics directly within the assistant.

Swagger MCP

An MCP server that connects to a Swagger specification and helps an AI to build all the required models to generate a MCP server for that service.

MCP-RSS-Crawler

一个 MCP 服务器，用于获取 RSS 订阅源并将其分享给 LLM（大型语言模型），从而使 AI 助手能够访问和呈现来自已配置订阅源的最新新闻和文章。

JVLink MCP Server

Enables natural language queries and analysis of Japanese horse racing data from JRA-VAN without writing SQL. Supports analyzing race results, jockey performance, breeding trends, and track conditions through conversation with Claude.

MCP Server

An implementation of the Model Context Protocol (MCP) server that enables multiple clients to connect simultaneously and handles basic context management and messaging with an extendable architecture.