Discover Awesome MCP Servers

Multi-AI MCP Server for Claude Code

Connects Claude Code with multiple AI models (Gemini, Grok-3, ChatGPT, DeepSeek) simultaneously, allowing users to get diverse AI perspectives, conduct AI debates, and leverage each model's unique strengths.

Law Office SQLite MCP Server

A Model Context Protocol server for law office database management that enables tracking clients, cases, billable time, and invoices.

Gemini Function Calling + Model Context Protocol(MCP) Flight Search

使用 Gemini 2.5 Pro 的模型上下文协议 (MCP)。使用 Gemini 的函数调用功能和 MCP 的航班搜索工具将对话式查询转换为航班搜索。

MCP-Typebot

Powerful Model Context Protocol server for managing Typebot chatbots, enabling operations like authentication, creating, updating, listing, and publishing bots through a standardized JSON interface.

Snowflake MCP Server

Enables AI assistants to securely connect to Snowflake data warehouses and execute SQL queries through natural language interactions. Supports multiple authentication methods and provides formatted query results with built-in security controls.

PuppeteerMCP Server

An MCP server that enables AI assistants to capture and analyze web page screenshots using Puppeteer, supporting multi-breakpoint captures, error reporting, and page interactions.

Procesio MCP Server

用于与 Procesio API 交互的 MCP 服务器

llm-mcp-server-template

LLM-MCP 服务器的模板项目

MCP Content Analyzer

Enables comprehensive content analysis through web scraping, document processing (PDF, DOCX, TXT, RTF), screenshot analysis, and local Excel database management. Provides intelligent workflows for extracting, analyzing, and storing content from multiple sources with automated categorization and search capabilities.

Database Query MCP Server

Enables secure read-only querying of multiple database types (MySQL, PostgreSQL, MSSQL, Oracle) through natural language. Automatically reads database configuration from project files and blocks any data modification operations for safety.

Godot Docs MCP

Enables AI agents to search and retrieve information from the official Godot game engine documentation. Provides tools to search documentation, get page content, and access detailed class information.

Outlook Meetings Scheduler MCP Server

Allows scheduling meetings in Microsoft Outlook using Microsoft Graph API, with features for creating calendar events and adding attendees by finding their email addresses.

Smartlead Simplified MCP Server

A Multi-Channel Proxy server that provides a structured interface for interacting with Smartlead's API, organizing functionality into logical tools for campaign management, lead management, and other marketing automation features.

Spotify Playlist MCP Server

Enables creating and managing Spotify playlists using natural language with advanced similarity matching across 8 different algorithms. Supports finding similar tracks based on audio features, mood, energy, genre, and custom weighted parameters to build personalized playlists automatically.

Minecraft RCON MCP Server

一个微型的 Minecraft MCP 服务器，使用 RCON 接口。

only_mcp

一个简单的原型 MCP v0.2 客户端和服务器实现

Email MCP Server

Enables Claude Desktop to send emails through Mailjet's API using the Model Context Protocol over Server-Sent Events. Provides secure email sending capabilities with API token authentication and user-provided credentials.

Stock MCP Server

一个使用模型上下文协议 (MCP) 的实时股票报价 MCP 服务器。

Pydantic MCP Agent with Chainlit

这个仓库利用 MCP 服务器来无缝集成多个代理工具。

Claude-to-Gemini MCP Server

Enables Claude to use Google Gemini as a secondary AI through MCP for large-scale codebase analysis and complex reasoning tasks. Supports both Gemini Flash and Pro models with specialized functions for general queries and comprehensive code analysis.

example-mcp-server-streamable-http

example-mcp-server-streamable-http

A Simple MCP Server and Client

