Discover Awesome MCP Servers

Todoist MCP

An MCP server that enables LLMs to interact with Todoist tasks, projects, and other features through the Todoist API.

NPM Types MCP Server

An MCP (Model Context Protocol) server for providing TypeScript type definitions as MCP Resources.

Webflow

Interactuar con sitios, páginas y colecciones de Webflow.

Git Prompts MCP Server

Un servidor de Protocolo de Contexto de Modelo que genera prompts basados en el contenido de un repositorio Git, incluyendo un comando para generar descripciones de PR a partir de diffs.

NexonCo MCP

An advanced Medical Care Platform server designed for accessing and analyzing clinical evidence data to support precision medicine and oncology research.

Realtime Crypto MCP Server

Un servidor que proporciona datos de criptomonedas en tiempo real a través del Protocolo de Contexto de Modelo, permitiendo el acceso a información detallada de intercambios y las tasas de criptomonedas actuales desde la API de CoinCap.

mcp-api-tools

A comprehensive suite of HTTP and API testing tools that enables AI agents to perform requests, check endpoint health, and decode JWTs. It also provides utilities for URL parsing and detailed security analysis of HTTP response headers.

Claude Code Notification Hooks

Provides automatic desktop notifications and contextual sounds for Claude Code operations across macOS, Windows, and Linux. It enhances the development experience by intelligently mapping specific event types to native system alerts and sounds.

Home Assistant Light MCP

A specialized MCP server for detailed control of Home Assistant lights, supporting advanced features like RGB colors, color temperatures, effects, and robust scene management. It includes specific fixes for IKEA Tradfri devices and intentionally focuses on lights only to ensure home safety.

Confluence MCP Server

A server application that integrates with Atlassian Confluence API, providing custom endpoints for MCP functionality to interact with Confluence content.

Home Depot MCP Server

Provides comprehensive investment research and analysis for The Home Depot, Inc. (HD) including real-time stock data, news sentiment analysis, economic indicators, SEC filings, and investment thesis generation. Enables users to perform complete financial analysis and market intelligence gathering through natural language queries.

IoTDB MCP Server

Un servidor de Protocolo de Contexto de Modelo que permite a los asistentes de IA interactuar de forma segura con las bases de datos Apache IoTDB a través de una interfaz controlada para listar tablas, leer datos y ejecutar consultas SQL.

PubMed MCP Server

Provides comprehensive access to NCBI's PubMed database of over 36 million biomedical citations, allowing users to search, retrieve, and analyze literature directly through MCP tools. It supports advanced queries, citation management, full-text retrieval from PubMed Central, and precise discovery using MeSH terms.

cntx-ui

Provides AI tools with direct access to project file bundles and structure through MCP resources and tools, enabling context-aware development workflows with real-time bundle management.

Paper Search MCP

Enables searching and downloading academic papers from multiple sources including arXiv, PubMed, bioRxiv, Google Scholar, and Semantic Scholar. Provides standardized tools for research workflows and OpenAI Deep Research integration.

Moz Da Pa1 MCP Server

Enables access to Moz API to retrieve Domain Authority, Page Authority, external URLs, and Spam Score metrics for website analysis.

Advanced Hasura GraphQL MCP Server

Un servidor de Protocolo de Contexto de Modelo que permite a los agentes de IA interactuar dinámicamente con los endpoints de Hasura GraphQL a través del lenguaje natural, soportando el descubrimiento de esquemas, la consulta/manipulación de datos y las agregaciones.

Weatherapi Com MCP Server

Provides access to comprehensive weather data including real-time conditions, forecasts, historical weather, marine data, astronomy information, and weather alerts through the Weatherapi.com API.

Columbia MCP Server

Facilitates deployment and management of services using the Model Context Protocol with a focus on high availability, scalability, and secure communication, leveraging Docker-based infrastructure, Prometheus, and Grafana for monitoring.

MCP Recherche d'entreprises

