Discover Awesome MCP Servers

TokenOracle MCP

Estimates, compares, and controls LLM API costs before agents spend tokens, with tools for cost estimation, model comparison, and budget checking.

yacy-mcp

Enables AI applications to perform web searches using a YaCy search engine instance through the Model Context Protocol.

mcp-gh-pr-mini

Un servidor MCP (Protocolo de Contexto de Modelo) mínimo para interactuar con las solicitudes de extracción de GitHub.

chatExcel

A Model Context Protocol server for intelligent Excel processing and data analysis, offering tools for reading, validating, executing code, and generating interactive visualizations with Excel files.

Rust Minidump MCP

Analyzes application crash dumps and extracts debug symbols, transforming Windows minidump files into readable stack traces and providing AI-powered crash analysis to help identify root causes and fix critical issues.

YouTube Channel MCP Server

Retrieves YouTube Channel statistics, metadata, and uploaded videos using the YouTube Data API v3.

peer-relay

A message relay MCP server enabling two separate Claude Code instances to exchange direct questions and answers asynchronously without sharing context.

hyperd-mcp

Pre-trade DeFi intelligence for AI agents. 20 paid x402 endpoints, USDC on Base.

bnbot-mcp-server

MCP server for BNBOT Chrome Extension to control Twitter/X via AI assistants like OpenClaw or Claude Desktop.

hr-assist

Automates employee onboarding workflows for HR teams, enabling tasks like data entry and email notifications through natural language.

Harness Engineering MCP

Enables AI coding environments to enforce engineering governance through MCP tools and resources for init, check, route, and review workflows.

io.github.neogeweb3/code-health-suite

Provides 28 MCP tools across 16 analysis engines for comprehensive Python code quality assessment, including complexity scoring, security scanning, dead code detection, dependency auditing, and test quality analysis.

mcp-swagger

