Discover Awesome MCP Servers

Claude Auto-Approve MCP

Automatically approves or blocks specified MCP tool calls in Claude Desktop by injecting JavaScript that restores granular per-chat approval control. Provides configurable permanent approvals while maintaining security through per-server tool whitelists and blacklists.

n8n MCP Server

Enables ChatGPT to manage n8n workflows through the official REST API. Supports creating, updating, deleting, and running workflows with execution status monitoring.

MCP Calculator

A modular calculator server built with the MCP SDK that provides basic arithmetic operations (addition, subtraction, multiplication, division) with Chinese language support. Features include calculation history tracking, configuration resources, and decimal calculation prompts with comprehensive error handling.

mcp-sketch

Local MCP server for parsing Sketch exported HTML zip archives and extracting design structure information.

WHOIS MCP Server

A Python-based server that provides tools for querying domain WHOIS information through the Chinaz API. It enables Claude and other MCP clients to retrieve domain registration details using standardized tools.

PostgreSQL MCP Server

Enables users to perform SQL query execution, schema exploration, and performance analysis on PostgreSQL databases through any MCP-compatible client. It prioritizes security with read-only protection by default and provides guided workflows for database documentation and optimization.

kernel-build-mcp

An MCP server designed for remote Linux kernel cross-compilation over Tailscale SSH. It enables users to manage configurations, execute kernel builds, and retrieve build artifacts directly through an MCP-compatible interface.

Smart Connections MCP Server

Enables semantic search and knowledge graph exploration of Obsidian vaults using Smart Connections embeddings. Provides intelligent note discovery, similarity search, and connection mapping through natural language queries.

Document360 MCP Server

Enables access to Document360 knowledge base content through simple GET operations. Allows searching, browsing categories, and reading articles from Document360 projects using natural language.

EvalView

MCP server that lets coding agents test AI agents. Create YAML test cases, snapshot golden baselines, check for regressions, and generate visual reports all from inside Claude Code or any MCP-compatible tool. Works with LangGraph, CrewAI, OpenAI, Claude, Mistral, and any HTTP API.

Jokes MCP Server

An MCP server that enables Microsoft Copilot Studio to fetch jokes from multiple sources including Chuck Norris jokes, Dad jokes, and Yo Mama jokes.

Beelzebub MCP Honeypot

Description: Introduce Beelzebub, an MCP‑based honeypot framework that enables creating decoy tools to detect prompt injection and malicious agent behavior. Motivation: Strengthen the security of LLM workflows by adding a non‑intrusive detection mechanism.

EdgeOne Geo MCP Server

Enables AI models to access user geolocation information through EdgeOne Pages Functions, allowing location-aware AI interactions.

Cloudflare Playwright MCP

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

Typefully MCP Server

A Model Context Protocol server that enables AI assistants to create and manage Twitter drafts on Typefully, supporting features like thread creation, scheduling, and retrieving published content.

MCP Basics

A centralized Model Context Protocol server that provides common development tools (like formatting and translation) across all your Cline projects without needing to install them individually.

Vimango MCP Server

Enables Claude to create and organize markdown research notes directly in your local vimango SQLite databases, with support for contexts, folders, and automatic synchronization.

API Wrapper MCP Server

