Discover Awesome MCP Servers

MCP SSH Agent

A server that enables secure interaction with remote SSH hosts through standardized MCP interface, providing functions like listing hosts, executing commands, and transferring files using native SSH tools.

Alayman Article Retrieval

Retrieves blog articles from an external API with metadata including titles, authors, URLs, and engagement metrics like share counts and view counts.

mcp-micromanage

Una herramienta de microgestión para flujos de trabajo de desarrollo: Ayuda al agente de codificación a planificar, rastrear y visualizar tareas de desarrollo secuenciales con una granularidad detallada a nivel de commit. Ofrece visualización interactiva, seguimiento automatizado del estado y gestión estructurada del flujo de trabajo.

Octopus Deploy MCP Server

A server that enables interaction with Octopus Deploy through the Model Context Protocol, allowing users to manage projects, releases, and deployments across different spaces.

Langgraph Deep Search MCP Server

An MCP server that utilizes LangGraph and Google Gemini to conduct comprehensive research through multi-iteration deep searches and quick results. It provides high-quality analysis with automated citations and grounding metadata for thorough investigations.

Workspace ONE UEM MCP Server

Enables AI assistants to interact with VMware Workspace ONE UEM environments for device management, user administration, and system operations. Provides access to 25+ commonly used UEM APIs with support for OAuth2 authentication and bulk operations.

Service Health MCP Server

A professional-grade MCP server that enables AI assistants to monitor web services, APIs, and HTTP endpoints with enterprise-level security.

WaPulse WhatsApp MCP Server

A Model Context Protocol server that integrates with WaPulse WhatsApp Web API, enabling users to send messages, manage groups, handle files, and perform various WhatsApp operations programmatically.

PodCrawlerMCP

