Discover Awesome MCP Servers

POC MCP Server

Un servidor de prueba de concepto que proporciona herramientas para acceder y administrar datos, formularios, respuestas a formularios y proyectos de Loomer, con capacidades de paginación, filtrado y ordenamiento.

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!

PDF Processor MCP Server

A Model Context Protocol server that enables Claude to fetch, process, and extract information from PDF documents, including LaTeX mathematical equations.

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.

Automation Script Generator MCP Server

Processes test scenarios from user prompts to generate complete WDIO test suites with intelligent file management that analyzes existing files to determine whether to update them or create new ones.

Cloudsword

一款帮助云租户发现和测试云上风险、增强云上防护能力的综合性开源工具

Steam MCP Server (Node.js/TypeScript)

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

MySQL MCP Server

A server that provides LLMs with read-only access to MySQL databases, allowing them to inspect database schemas and execute read-only queries.

SettleMint

Aproveche el servidor del Protocolo de Contexto de Modelos de SettleMint para interactuar sin problemas con la infraestructura blockchain empresarial. Construya, implemente y gestione contratos inteligentes a través de asistentes impulsados por IA, optimizando su flujo de trabajo de desarrollo blockchain para una máxima eficiencia.

Confluence MCP Server

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

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.

Pica MCP Server

Una implementación en TypeScript del servidor del Protocolo de Contexto de Modelo para Pica que permite a los usuarios de Claude Desktop interactuar con plataformas conectadas como Gmail, Google Sheets, Slack y bases de datos a través de comandos en lenguaje natural.

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.

Stellastra MCP Server

An MCP Server that enables multi-agent conversation interactions with the Stellastra API, auto-generated using AG2's MCP builder.

Dokploy MCP Server

A middleware service that allows LLMs and AI assistants to directly interact with the Dokploy platform through a standardized interface, providing access to Docker, project, and application management capabilities.

sequential-thinking-claude-code

sequential-thinking-claude-code

RhinoMCP

A Model Context Protocol server that connects Rhino and Grasshopper to Claude AI, enabling prompt-assisted 3D modeling, scene creation, and manipulation through direct AI interaction with the Rhino environment.

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 Server Aibd Devcontainer

Servidor MCP para el desarrollo impulsado por IA en DevContainers de VS Code.

mcp-remote-server

Servidor de contexto remoto MCP para la integración de Copilot

mcp

Servidor de MCP