Discover Awesome MCP Servers

Splitwise MCP Server

A server that wraps the Splitwise API so Claude can read and manage expenses, including listing, creating, updating, and deleting expenses with support for equal and custom splits.

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.

django-rest-framework-mcp

Exposes Django REST Framework APIs as MCP tools, enabling natural language interactions with your data models such as CRUD operations and custom actions, with automatic schema generation from DRF serializers.

TorchV AIS MCP Server

Enables read, write, edit, and file transfer operations on TorchV AIS enterprise knowledge bases. Supports document management, repository browsing, and administrative tasks with configurable readonly, write, or admin permission levels.

Umbra

Umbra is the trust layer for AI-generated code. It scores any repo 0-100 with file:line evidence (security, slop, Docker-verified build/boot, and claim receipts that catch agents lying about tests), and guards agent file writes mid-stream blocking leaked keys, alg:none JWTs, and git-hook plants before they land. Tools: scan_repo, guard_content, get_score.

Velociraptor MCP

A proof-of-concept MCP bridge that exposes Velociraptor's forensic triage tools to LLMs, enabling natural language querying of Windows endpoints for artifacts like network connections and suspicious processes.

corrupt-cli

Generates production-ready, white-labeled web architectures (Next.js + Supabase or static) from vertical packs and blueprints. Enables AI agents to scaffold inventory sites, SaaS platforms, and custom verticals, including Supabase provisioning, edge functions, and deployment.

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.

Local Documents MCP Server

A Model Context Protocol server that allows AI assistants to discover, load, and process local documents on Windows systems, with support for multiple file formats and OCR capabilities for scanned PDFs.

knowledge-index

A private, self-hosted RAG service over MCP that enables document ingestion, hybrid retrieval (BM25 + dense vectors fused with RRF), and notebook management through 14 tools, keeping documents on your own hardware.

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.

OpenStack MCP Server

Un servicio ligero y extensible que permite a los asistentes de IA ejecutar de forma segura comandos de la CLI de OpenStack a través del Protocolo de Contexto del Modelo (MCP).

Mobile E2E MCP

AI-safe mobile device control via MCP: a policy-guarded, session-oriented mobile automation harness for AI agents with 66 MCP tools and an Explorer for automatic page traversal.

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.

Crownpeak DQM MCP Server

Enables quality checking and content management for websites through the Crownpeak DQM CMS REST API. Supports running quality checks, spellchecking, asset management, and checkpoint monitoring with both desktop and cloud deployment options.

daily-dose

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

Strapi MCP Server

Espejo de

agent-env-mcp

Provides a restricted Docker-based sandbox for LLM agents, enabling file operations, command execution, and local Git within an isolated runtime.

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.

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.

MCP Architect

Provides comprehensive architectural expertise through specialized agents, resources, and tools for generating, evaluating, and modifying architectural designs.

Unofficial Clinical Trials MCP Server

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

MCP cldkctl Server

A Model Context Protocol server that provides access to Cloudeka's cldkctl CLI functionality through Claude Desktop, Cursor, and other MCP-compatible clients.