Here are a few ways to enable your MCP (presumably "Microservices Control Plane") server to use a Swagger/OpenAPI description to call APIs, along with explanations and considerations: **Understanding the Goal** The core idea is to leverage a Swagger/OpenAPI definition (usually a `swagger.json` or `openapi.yaml` file) to: 1. **Understand the API:** The MCP server needs to know the available endpoints, request parameters, response structures, and authentication methods of the APIs it will be calling. 2. **Generate API Calls:** Instead of hardcoding API calls, the MCP server can dynamically construct requests based on the Swagger definition. 3. **Validate Requests/Responses:** The MCP server can validate that the requests it's sending conform to the API specification and that the responses it receives are also valid. 4. **Provide a User Interface (Optional):** Swagger UI or similar tools can be integrated to provide a user-friendly way to explore and test the APIs. **Methods and Approaches** Here are several approaches, ranging from simpler to more complex, depending on the capabilities of your MCP server and the level of automation you need: **1. Manual Configuration (Simple but Limited)** * **Description:** This is the most basic approach. You manually read the Swagger definition and configure your MCP server based on that information. * **How it Works:** 1. Obtain the `swagger.json` or `openapi.yaml` file for the API you want to call. 2. Examine the file to understand the endpoints, parameters, and data structures. 3. Configure your MCP server (through its configuration files, UI, or API) to make the necessary HTTP requests to the API. This involves specifying the URL, HTTP method (GET, POST, PUT, DELETE, etc.), headers, and request body. * **Pros:** * Simple to implement initially. * No need for complex libraries or integrations. * **Cons:** * Very manual and error-prone. * Doesn't automatically adapt to API changes. You have to manually update the configuration whenever the API definition changes. * No automatic validation. * Not scalable for many APIs. **2. Code Generation (More Automated)** * **Description:** Use a code generation tool to generate client code from the Swagger definition. Your MCP server then uses this generated code to interact with the API. * **How it Works:** 1. Use a tool like Swagger Codegen, OpenAPI Generator, or similar tools. These tools take a Swagger/OpenAPI definition as input and generate client code in various programming languages (e.g., Java, Python, Go, JavaScript). 2. Integrate the generated client code into your MCP server. 3. The generated code provides functions or classes that you can use to easily call the API endpoints. * **Pros:** * More automated than manual configuration. * Type-safe (if using a typed language like Java or TypeScript). * Reduces the risk of errors. * Can handle complex API structures. * **Cons:** * Requires a code generation step. * You need to regenerate the code whenever the API definition changes. This can be automated with CI/CD pipelines. * Adds a dependency on the code generation tool. * The generated code might need some customization to fit your specific needs. **3. Dynamic API Client Libraries (Most Flexible)** * **Description:** Use a library that can dynamically interpret a Swagger/OpenAPI definition at runtime and create API clients on the fly. * **How it Works:** 1. Choose a library that supports dynamic API client generation. Examples include: * **Python:** `swagger-ui-bundle` (for UI), potentially combined with libraries like `requests` for making HTTP requests. You'd need to write code to parse the Swagger definition and use `requests` to construct the calls. * **JavaScript:** `swagger-client` (a popular option). * **Java:** Consider using a library like `springdoc-openapi` to dynamically generate API documentation and potentially use it to create clients. 2. Load the Swagger definition into the library. 3. Use the library's API to discover the available endpoints and create API calls. * **Pros:** * Very flexible and adaptable to API changes. You can reload the Swagger definition at runtime. * No code generation step required. * Can be used to build generic API clients. * **Cons:** * More complex to implement than code generation. * Requires a good understanding of the library's API. * Might have performance overhead compared to generated code. * Error handling can be more challenging. **4. API Gateway Integration (If Applicable)** * **Description:** If your MCP server interacts with APIs through an API gateway (e.g., Kong, Apigee, Tyk), the gateway might already support Swagger/OpenAPI integration. * **How it Works:** 1. Import the Swagger/OpenAPI definition into the API gateway. 2. The API gateway will use the definition to: * Validate requests. * Transform requests/responses. * Apply security policies. * Route requests to the appropriate backend services. 3. Your MCP server simply makes requests to the API gateway, and the gateway handles the details of interacting with the backend APIs. * **Pros:** * Offloads API management tasks to the API gateway. * Provides a central point for security and monitoring. * Simplifies the MCP server's code. * **Cons:** * Requires an API gateway. * Adds complexity to the overall architecture. **Example (Conceptual - Python with `requests`)** ```python import requests import json def call_api_from_swagger(swagger_file, endpoint_name, parameters=None): """ Calls an API endpoint based on a Swagger/OpenAPI definition. Args: swagger_file: Path to the swagger.json or openapi.yaml file. endpoint_name: The name of the endpoint to call (e.g., "getUser"). You'll need to parse the Swagger file to find the correct path. parameters: A dictionary of parameters to pass to the API. """ with open(swagger_file, 'r') as f: swagger_data = json.load(f) # Or use yaml.load if it's a YAML file # **Important:** This is a simplified example. You'll need to # parse the Swagger data to find the correct path, HTTP method, # and parameter definitions. The Swagger data structure is complex. # Example: Assume the Swagger file has a path like "/users/{userId}" # and a GET method. base_url = swagger_data['servers'][0]['url'] # Get the base URL path = None method = None for p, path_data in swagger_data['paths'].items(): for m in path_data: if path_data[m].get('operationId') == endpoint_name: path = p method = m.upper() # GET, POST, etc. break if path: break if not path or not method: raise ValueError(f"Endpoint '{endpoint_name}' not found in Swagger file.") url = base_url + path # Handle parameters (path parameters, query parameters, request body) if parameters: # **More complex logic needed here to handle different parameter types** # This is a very basic example for query parameters. url += "?" + "&".join([f"{k}={v}" for k, v in parameters.items()]) try: response = requests.request(method, url) response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx) return response.json() # Or response.text if it's not JSON except requests.exceptions.RequestException as e: print(f"Error calling API: {e}") return None # Example usage: # result = call_api_from_swagger("swagger.json", "getUser", {"userId": 123}) # if result: # print(result) ``` **Key Considerations** * **Swagger/OpenAPI Version:** Make sure your chosen library or tool supports the version of Swagger/OpenAPI used by the APIs you're calling (Swagger 2.0, OpenAPI 3.0, etc.). * **Authentication:** Handle API authentication (API keys, OAuth 2.0, etc.) correctly. The Swagger definition will often describe the authentication methods required. * **Error Handling:** Implement robust error handling to deal with API errors, network issues, and invalid data. * **Data Validation:** Validate both the requests you're sending and the responses you're receiving against the Swagger definition. * **API Updates:** Have a strategy for handling API updates. This might involve automatically reloading the Swagger definition or regenerating code. * **Security:** Be careful about storing API keys or other sensitive information in your MCP server's configuration. Use secure storage mechanisms like environment variables or secrets management systems. * **Performance:** Consider the performance implications of dynamically interpreting Swagger definitions at runtime. Code generation might be more efficient for performance-critical applications. **In summary, the best approach depends on the complexity of your APIs, the capabilities of your MCP server, and your desired level of automation. Start with a simpler approach and gradually move to more complex solutions as needed.** **Translation to Spanish:** Aquí hay algunas formas de habilitar su servidor MCP (presumiblemente "Microservices Control Plane" o "Plano de Control de Microservicios") para que use una descripción de Swagger/OpenAPI para llamar a las API, junto con explicaciones y consideraciones: **Entendiendo el Objetivo** La idea central es aprovechar una definición de Swagger/OpenAPI (generalmente un archivo `swagger.json` o `openapi.yaml`) para: 1. **Comprender la API:** El servidor MCP necesita conocer los endpoints disponibles, los parámetros de solicitud, las estructuras de respuesta y los métodos de autenticación de las API que llamará. 2. **Generar Llamadas a la API:** En lugar de codificar las llamadas a la API, el servidor MCP puede construir dinámicamente las solicitudes basándose en la definición de Swagger. 3. **Validar Solicitudes/Respuestas:** El servidor MCP puede validar que las solicitudes que envía se ajusten a la especificación de la API y que las respuestas que recibe también sean válidas. 4. **Proporcionar una Interfaz de Usuario (Opcional):** Swagger UI o herramientas similares se pueden integrar para proporcionar una forma fácil de usar para explorar y probar las API. **Métodos y Enfoques** Aquí hay varios enfoques, que van desde los más simples hasta los más complejos, dependiendo de las capacidades de su servidor MCP y el nivel de automatización que necesite: **1. Configuración Manual (Simple pero Limitada)** * **Descripción:** Este es el enfoque más básico. Usted lee manualmente la definición de Swagger y configura su servidor MCP basándose en esa información. * **Cómo funciona:** 1. Obtenga el archivo `swagger.json` o `openapi.yaml` para la API que desea llamar. 2. Examine el archivo para comprender los endpoints, los parámetros y las estructuras de datos. 3. Configure su servidor MCP (a través de sus archivos de configuración, UI o API) para realizar las solicitudes HTTP necesarias a la API. Esto implica especificar la URL, el método HTTP (GET, POST, PUT, DELETE, etc.), los encabezados y el cuerpo de la solicitud. * **Pros:** * Simple de implementar inicialmente. * No necesita bibliotecas o integraciones complejas. * **Contras:** * Muy manual y propenso a errores. * No se adapta automáticamente a los cambios de la API. Debe actualizar manualmente la configuración cada vez que cambie la definición de la API. * Sin validación automática. * No escalable para muchas API. **2. Generación de Código (Más Automatizado)** * **Descripción:** Use una herramienta de generación de código para generar código de cliente a partir de la definición de Swagger. Su servidor MCP luego usa este código generado para interactuar con la API. * **Cómo funciona:** 1. Use una herramienta como Swagger Codegen, OpenAPI Generator o herramientas similares. Estas herramientas toman una definición de Swagger/OpenAPI como entrada y generan código de cliente en varios lenguajes de programación (por ejemplo, Java, Python, Go, JavaScript). 2. Integre el código de cliente generado en su servidor MCP. 3. El código generado proporciona funciones o clases que puede usar para llamar fácilmente a los endpoints de la API. * **Pros:** * Más automatizado que la configuración manual. * Type-safe (si usa un lenguaje tipado como Java o TypeScript). * Reduce el riesgo de errores. * Puede manejar estructuras de API complejas. * **Contras:** * Requiere un paso de generación de código. * Debe regenerar el código cada vez que cambie la definición de la API. Esto se puede automatizar con pipelines de CI/CD. * Agrega una dependencia de la herramienta de generación de código. * El código generado podría necesitar alguna personalización para adaptarse a sus necesidades específicas. **3. Bibliotecas de Cliente de API Dinámicas (Más Flexibles)** * **Descripción:** Use una biblioteca que pueda interpretar dinámicamente una definición de Swagger/OpenAPI en tiempo de ejecución y crear clientes de API sobre la marcha. * **Cómo funciona:** 1. Elija una biblioteca que admita la generación dinámica de clientes de API. Los ejemplos incluyen: * **Python:** `swagger-ui-bundle` (para la UI), potencialmente combinado con bibliotecas como `requests` para realizar solicitudes HTTP. Necesitaría escribir código para analizar la definición de Swagger y usar `requests` para construir las llamadas. * **JavaScript:** `swagger-client` (una opción popular). * **Java:** Considere usar una biblioteca como `springdoc-openapi` para generar dinámicamente la documentación de la API y potencialmente usarla para crear clientes. 2. Cargue la definición de Swagger en la biblioteca. 3. Use la API de la biblioteca para descubrir los endpoints disponibles y crear llamadas a la API. * **Pros:** * Muy flexible y adaptable a los cambios de la API. Puede volver a cargar la definición de Swagger en tiempo de ejecución. * No se requiere un paso de generación de código. * Se puede usar para construir clientes de API genéricos. * **Contras:** * Más complejo de implementar que la generación de código. * Requiere una buena comprensión de la API de la biblioteca. * Podría tener una sobrecarga de rendimiento en comparación con el código generado. * El manejo de errores puede ser más desafiante. **4. Integración de API Gateway (Si Aplica)** * **Descripción:** Si su servidor MCP interactúa con las API a través de un API gateway (por ejemplo, Kong, Apigee, Tyk), el gateway podría ya admitir la integración de Swagger/OpenAPI. * **Cómo funciona:** 1. Importe la definición de Swagger/OpenAPI en el API gateway. 2. El API gateway usará la definición para: * Validar solicitudes. * Transformar solicitudes/respuestas. * Aplicar políticas de seguridad. * Enrutar las solicitudes a los servicios backend apropiados. 3. Su servidor MCP simplemente realiza solicitudes al API gateway, y el gateway se encarga de los detalles de la interacción con las API backend. * **Pros:** * Descarga las tareas de administración de la API al API gateway. * Proporciona un punto central para la seguridad y el monitoreo. * Simplifica el código del servidor MCP. * **Contras:** * Requiere un API gateway. * Agrega complejidad a la arquitectura general. **Ejemplo (Conceptual - Python con `requests`)** ```python import requests import json def call_api_from_swagger(swagger_file, endpoint_name, parameters=None): """ Llama a un endpoint de API basado en una definición de Swagger/OpenAPI. Args: swagger_file: Ruta al archivo swagger.json o openapi.yaml. endpoint_name: El nombre del endpoint a llamar (por ejemplo, "getUser"). Necesitará analizar el archivo Swagger para encontrar la ruta correcta. parameters: Un diccionario de parámetros para pasar a la API. """ with open(swagger_file, 'r') as f: swagger_data = json.load(f) # O use yaml.load si es un archivo YAML # **Importante:** Este es un ejemplo simplificado. Necesitará # analizar los datos de Swagger para encontrar la ruta correcta, el método HTTP, # y las definiciones de parámetros. La estructura de datos de Swagger es compleja. # Ejemplo: Asuma que el archivo Swagger tiene una ruta como "/users/{userId}" # y un método GET. base_url = swagger_data['servers'][0]['url'] # Obtener la URL base path = None method = None for p, path_data in swagger_data['paths'].items(): for m in path_data: if path_data[m].get('operationId') == endpoint_name: path = p method = m.upper() # GET, POST, etc. break if path: break if not path or not method: raise ValueError(f"Endpoint '{endpoint_name}' no encontrado en el archivo Swagger.") url = base_url + path # Manejar parámetros (parámetros de ruta, parámetros de consulta, cuerpo de la solicitud) if parameters: # **Se necesita una lógica más compleja aquí para manejar diferentes tipos de parámetros** # Este es un ejemplo muy básico para los parámetros de consulta. url += "?" + "&".join([f"{k}={v}" for k, v in parameters.items()]) try: response = requests.request(method, url) response.raise_for_status() # Levantar HTTPError para respuestas incorrectas (4xx o 5xx) return response.json() # O response.text si no es JSON except requests.exceptions.RequestException as e: print(f"Error al llamar a la API: {e}") return None # Ejemplo de uso: # result = call_api_from_swagger("swagger.json", "getUser", {"userId": 123}) # if result: # print(result) ``` **Consideraciones Clave** * **Versión de Swagger/OpenAPI:** Asegúrese de que la biblioteca o herramienta elegida admita la versión de Swagger/OpenAPI utilizada por las API que está llamando (Swagger 2.0, OpenAPI 3.0, etc.). * **Autenticación:** Maneje correctamente la autenticación de la API (claves de API, OAuth 2.0, etc.). La definición de Swagger a menudo describirá los métodos de autenticación requeridos. * **Manejo de Errores:** Implemente un manejo de errores robusto para lidiar con errores de API, problemas de red y datos no válidos. * **Validación de Datos:** Valide tanto las solicitudes que está enviando como las respuestas que está recibiendo con la definición de Swagger. * **Actualizaciones de la API:** Tenga una estrategia para manejar las actualizaciones de la API. Esto podría implicar volver a cargar automáticamente la definición de Swagger o regenerar el código. * **Seguridad:** Tenga cuidado al almacenar claves de API u otra información confidencial en la configuración de su servidor MCP. Use mecanismos de almacenamiento seguros como variables de entorno o sistemas de administración de secretos. * **Rendimiento:** Considere las implicaciones de rendimiento de la interpretación dinámica de las definiciones de Swagger en tiempo de ejecución. La generación de código podría ser más eficiente para aplicaciones críticas para el rendimiento. **En resumen, el mejor enfoque depende de la complejidad de sus API, las capacidades de su servidor MCP y el nivel de automatización deseado. Comience con un enfoque más simple y avance gradualmente a soluciones más complejas según sea necesario.**

