Discover Awesome MCP Servers

Airbnb MCP Server

Enables searching for Airbnb listings and retrieving detailed property information including pricing, amenities, and host details without requiring an API key.

mcp-internet-speed-test

mcp-internet-speed-test

Roblox Studio MCP Assistant

Enables AI assistants to interact with Roblox Studio in real-time, allowing creation and manipulation of game objects through natural language commands via an HTTP-based plugin system.

Google Drive MCP Server

Enables read-only access to multiple Google Drive accounts simultaneously through secure service account authentication. Supports listing, searching, and extracting content from Google Workspace documents, spreadsheets, and text files.

Webots MCP Server

Enables real-time monitoring and control of any Webots robot simulation, providing access to robot state, sensors, camera feeds, and simulation controls (pause, resume, reset) through natural language.

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.

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.

MCP Weather Server

Enables users to get current weather information for any city worldwide using the Open-Meteo API. Provides temperature and wind speed data through natural language queries.

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.

TrainingPeaks-MCP

TrainingPeaks MCP server for Claude Desktop and AI assistants. Query workouts, analyze fitness, power peaks and more.

MCPeasy

A production-grade multi-tenant MCP server that provides different tools and configurations to different clients using API key-based routing.

开发 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!

Canvas MCP

Enables AI agents to interact with Canvas LMS and Gradescope, allowing users to query courses, assignments, modules, calendar events, and find relevant resources using natural language.

TypeScript MCP Server Boilerplate

A starter project designed to quickly build and deploy Model Context Protocol (MCP) servers using the TypeScript SDK and Zod for schema validation. It features example implementations for tools and resources, providing a solid foundation for custom MCP development and integration.

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.

MCP Memory System

Enables AI assistants to maintain persistent conversations and context between sessions through automated saving and global installation across projects. Provides zero-configuration memory persistence with automatic conversation history preservation.

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 Odoo Bridge Server

Enables AI assistants to interact with Odoo data using natural language to search, read, create, and update records. It acts as a secure bridge between MCP clients and Odoo instances version 17.0 through 19.0.

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.

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.

Whissle MCP Server

A Python-based server that provides access to Whissle API endpoints for speech-to-text, diarization, translation, and text summarization.

Hashkey MCP Server

A Model Context Protocol server that provides onchain tools for AI applications to interact with the Hashkey Network, enabling cryptocurrency transfers, smart contract deployment, and blockchain interactions.

Remote MCP Server

A Cloudflare Workers-based MCP server that enables connecting AI assistants like Claude Desktop to custom tools without authentication requirements.

Market Expert MCP

A specialized MCP server that provides institutional-grade financial data and market research via the Finnhub API. It enables AI agents to function as equity researchers, generating professional market reports and high-fidelity analysis for stock tickers.

EnrichB2B MCP Server

Un servidor que implementa el Protocolo de Contexto de Modelo que permite a los usuarios recuperar información de perfiles de LinkedIn y datos de actividad a través de la API EnrichB2B, y generar texto utilizando los modelos OpenAI GPT-4 o Anthropic Claude.