Discover Awesome MCP Servers

Mock Data Server

MCP server that generates mock data.

MCP YAML API

A Model Context Protocol server that creates tools from API configurations defined in YAML files, allowing easy integration of external APIs into an MCP ecosystem without coding.

QuickBooks Online MCP Server

Enables AI assistants to query and manage QuickBooks Online data through natural language, including customers, invoices, bills, vendors, accounts, and financial reports.

MCP Task Manager Server

Un servidor local del Protocolo de Contexto de Modelo que proporciona herramientas de backend para que los agentes de IA gestionen proyectos y tareas con almacenamiento persistente en SQLite, lo que permite un seguimiento estructurado de las tareas del proyecto con dependencias, prioridades y estados.

mcp-repo-graph

Structural graph map of any codebase. Scans entities, relationships, and feature flows across 13 languages so LLMs navigate by structure instead of reading everything.

OpenTester

OpenTester is a testing execution engine designed for AI coding tools (Claude Code, Cursor, OpenCode, etc.). It provides a unified DSL format and MCP interface, enabling Agents to generate, execute, and manage test cases, achieving an automated "code-test-fix" workflow.

renoun-mpc

Structural observability for AI conversations. Detects loops, stuck states, breakthroughs, and convergence across 17 channels without analyzing content.

mcp-gh-pr-mini

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

Bulk WhatsApp Validator

Enables validation of single or bulk WhatsApp numbers and retrieval of account metadata, such as business status and profile info, via the Bulk WhatsApp Validator API.

MCP Autonomous Analyst

A local, agentic AI pipeline that analyzes tabular data, detects anomalies, and generates interpretive summaries using local LLMs orchestrated via the Model Context Protocol.

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.

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.

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

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

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.

yfinance MCP Server

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

Herald

The self-hosted MCP bridge between Claude Chat and Claude Code.

MCP Meeting Agent

Enhances meetings by providing technology trivia questions, interesting fun facts, and current GitHub trending repositories. Generates formatted meeting notes with engaging content to make meetings more interactive and informative.

Google Data Catalog MCP Server by CData

This project builds a read-only MCP server. For full read, write, update, delete, and action capabilities and a simplified setup, check out our free CData MCP Server for Google Data Catalog (beta): https://www.cdata.com/download/download.aspx?sku=HGZK-V&type=beta

mcp_repod27deec8-0d1e-446e-b4d2-f2860d808f71

Este es un repositorio de prueba creado por un script de prueba del Servidor MCP para GitHub.

TypeScript MCP Server Boilerplate

A boilerplate project for quickly developing Model Context Protocol servers using TypeScript SDK, with example implementations of calculator tools, greeting functionality, and resource management.

Memory MCP

A knowledge-graph-based memory system for AI agents that enables persistent information storage between conversations.

Liana-MCP

Enables natural language interface for single-cell RNA-Seq analysis using Liana. Supports reading/writing scRNA-Seq data, cell-cell communication analysis, and visualization through circle plots and dotplots.

MCP Container Weather Server

A Docker-based MCP server that provides current weather information for cities worldwide. Enables AI assistants like Claude to fetch temperature, weather conditions, and humidity data through a standardized interface.

Feishu/Lark OpenAPI MCP

A toolkit that enables AI assistants to directly call Feishu/Lark API interfaces for automation scenarios like document processing, conversation management, and calendar scheduling.

MCP WordPress Server

Enables comprehensive WordPress site management through natural language in Claude Desktop, supporting multiple sites with 59 tools for content creation, media management, user administration, and performance monitoring.

ssis-adf-agent

An MCP server that enables automated analysis and conversion of SSIS packages into Azure Data Factory JSON artifacts directly through GitHub Copilot. It streamlines ETL modernization by detecting complex patterns, translating script tasks, and generating production-ready pipelines following Microsoft best practices.

Firebase Management MCP Server

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