Harnios MCP

Harnios is a self-hosted, MCP-based storage system that gives every AI assistant you use — Claude, ChatGPT, Cursor, or anything else — a shared, persistent memory of your business: knowledge base, skills, projects, operational tables, and reports, all in one place. Connect a new tool once, and it reads and writes through the same store instead of starting from zero.

myUplink MCP Server

Connects MCP clients (e.g., Claude) to your NIBE myUplink heat-pump account for reading sensors and controlling settings via OAuth2 authentication.

mcp-lastfm

Provides 41 read-only tools to search and browse Last.fm data, including artists, albums, tracks, user scrobble history, and charts.

SAMP-MCP

A comprehensive MCP server for SA-MP server development and management, enabling AI-assisted server administration, Pawn scripting, plugin management, and diagnostics.

fred-mcp

Enables querying and retrieving Federal Reserve Economic Data (FRED) including series, categories, releases, sources, and tags, with support for stdio and HTTP transports and bring-your-own-key authentication.

Roblox Studio MCP

A production MCP integration that lets AI agents control Roblox Studio to autonomously build, test, and debug Roblox games. Provides 39 tools for explorer control, script management, terrain generation, and autonomous testing.

models-mcp

Enables searching, comparing, and inspecting AI models by pricing, context window, and capabilities via the models.dev catalog.