Enables interaction with the French business search API from data.gouv.fr, allowing users to search for French companies by text or geographical criteria and access essential business information.

AI Assistant Chat with Nmap Tool Integration

Okay, here's an example of a simple MCP (Management Console Program) server, along with a basic structure for incorporating `nmap` scans as tools. This is a conceptual outline and would require more detailed coding for a fully functional implementation. I'll provide explanations in both English and Spanish. **English:** **Concept:** The MCP server will: 1. **Listen for connections:** Accept incoming connections from clients (e.g., other scripts or programs). 2. **Receive commands:** Parse commands sent by the client. These commands will specify which `nmap` scan to run and on what target. 3. **Execute `nmap`:** Run the specified `nmap` command using the target provided. 4. **Return results:** Send the output of the `nmap` scan back to the client. **Simplified Python Example (using `subprocess` and `socket`):** ```python import socket import subprocess import json HOST = '127.0.0.1' # Standard loopback interface address (localhost) PORT = 65432 # Port to listen on (non-privileged ports are > 1023) def run_nmap_scan(target, scan_type): """Runs an nmap scan and returns the output.""" try: if scan_type == "quick": command = ["nmap", "-F", target] # Quick scan elif scan_type == "syn": command = ["nmap", "-sS", target] # SYN scan else: return "Error: Invalid scan type." result = subprocess.run(command, capture_output=True, text=True, timeout=60) # Added timeout if result.returncode == 0: return result.stdout else: return f"Error: nmap returned code {result.returncode}\n{result.stderr}" except subprocess.TimeoutExpired: return "Error: nmap scan timed out." except FileNotFoundError: return "Error: nmap not found. Make sure it's installed and in your PATH." except Exception as e: return f"Error: An unexpected error occurred: {e}" with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) s.listen() print(f"Listening on {HOST}:{PORT}") conn, addr = s.accept() with conn: print(f"Connected by {addr}") while True: data = conn.recv(1024) if not data: break try: request = json.loads(data.decode()) target = request.get("target") scan_type = request.get("scan_type") if not target or not scan_type: response = {"status": "error", "message": "Missing target or scan_type"} else: nmap_output = run_nmap_scan(target, scan_type) response = {"status": "success", "result": nmap_output} except json.JSONDecodeError: response = {"status": "error", "message": "Invalid JSON"} except Exception as e: response = {"status": "error", "message": str(e)} conn.sendall(json.dumps(response).encode()) ``` **Client Example (Python):** ```python import socket import json HOST = '127.0.0.1' # The server's hostname or IP address PORT = 65432 # The port used by the server with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.connect((HOST, PORT)) request = {"target": "scanme.nmap.org", "scan_type": "quick"} # Example request s.sendall(json.dumps(request).encode()) data = s.recv(4096) # Increased buffer size print('Received:', repr(json.loads(data.decode()))) ``` **Explanation:** * **`run_nmap_scan(target, scan_type)`:** This function takes a target IP address/hostname and a scan type ("quick" or "syn") as input. It constructs the `nmap` command, executes it using `subprocess.run`, and returns the output. Error handling is included for `nmap` not being found, timeouts, and other exceptions. A timeout is added to prevent scans from running indefinitely. * **Socket Setup:** The code sets up a basic TCP socket server that listens for connections on `HOST` and `PORT`. * **Command Handling:** When a client connects, the server receives data, decodes it as JSON, and extracts the `target` and `scan_type`. It then calls `run_nmap_scan` to perform the scan. * **JSON Communication:** The client and server communicate using JSON (JavaScript Object Notation) for structured data exchange. This makes it easier to send and receive complex commands and results. * **Error Handling:** The code includes basic error handling for invalid JSON, missing parameters, and `nmap` errors. * **Client:** The client connects to the server, sends a JSON request specifying the target and scan type, and prints the received response. **Important Considerations:** * **Security:** This is a *very* basic example and has significant security implications. **Never** expose this kind of server directly to the internet. You need to implement proper authentication, authorization, and input validation to prevent malicious users from running arbitrary commands on your system. Consider using a more robust framework like Flask or Django for a production-ready solution. * **Input Validation:** Thoroughly validate the `target` and `scan_type` parameters to prevent command injection vulnerabilities. Use a whitelist of allowed scan types. * **Permissions:** The user running the MCP server needs to have the necessary permissions to execute `nmap`. Be very careful about granting excessive permissions. * **Error Handling:** Implement more robust error handling and logging. * **Scalability:** This simple example is not designed for high concurrency. For a production system, you'll need to use a more scalable architecture (e.g., using threads, asynchronous I/O, or a message queue). * **Nmap Installation:** Ensure `nmap` is installed on the server and accessible in the system's PATH. **Spanish:** **Concepto:** El servidor MCP: 1. **Escuchará conexiones:** Aceptará conexiones entrantes de clientes (por ejemplo, otros scripts o programas). 2. **Recibirá comandos:** Analizará los comandos enviados por el cliente. Estos comandos especificarán qué escaneo de `nmap` ejecutar y en qué objetivo. 3. **Ejecutará `nmap`:** Ejecutará el comando `nmap` especificado utilizando el objetivo proporcionado. 4. **Devolverá resultados:** Enviará la salida del escaneo de `nmap` de vuelta al cliente. **Ejemplo Simplificado en Python (usando `subprocess` y `socket`):** ```python import socket import subprocess import json HOST = '127.0.0.1' # Dirección de interfaz de bucle invertido estándar (localhost) PORT = 65432 # Puerto para escuchar (los puertos no privilegiados son > 1023) def run_nmap_scan(target, scan_type): """Ejecuta un escaneo de nmap y devuelve la salida.""" try: if scan_type == "quick": command = ["nmap", "-F", target] # Escaneo rápido elif scan_type == "syn": command = ["nmap", "-sS", target] # Escaneo SYN else: return "Error: Tipo de escaneo inválido." result = subprocess.run(command, capture_output=True, text=True, timeout=60) # Se agregó un tiempo de espera if result.returncode == 0: return result.stdout else: return f"Error: nmap devolvió el código {result.returncode}\n{result.stderr}" except subprocess.TimeoutExpired: return "Error: El escaneo de nmap excedió el tiempo de espera." except FileNotFoundError: return "Error: nmap no se encontró. Asegúrate de que esté instalado y en tu PATH." except Exception as e: return f"Error: Ocurrió un error inesperado: {e}" with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) s.listen() print(f"Escuchando en {HOST}:{PORT}") conn, addr = s.accept() with conn: print(f"Conectado por {addr}") while True: data = conn.recv(1024) if not data: break try: request = json.loads(data.decode()) target = request.get("target") scan_type = request.get("scan_type") if not target or not scan_type: response = {"status": "error", "message": "Falta el objetivo o el tipo de escaneo"} else: nmap_output = run_nmap_scan(target, scan_type) response = {"status": "success", "result": nmap_output} except json.JSONDecodeError: response = {"status": "error", "message": "JSON inválido"} except Exception as e: response = {"status": "error", "message": str(e)} conn.sendall(json.dumps(response).encode()) ``` **Ejemplo de Cliente (Python):** ```python import socket import json HOST = '127.0.0.1' # El nombre de host o la dirección IP del servidor PORT = 65432 # El puerto utilizado por el servidor with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.connect((HOST, PORT)) request = {"target": "scanme.nmap.org", "scan_type": "quick"} # Ejemplo de solicitud s.sendall(json.dumps(request).encode()) data = s.recv(4096) # Aumenté el tamaño del buffer print('Recibido:', repr(json.loads(data.decode()))) ``` **Explicación:** * **`run_nmap_scan(target, scan_type)`:** Esta función toma una dirección IP/nombre de host objetivo y un tipo de escaneo ("quick" o "syn") como entrada. Construye el comando `nmap`, lo ejecuta usando `subprocess.run` y devuelve la salida. Se incluye el manejo de errores para cuando `nmap` no se encuentra, tiempos de espera y otras excepciones. Se agrega un tiempo de espera para evitar que los escaneos se ejecuten indefinidamente. * **Configuración del Socket:** El código configura un servidor de socket TCP básico que escucha las conexiones en `HOST` y `PORT`. * **Manejo de Comandos:** Cuando un cliente se conecta, el servidor recibe datos, los decodifica como JSON y extrae el `target` y el `scan_type`. Luego llama a `run_nmap_scan` para realizar el escaneo. * **Comunicación JSON:** El cliente y el servidor se comunican utilizando JSON (JavaScript Object Notation) para el intercambio de datos estructurados. Esto facilita el envío y la recepción de comandos y resultados complejos. * **Manejo de Errores:** El código incluye un manejo de errores básico para JSON inválido, parámetros faltantes y errores de `nmap`. * **Cliente:** El cliente se conecta al servidor, envía una solicitud JSON especificando el objetivo y el tipo de escaneo, e imprime la respuesta recibida. **Consideraciones Importantes:** * **Seguridad:** Este es un ejemplo *muy* básico y tiene implicaciones de seguridad significativas. **Nunca** expongas este tipo de servidor directamente a Internet. Necesitas implementar autenticación, autorización y validación de entrada adecuadas para evitar que usuarios maliciosos ejecuten comandos arbitrarios en tu sistema. Considera usar un framework más robusto como Flask o Django para una solución lista para producción. * **Validación de Entrada:** Valida exhaustivamente los parámetros `target` y `scan_type` para evitar vulnerabilidades de inyección de comandos. Utiliza una lista blanca de tipos de escaneo permitidos. * **Permisos:** El usuario que ejecuta el servidor MCP necesita tener los permisos necesarios para ejecutar `nmap`. Ten mucho cuidado al otorgar permisos excesivos. * **Manejo de Errores:** Implementa un manejo de errores y registro más robustos. * **Escalabilidad:** Este simple ejemplo no está diseñado para una alta concurrencia. Para un sistema de producción, necesitarás usar una arquitectura más escalable (por ejemplo, usando hilos, E/S asíncrona o una cola de mensajes). * **Instalación de Nmap:** Asegúrate de que `nmap` esté instalado en el servidor y accesible en el PATH del sistema. This example provides a starting point. Remember to prioritize security and implement proper safeguards before deploying anything like this in a real-world environment. Good luck!

