Discover Awesome MCP Servers

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.

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.

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.

Webex MCP Server

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

limited-github-cli-mcp

Servidor MCP para la CLI de Github

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.

MCP Server for NASA API integration.

Servidor de demostración MCP

HoloViz MCP

A comprehensive MCP server that provides intelligent access to the HoloViz ecosystem, enabling AI assistants to help you build interactive dashboards and data visualizations with Panel, hvPlot, Lumen, Datashader, and your favorite Python libraries.

FastAPI MCP Production Kit

A local-first FastAPI and MCP safety kit for turning internal HTTP APIs into controlled MCP tools, with per-tool scopes, quotas, audit events, and default-deny web-access boundaries.

ya-tracker-mcp

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

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.

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.

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.

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.

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.

MCP Wolfram Alpha Server

The MCP server that uses Wolfram Alpha via API.

screen-mcp

An MCP server that gives a model eyes and hands on a Linux Wayland desktop, enabling screenshot capture, mouse/keyboard control, OCR, and icon detection via OmniParser.

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.

Sky Windows Remote Executor

Enables remote execution of commands, file operations, screenshots, and clipboard access on Windows machines through MCP tools.

cc-switch-websearch

Provides a web_search MCP tool for cc-switch, backed by a self-hosted SearXNG instance, enabling AI assistants like Claude Code to perform web searches without a premium API key.

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.

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.

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.

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.