mariana-outlook-mcp

Gives Claude Code access to Outlook Mail, Calendar, and Contacts via Microsoft Graph, with safety-first defaults (no sending, no hard deletes, every mutation logged). Supports multiple Microsoft accounts through a PKCE OAuth flow.

RAG-MCP

A Python server that enables retrieval-augmented generation through semantic, question/answer, and style search modalities using PostgreSQL and pgvector for embedding storage and retrieval.

app-store-connect-mcp

Enables management of App Store Connect and TestFlight beta testers, including adding/removing testers by email and listing apps and beta groups using an individual API key.

langfuse-mcp

MCP server for Langfuse that lets Claude Code create projects, manage API keys, and query traces without touching the web UI. Designed to work with a self-hosted Langfuse v3 stack running locally via Docker Compose.

automatelab-ai-seo

Vendor-agnostic MCP server that audits, scores, and rewrites web pages for AI-citation eligibility. No API keys. No registration. Works in Claude Desktop, Cursor, Cline, Windsurf, VS Code (Copilot / Continue), and any client that speaks the Model Context Protocol.

identity-mcp

MCP server that gives AI agents disposable email addresses and real phone numbers with automatic OTP extraction and self-destructing identities.

md-to-text

A Model Context Protocol server that converts Markdown documents to plain text with flexible options and dual protocol support.

vibe-prompt-mcp

Fix your vibe coding prompts before they reach the AI. Scores and rewrites across 4 dimensions — no API key, no server, just npx. Now with codebase-aware context injection for design, database, API, auth, testing, and state management.

pi-mcp

MCP server for Raspberry Pi exposing tools for host health checks, shell execution, and Docker container restarts over authenticated HTTP.

opds-mcp

An MCP server that lets an LLM browse, search, and download books from OPDS catalogs (e.g., Project Gutenberg, Standard Ebooks) using tools for feed navigation, full-text search, and acquisition link downloads.