Discover Awesome MCP Servers

sonic-mcp

MCP server that connects Claude Code to Sonic Pi for AI-assisted beat making, enabling live code execution and pattern management.

filesystem-mcp

Enables AI assistants to read, write, and manage files on the local system with security features like path restrictions and optional read-only mode.

nexus-mcp

A TypeScript SDK for building MCP servers with HMAC authentication, manifest generation, and tool scaffolding.

docker-telethon-plus

Exposes a Telegram user account via MCP, enabling AI agents to send, read, and manage messages, chats, and media using full MTProto access through Telethon. It wraps Telethon behind a JSON HTTP API and MCP endpoint, allowing agents to interact with Telegram as the authenticated user.

mcp-home-server

Self-hostable MCP server that gives Claude tools to run shell scripts and read files on a home server, deployed via Multipass VM and Cloudflare Tunnel.

Webex MCP Server

A Model Context Protocol (MCP) server that provides AI assistants with comprehensive access to Cisco Webex messaging capabilities.

atelier-mcp

Post-generation quality gate MCP server that audits and fixes AI-generated code for UI/UX design compliance and backend architecture robustness via tools like critique_ui, critique_backend, and generate_fix.

amazon-scraper-api

Fetch live Amazon product data using Amazon Scraper API MCP server

Everything MCP Server

A remote MCP server that provides demo tools for echoing text, adding numbers, getting current time, and random facts. It uses Streamable HTTP transport and can be deployed to Render.com for connection to Claude via custom connectors.

tachikoma-game-design-mcp

A read-only MCP server that enables semantic search over a Chroma library of narrative and game design content, using multilingual embeddings (BAAI/bge-m3) and offering tools to query indexed books, retrieve page chunks, and list available titles.

Short Video MCP Server

A FastMCP-based service that extracts no-watermark links from 20+ video platforms (including TikTok, Kuaishou, etc.) and can convert video speech to text.

rag-mcp-azure

A lightweight RAG server deployed on Azure Container Apps that ingests PDFs, creates embeddings, and exposes a search_documents tool over MCP for retrieving relevant document chunks.

Magento Spec MCP

Provides AI agents with Magento 2.4.8-p5 / PHP 8.3 technical standards, patterns, and review checklists via MCP tools, enabling them to reference the single source of truth when working on Magento projects.

gmail-mcp-server

Enables reading, sending, searching, and managing Gmail through Claude using the official Google Gmail API.

posecode

MCP server for Posecode

LearnWorlds MCP

Enables AI assistants to manage a LearnWorlds school via the full public API, covering all 94 endpoints for courses, users, enrollments, payments, and more.

ardupilot-mavlink-mcp

Enables AI agents to interact with an ArduPilot vehicle in real-time via MAVLink, including reading state, inspecting and changing parameters, switching flight modes, diagnosing arming failures, and gated arming/disarming.

Workspace MCP

Secure local development platform that exposes controlled developer capabilities (FS, Git, search, command execution) to AI assistants via MCP with deny-by-default security and audit logging.

Hello MCP

