Discover Awesome MCP Servers

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.

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!

Shopify Storefront MCP Server

Enables interaction with multiple Shopify stores simultaneously through the Storefront API. Supports product search, cart management, and store operations across configured Shopify stores through natural language.

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.

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

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

MCP Outlook Scheduler

Enables AI assistants to intelligently schedule meetings by checking Microsoft Outlook calendars, finding available time slots across multiple participants, and automatically booking meetings with Teams integration. Uses Microsoft Graph API with smart fallback logic for optimal scheduling.

MySQL MCP Server

Enables AI assistants to manage MySQL databases through natural language commands. Supports database operations, table management, data queries, and import/export functionality with built-in security features.

MCP Server SPARQL

Un servidor MCP para consultar un endpoint SPARQL.

Data Planning Agent

Transforms high-level business intents into structured Data Product Requirement Prompts through AI-powered conversational refinement. Guides users through clarifying questions to gather comprehensive requirements for automated Business Intelligence dashboard generation.

mcp

Servidor de MCP

AI MCP Server of Blockchain

Un servidor MCP de blockchain que soporta Ethereum, Bitcoin y VeChain.

mcp-taskade

mcp-taskade

Telegram Notification MCP Server

Enables Claude Code to send Telegram notifications when tasks complete, errors occur, or user intervention is needed. Runs serverless on Cloudflare Workers with support for formatted messages and flexible chat targeting.

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

ML Jupyter MCP

Execute Python code with persistent state across Claude conversations using a background Jupyter kernel. Supports creating notebooks, managing virtual environments, and maintaining variables/imports between code executions.

MCP Notes

A personal knowledge management system built on the Model Context Protocol that transforms daily notes into organized, searchable knowledge.

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.

Weather MCP Server

Provides weather information including alerts and forecasts for any location, web search capabilities through Brave Search API, and basic math operations. Includes weather-based event suggestions to help users plan activities based on current conditions.

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.