Discover Awesome MCP Servers

godotlens-mcp

An MCP server providing 15 semantic analysis tools for GDScript, powered by Godot's built-in Language Server.

Brown Courses MCP Server

Enables searching Brown University courses, getting detailed course info, and checking schedule conflicts via natural language, using the university's public course catalog API.

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.

Module Craft

MCP server for standardizing software module development with tools for planning, code quality analysis, security scanning, performance evaluation, documentation generation, accessibility checks, and progress tracking.

SAMP-MCP

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

Harness Engineering MCP

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

Jokes MCP Server

Delivers Chuck Norris jokes and Dad jokes on demand through Microsoft Copilot Studio and GitHub Copilot. Demonstrates how to deploy and integrate MCP servers with Microsoft's AI platforms.

claude-secrets

Encrypted token store for Claude Code sessions, providing MCP tools for secure secret management with macOS Keychain integration, per-project allowlists, and native dialog input.

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

🔌 Zyla API Hub MCP Server

Servidor MCP de Zyla API Hub

Bear MCP Server

An MCP server that integrates Bear Note Taking App with Claude Desktop, allowing Claude to read, create, search notes and manage tags directly from Bear.

HK Prompt MCP Server

An MCP server that provides custom prompts for guiding bot interactions, specifically to avoid using brackets in descriptions.

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.

Bibliography Search MCP

A multi-source academic bibliography search server that retrieves papers from 7 databases with automatic language detection, LLM-powered query planning, and relevance scoring.

SSH MCP Server

Enables SSH connectivity and remote command execution on servers, allowing users to test connections and run commands remotely with support for both local networks and public servers.

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.

large-repo-mcp-server

A stdio-based MCP server for fast, bounded search and navigation of large code repositories using ripgrep, with tools for project-wide search, symbol lookup, file listing, and code reading.

organon-create-image

MCP server for generating images using Gemini, supporting multiple aspect ratios and both AI Studio and Vertex AI backends.

MCP Servers for QA and Release Coordination

A collection of MCP servers for Slack, Jira, Confluence, and release coordination to automate QA workflows and daily release status reporting.

Supabase Coolify MCP Server

Enables comprehensive management of self-hosted Supabase instances on Coolify, including database migrations, edge functions deployment, storage management, auth configuration, and full application lifecycle control through AI agents.

@mobilpay/mcp-server

An MCP server for KG Financial's payment services integration, enabling AI coding tools to generate accurate code by automatically searching payment integration documentation through natural language queries.

asm-hubspot-mcp-client-openclaw

Bridges AI assistants to HubSpot CRM via OAuth2.1+PKCE, enabling tool access through OpenClaw or stdio MCP.

MCP Jira DevFlow

A Scrum-aware MCP server that provides semantic analysis of Jira issues, sprint health, and Agile workflow intelligence, returning structured summaries and recommendations instead of raw Jira payloads.

Bit2Me MCP Server

Enables AI assistants to interact with the Bit2Me cryptocurrency ecosystem, including real-time market data, wallet management, trading, and products like Earn and Loans.

kubernetes-mcp

MCP server that gives AI assistants full access to Kubernetes clusters and Helm, exposing 73 tools for managing pods, deployments, services, configs, secrets, logs, exec, port-forwarding, Helm lifecycle, and more.

intervals-icu-mcp

Read/write MCP server for Intervals.icu — 51 tools spanning activities, streams, wellness, calendar, gear, and sport zones, plus structured workout generation with a built-in syntax reference for cycling, running, and swimming.

etfedge-mcp

Read-only MCP server for Taiwan active ETF research database, providing tools to list ETFs, track buy/sell deltas, view stock history and PnL, and find consensus buys across ETFs.

tron-event-mcp

Enables natural-language-driven on-chain data analysis for TRON blockchain events via MongoDB, allowing AI assistants to query blocks, transactions, contract events, and perform analytics like aggregations, histograms, and address profiling.