Discover Awesome MCP Servers

Real Time News Data MCP Server

Enables access to real-time news articles through search, topic headlines, full story coverage, and geo-based local news across multiple countries and languages using the Real Time News Data API.

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.

Remote MCP Server Template (Authless)

A template for deploying custom MCP servers on Cloudflare Workers without authentication. Enables users to create and deploy their own tools accessible from Claude Desktop and AI Playground via SSE endpoints.

MCP Notes

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

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!

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.

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.

Todoist MCP

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

AWS Billing MCP Server

Enables users to analyze AWS costs, track spending trends, and detect anomalies directly within Claude Desktop using the AWS Cost Explorer API. It provides tools to identify major cost drivers and compare usage across different time periods through natural language queries.

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

Tushare MCP Server

Provides access to Tushare financial data through the Model Context Protocol, enabling users to query and retrieve Chinese stock market and financial information.

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.

WhatsApp MCP Server

Enables AI agents to interact with your personal WhatsApp account, allowing them to search messages and contacts, retrieve chat history, and send messages to individuals or groups. Uses WhatsApp Web API with local data storage for privacy and security.

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.

NotebookLM MCP Server

Enables interaction with Google's NotebookLM through natural language, allowing users to create and manage notebooks, add sources from URLs/YouTube/Google Drive, query AI for insights, generate audio podcasts and other studio content, and perform AI-powered research and analysis.

Confluence MCP Server

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

PyTorch Documentation Search Tool

Provides semantic search capabilities over PyTorch documentation, enabling users to find relevant documentation, APIs, code examples, and error messages through Claude Code integration.

elisp-dev-mcp

Elisp (Emacs Lisp) development support tools, running in Emacs

Hostaway MCP Server

Enables AI assistants to interact with Hostaway's property management platform through standardized MCP tools. Provides access to listings, bookings, guest communication, and availability checking for vacation rental management.

Jetson MCP Server

A Model Context Protocol server that enables monitoring and remote control of Nvidia Jetson boards using natural language commands over a network connection.

Kagi Search

Integración de la API de búsqueda de Kagi.