Discover Awesome MCP Servers

searchAPI-mcp

A Model Context Protocol (MCP) based search API server that provides standardized access to Google Maps, Google Flights, Google Hotels and other services. This server enables AI assistants to access various search services through a unified interface.

MCP Dual-Cycle Reasoner

A Model Context Protocol server that empowers AI agents with metacognitive monitoring to detect reasoning loops and provide intelligent recovery using case-based reasoning and statistical analysis.

MCP Sandbox

Automatically converts JavaScript modules into MCP-compatible servers, making any JavaScript function accessible to AI systems through secure sandboxing with automatic type inference.

MLB V3 Scores MCP Server

An MCP Server that enables interaction with MLB scores and statistics via the SportsData.io MLB V3 Scores API, allowing users to access baseball data through natural language queries.

HubSpot MCP Server

Enables AI assistants to interact with HubSpot CRM for managing contacts, companies, deals, and sending emails through natural language commands.

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.

Date-time Tools MCP

Provides tools for date-time manipulation, including timezone conversion and arithmetic operations like adding or subtracting time units. It also enables users to retrieve current date, time, and timezone information.

Weather MCP Server

Provides access to US weather data from the National Weather Service API, enabling retrieval of active weather alerts by state and detailed forecasts for specific coordinates.

AI Code Review MCP Server

Integrates GitHub repository management and local file system access to enable AI agents to perform code reviews and manage pull requests. It provides tools for listing repositories, retrieving PR diffs, and searching or reading files within a specified workspace.

smartthings-mcp

A lightweight server for Samsung SmartThings, offering tools to manage devices and rooms. Features include room mapping, device listing, status checks, and command execution. #IoT, #Python, #HomeAutomation #Smartthings

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).

tavily-mcp-python

Tavily MCP Server implementation that uses fastmcp and supports both sse and stdio transports. It also supports more up to date functionalities of Tavily.

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.

MCP-Server-MySSL

MySSL MCP Servidor

Debug Companion MCP

Enables AI coding agents to debug Python projects by running pytest, extracting failure locations, displaying code context around failures, and optionally requesting fix suggestions from Gemini.

Remote MCP Server

A Cloudflare Workers-based MCP server that enables deployment of custom tools accessible via the Model Context Protocol without authentication requirements.

MCP Specification Server

Provides complete access to Model Context Protocol documentation through an MCP server, allowing LLMs to query specific sections like 'Tools', 'Resources', and 'Authorization' to retrieve comprehensive protocol specifications.

CAD-Query MCP Server

Enables conversational 3D modeling by providing CAD-Query functionality to validate parametric 3D models against criteria and export to STL/STEP formats for 3D printing and CAD applications.

Dad Joke Visualizer

Generates clean, PG-13 dad jokes using AI and creates visual illustrations to accompany them on beautiful web pages. Works seamlessly with Cursor's Auto feature for interactive joke creation through natural language prompts.

Quick-start Auto MCP

A tool that helps users easily register Anthropic's Model Context Protocol in Claude Desktop and Cursor, providing ready-made MCP tools for RAG, web search, and Dify integrations.

GPT OpenMemory MCP Server

Enables ChatGPT Desktop to save and manage conversation memories locally in SQLite, with features for searching past conversations, creating summaries, and exporting dialogues to markdown files.

Wiki OSRS MCP

Provides access to Old School RuneScape wiki information and game data through MCP tools. Enables users to query OSRS game content, items, and mechanics via natural language.

MCP News Server

A server providing access to news articles from various categories including tech, data science, cybersecurity, and more, allowing retrieval and summarization of latest content.

RideWithGPS MCP Server

An AI-powered companion that provides access to the RideWithGPS API, allowing you to interact with cycling routes, trips, events, and user data through natural language.

Simple Streamable HTTP MCP Server

A reference implementation demonstrating proper MCP server patterns with HTTP transport, featuring session management, progress notifications, and example tools for testing server functionality. Serves as a clean template for building MCP servers with streamable responses and comprehensive error handling.

USQL MCP Server

Enables AI assistants to execute SQL queries against any database supported by the usql CLI tool. Provides seamless database interaction through MCP by forwarding queries directly to usql and returning results in JSON or CSV format.

MCP Server for NASA API integration.

Servidor de demostración MCP