Discover Awesome MCP Servers

daily-dose

Provides persistent local memory of Claude Code sessions with TODO management and searchable activity logs via MCP tools.

omnisearch-mcp

Enables LLM agents to search academic literature across multiple sources (IEEE, arXiv, ACM, Semantic Scholar, CORE, Scite, Consensus) and index/search local PDFs.

NVM MCP Server

An MCP server that wraps NVM (Node Version Manager) to give Antigravity agents full control over Node.js versions without requiring Node or npm to be on the system PATH. It provides tools to install, switch between, and run commands with different Node versions directly within agent workflows.

Desktop Controller MCP Server

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

apple-calendar-jxa-mcp

Enables read/write access to Apple Calendar on macOS by bypassing permission restrictions via JXA scripts, allowing users to manage calendar events through natural language.

ShopGraph

Structured product data from the open web — where platform APIs don't reach. Schema.org + AI extraction. Pay per call via Stripe MPP.

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.

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.

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.

ya-tracker-mcp

MCP server for Yandex Tracker API that provides 146 tools for managing issues, projects, boards, sprints, worklog and more.

mcp-weather

A Model Context Protocol (MCP) server built with the mcp-framework to provide weather-related tools and data to AI clients. It enables integration of weather capabilities and custom tools into the MCP ecosystem for use with platforms like Claude Desktop.

mesie-career-engineering

MCP server providing 200 compressed engineering careers across software, systems, mechanical, civil, and DevOps, with tools for listing, searching, and retrieving career profiles.

mcp-agent-proxy

An MCP server that acts as a proxy to connect MCP clients to agent frameworks like Mastra and LangGraph, enabling agent discovery, dynamic server connections, and recursive agent networks.

EDC MCP Server

Enables AI assistants to interact with Eclipse Dataspace Components (EDC) connectors for dataspace operations including asset, policy, contract, catalog, negotiation, and data transfer management.

Slideshow Studio MCP

Replicate viral TikTok slideshows in your niche by talking to your agent. It generates images locally or via API and assembles the final result.

Weather & WordPress MCP Server

An integration tool that allows users to fetch weather alerts/forecasts from the National Weather Service API and retrieve latest posts from hafiz.blog through natural language interactions with Claude.

rigol-dg900-mcp

MCP server that lets an AI assistant drive a RIGOL DG800 Pro / DG900 Pro arbitrary waveform generator over LAN (raw SCPI on TCP 5555), with tools for setting waveforms, output loads, and reading status.

MusicBrainz MCP Server

Enables AI assistants to query the MusicBrainz music database for artists, albums, recordings, and labels. It provides tools for advanced searches, detailed metadata retrieval, and accessing cover art information.

openclaw-mcp-bridge

A smart bridge that aggregates multiple MCP servers under a single interface, providing relevance filtering and optional caching for efficient tool selection and execution.

limited-github-cli-mcp

Servidor MCP para la CLI de Github

kali-tools-mcp

Exposes a hardened Docker container with Kali Linux security tools (nmap, sqlmap, dig, whois, etc.) as MCP tools, enabling network reconnaissance, web analysis, and vulnerability scanning through natural language commands.