Discover Awesome MCP Servers

Nano Banana Pro MCP Server

Brings Google Gemini 2.0 Flash native image generation capabilities into Claude Code, enabling users to generate, edit, compose, and iteratively refine images using natural language prompts directly from their coding environment.

Docmost MCP Server

Enables AI agents to search, create, modify, and organize documentation pages and spaces in Docmost.

Locket MCP Server

Enables interaction with a read-later and link sharing social feed app, allowing users to manage links, bookmarks, and share through web, API, and MCP.

Trello MCP Server

Provides seamless integration with Trello's API to manage boards, lists, and cards through natural language. It supports full CRUD operations, card movement, and the ability to load Trello resources directly into an LLM's context for analysis.

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.

netsuite-saved-search-mcp

Exposes NetSuite saved search exports as a structured query interface for Claude, enabling file discovery, column inspection, filtering, aggregation, memo categorization, and anomaly detection.

boondmanager-mcp-server

MCP server for the BoondManager API, enabling Claude to search, create, and modify records across 36 domains with 158 tools.

internet-context-mcp

A read-only MCP server that gives AI agents the web as compact, ranked, verified evidence — no API keys, no cloud retrieval, all models local.

MCP Notes

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

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.

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!

gmail-mcp

A Model Context Protocol server that enables full management of Gmail accounts, including messages, threads, labels, and drafts. It leverages the Gmail API to allow searching, sending, and organizing emails via secure OAuth2 authentication.

agente-traduccion-mcp

MCP server for translation and localization workflows. It exposes tools for glossary lookup, translation memory reuse, segment alignment, and demo multicloud translation.

Salyut

Fans out queries to multiple independent free LLMs from different providers and returns their answers side by side, enabling sanity-checking of decisions or getting multiple perspectives during coding sessions.

mc3000-mcp

MCP server for monitoring and controlling SKYRC MC3000 battery chargers over Bluetooth Low Energy.

Kitsu MCP Server

Connects AI assistants to the Kitsu open-source production management platform for animation, VFX, and game studios. It provides over 70 tools to manage projects, assets, shots, tasks, and production pipelines through natural language.

doc-search

MCP server for hybrid documentation search (keyword + vector) and RAG chat, enabling natural language queries with cited answers from indexed repositories.

usafiri-mcp

MCP server for Kenya transport — matatu route finder, NTSA services, boda licensing, freight logistics, passenger rights.

Aviation MCP Server

Enables querying real-time aircraft data from ADS-B Exchange using multiple query types such as callsign, registration, aircraft type, location, and more, via a FastMCP server with API key authentication.

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.

code-context-v2

Enables semantic code search across indexed codebases using natural language queries, with support for CLI and MCP interfaces.

railrouter-lite

RailRouter Lite is a real, production-ready MCP server implementing the Model Context Protocol. It exposes one tool: route_payment. This tool intelligently routes payments to the optimal rail (Stripe MPP, Coinbase x402, or Google AP2) in real time, choosing based on cost, latency, and success rate. Every decision is logged to a Cloudflare D1 database, creating compounding routing intelligence

dockhand-mcp

Exposes the Dockhand Docker management API as tools for LLMs, enabling container, stack, image, volume, and network management via natural language.

substack-mcp

An MCP server that gives Copilot access to Substack posts from your authenticated reader account, including paid subscriptions, enabling daily summary generation by syncing, caching, and summarizing posts.

Jangada Docs MCP

Enables AI assistants to access the complete documentation of the jangada library, ensuring they write code using the correct and current API without guessing function names or parameters.

storytelling-media-mcp

Provides tools for agent-driven video creation, including image generation via Google's GenAI, video generation, and local video stitching with FFmpeg.

Confluence MCP Server

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

Web Search MCP

Multi-source web search MCP server with RRF fusion, 4-layer URL extraction, and provider health tracking.

first-mcp-server

Enables adding two numbers through a single MCP tool and returns the sum as text.

SAG MCP Server

Enables full read/write management of SAG knowledge bases, including source and document CRUD, semantic search, knowledge graph queries, and model configuration through 18 MCP tools.