Aquí tienes una implementación mínima de un servidor MCP en Python usando el SDK de MCP Python: ```python import asyncio import mcp async def handle_connection(reader, writer): """Handles a single client connection.""" try: while True: # Read a message from the client message = await mcp.read_message(reader) if message is None: # Connection closed by client break # Process the message (replace with your logic) print(f"Received: {message}") response = {"type": "ack", "request_id": message.get("request_id")} # Acknowledge the message # Send a response back to the client await mcp.write_message(writer, response) except Exception as e: print(f"Error handling connection: {e}") finally: writer.close() await writer.wait_closed() print("Connection closed.") async def main(): """Starts the MCP server.""" server = await asyncio.start_server( handle_connection, '127.0.0.1', 8888) # Listen on localhost:8888 addr = server.sockets[0].getsockname() print(f'Serving on {addr}') async with server: await server.serve_forever() if __name__ == "__main__": asyncio.run(main()) ``` **Explanation:** 1. **`import asyncio` and `import mcp`:** Imports the necessary libraries. `asyncio` is for asynchronous programming, and `mcp` is the MCP Python SDK. 2. **`handle_connection(reader, writer)`:** This coroutine handles a single client connection. - It takes `reader` and `writer` objects, which are used for reading from and writing to the client socket, respectively. - **`while True:`:** This loop continuously reads messages from the client. - **`message = await mcp.read_message(reader)`:** Uses the `mcp.read_message()` function from the SDK to read a complete MCP message from the `reader`. This function handles the framing and parsing of the MCP message. It returns `None` if the connection is closed. - **`if message is None: break`:** If `read_message` returns `None`, it means the client has closed the connection, so the loop breaks. - **`print(f"Received: {message}")`:** Prints the received message to the console (replace this with your actual message processing logic). - **`response = {"type": "ack", "request_id": message.get("request_id")}`:** Creates a simple acknowledgement (ACK) response. Crucially, it includes the `request_id` from the incoming message. This is important for clients to correlate responses with their requests. You'll likely want to customize this response based on the content of the incoming message. - **`await mcp.write_message(writer, response)`:** Uses the `mcp.write_message()` function from the SDK to write the response back to the client. This function handles the framing of the MCP message for transmission. - **`except Exception as e:`:** Catches any exceptions that occur during the connection handling and prints an error message. - **`finally:`:** Ensures that the writer is closed and the connection is cleaned up, even if an error occurs. 3. **`main()`:** This coroutine sets up and starts the MCP server. - **`server = await asyncio.start_server(handle_connection, '127.0.0.1', 8888)`:** Creates an asynchronous TCP server that listens on `127.0.0.1` (localhost) on port `8888`. The `handle_connection` coroutine is called for each new client connection. - **`addr = server.sockets[0].getsockname()`:** Gets the address that the server is listening on. - **`print(f'Serving on {addr}')`:** Prints the server address to the console. - **`async with server: await server.serve_forever()`:** Starts the server and keeps it running indefinitely, handling incoming connections. The `async with` statement ensures that the server is properly closed when the program exits. 4. **`if __name__ == "__main__": asyncio.run(main())`:** This is the standard way to run an `asyncio` program. It creates an event loop and runs the `main()` coroutine. **How to Run:** 1. **Install the MCP Python SDK:** ```bash pip install python-mcp ``` 2. **Save the code:** Save the code as a Python file (e.g., `mcp_server.py`). 3. **Run the server:** ```bash python mcp_server.py ``` The server will start and listen for connections on `127.0.0.1:8888`. **Key Improvements and Considerations:** * **Error Handling:** The `try...except...finally` block in `handle_connection` is crucial for robust error handling. It prevents the server from crashing if a client sends invalid data or disconnects unexpectedly. * **Asynchronous Programming:** The use of `asyncio` allows the server to handle multiple client connections concurrently without blocking. This is essential for scalability. * **MCP SDK:** The `mcp.read_message()` and `mcp.write_message()` functions from the MCP Python SDK handle the complexities of MCP message framing and parsing, making it much easier to work with MCP. * **Acknowledgement (ACK):** The server sends an ACK message back to the client. This is a basic form of confirmation that the message was received. In a real-world application, you would likely want to send more informative responses. * **`request_id`:** The inclusion of the `request_id` in the ACK message is *critical* for clients to match responses to their original requests, especially when dealing with asynchronous communication. * **Message Processing:** The `print(f"Received: {message}")` line is a placeholder for your actual message processing logic. You'll need to replace this with code that handles the specific types of messages that your server is designed to receive. * **Security:** This is a very basic example and does not include any security measures. In a production environment, you would need to implement appropriate authentication and authorization mechanisms. * **Logging:** Consider adding logging to your server to help with debugging and monitoring. * **Configuration:** You might want to make the server's address and port configurable via command-line arguments or a configuration file. * **Client Implementation:** You'll need a client implementation that uses the MCP Python SDK to connect to the server and send messages. A basic client example would look something like this: ```python import asyncio import mcp async def main(): reader, writer = await asyncio.open_connection('127.0.0.1', 8888) message = {"type": "hello", "data": "Hello from the client!", "request_id": "12345"} await mcp.write_message(writer, message) print(f"Sent: {message}") response = await mcp.read_message(reader) print(f"Received: {response}") writer.close() await writer.wait_closed() if __name__ == "__main__": asyncio.run(main()) ``` Remember to install the `python-mcp` package for the client as well. Run the server first, then run the client. This minimal implementation provides a solid foundation for building a more complex MCP server. Remember to adapt the message processing logic and response generation to meet the specific requirements of your application.

Hive Mind MCP Server

Automatically generates and maintains living documentation for codebases by creating hierarchical hivemind.md files and flowchart diagrams at every directory level, enabling AI navigation and real-time or retroactive documentation of code structure, requirements, and dependencies.

pymcp-sse: Python MCP over SSE Library

Librería asíncrona de Python para construir servidores y clientes del Protocolo de Contexto de Modelo (MCP) sobre HTTP/SSE, ideal para agentes de IA, integraciones de herramientas y ecosistemas de chatbots.

NotebookLM MCP Server

Enables automated interactions with Google's NotebookLM through browser automation. Supports persistent sessions, document uploads, notebook management, and streaming chat responses for AI-powered document analysis.

Assistente Empresarial MCP Server

Enables natural-language queries about sales and inventory from an Excel spreadsheet, plus web search and currency exchange rates via external APIs.

global-news-intelligence-mcp

MCP server that fetches, ranks, and summarizes global news from 28 RSS sources across 12 categories, exposing 16 tools for LLMs to query technology, AI, finance, politics, and more.

Fast Context MCP

Enables AI-driven semantic code search via natural language queries, integrating with MCP clients like Claude Desktop to retrieve relevant code context from any codebase.

Amazon India Product Research MCP

Enables beginner Amazon India sellers to research product opportunities, estimate demand, analyze competition, calculate profitability, find suppliers, mine reviews, research keywords, and generate listings through Claude Desktop.

mcp-guardian

Scans MCP tool descriptions for prompt injection attacks, including cross-tool instructions, privilege escalation, and data exfiltration patterns. It can be used as a CLI scanner or integrated as an MCP server itself.

Binance Futures MCP Server

Enables AI assistants like Claude to manage Binance USDⓈ-M Futures trading through 14 tools for orders, positions, account details, and risk settings.

Unofficial Clinical Trials MCP Server

Provides access to the ClinicalTrials.gov API, enabling search, analysis, and retrieval of clinical trial data through MCP tools.

Desktop Controller MCP Server

Give any AI full control of your desktop. Mouse, keyboard, screenshots — all through the Model Context Protocol.