Here are a few options for translating "MCP server for podcast discovery through web crawling," depending on the nuance you want to convey: **Option 1 (Most straightforward):** * **Servidor MCP para el descubrimiento de podcasts mediante rastreo web.** * This is a direct translation and likely the most common way to express this. **Option 2 (Slightly more technical, emphasizing the process):** * **Servidor MCP para el descubrimiento de podcasts a través del rastreo de la web.** * Using "a través de" (through) can emphasize the *process* of web crawling. **Option 3 (Focusing on the purpose):** * **Servidor MCP para descubrir podcasts utilizando rastreo web.** * This focuses on the *purpose* of the web crawling, which is to discover podcasts. **Breakdown of the terms:** * **MCP Server:** Servidor MCP (This is likely an acronym and should remain as is unless you know the full Spanish equivalent). * **Podcast Discovery:** Descubrimiento de podcasts * **Web Crawling:** Rastreo web (This is a common and accepted translation. You could also use "indexación web" but it's more about indexing than the crawling process itself). **Which option is best?** Option 1 is generally the safest and most widely understood. Choose Option 2 or 3 if you want to emphasize a specific aspect of the process.

MCP Observer Server

A file monitoring server that tracks filesystem events and provides real-time notifications to AI assistants, enabling them to automatically respond to file changes without manual updates.

Amp MCP

Provides developer-focused documentation and tools for building applications on Amp, a high-performance blockchain ETL system. Includes guides, schemas, code examples, and troubleshooting resources for querying and transforming blockchain data.

Neil Mcp Server Include Mysql

include: mcp-mysql

MCP DNS

A Model Context Protocol tool that provides DNS querying capabilities for various record types (A, AAAA, MX, TXT, CNAME, NS, etc.) through a standardized MCP interface.

ai-scheduler-mcp

Entiendo que necesitas un servidor MCP (Microservices Communication Platform) compatible con SSE (Server-Sent Events) para la programación, utilizando las APIs de Google Tasks y Google Calendar. Aquí te presento una traducción más detallada y algunas consideraciones: **Traducción:** "Un servidor MCP compatible con SSE para la programación, que utiliza las APIs de Google Tasks y Google Calendar." **Consideraciones adicionales para la implementación:** * **MCP (Microservices Communication Platform):** Esto implica que el servidor debe estar diseñado para comunicarse con otros microservicios. ¿Qué tipo de comunicación necesitas? (REST, gRPC, etc.) ¿Qué plataforma MCP estás considerando (si es que ya tienes una)? * **SSE (Server-Sent Events):** Esto es crucial. SSE permite que el servidor envíe actualizaciones al cliente en tiempo real. Esto es ideal para notificar cambios en las tareas o eventos del calendario. * **Google Tasks API:** Necesitarás autenticación y autorización para acceder a las tareas de los usuarios. Debes considerar cómo manejarás las credenciales y los permisos. * **Google Calendar API:** Similar a Tasks, necesitarás autenticación y autorización para acceder a los calendarios de los usuarios. * **Programación (Scheduling):** ¿Qué tipo de programación necesitas? ¿Crear eventos? ¿Actualizar tareas? ¿Recibir notificaciones de cambios? La respuesta a esta pregunta definirá la funcionalidad principal del servidor. * **Lenguaje de programación:** ¿Qué lenguaje de programación prefieres usar para construir el servidor? (Python, Node.js, Go, Java, etc.) **En resumen, una traducción más completa y contextualizada sería:** "Necesito un servidor MCP compatible con SSE, que utilice las APIs de Google Tasks y Google Calendar para la funcionalidad de programación. Este servidor debe ser capaz de [especificar la funcionalidad de programación, por ejemplo: crear eventos, actualizar tareas, enviar notificaciones en tiempo real, etc.] y debe estar implementado en [especificar el lenguaje de programación]." Espero que esto te sea útil. Si me proporcionas más detalles sobre tus requisitos, puedo ofrecerte una traducción aún más precisa y útil.

AI Content Detector

Enables detection of AI-generated content from ChatGPT, GPT-4, and Gemini models through the BACH AI Content Detector API.

MCPLab

Aquí tienes ejemplos, código, diseños y tutoriales sobre MCP (Model Context Protocol) servidor-cliente: **Es importante notar que "MCP (Model Context Protocol)" no es un término ampliamente reconocido o estandarizado en la industria del software. Es posible que te refieras a un protocolo específico que se usa internamente en un proyecto o empresa, o quizás a un concepto más general. Por lo tanto, la información que puedo proporcionar será basada en la *interpretación* de lo que podría significar un protocolo de este tipo, asumiendo que se trata de un protocolo para la comunicación entre un servidor y un cliente para el intercambio de información sobre modelos (de datos, de machine learning, etc.).** **Asunciones:** * **Propósito:** Permitir que un cliente solicite y reciba información sobre modelos disponibles en un servidor. Esto podría incluir metadatos del modelo, la estructura del modelo, ejemplos de datos, o incluso el propio modelo (dependiendo de la seguridad y el propósito). * **Arquitectura:** Un modelo cliente-servidor donde el servidor mantiene información sobre los modelos y el cliente la solicita. * **Formato de Datos:** JSON es un formato común para el intercambio de datos, por lo que lo usaremos en los ejemplos. Sin embargo, se podría usar otros formatos como Protocol Buffers, Avro, o incluso XML. * **Transporte:** HTTP/HTTPS es un protocolo de transporte común para este tipo de comunicación. También se podría usar gRPC o WebSockets. **Ejemplo Conceptual (Usando HTTP/JSON):** **1. Definición del Protocolo (Conceptual):** * **Solicitud (Cliente -> Servidor):** * `GET /models` - Obtiene una lista de todos los modelos disponibles. * `GET /models/{model_id}` - Obtiene información detallada sobre un modelo específico. * `GET /models/{model_id}/schema` - Obtiene el esquema del modelo (estructura de datos esperada). * `GET /models/{model_id}/example` - Obtiene un ejemplo de datos para el modelo. * **Respuesta (Servidor -> Cliente):** * JSON con la información solicitada. Los códigos de estado HTTP estándar (200 OK, 404 Not Found, 500 Internal Server Error, etc.) se utilizan para indicar el éxito o el fracaso de la solicitud. **2. Ejemplo de Código (Python - Flask para el Servidor, Requests para el Cliente):** **Servidor (Flask):** ```python from flask import Flask, jsonify app = Flask(__name__) # Simulación de datos de modelos models = { "model1": { "id": "model1", "name": "Predicción de Precios de Viviendas", "description": "Un modelo para predecir el precio de una vivienda basado en sus características.", "version": "1.0" }, "model2": { "id": "model2", "name": "Clasificación de Imágenes", "description": "Un modelo para clasificar imágenes en diferentes categorías.", "version": "2.0" } } model_schemas = { "model1": { "type": "object", "properties": { "area": {"type": "number"}, "bedrooms": {"type": "integer"}, "bathrooms": {"type": "integer"} }, "required": ["area", "bedrooms", "bathrooms"] } } model_examples = { "model1": { "area": 1500, "bedrooms": 3, "bathrooms": 2 } } @app.route('/models', methods=['GET']) def list_models(): return jsonify(list(models.values())) @app.route('/models/<model_id>', methods=['GET']) def get_model(model_id): if model_id in models: return jsonify(models[model_id]) else: return jsonify({"error": "Modelo no encontrado"}), 404 @app.route('/models/<model_id>/schema', methods=['GET']) def get_model_schema(model_id): if model_id in model_schemas: return jsonify(model_schemas[model_id]) else: return jsonify({"error": "Esquema del modelo no encontrado"}), 404 @app.route('/models/<model_id>/example', methods=['GET']) def get_model_example(model_id): if model_id in model_examples: return jsonify(model_examples[model_id]) else: return jsonify({"error": "Ejemplo del modelo no encontrado"}), 404 if __name__ == '__main__': app.run(debug=True) ``` **Cliente (Python - Requests):** ```python import requests SERVER_URL = "http://127.0.0.1:5000" # Cambia si el servidor está en otra dirección def list_models(): response = requests.get(f"{SERVER_URL}/models") if response.status_code == 200: print("Lista de Modelos:") print(response.json()) else: print(f"Error: {response.status_code} - {response.text}") def get_model_details(model_id): response = requests.get(f"{SERVER_URL}/models/{model_id}") if response.status_code == 200: print(f"Detalles del Modelo {model_id}:") print(response.json()) elif response.status_code == 404: print(f"Modelo {model_id} no encontrado.") else: print(f"Error: {response.status_code} - {response.text}") def get_model_schema(model_id): response = requests.get(f"{SERVER_URL}/models/{model_id}/schema") if response.status_code == 200: print(f"Esquema del Modelo {model_id}:") print(response.json()) elif response.status_code == 404: print(f"Esquema del Modelo {model_id} no encontrado.") else: print(f"Error: {response.status_code} - {response.text}") def get_model_example(model_id): response = requests.get(f"{SERVER_URL}/models/{model_id}/example") if response.status_code == 200: print(f"Ejemplo del Modelo {model_id}:") print(response.json()) elif response.status_code == 404: print(f"Ejemplo del Modelo {model_id} no encontrado.") else: print(f"Error: {response.status_code} - {response.text}") if __name__ == '__main__': list_models() get_model_details("model1") get_model_details("model3") # Modelo inexistente get_model_schema("model1") get_model_example("model1") ``` **3. Diseño:** * **Servidor:** * **API RESTful:** Usar una API RESTful con endpoints claros y bien definidos. * **Autenticación y Autorización:** Implementar mecanismos de autenticación (e.g., API keys, OAuth) y autorización para controlar el acceso a los modelos. Esto es *crucial* si los modelos son sensibles. * **Control de Versiones:** Gestionar las versiones de los modelos para permitir la compatibilidad con versiones anteriores. * **Logging y Monitoring:** Implementar logging y monitoring para rastrear el uso de la API y detectar problemas. * **Escalabilidad:** Diseñar el servidor para que pueda escalar horizontalmente para manejar un gran número de solicitudes. * **Cliente:** * **Manejo de Errores:** Implementar un manejo robusto de errores para lidiar con fallos de red, errores del servidor, etc. * **Reintentos:** Implementar lógica de reintento para solicitudes fallidas. * **Cache:** Implementar un mecanismo de cache para almacenar en caché la información del modelo y reducir la carga en el servidor. * **Asincronía:** Usar operaciones asíncronas para evitar bloquear la interfaz de usuario mientras se espera la respuesta del servidor. **4. Tutoriales y Recursos Adicionales:** * **Flask (Python):** [https://flask.palletsprojects.com/](https://flask.palletsprojects.com/) * **Requests (Python):** [https://requests.readthedocs.io/](https://requests.readthedocs.io/) * **RESTful APIs:** Busca tutoriales sobre cómo diseñar y construir APIs RESTful. * **Autenticación y Autorización:** Investiga sobre OAuth 2.0, JWT (JSON Web Tokens), y otros mecanismos de autenticación. * **gRPC:** Si necesitas un protocolo de alto rendimiento, considera gRPC: [https://grpc.io/](https://grpc.io/) * **Protocol Buffers:** Un formato de serialización eficiente para gRPC: [https://developers.google.com/protocol-buffers](https://developers.google.com/protocol-buffers) **Consideraciones Adicionales:** * **Seguridad:** La seguridad es primordial. Asegúrate de proteger los modelos y la información que se intercambia entre el cliente y el servidor. * **Rendimiento:** Optimiza el rendimiento del servidor y del cliente para garantizar una experiencia de usuario fluida. * **Documentación:** Documenta el protocolo y la API de forma clara y concisa. * **Pruebas:** Escribe pruebas unitarias y de integración para garantizar la calidad del código. **En resumen, el "MCP" que he interpretado es un protocolo para el intercambio de información sobre modelos entre un cliente y un servidor. La implementación específica dependerá de tus necesidades y requisitos. Los ejemplos de código y las consideraciones de diseño proporcionadas son un punto de partida para construir tu propio protocolo.** Si "MCP" significa algo diferente, por favor, proporciona más detalles para que pueda darte una respuesta más precisa.

Fraim Context MCP

Enables semantic search of project documentation using hybrid vector and full-text search with fast and deep query modes for immediate results or complex multi-round synthesis.

Firebase App Check MCP Server

An MCP server that enables interaction with the Firebase App Check API, allowing users to verify and manage the authenticity of requests to Firebase backend services through natural language.

idescat-mcp

Provides access to Catalonia's statistical data via the IDESCAT Tables API v2. It enables users to navigate catalogs, inspect metadata, and query data with territorial filters and resolved labels.

Dedalus MCP Documentation Server

Enables AI-powered querying and management of documentation through markdown file serving, keyword search, and OpenAI-based Q\&A capabilities. Supports document indexing, analysis, and agent handoffs with rate limiting protection.

Remote MCP Server on Cloudflare

Enables the deployment of a remote Model Context Protocol server to Cloudflare Workers without authentication. It allows users to define custom tools that can be accessed via SSE by clients like Claude Desktop or the Cloudflare AI Playground.

Advanced HWP MCP Server

Enables comprehensive control of Hangul (HWP) documents through an MCP server, supporting operations from basic document management to advanced formatting, tables, images, and document structure manipulation.

Postal MCP Server

A SQLite-backed message queue system that enables multiple AI agents to communicate with each other via a simple HTTP interface.

Gaia-Protocol

Gaia Protocol—a planetary DAO for global resource management using quantum-entangled ledgers and algorithmic governance.

Oracle MCP Server

Implementación de un servidor de Protocolo de Contexto de Modelo (MCP) para operaciones de bases de datos Oracle.

MCP Server with Qdrant

qdrant + mcp-qdrant-server

Excel to JSON MCP by WTSolutions

The Excel to JSON MCP provides a standardized interface for converting Excel and CSV data into JSON format using the Model Context Protocol.

whois-mcp

A WHOIS domain name query server based on Model Context Protocol (MCP), supporting the resolution of over 877 top-level domains and 169 country code top-level domains, and providing comprehensive domain name registration information query functions.