Okay, I understand you want to create an MCP (presumably meaning "Minimal Communication Protocol") server that can handle requests for *any* API. This is a very broad request, as the implementation details will heavily depend on the specific API you want to support. However, I can provide a conceptual outline and a basic Python example to illustrate the core principles. **Conceptual Outline** 1. **API Definition:** The most crucial step. You *must* have a clear definition of the API you want to support. This includes: * **Endpoints:** The URLs or routes that the API exposes (e.g., `/users`, `/products/{id}`). * **HTTP Methods:** The HTTP methods used for each endpoint (e.g., GET, POST, PUT, DELETE). * **Request Parameters:** The data that needs to be sent in the request (e.g., query parameters, request body). Specify data types and validation rules. * **Request Body Format:** If the API uses request bodies (e.g., for POST or PUT requests), define the format (e.g., JSON, XML, form data). * **Response Format:** The format of the data returned by the API (e.g., JSON, XML). Define the structure and data types. * **Error Handling:** How errors are reported (e.g., HTTP status codes, error messages in the response body). 2. **MCP Protocol Definition:** Define your "Minimal Communication Protocol." This is how your clients will communicate with your server. Consider these aspects: * **Message Format:** How will the client send the API request information to the server? A simple text-based format might be suitable for a minimal protocol. For example: ``` METHOD:GET ENDPOINT:/users HEADER:Authorization: Bearer <token> ``` Or, you could use a more structured format like JSON: ```json { "method": "GET", "endpoint": "/users", "headers": {"Authorization": "Bearer <token>"}, "body": null } ``` * **Response Format:** How will the server send the API response back to the client? Again, a simple text-based format or JSON could be used. * **Error Handling:** How will the server indicate errors to the client? 3. **Server Implementation:** * **Socket Listener:** The server needs to listen on a specific port for incoming client connections. * **Message Parsing:** The server needs to parse the incoming MCP message to extract the API request details (method, endpoint, headers, body). * **API Request Handling:** Based on the parsed request, the server needs to: * Construct the appropriate API request. * Send the request to the actual API endpoint. * Receive the API response. * **Response Formatting:** The server needs to format the API response into the MCP response format and send it back to the client. * **Error Handling:** The server needs to handle errors that occur during any of these steps and send appropriate error responses to the client. **Python Example (Illustrative)** This is a very basic example using Python's `socket` library. It assumes a simple text-based MCP protocol. **This is not production-ready code.** It lacks proper error handling, security, and scalability. ```python import socket import requests import json # Configuration HOST = '127.0.0.1' # Standard loopback interface address (localhost) PORT = 65432 # Port to listen on (non-privileged ports are > 1023) API_BASE_URL = "https://jsonplaceholder.typicode.com" # Example API def handle_client(conn, addr): print(f"Connected by {addr}") while True: data = conn.recv(1024) # Receive up to 1024 bytes if not data: break try: # Decode the received data (assuming UTF-8 encoding) request_str = data.decode('utf-8') # Parse the request (very basic parsing) lines = request_str.strip().split('\n') method = lines[0].split(':')[1].strip() endpoint = lines[1].split(':')[1].strip() headers = {} for line in lines[2:]: if line.startswith("HEADER:"): header_parts = line[7:].split(':') if len(header_parts) == 2: headers[header_parts[0].strip()] = header_parts[1].strip() # Construct the API URL api_url = API_BASE_URL + endpoint # Make the API request try: response = requests.request(method, api_url, headers=headers) response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx) api_response_data = response.json() # Assuming JSON response # Format the API response into MCP response (JSON) mcp_response = json.dumps(api_response_data) conn.sendall(mcp_response.encode('utf-8')) except requests.exceptions.RequestException as e: error_message = f"API Request Error: {str(e)}" conn.sendall(error_message.encode('utf-8')) print(error_message) except Exception as e: error_message = f"Error processing request: {str(e)}" conn.sendall(error_message.encode('utf-8')) print(error_message) conn.close() print(f"Connection closed with {addr}") def main(): with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) s.listen() print(f"Listening on {HOST}:{PORT}") while True: conn, addr = s.accept() handle_client(conn, addr) if __name__ == "__main__": main() ``` **Explanation:** * **`handle_client(conn, addr)`:** This function handles the communication with a single client. * **`conn.recv(1024)`:** Receives data from the client. * **Request Parsing:** The code parses the incoming data, assuming a simple text-based format. It extracts the method, endpoint, and headers. **This is very basic and needs to be improved for real-world use.** * **`requests.request(method, api_url, headers=headers)`:** Uses the `requests` library to make the actual API request. * **Response Formatting:** The API response (assumed to be JSON) is formatted into a JSON string and sent back to the client. * **Error Handling:** Basic error handling is included, but it's not comprehensive. * **`main()`:** Sets up the socket listener and accepts incoming connections. **To run this example:** 1. **Save:** Save the code as a Python file (e.g., `mcp_server.py`). 2. **Install `requests`:** `pip install requests` 3. **Run:** `python mcp_server.py` **Example Client (Python):** ```python import socket HOST = '127.0.0.1' PORT = 65432 with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.connect((HOST, PORT)) request = f"METHOD:GET\nENDPOINT:/todos/1\nHEADER:Content-Type: application/json" s.sendall(request.encode('utf-8')) data = s.recv(1024) print('Received:', data.decode('utf-8')) ``` **Important Considerations:** * **Security:** This example is *not* secure. You need to implement proper authentication, authorization, and input validation to protect your server. Consider using HTTPS for secure communication. * **Error Handling:** The error handling is very basic. You need to handle different types of errors gracefully and provide informative error messages to the client. * **Scalability:** This example is not scalable. For production use, you'll need to use a more robust server architecture (e.g., using a framework like Flask or Django, and a multi-threaded or asynchronous approach). * **Data Validation:** Validate all incoming data to prevent injection attacks and other security vulnerabilities. * **API Rate Limiting:** Implement rate limiting to prevent abuse of your server. * **Logging:** Implement logging to track requests and errors. * **Configuration:** Use a configuration file to store settings like the API base URL, port number, and other parameters. * **Protocol Design:** Carefully design your MCP protocol to be efficient and easy to parse. Consider using a binary protocol for better performance. * **Asynchronous I/O:** For handling many concurrent connections, consider using asynchronous I/O (e.g., with `asyncio` in Python). **In summary, creating a generic MCP server for any API is a complex task. You need to carefully define your MCP protocol, handle API requests and responses, and implement proper error handling, security, and scalability. The example above provides a basic starting point, but it needs to be significantly improved for real-world use.** **中文翻译：** 好的，我理解您想要创建一个 MCP（大概意思是“最小通信协议”）服务器，它可以处理任何 API 的请求。 这是一个非常广泛的要求，因为实现细节将很大程度上取决于您想要支持的特定 API。 但是，我可以提供一个概念性的概述和一个基本的 Python 示例来说明核心原则。 **概念性概述** 1. **API 定义：** 最关键的一步。 您*必须*清楚地定义您想要支持的 API。 这包括： * **端点：** API 公开的 URL 或路由（例如，`/users`，`/products/{id}`）。 * **HTTP 方法：** 每个端点使用的 HTTP 方法（例如，GET，POST，PUT，DELETE）。 * **请求参数：** 需要在请求中发送的数据（例如，查询参数，请求体）。 指定数据类型和验证规则。 * **请求体格式：** 如果 API 使用请求体（例如，对于 POST 或 PUT 请求），请定义格式（例如，JSON，XML，表单数据）。 * **响应格式：** API 返回的数据的格式（例如，JSON，XML）。 定义结构和数据类型。 * **错误处理：** 如何报告错误（例如，HTTP 状态代码，响应体中的错误消息）。 2. **MCP 协议定义：** 定义您的“最小通信协议”。 这是您的客户端将如何与您的服务器通信。 考虑以下几个方面： * **消息格式：** 客户端将如何将 API 请求信息发送到服务器？ 简单的基于文本的格式可能适合于最小协议。 例如： ``` METHOD:GET ENDPOINT:/users HEADER:Authorization: Bearer <token> ``` 或者，您可以使用更结构化的格式，例如 JSON： ```json { "method": "GET", "endpoint": "/users", "headers": {"Authorization": "Bearer <token>"}, "body": null } ``` * **响应格式：** 服务器将如何将 API 响应发送回客户端？ 同样，可以使用简单的基于文本的格式或 JSON。 * **错误处理：** 服务器将如何向客户端指示错误？ 3. **服务器实现：** * **套接字监听器：** 服务器需要监听特定端口上的传入客户端连接。 * **消息解析：** 服务器需要解析传入的 MCP 消息以提取 API 请求详细信息（方法，端点，标头，正文）。 * **API 请求处理：** 根据解析的请求，服务器需要： * 构造适当的 API 请求。 * 将请求发送到实际的 API 端点。 * 接收 API 响应。 * **响应格式化：** 服务器需要将 API 响应格式化为 MCP 响应格式，然后将其发送回客户端。 * **错误处理：** 服务器需要处理在任何这些步骤中发生的错误，并将适当的错误响应发送给客户端。 **Python 示例（说明性）** 这是一个使用 Python 的 `socket` 库的非常基本的示例。 它假定一个简单的基于文本的 MCP 协议。 **这不是生产就绪的代码。** 它缺乏适当的错误处理，安全性和可伸缩性。 ```python import socket import requests import json # 配置 HOST = '127.0.0.1' # 标准环回接口地址（localhost） PORT = 65432 # 监听端口（非特权端口 > 1023） API_BASE_URL = "https://jsonplaceholder.typicode.com" # 示例 API def handle_client(conn, addr): print(f"Connected by {addr}") while True: data = conn.recv(1024) # 接收最多 1024 字节 if not data: break try: # 解码接收到的数据（假设 UTF-8 编码） request_str = data.decode('utf-8') # 解析请求（非常基本的解析） lines = request_str.strip().split('\n') method = lines[0].split(':')[1].strip() endpoint = lines[1].split(':')[1].strip() headers = {} for line in lines[2:]: if line.startswith("HEADER:"): header_parts = line[7:].split(':') if len(header_parts) == 2: headers[header_parts[0].strip()] = header_parts[1].strip() # 构造 API URL api_url = API_BASE_URL + endpoint # 发出 API 请求 try: response = requests.request(method, api_url, headers=headers) response.raise_for_status() # 为错误的响应（4xx 或 5xx）引发 HTTPError api_response_data = response.json() # 假设 JSON 响应 # 将 API 响应格式化为 MCP 响应（JSON） mcp_response = json.dumps(api_response_data) conn.sendall(mcp_response.encode('utf-8')) except requests.exceptions.RequestException as e: error_message = f"API 请求错误：{str(e)}" conn.sendall(error_message.encode('utf-8')) print(error_message) except Exception as e: error_message = f"处理请求时出错：{str(e)}" conn.sendall(error_message.encode('utf-8')) print(error_message) conn.close() print(f"与 {addr} 的连接已关闭") def main(): with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) s.listen() print(f"监听 {HOST}:{PORT}") while True: conn, addr = s.accept() handle_client(conn, addr) if __name__ == "__main__": main() ``` **说明：** * **`handle_client(conn, addr)`：** 此函数处理与单个客户端的通信。 * **`conn.recv(1024)`：** 接收来自客户端的数据。 * **请求解析：** 代码解析传入的数据，假设为简单的基于文本的格式。 它提取方法，端点和标头。 **这非常基本，需要改进以用于实际应用。** * **`requests.request(method, api_url, headers=headers)`：** 使用 `requests` 库发出实际的 API 请求。 * **响应格式化：** API 响应（假定为 JSON）被格式化为 JSON 字符串并发送回客户端。 * **错误处理：** 包含基本的错误处理，但并不全面。 * **`main()`：** 设置套接字监听器并接受传入的连接。 **要运行此示例：** 1. **保存：** 将代码另存为 Python 文件（例如，`mcp_server.py`）。 2. **安装 `requests`：** `pip install requests` 3. **运行：** `python mcp_server.py` **示例客户端 (Python):** ```python import socket HOST = '127.0.0.1' PORT = 65432 with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.connect((HOST, PORT)) request = f"METHOD:GET\nENDPOINT:/todos/1\nHEADER:Content-Type: application/json" s.sendall(request.encode('utf-8')) data = s.recv(1024) print('Received:', data.decode('utf-8')) ``` **重要注意事项：** * **安全性：** 此示例*不*安全。 您需要实施适当的身份验证，授权和输入验证来保护您的服务器。 考虑使用 HTTPS 进行安全通信。 * **错误处理：** 错误处理非常基本。 您需要优雅地处理不同类型的错误，并向客户端提供有用的错误消息。 * **可伸缩性：** 此示例不可伸缩。 对于生产用途，您需要使用更强大的服务器架构（例如，使用 Flask 或 Django 之类的框架，以及多线程或异步方法）。 * **数据验证：** 验证所有传入数据，以防止注入攻击和其他安全漏洞。 * **API 速率限制：** 实施速率限制以防止滥用您的服务器。 * **日志记录：** 实施日志记录以跟踪请求和错误。 * **配置：** 使用配置文件来存储诸如 API 基本 URL，端口号和其他参数之类的设置。 * **协议设计：** 仔细设计您的 MCP 协议，使其高效且易于解析。 考虑使用二进制协议以获得更好的性能。 * **异步 I/O：** 为了处理许多并发连接，请考虑使用异步 I/O（例如，在 Python 中使用 `asyncio`）。 **总而言之，为任何 API 创建通用 MCP 服务器是一项复杂的任务。 您需要仔细定义您的 MCP 协议，处理 API 请求和响应，并实施适当的错误处理，安全性和可伸缩性。 上面的示例提供了一个基本的起点，但是需要对其进行重大改进才能用于实际应用。**

