Discover Awesome MCP Servers

Gmail MCP Server

Enables AI assistants to read unread Gmail messages and compose draft replies while maintaining thread continuity. It includes optional Notion integration to fetch and apply specific style guides for consistent professional communication.

Motion MCP Server

Bridges Motion's API with LLMs so you can manage tasks, search projects, check schedules, and more through natural conversation.

eu-regulations

Query 37 EU regulations — from GDPR and AI Act to DORA, MiFID II, eIDAS, Medical Device Regulation, and more — directly from Claude, Cursor, or any MCP-compatible client.

tokensave

Supercharge your Agent with Semantic Code Intelligence and save 💰 in the process!

mcp-coordinator

Prevents AI coding agents from conflicting by coordinating file claims and resolving conflicts in real-time across multiple sessions.

NetBrain MCP

An open-source network operations integration platform that connects large language models with network devices through the Model Context Protocol, allowing AI assistants to perform network configuration, diagnostics, and management tasks.

Bing Flights MCP Server

Enables flight search and price comparison by scraping flight information from Bing Flights. Supports one-way and round-trip searches with customizable passenger counts, cabin classes, and booking details.

LibreOffice MCP Server

Enables AI assistants to create, read, convert, and manipulate LibreOffice documents programmatically, supporting 50+ file formats including Writer, Calc, Impress documents with real-time editing, batch operations, and document analysis capabilities.

2slides MCP Server

Enables users to generate presentation slides using 2slides.com's API through Claude Desktop. Supports searching for slide themes, generating slides from text input, and monitoring job status for slide creation.

xcsc-tushare-mcp

A FastMCP-based MCP server that provides AI assistants with access to XCSC Tushare financial data APIs, supporting stdio and HTTP transport for stocks, indices, funds, and more.

Discord MCP Server

A secure server that enables interaction with Discord channels through JWT-authenticated API calls, allowing users to send messages, fetch channel data, search content, and perform moderation actions.

GitLab MCP Server

A Model Context Protocol (MCP) server for GitLab integration, written in TypeScript. This server allows you to interact with GitLab merge requests, commits, pipelines, and jobs through MCP tools.

mcpilot

Context-aware MCP server advisor. Tells you what to install for your specific project — and why.

GemmaJnana

Multi-domain MCP server enabling AI agents to plan and execute vacation travel and birthday party logistics via local tool pipelines.

Obsidian MCP

Enables AI agents to manage Obsidian vaults through full CRUD operations, wikilink management, and section-level manipulation. It supports frontmatter editing, tag-based searching, and automated link updates to maintain vault integrity.

TestRail MCP Server

Enables comprehensive TestRail test management integration with support for projects, test cases, runs, results, advanced reporting, analytics, and AutoSpectra test automation framework synchronization.

Settled

Enables AI agents to query a team's decision ledger to check if past decisions are still binding before taking action, via the decisions:// MCP protocol.

aiohttp-mcp

