Discover Awesome MCP Servers

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.

gmail-mcp-server

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

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.

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.

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.

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.

amazon-scraper-api

Fetch live Amazon product data using Amazon Scraper API MCP server

FinOps Agentic Reconciliation MCP Server

This MCP server enables autonomous finance operations, providing tools to run 3-way matching audits, fetch unmatched invoices, trigger vendor holds, and retrieve vendor aging summaries. It integrates with an AI agent for policy-based discrepancy resolution and executive dashboards.

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.

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.

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.

AI Assistant MCP Server

MCP server providing tools to chat with an AI agent, fetch weather data, and monitor agent status via the Model Context Protocol.

Weixin MCP

Enables reading and extracting content from WeChat public account articles using browser automation, allowing AI models to analyze and summarize WeChat articles through natural language requests.

isu-moodle-mcp

Enables Claude to interact with Moodle via the official REST API for read-only tasks like listing courses, materials, assignments, submissions, and grades. Uses token-based authentication and emphasizes safe, no-write operations.

x402-mcp

A hybrid MCP server that integrates x402 payment protocol, providing tools to manage cryptocurrency payments and dynamically create HTTP endpoints protected by payments.

Seokh Unity Open MCP

An MCP server for Unity that provides 300 typed tools for editor automation, asset analysis, validation, and diagnostics, supporting live Editor, headless batch, and offline modes.

Chiro ERP - Issue Pipeline Orchestrator

Automates GitHub issue-to-PR workflows using specialized AI agents (analyst, architect, developer, tester, reviewer) that analyze requirements, design solutions, implement code, generate tests, and perform code reviews with HIPAA compliance checks.

API Creator MCP

Generates complete, production-ready REST, GraphQL, and microservice APIs with built-in security, validation, and deployment configurations.

Twitch MCP Server

Enables access to Twitch API data for retrieving channel statistics, viewership information, stream status, and discovering channels and game categories. Provides real-time Twitch data including follower counts, current viewer numbers, and search functionality through natural language interactions.