Console MCP Server

Captures and stores console output from any process in SQLite with full-text search, enabling AI assistants to search logs, monitor errors, and analyze multi-process activity through natural language queries.

Name.com MCP Server

Enables management of domains and DNS records through the Name.com REST API. Users can search for available domains, check bulk availability, and configure DNS records or nameservers using natural language.

syplugin-anMCPServer

A Model Context Protocol server plugin for SiYuan note-taking application that enables searching documents, retrieving content, and writing to notes through an HTTP-based interface.

CodeLogic

与 CodeLogic 互动，这是一个软件智能平台，可以绘制复杂代码和数据架构依赖关系图，从而提高人工智能的准确性和洞察力。

AIO-Osint

All in one Osint tools

pyBittle MCP Server

A Python server that enables remote control of Bittle robots via Bluetooth using the Model Context Protocol (MCP), allowing users to programmatically send movement and pose commands.

OpenAI Tool Bridge

一个轻量级的桥梁，将 OpenAI 的内置工具（如网页搜索和代码解释器）封装为模型上下文协议 (Model Context Protocol, MCP) 服务器，从而使它们能够与 Claude 和其他兼容 MCP 的模型一起使用。

Running Formulas MCP Server

Provides comprehensive running performance calculations including VDOT, training paces, race time predictions, velocity markers, and heart rate zones using Jack Daniels, Greg McMillan, and Riegel methodologies.

ragmap

MapRag is a discovery + routing layer for retrieval. It indexes RAG-capable MCP servers, enriches them with structured metadata, and helps agents (and humans) quickly find the right retrieval server for a task under constraints like citations, freshness, privacy, domain, and latency. MapRag does not do RAG itself. It helps you choose the best RAG tool/server to do the retrieval.

Inbox MCP

Transform your inbox into an intelligent, LLM-powered assistant that manages, organizes, and streamlines email using conversational language. Compatible with Gmail, Outlook, iCloud, Yahoo, and IMAP services through Nylas v3 API.