Superjolt MCP Server

Enables AI-powered infrastructure management of JavaScript applications via natural language commands, allowing users to deploy, configure, and manage cloud services through Claude Desktop.

OpenSearch MCP Server

Un servidor de Protocolo de Contexto de Modelo que permite consultar y analizar los registros de seguridad de Wazuh almacenados en OpenSearch, con funciones para buscar alertas, obtener información detallada, generar estadísticas y visualizar tendencias.

MCP Design System Bridge

Enables bidirectional synchronization between IDEs and Figma for Design System management, allowing developers to generate React components and synchronize design tokens, icons, and components across platforms.

Keyword Search MCP Server

Enables case-insensitive keyword search within files, returning matching lines with their line numbers through a FastAPI-powered interface.

openemr-mcp

An MCP server that connects AI assistants to OpenEMR instances to manage patient records, clinical trends, and medication safety. It provides 17 tools for tasks such as patient search, drug interaction checks, and generating comprehensive health trajectories and visit preparations.

Steam MCP Server (Node.js/TypeScript)

Servidor MCP para estadísticas de juegos de la API web de Steam

Tempo

An MCP server for Spotify control and synchronized lyrics retrieval that enables playback management, queue navigation, and music search capabilities. It also features perception tools for real-time track analysis, including BPM, key detection, and timestamped lyrics.