Here are some tools and approaches for building Model Context Protocol (MCP) servers on top of `aiohttp` in Python: **Core Libraries & Concepts** * **`aiohttp`:** The foundation. You'll use `aiohttp.web` to create the HTTP server, define routes, and handle requests. Key components: * `aiohttp.web.Application`: The central application object. * `aiohttp.web.RouteTableDef`: For defining routes (e.g., `/model/load`, `/model/predict`). * `aiohttp.web.Request`: Represents an incoming HTTP request. You'll access data from the request body (usually JSON) and headers. * `aiohttp.web.Response`: Represents the HTTP response you send back to the client. You'll set the status code, headers (e.g., `Content-Type: application/json`), and the response body (usually JSON). * `aiohttp.web.json_response`: A helper function to create a JSON response. * **`asyncio`:** `aiohttp` is built on `asyncio`, so you'll need to understand asynchronous programming. Use `async def` to define coroutines (asynchronous functions) that handle requests. Use `await` to call other asynchronous functions (e.g., loading a model, making a prediction). * **JSON Serialization/Deserialization:** MCP typically uses JSON for request and response bodies. Use the built-in `json` module (`json.loads` to parse JSON from the request body, `json.dumps` to serialize data into JSON for the response). `aiohttp.web.json_response` handles JSON serialization for you. **Libraries for Structure and Validation** * **`marshmallow`:** A popular library for serializing and deserializing complex data structures (like Python objects) to and from JSON. It also provides validation capabilities. This is *highly* recommended for MCP servers to ensure data integrity. * Define schemas using `marshmallow.Schema` to specify the structure and data types of your request and response payloads. * Use `schema.load(request_data)` to validate and deserialize the request data into Python objects. This will raise a `marshmallow.exceptions.ValidationError` if the data doesn't conform to the schema. * Use `schema.dump(response_data)` to serialize Python objects into JSON for the response. * **`pydantic`:** Another popular data validation and settings management library. It uses Python type hints for validation and serialization. Similar to `marshmallow` in its purpose, but often considered more concise and Pythonic. It integrates well with FastAPI (see below). * **`attrs`:** A library for defining classes with attributes. It can be used in conjunction with `marshmallow` or `pydantic` to define the data structures that your schemas will serialize/deserialize. **Frameworks (Optional, but Recommended for Larger Projects)** * **`FastAPI`:** A modern, high-performance web framework for building APIs with Python. It's built on `starlette` (which is built on `asyncio`) and integrates seamlessly with `pydantic` for data validation and serialization. FastAPI provides automatic API documentation (using OpenAPI/Swagger) and is generally a great choice for building robust MCP servers. It handles a lot of the boilerplate for you. * **`Sanic`:** Another asynchronous web framework that's known for its speed. It's a good alternative to `aiohttp` if you're looking for maximum performance. However, it might have a slightly steeper learning curve than FastAPI. * **`aiohttp-apispec`:** A library that integrates `aiohttp` with `apispec` (which is used to generate OpenAPI/Swagger documentation). This is useful if you want to document your MCP API using the OpenAPI standard. **Model Serving Libraries (For Integrating with Machine Learning Models)** * **`Triton Inference Server`:** A high-performance inference server from NVIDIA that supports a wide range of models and frameworks (TensorFlow, PyTorch, ONNX, etc.). You can use `aiohttp` to build a front-end that interacts with Triton. This is a good choice if you need to serve models at scale. * **`TorchServe`:** A model serving framework from PyTorch. Similar to Triton, it provides a way to deploy and serve PyTorch models. * **`TensorFlow Serving`:** A model serving framework from TensorFlow. * **Custom Model Loading/Inference:** If you have simpler model serving needs, you can load your models directly into your `aiohttp` application and perform inference within the request handlers. This is suitable for smaller models and lower traffic. Libraries like `scikit-learn`, `transformers`, `torch`, or `tensorflow` would be used directly for model loading and prediction. **Example (Illustrative, using `aiohttp` and `marshmallow`)** ```python import asyncio import json from aiohttp import web import marshmallow # Define a schema for the request data class PredictionRequestSchema(marshmallow.Schema): input_data = marshmallow.fields.List(marshmallow.fields.Float(), required=True) # Define a schema for the response data class PredictionResponseSchema(marshmallow.Schema): prediction = marshmallow.fields.Float(required=True) # In-memory model (replace with your actual model loading) model = None # Placeholder for your ML model async def load_model(app): """Load the model into the application state.""" global model # Simulate loading a model (replace with actual model loading) await asyncio.sleep(1) # Simulate loading time model = lambda x: sum(x) / len(x) # Dummy model: average of inputs print("Model loaded") app['model'] = model # Store the model in the application state async def predict_handler(request): """Handles prediction requests.""" try: data = await request.json() schema = PredictionRequestSchema() try: validated_data = schema.load(data) except marshmallow.exceptions.ValidationError as err: return web.json_response({"error": err.messages}, status=400) input_data = validated_data['input_data'] # Perform prediction using the loaded model prediction = request.app['model'](input_data) # Access model from app state # Create the response response_data = {"prediction": prediction} response_schema = PredictionResponseSchema() result = response_schema.dump(response_data) # Serialize to JSON return web.json_response(result) except Exception as e: print(f"Error during prediction: {e}") return web.json_response({"error": str(e)}, status=500) async def load_handler(request): """Handles model loading requests (optional).""" try: # Simulate model loading (replace with actual loading logic) await load_model(request.app) return web.json_response({"message": "Model loaded successfully"}) except Exception as e: print(f"Error loading model: {e}") return web.json_response({"error": str(e)}, status=500) async def create_app(): app = web.Application() app.add_routes([ web.post('/model/predict', predict_handler), web.post('/model/load', load_handler), # Optional endpoint for loading ]) # Load the model when the application starts app.on_startup.append(load_model) return app if __name__ == '__main__': loop = asyncio.get_event_loop() app = loop.run_until_complete(create_app()) web.run_app(app, port=8080) ``` **Key Considerations for MCP Servers:** * **Model Loading:** How will you load your models? From disk? From a model registry? Will you load them on startup or on demand? The `load_model` function in the example is a placeholder. * **Model Management:** If you have multiple models, how will you manage them? Will you use a model versioning system? * **Scalability:** How will you scale your server to handle increasing traffic? Consider using a load balancer and running multiple instances of your server. * **Monitoring:** How will you monitor the performance of your server? Collect metrics like request latency, error rates, and resource usage. * **Security:** Implement appropriate security measures, such as authentication and authorization, to protect your models and data. * **Error Handling:** Implement robust error handling to gracefully handle unexpected errors and provide informative error messages to the client. * **Logging:** Use a logging library (e.g., `logging`) to log important events and errors. * **Asynchronous Operations:** Ensure that all I/O-bound operations (e.g., reading from disk, making network requests) are performed asynchronously to avoid blocking the event loop. * **Data Validation:** Always validate the input data to prevent errors and security vulnerabilities. Use `marshmallow` or `pydantic` for this. * **Concurrency:** Be mindful of concurrency issues when accessing shared resources (e.g., the model). Use appropriate locking mechanisms if necessary. However, avoid locks as much as possible in asynchronous code. **In summary:** 1. **Choose a Framework:** Start with `aiohttp` directly for simple cases. For more complex projects, `FastAPI` is highly recommended. 2. **Data Validation:** Use `marshmallow` or `pydantic` for robust data validation. 3. **Model Serving:** Select a model serving library (Triton, TorchServe, TensorFlow Serving) if you need to serve models at scale. Otherwise, load models directly into your application. 4. **Implement MCP Endpoints:** Create the necessary endpoints (e.g., `/model/load`, `/model/predict`) to conform to the MCP specification. 5. **Handle Errors and Logging:** Implement comprehensive error handling and logging. 6. **Consider Scalability and Monitoring:** Plan for scalability and monitoring from the beginning. This comprehensive guide should give you a solid foundation for building MCP servers on top of `aiohttp`. Remember to adapt the example code and choose the libraries that best fit your specific needs.

