Discover Awesome MCP Servers

GitHub Actions MCP Server

GitHub Actions Model Context Protocol Server that allows you to create, manage, monitor, and interact with workflows.

HK Prompt MCP Server

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

🔌 Zyla API Hub MCP Server

Servidor MCP de Zyla API Hub

NotesY

A Claude MCP integration that allows seamless interaction with Apple Notes through natural language, enabling users to create, update, delete, and search notes.

RemixPost MCP Server

An MCP server that repurposes text or URL content into platform-optimized posts for Twitter, LinkedIn, Instagram, and newsletters using AI. It enables users to automatically transform articles and blog posts into engagement-ready social media threads and professional captions.

ATproto Docs MCP Server

A remote MCP server providing a tool for searching and querying ATprotocol documentation, helping developers easily access information while building on the protocol.

PythonCMCPServer

Construyendo un Servidor MCP Personalizado usando Python

SVG Canvas MCP

An MCP server for Claude Code that enables the creation and manipulation of professional-grade SVG graphics using features like layer management, complex path drawing, and animations. It includes AI-assisted design capabilities for color suggestions and layout optimization, supporting exports to SVG and PNG formats.

MCP BMI Server Template

A minimal FastAPI-based MCP server that provides a tool for calculating Body Mass Index (BMI) using SSE for discovery. It serves as a template for developers to build and deploy lightweight MCP services on platforms like Render.

Dnevnik.ru MCP Server

An MCP server that integrates with the Dnevnik.ru API to provide AI assistants with access to school schedules, grades, and homework. It enables users to query educational data and manage school-related information through natural language.

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.

Boosty MCP DeFi Platform

An enterprise-grade MCP server platform for executing real DeFi operations on Solana and EVM chains using natural language. It enables users to perform live trading, volume generation, and wallet management directly within Claude Desktop.

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

MobSF MCP Server

A Node.js-based Model Context Protocol implementation that provides a standardized interface for integrating Mobile Security Framework's security analysis capabilities into automated workflows and third-party tools.

yfinance MCP Server

Finance mcp server- Get up-to-date prices and news about stocks and cryptocurrencies

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.

MCP File Downloader

Enables Claude Desktop to download files from web URLs with automatic browser fallback for JavaScript-heavy sites. Supports smart redirect handling, custom file naming, and cross-platform compatibility.

Sauce Labs MCP Server

Enables AI assistants to interact with Sauce Labs testing platform through natural language, providing access to device cloud management, test job analysis, build monitoring, and testing infrastructure insights. Supports both Virtual Device Cloud (VDC) and Real Device Cloud (RDC) with comprehensive test analytics and team collaboration features.

Fast MCP Task Manager

Enables AI-powered task management with Google Gemini integration, providing CRUD operations, task analytics, CSV export, and natural language interaction for comprehensive project management.

Multi-agent Communication Protocol Server

A standardized interface for agent-to-agent communication that enables composability, supports streaming, and implements server-sent events (SSE) for real-time interaction.

GoHighLevel MCP Server

Connects Claude Desktop to GoHighLevel CRM with 269+ tools across 19+ categories for complete contact management, messaging, sales pipeline automation, e-commerce operations, and business management through natural language.

Simple MCP Server

A minimalist MCP server that provides a single tool to retrieve a developer name, demonstrating the basic structure for Claude's Model Completion Protocol integration.

Pixabay MCP Server

Enables AI assistants to search for and retrieve images, illustrations, and videos directly from Pixabay. It provides specialized tools for discovering diverse media content like photos and animations using the Pixabay API.

EdgeBox

A local sandbox that provides AI agents with code execution, filesystem access, and a full GUI desktop environment for 'computer use' capabilities. It exposes tools for shell commands, multi-language code interpretation, and remote desktop automation via the Model Context Protocol.

GLM-4.6 MCP Server

Enables Claude to consult GLM-4.6's architectural intelligence for system design, code analysis, scalability patterns, and technical decision-making. Provides specialized tools for enterprise architecture consultation, distributed systems design, and code review through the Model Context Protocol.

Firebase Management MCP Server

An MCP Server providing access to Google's Firebase API, allowing natural language interaction with Firebase services and resources.

Strapi Content MCP

Enables AI assistants to interact directly with Strapi v5 CMS content through full CRUD operations, media uploads, and content type exploration using Strapi's Document Service API.

CrowdStrike Falcon MCP Server

An MCP server that enables interaction with the CrowdStrike Falcon API for managing hosts, detections, IOCs, and security policies. It supports both STDIO and HTTP/REST transport modes for seamless integration with AI clients like Claude and Cursor.