Okay, here's a simple example of an MCP (Minecraft Communications Protocol) client and server in Python. This is a very basic example and doesn't implement the full MCP protocol, but it demonstrates the core concepts of sending and receiving data. **Important Considerations:** * **Security:** This example is *not* secure. It doesn't include any encryption or authentication. Do not use this in a production environment. * **Error Handling:** The error handling is minimal. A real-world implementation would need much more robust error handling. * **MCP Complexity:** The actual MCP protocol used by Minecraft is significantly more complex than this example. This is a simplified illustration. * **Python:** This example uses Python 3. **Server (server.py):** ```python import socket HOST = '127.0.0.1' # Standard loopback interface address (localhost) PORT = 25565 # Port to listen on (non-privileged ports are > 1023) def handle_client(conn, addr): print(f"Connected by {addr}") while True: try: data = conn.recv(1024) # Receive up to 1024 bytes if not data: break # Client disconnected decoded_data = data.decode('utf-8') print(f"Received from {addr}: {decoded_data}") # Echo the data back to the client (in uppercase) response = decoded_data.upper().encode('utf-8') conn.sendall(response) except ConnectionResetError: print(f"Client {addr} forcibly disconnected.") break except Exception as e: print(f"Error handling client {addr}: {e}") break conn.close() print(f"Connection with {addr} closed.") def main(): with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) s.listen() print(f"Server listening on {HOST}:{PORT}") while True: conn, addr = s.accept() handle_client(conn, addr) # Handle each client in the main thread (for simplicity) if __name__ == "__main__": main() ``` **Client (client.py):** ```python import socket HOST = '127.0.0.1' # The server's hostname or IP address PORT = 25565 # The port used by the server def main(): with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: try: s.connect((HOST, PORT)) print(f"Connected to {HOST}:{PORT}") message = "Hello, MCP Server!" s.sendall(message.encode('utf-8')) data = s.recv(1024) print(f"Received: {data.decode('utf-8')}") except ConnectionRefusedError: print("Connection refused. Is the server running?") except Exception as e: print(f"An error occurred: {e}") print("Client finished.") if __name__ == "__main__": main() ``` **How to Run:** 1. **Save:** Save the server code as `server.py` and the client code as `client.py`. 2. **Run the Server:** Open a terminal or command prompt and navigate to the directory where you saved the files. Run the server: ```bash python server.py ``` 3. **Run the Client:** Open another terminal or command prompt (in the same directory) and run the client: ```bash python client.py ``` **Explanation:** * **`socket` Module:** The `socket` module is Python's standard library for network communication. * **Server:** * Creates a socket, binds it to an address (IP and port), and listens for incoming connections. * `s.accept()`: Accepts a connection, creating a new socket (`conn`) for communication with that specific client. * `conn.recv(1024)`: Receives data from the client (up to 1024 bytes at a time). * `conn.sendall(response)`: Sends data back to the client. * `conn.close()`: Closes the connection with the client. * **Client:** * Creates a socket and connects to the server's address. * `s.sendall(message.encode('utf-8'))`: Sends a message to the server. The message is encoded into bytes using UTF-8. * `s.recv(1024)`: Receives data from the server. * `data.decode('utf-8')`: Decodes the received bytes back into a string. * `s.close()`: Closes the connection. * **Encoding/Decoding:** Data sent over a socket must be in bytes. The `.encode('utf-8')` method converts a string to bytes using UTF-8 encoding. The `.decode('utf-8')` method converts bytes back to a string. * **`with socket.socket(...) as s:`:** This uses a context manager to ensure that the socket is properly closed when the `with` block exits, even if errors occur. **What you'll see:** * **Server Output:** The server will print "Server listening..." and then, when the client connects, it will print "Connected by..." and the client's address. It will then print the message received from the client and the address of the client. Finally, it will print "Connection with... closed." * **Client Output:** The client will print "Connected to..." and then "Received:..." followed by the uppercase version of the message it sent. Finally, it will print "Client finished." **To make it more like MCP (but still simplified):** 1. **Data Structures:** Instead of just sending strings, you'd need to define data structures (e.g., using `struct` module in Python) to represent the different types of packets that MCP uses. 2. **Packet IDs:** Each packet type has an ID. The client and server need to agree on these IDs. 3. **Handshaking:** MCP has a handshake process where the client and server exchange information about the protocol version they are using. 4. **State Management:** The server needs to keep track of the client's state (e.g., whether the client is logged in, what world the client is in). 5. **Compression/Encryption:** MCP uses compression and encryption for performance and security. This example provides a basic foundation. Building a real MCP implementation is a complex task. --- **Chinese Translation (Simplified Chinese):** 这是一个简单的 MCP (Minecraft 通讯协议) 客户端和服务器的例子，使用 Python 编写。 这是一个非常基础的例子，并没有实现完整的 MCP 协议，但它演示了发送和接收数据的核心概念。 **重要注意事项：** * **安全性：** 这个例子 *不* 安全。 它不包含任何加密或身份验证。 请勿在生产环境中使用它。 * **错误处理：** 错误处理非常少。 实际应用需要更强大的错误处理。 * **MCP 复杂性：** Minecraft 实际使用的 MCP 协议比这个例子复杂得多。 这是一个简化的说明。 * **Python：** 这个例子使用 Python 3。 **服务器 (server.py):** ```python import socket HOST = '127.0.0.1' # 标准回环接口地址 (localhost) PORT = 25565 # 监听端口 (非特权端口 > 1023) def handle_client(conn, addr): print(f"Connected by {addr}") while True: try: data = conn.recv(1024) # 接收最多 1024 字节 if not data: break # 客户端断开连接 decoded_data = data.decode('utf-8') print(f"Received from {addr}: {decoded_data}") # 将数据回显给客户端 (转换为大写) response = decoded_data.upper().encode('utf-8') conn.sendall(response) except ConnectionResetError: print(f"Client {addr} forcibly disconnected.") break except Exception as e: print(f"Error handling client {addr}: {e}") break conn.close() print(f"Connection with {addr} closed.") def main(): with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) s.listen() print(f"Server listening on {HOST}:{PORT}") while True: conn, addr = s.accept() handle_client(conn, addr) # 在主线程中处理每个客户端 (为了简单起见) if __name__ == "__main__": main() ``` **客户端 (client.py):** ```python import socket HOST = '127.0.0.1' # 服务器的主机名或 IP 地址 PORT = 25565 # 服务器使用的端口 def main(): with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: try: s.connect((HOST, PORT)) print(f"Connected to {HOST}:{PORT}") message = "Hello, MCP Server!" s.sendall(message.encode('utf-8')) data = s.recv(1024) print(f"Received: {data.decode('utf-8')}") except ConnectionRefusedError: print("Connection refused. Is the server running?") except Exception as e: print(f"An error occurred: {e}") print("Client finished.") if __name__ == "__main__": main() ``` **如何运行：** 1. **保存：** 将服务器代码保存为 `server.py`，将客户端代码保存为 `client.py`。 2. **运行服务器：** 打开终端或命令提示符，导航到保存文件的目录。 运行服务器： ```bash python server.py ``` 3. **运行客户端：** 打开另一个终端或命令提示符（在同一目录下），然后运行客户端： ```bash python client.py ``` **解释：** * **`socket` 模块：** `socket` 模块是 Python 的标准库，用于网络通信。 * **服务器：** * 创建一个套接字，将其绑定到地址（IP 和端口），并监听传入的连接。 * `s.accept()`：接受连接，创建一个新的套接字 (`conn`) 用于与该特定客户端通信。 * `conn.recv(1024)`：从客户端接收数据（一次最多 1024 字节）。 * `conn.sendall(response)`：将数据发送回客户端。 * `conn.close()`：关闭与客户端的连接。 * **客户端：** * 创建一个套接字并连接到服务器的地址。 * `s.sendall(message.encode('utf-8'))`：向服务器发送消息。 该消息使用 UTF-8 编码转换为字节。 * `s.recv(1024)`：从服务器接收数据。 * `data.decode('utf-8')`：将接收到的字节解码回字符串。 * `s.close()`：关闭连接。 * **编码/解码：** 通过套接字发送的数据必须是字节。 `.encode('utf-8')` 方法使用 UTF-8 编码将字符串转换为字节。 `.decode('utf-8')` 方法将字节转换回字符串。 * **`with socket.socket(...) as s:`：** 这使用上下文管理器来确保在 `with` 块退出时正确关闭套接字，即使发生错误也是如此。 **你会看到什么：** * **服务器输出：** 服务器将打印 "Server listening..."，然后，当客户端连接时，它将打印 "Connected by..." 和客户端的地址。 然后它将打印从客户端收到的消息和客户端的地址。 最后，它将打印 "Connection with... closed." * **客户端输出：** 客户端将打印 "Connected to..."，然后打印 "Received:..."，后跟它发送的消息的大写版本。 最后，它将打印 "Client finished." **为了使其更像 MCP（但仍然简化）：** 1. **数据结构：** 不是只发送字符串，你需要定义数据结构（例如，使用 Python 中的 `struct` 模块）来表示 MCP 使用的不同类型的包。 2. **数据包 ID：** 每种数据包类型都有一个 ID。 客户端和服务器需要就这些 ID 达成一致。 3. **握手：** MCP 有一个握手过程，客户端和服务器交换有关他们正在使用的协议版本的信息。 4. **状态管理：** 服务器需要跟踪客户端的状态（例如，客户端是否已登录，客户端位于哪个世界）。 5. **压缩/加密：** MCP 使用压缩和加密来提高性能和安全性。 这个例子提供了一个基本的基础。 构建真正的 MCP 实现是一项复杂的任务。

Jokes MCP Server

An MCP server that retrieves jokes from three different sources: Chuck Norris jokes, Dad jokes, and Yo Mama jokes.

File System MCP Server

镜子 (jìng zi)

crawl4ai-mcp

一个用于网页抓取和爬行的 MCP 服务器，使用 Crawl4AI 构建。 (Yī gè yòng yú wǎngyè zhuāqǔ hé páxíng de MCP fúwùqì, shǐyòng Crawl4AI gòujiàn.)

AWS SecurityHub MCP Server

This server implements the Multi-Agent Conversation Protocol for AWS SecurityHub, enabling interaction with AWS SecurityHub API through natural language commands.

MCP-RAG

An MCP-compatible system that handles large files (up to 200MB) with intelligent chunking and multi-format document support for advanced retrieval-augmented generation.