Minted MCP Server

Enables interaction with Minted.com to retrieve address book contacts, order history, and delivery information for recent card orders.

MCP Workflow Tracker

Provides observability for multi-agent workflows by tracking hierarchical task structure, architectural decisions, reasoning, encountered problems, code modifications with Git diffs, and temporal metrics.

开发 SSE 类型的 MCP 服务

Okay, here's a breakdown of how you might approach building a Claude-based demo using Server-Sent Events (SSE) with both a command-line interface (CLI) and a web client, along with a conceptual outline in Spanish: **Conceptual Outline (Spanish)** Este es un esquema conceptual para construir una demostración de Claude utilizando Eventos Enviados por el Servidor (SSE) con un cliente de línea de comandos (CLI) y un cliente web: 1. **Servidor (Backend):** * **API SSE:** Un punto final (endpoint) que genera eventos SSE. Recibe la entrada del usuario, la envía a Claude, y transmite la respuesta de Claude *en tiempo real* como eventos SSE. * **Conexión a Claude:** Utiliza la API de Claude (Anthropic API) para enviar la entrada del usuario y recibir la respuesta. Necesitarás una clave API de Anthropic. * **Manejo de Errores:** Implementa un manejo robusto de errores para problemas de conexión, errores de la API de Claude, etc. * **Tecnologías:** Python (Flask, FastAPI), Node.js (Express), Go, etc. Flask y FastAPI son populares para APIs en Python. 2. **Cliente CLI (Línea de Comandos):** * **Envío de Entrada:** Permite al usuario ingresar texto a través de la línea de comandos. * **Conexión SSE:** Se conecta al punto final SSE del servidor. * **Recepción y Visualización:** Recibe los eventos SSE y muestra la respuesta de Claude en la terminal *en tiempo real*. * **Tecnologías:** Python (requests, sseclient-py), Node.js (node-fetch, sseclient), etc. 3. **Cliente Web (Frontend):** * **Interfaz de Usuario:** Proporciona una interfaz web (HTML, CSS, JavaScript) con un área de entrada de texto y un área de visualización de la respuesta. * **Conexión SSE:** Utiliza JavaScript para conectarse al punto final SSE del servidor. * **Recepción y Visualización:** Recibe los eventos SSE y actualiza la interfaz web para mostrar la respuesta de Claude *en tiempo real*. * **Tecnologías:** HTML, CSS, JavaScript, posiblemente un framework como React, Vue, o Angular. 4. **Consideraciones Adicionales:** * **Autenticación:** Si es necesario, implementa autenticación para proteger el acceso a la API. * **Limitación de Tasa (Rate Limiting):** Implementa limitación de tasa para evitar el abuso de la API de Claude. * **Logging:** Implementa logging para rastrear el uso y diagnosticar problemas. * **Variables de Entorno:** Utiliza variables de entorno para almacenar la clave API de Claude y otras configuraciones sensibles. **Detailed Breakdown (English with Spanish Translations)** Here's a more detailed breakdown of each component: **1. Server (Backend)** * **Technology Choice:** Python with Flask or FastAPI is a good choice for its simplicity and ease of use. Node.js with Express is another popular option. * **API Endpoint (Punto Final de la API):** Create an endpoint that handles SSE. For example, `/stream`. ```python # Flask example from flask import Flask, Response, request import anthropic # Assuming you have the Anthropic Python library app = Flask(__name__) ANTHROPIC_API_KEY = "YOUR_ANTHROPIC_API_KEY" # Replace with your actual API key client = anthropic.Anthropic(api_key=ANTHROPIC_API_KEY) @app.route('/stream') def stream(): prompt = request.args.get('prompt', 'Tell me a story.') # Get prompt from request def generate(): try: with client.messages.stream( model="claude-3-opus-20240229", # Or your preferred model max_tokens=1024, messages=[{"role": "user", "content": prompt}], ) as response: for event in response.text_stream: yield f"data: {event}\n\n" # SSE format except Exception as e: yield f"data: ERROR: {str(e)}\n\n" # Send error as SSE return Response(generate(), mimetype='text/event-stream') if __name__ == '__main__': app.run(debug=True) ``` * **Explanation:** * The `/stream` route handles the SSE connection. * It retrieves the user's prompt from the request parameters (`request.args.get('prompt')`). * The `generate()` function is a generator that yields SSE data events. * It uses the Anthropic API to stream the response from Claude. * Each chunk of the response is formatted as `data: {chunk}\n\n` (the SSE format). * Error handling is included to send errors as SSE events. * The `Response` object is created with the `text/event-stream` mimetype. * **Claude API Integration (Integración de la API de Claude):** Use the Anthropic API to send the user's input and receive the response. You'll need an API key. * **Error Handling (Manejo de Errores):** Implement robust error handling for connection problems, API errors, etc. Send error messages as SSE events. **2. CLI Client (Cliente CLI)** * **Technology Choice:** Python with `requests` and `sseclient-py` is a good option. ```python import requests import sseclient def main(): prompt = input("Enter your prompt: ") url = f"http://localhost:5000/stream?prompt={prompt}" # Adjust URL if needed try: response = requests.get(url, stream=True) response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx) client = sseclient.SSEClient(response.raw) for event in client.events(): if event.event == 'message': # Check if the event is a message print(event.data, end="", flush=True) # Print the data without a newline else: print(f"Event: {event.event}, Data: {event.data}") # Handle other events except requests.exceptions.RequestException as e: print(f"Error connecting to the server: {e}") except Exception as e: print(f"An error occurred: {e}") if __name__ == "__main__": main() ``` * **Explanation:** * Prompts the user for input. * Constructs the URL for the SSE endpoint, including the prompt as a query parameter. * Uses `requests` to make a GET request to the SSE endpoint with `stream=True`. * Uses `sseclient` to parse the SSE stream. * Iterates through the events received from the server. * Prints the data from each event to the console. * Includes error handling for network issues and other exceptions. **3. Web Client (Cliente Web)** * **Technology Choice:** HTML, CSS, JavaScript. Consider using a framework like React, Vue, or Angular for a more structured approach. ```html <!DOCTYPE html> <html> <head> <title>Claude SSE Demo</title> </head> <body> <h1>Claude SSE Demo</h1> <input type="text" id="promptInput" placeholder="Enter your prompt"> <button onclick="startStream()">Send</button> <div id="responseArea"></div> <script> function startStream() { const prompt = document.getElementById("promptInput").value; const responseArea = document.getElementById("responseArea"); responseArea.innerHTML = ""; // Clear previous response const eventSource = new EventSource(`http://localhost:5000/stream?prompt=${prompt}`); // Adjust URL eventSource.onmessage = function(event) { responseArea.innerHTML += event.data; }; eventSource.onerror = function(error) { console.error("SSE error:", error); responseArea.innerHTML += "<p>Error: " + error + "</p>"; eventSource.close(); // Close the connection on error }; } </script> </body> </html> ``` * **Explanation:** * Basic HTML structure with an input field, a button, and a `div` to display the response. * The `startStream()` function is called when the button is clicked. * It creates an `EventSource` object to connect to the SSE endpoint. * The `onmessage` event handler appends the received data to the `responseArea`. * The `onerror` event handler logs errors and displays an error message. **Important Considerations (Consideraciones Importantes)** * **API Key Security (Seguridad de la Clave API):** Never hardcode your API key directly into your code. Use environment variables. * **Streaming vs. Single Request (Streaming vs. Solicitud Única):** SSE is ideal for streaming responses. If you don't need streaming, a regular HTTP request/response might be simpler. * **Error Handling (Manejo de Errores):** Thorough error handling is crucial for a good user experience. * **CORS (Compartir Recursos de Origen Cruzado):** If your frontend and backend are on different domains, you'll need to configure CORS on your backend. Flask has the `flask_cors` extension for this. * **Rate Limiting (Limitación de Tasa):** Be mindful of the Anthropic API's rate limits. Implement rate limiting in your backend to prevent exceeding the limits. * **Model Selection (Selección del Modelo):** Choose the appropriate Claude model for your needs (e.g., `claude-3-opus-20240229`, `claude-3-haiku-20240307`). **Next Steps (Próximos Pasos)** 1. **Get an Anthropic API Key (Obtén una Clave API de Anthropic):** Sign up for an Anthropic account and get an API key. 2. **Install Dependencies (Instala las Dependencias):** Install the necessary Python packages (e.g., `pip install flask anthropic requests sseclient-py`). 3. **Implement the Backend (Implementa el Backend):** Start with the Flask/FastAPI example and adapt it to your needs. 4. **Implement the CLI Client (Implementa el Cliente CLI):** Use the Python example as a starting point. 5. **Implement the Web Client (Implementa el Cliente Web):** Create the HTML, CSS, and JavaScript for your web interface. 6. **Test and Debug (Prueba y Depura):** Thoroughly test your application and debug any issues. This comprehensive outline should give you a solid foundation for building your Claude SSE demo. Remember to replace `"YOUR_ANTHROPIC_API_KEY"` with your actual API key. Good luck!

Jupiter MCP Server

Servidor de Protocolo de Contexto del Modelo que proporciona a Claude AI acceso a la API de intercambio de Jupiter en Solana.

Canvelete

Enables programmatic design creation and manipulation on the Canvelete platform through AI assistants. Supports design management, canvas element manipulation, template application, asset management, and real-time synchronization with the design editor.

MCPServer

Un servidor MCP sencillo para habilitar flujos de trabajo agenticos.

mcp-server-anki

Enables AI tools to manage Anki flashcards, including deck management, card search, creation, editing, deletion, and statistics.

Webpage Design Analyzer

An MCP server that analyzes webpage design images using vision models and generates development documentation in Markdown format.

Threat Intelligence MCP Server

Aggregates real-time threat intelligence from multiple sources including Feodo Tracker, URLhaus, CISA KEV, and ThreatFox, with IP/hash reputation checking via VirusTotal, AbuseIPDB, and Shodan for comprehensive security monitoring.

apple-fm-mcp

Exposes Apple's on-device 3B parameter LLM to Claude Code and Claude Desktop via MCP. Zero API cost, fully private, runs on Neural Engine.