Discover Awesome MCP Servers

Training Platform MCP G2

MCP server for tracking user course progress, providing tools to retrieve and save course and stage progress for authenticated users with data persisted in SQL Server.

Claims desk MCP Server

Medicare claim documentation lookup for CPT codes against live CMS sources, returning structured requirements and document URIs with optional enrichment via RCI APIs.

Neleus MCP

Enables interaction with Hyperliquid markets for technical analysis, order book data retrieval, and cryptocurrency trading. Supports read-only market access without credentials and authenticated trading operations via private key configuration.

@aibtc/mcp-server

Bitcoin-native MCP server for AI agents: BTC/STX wallets, DeFi yield, sBTC peg, NFTs, and x402 payments.

Model Context Provider (MCP) Server

Facilita una interacción mejorada con modelos de lenguaje grandes (LLMs) al proporcionar una gestión inteligente del contexto, integración de herramientas y coordinación de modelos de IA de múltiples proveedores para flujos de trabajo eficientes impulsados por la IA.

fintools-mcp

Provides a comprehensive financial analysis toolkit for AI assistants, featuring technical indicators, options chain analysis, and risk-based position sizing. It enables users to perform stock market analysis and evaluate trade performance using real-time data from Yahoo Finance.

happy-thoughts

Pay-per-thought AI second opinions for autonomous agents. Agents pay 0.01–0.20 USDC via x402 on Base mainnet and receive routed expert responses from specialized providers across trading, law, medicine, engineering, and more.

medRxiv MCP Server

Espejo de

xctools-mcp-server

Provides structured access to Xcode development tools including xcrun, xcodebuild, and xctrace for building, testing, and analyzing projects.

AI Model Catalog MCP Server

Provides a live, audited catalog of AI models from NVIDIA NIM, OpenRouter, Nous Portal, and other providers, enabling search, retrieval, and usage examples via MCP tools and resources.

AgentBridge

Expose your VS Code workspace's tools — files, terminal, LSP, diagnostics, and images — to remote MCP clients over a public HTTPS tunnel.

Gamedev All-in-One MCP

Unifies Roblox Studio, Unity, Unreal Engine, and Blender into a single AI-powered control plane with 78 tools for automated game development.

XServer MCP Server

MCP server for Xserver hosting that provides tools to manage mail accounts, DNS records, server information, and domain verification through natural language.

CyberDestiny

Provides 35 MCP tools for Chinese metaphysical divination, including BaZi, ZiWei, QiMen, and daily fortune subscriptions, enabling AI agents to perform complex fortune-telling and calendar predictions.

Syracuse Company News API

Enables access to Syracuse Company news API for registering accounts and fetching stories by location, industry, or organization. Supports local and remote MCP server modes.

NovaCorp Operations Assistant

A multi-agent operations assistant that answers business questions by searching local documents and order records.

mcp-nec2-antenna

Design and simulate wire antennas using the NEC2 method-of-moments solver via MCP. Supports dipole, Yagi-Uda, vertical, loop, and inverted-V geometries with pattern, impedance, and VSWR analysis.

downscoping-mcp

A security-focused tool that implements least-privilege credential injection for Claude Code by intercepting Bash and MCP tool calls to swap in minimum-privilege tokens. It enables secure execution of CLI commands and MCP operations by matching tool arguments against declarative YAML policies to prevent unauthorized access.

Alloy MCP Server

Enables Claude to write, compile, and execute formal verification models in Alloy and read raw mathematical graph structures back into its context window.

Feedthrough

Debug bridge inside your web app: an agent reads the DOM, console and network. Any browser.

Prefeitura SP São Paulo: Regularidade OTTC

A read-only MCP server to query São Paulo's city hall for Regularidade OTTC (establishment regularity) data. Works with any MCP client over HTTP.

MultiAiPanel

A Chrome side panel hosting multiple AIs (ChatGPT, Claude, Gemini, Grok, DeepSeek) that also functions as an MCP server for downstream agents, enabling multi-model comparison and agent coordination.

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.

jp-address-mcp

Normalizes and verifies Japanese postal addresses, splitting messy strings into structured fields with geolocation and verification.

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.

ssh-mcp

Enables remote server management via SSH, including command execution, file transfer (SFTP), and interactive shell sessions, with support for multiple hosts.

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.

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