Discover Awesome MCP Servers

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.

Procore MCP Server

MCP Server to communite with the Procore API

HTTP OAuth MCP Server

A reference implementation for creating an MCP server supporting Streamable HTTP & SSE Transports with OAuth authorization, allowing developers to build OAuth-authorized MCP servers with minimal configuration.

Debug MCP

A debugging gateway for distributed systems that provides 17 tools for interacting with AWS CloudWatch, Step Functions, LangSmith, and Jira. It enables efficient log analysis, workflow tracing, and ticket management while significantly reducing token usage through a single-interface discovery pattern.

ShopGraph

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

Unicode Puzzles MCP

Creates and manages encoded messages using zero-width characters and advanced Unicode steganography techniques, enabling quantum-themed puzzle generation with hidden secrets.

SearchAPI MCP Server

Model Context Protocol server that enables AI assistants like Claude to access searchapi.io API for searching Google Maps, flights, hotels, and other web information.

Kali Pentest MCP Server

Provides secure access to Kali Linux penetration testing tools including nmap, nikto, dirb, wpscan, and sqlmap for educational vulnerability assessment on whitelisted targets. Runs in a controlled Docker environment and includes reconnaissance capabilities for authorized security testing.

Indian Railways MCP Server

El servidor MCP de los Ferrocarriles Indios proporciona información en vivo sobre el estado de las estaciones y los trenes utilizando el Protocolo de Contexto de Modelo (MCP). Este servidor está diseñado para gestionar las solicitudes de datos en vivo de los Ferrocarriles Indios.

MCP LaTeX Server

Enables AI assistants to create, edit, and validate LaTeX documents through a standardized protocol with support for multiple document classes and package management. It provides tools for document structure analysis and file organization to streamline the generation of professional academic papers.

PubChem MCP Server

Provides access to over 110 million chemical compounds with tools for chemical search, structure analysis, property calculation, bioassay data retrieval, and safety information through the PubChem database.

Gmail MCP Server

Enables interaction with Gmail through the Gmail API with OAuth2 authentication. Supports reading, sending, searching emails, and managing read status through natural language.

Deno Sandbox MCP Server

Un servidor MCP que te permite ejecutar código TypeScript y JavaScript de forma segura en tu máquina local utilizando el sandbox de Deno®. Este servidor proporciona un entorno controlado para ejecutar código con controles de permisos explícitos. Este proyecto no está afiliado de ninguna manera con Deno Land LLC.

SecOps MCP

Provides access to 13+ penetration testing and security audit tools through a unified MCP interface. Enables security professionals to perform vulnerability scanning, web fuzzing, network reconnaissance, and other security assessments through containerized tools like Nuclei, Nmap, SQLMap, and FFUF.

Strava MCP Server

Connects Claude to your Strava account for analyzing training, predicting race times, and generating periodized training plans via natural language.

Lyngdorf MCP Server

Controls Lyngdorf Audio devices (TDAI, MP, CD series) via TCP with automatic device discovery, comprehensive audio controls including volume, source selection, RoomPerfect, and playback management with built-in safety features.

coinvoyage-paykit

Non-custodial multi-chain crypto payment gateway via CoinVoyage. 15 tools for creating PayOrders, managing webhooks, and cross-chain swaps. Supports BTC, SOL, ETH, Base, Arbitrum, Polygon, BSC, Sui, USDC/USDT.

ComfyUI MCP Server

A server that integrates ComfyUI with MCP, allowing users to generate images and download them through natural language interactions.

Meshimize

MCP server for the Meshimize agent communication platform: Q\&A groups, messaging and group discovery

Mcp Server Danchoicloud

Servidor MCP

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.

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.

SENTRA MCP

A minimal FastAPI-based MCP server that provides basic utility tools like ping and time functions. Designed for easy deployment with Docker support, authentication, and extensible architecture for future tool additions.

Claude Imagine

A visual UI builder that enables Claude to create and update web interfaces in real-time by sending HTML updates to a browser through an MCP server with WebSocket communication.

@squidlerio/mcp

An MCP proxy that connects AI clients to the remote Squidler MCP server while providing local Chrome session management for testing localhost URLs. It enables transparent tool forwarding and allows browser-based test cases to run through a local browser instead of cloud instances.

MCP Indexer

Enables semantic code search across multiple repositories using natural language queries. Provides intelligent code discovery, symbol lookups, and cross-repo dependency analysis for AI coding agents.