Discover Awesome MCP Servers

motherduck-mcp

MCP server for SQL analytics on DuckDB and MotherDuck databases, enabling AI assistants and IDEs to query data via natural language.

Kali Linux MCP Server

Provides secure access to Kali Linux security tools through containerized execution, enabling network scanning, web application testing, and security assessments.

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.

spotify-mcp-server

Connects AI assistants to the Spotify Web API, enabling playback control, search, and recommendations.

offline-mcp-educational-server

Enables generation of educational content like MCQs, lesson plans, and flashcards without relying on external LLMs, fully offline and compatible with Claude Desktop.

Ollama MCP Wrapper

Enables AI agents to interact with local Ollama models for text generation and tool calling with prompt injection protection.

multi-mailbox-gmail

Enables connecting and searching multiple Gmail or Google Workspace accounts via friendly aliases, with read-only access and source mailbox attribution for each result.

x402-codesearch-mcp

Enables free indexing of repository files into a live semantic code search Worker via the index_code tool, while semantic search requires calling the paid x402-gated endpoint directly.

ASO MCP Server

Enables App Store Optimization research for Google Play Store, including app search, details, reviews, keyword suggestions, and metadata validation.

wp-mcp

MCP server for WordPress content management via REST API, supporting posts, pages, media, comments, and terms through natural language interfaces like Cursor, ChatGPT, Codex, and Claude.

calso

MCP server for Calso, a local Persian calendar and task manager. It provides 17 tools enabling AI to create tasks, read schedules, and plan days with Solar Hijri dates.

Unity MCP

Connects Claude Code to the Unity Editor via MCP, enabling AI-driven control of scenes, assets, components, UI, animations, and more through 91 tools.

ProjectDoc

Enables AI editors to collaboratively manage project documentation, including todos, decisions, pitfalls, and interfaces, through MCP protocol tools.

Remote MCP Server Authless

A serverless MCP implementation on Cloudflare Workers that allows connecting AI models to custom tools without requiring authentication.

obsidian-mcp

Enables LLM clients to read, create, edit, delete, move, and search notes in local Obsidian vaults via direct filesystem access, including tag management and support for multiple vaults.

dns-mcp

Resolves DNS records (A, AAAA, MX, etc.) for a given hostname using Node's built-in dns/promises resolver.

mcp-rag-agent

Enables document-based Q&A with multi-modal RAG, hybrid retrieval, knowledge graph reasoning, and multi-agent orchestration via MCP tools.

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.

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

MCP Server Validation

Repositorio de prueba para la validación del servidor GitHub MCP

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.

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.

SEO Research MCP

Enables AI coding assistants to perform SEO research tasks including backlink analysis, keyword research, traffic estimation, and keyword difficulty analysis using Ahrefs data directly within IDEs.