Discover Awesome MCP Servers

Vision MCP for Reasonix

Provides vision capabilities to Reasonix, enabling analysis of images/videos, OCR, and comparisons via OpenAI-compatible vision models.

mcp-datetime

MCP server providing 10 date and time tools including timezone conversion, date math, cron explanation, business days calculation, and more, enabling LLMs to handle datetime operations.

flyto-indexer

MCP server that gives AI assistants impact analysis, cross-project reference tracking, and code health scoring.

Wildfire MCP Server

Detects, monitors, and analyzes potential wildfires globally using NASA FIRMS, OpenWeatherMap, and Google Earth Engine data.

RELION MCP Server

Enables AI agents to control RELION 5.x cryo-EM structure determination software through natural language, providing 23 tools for the complete single-particle analysis pipeline.

news-volume-mcp

MCP server providing news article mention volume data, weekly series, growth percentages, and a live Google News feed as an AI tool.

mcp-elasticsearch

Enables read-only interaction with Elasticsearch, supporting listing indices, retrieving mappings, and executing search/aggregation queries via MCP.

@hyperstar/mcp

Local stdio MCP server for Hyperstar headless workflows, providing tools for creator search, campaign management, bulk email, and inbox operations.

mcp-ollama-account-rotation

MCP server that routes Ollama Cloud API requests across multiple user-owned accounts with automatic rotation to handle quota exhaustion, rate limits, and failures.

mcp-postgres-full-access-extended

Enables full read-write access to PostgreSQL databases with transaction management and safety controls, allowing LLMs to query and modify database content.

RFQ_SIEMENS_Teamcenter_MCP

Enables Phase 1 upload-to-Teamcenter-draft workflow with file validation, extraction, similarity search, BQ drafting, document generation, approval, and save, including a deterministic mock mode for demos.

Task Management MCP Server

Connects AI assistants to a task management API for creating, updating, and tracking tasks with iPhone notifications.

remote-mcp-server-authless

Deploys a stateless remote MCP server on Cloudflare Workers without authentication, enabling remote tool calls from MCP clients.

Prometheus MCP Server

Enables AI assistants to execute PromQL queries and discover metrics across multiple Prometheus tenants using the Model Context Protocol. It supports single and multi-tenant configurations with secure authentication for instant and range query analysis.

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

Um servidor de Protocolo de Contexto de Modelo que permite consultar e analisar logs de segurança do Wazuh armazenados no OpenSearch, com recursos para pesquisar alertas, obter informações detalhadas, gerar estatísticas e visualizar tendências.

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

Um servidor de prova de conceito que fornece ferramentas para acessar e gerenciar dados, formulários, respostas de formulários e projetos do Loomer, com recursos de paginação, filtragem e ordenação.

AI Assistant Chat with Nmap Tool Integration

Okay, here's an example of a simple MCP (Management Console Protocol) server, along with a basic structure for integrating `nmap` scans as tools. This is a conceptual outline and will require further development to be fully functional. It focuses on the core ideas and provides a starting point. **Important Considerations:** * **Security:** Running `nmap` from a server accessible over a network requires careful security considerations. You *must* implement proper authentication, authorization, and input sanitization to prevent unauthorized access and command injection vulnerabilities. This example is *not* secure as-is. * **Error Handling:** Robust error handling is crucial. The example provides basic error handling, but you'll need to expand it significantly for a production environment. * **Asynchronous Operations:** `nmap` scans can take a long time. Consider using asynchronous operations (e.g., threads, asyncio) to avoid blocking the server while scans are running. * **Data Serialization:** The example uses simple string formatting. For more complex data, consider using JSON or another serialization format. * **Platform Dependencies:** This example assumes `nmap` is installed and accessible in the system's PATH. ```python import socket import subprocess import threading # For handling multiple connections concurrently # Configuration HOST = '0.0.0.0' # Listen on all interfaces PORT = 12345 # Port to listen on BUFFER_SIZE = 1024 def handle_client(conn, addr): """Handles communication with a single client.""" print(f"Connected by {addr}") try: while True: data = conn.recv(BUFFER_SIZE) if not data: break # Client disconnected message = data.decode().strip() print(f"Received from {addr}: {message}") response = process_command(message) conn.sendall(response.encode()) except Exception as e: print(f"Error handling client {addr}: {e}") finally: conn.close() print(f"Connection closed with {addr}") def process_command(command): """Processes commands received from the client.""" try: if command.startswith("nmap_scan"): target = command.split(" ")[1] # e.g., "nmap_scan 192.168.1.1" return run_nmap_scan(target) elif command.startswith("nmap_quickscan"): target = command.split(" ")[1] return run_nmap_quickscan(target) elif command == "help": return "Available commands: nmap_scan <target>, nmap_quickscan <target>, help" else: return "Unknown command. Type 'help' for available commands." except IndexError: return "Invalid command format. Type 'help' for available commands." except Exception as e: return f"Error processing command: {e}" def run_nmap_scan(target): """Runs a basic nmap scan and returns the output.""" try: # SECURITY WARNING: Sanitize the target input! Prevent command injection! # Example (basic, but not foolproof): if not target.replace(".", "").isdigit(): # Check if it's a valid IP-like string return "Invalid target. Must be an IP address." command = ["nmap", target] # Basic scan result = subprocess.run(command, capture_output=True, text=True, timeout=60) # Added timeout if result.returncode == 0: return result.stdout else: return f"Nmap scan failed: {result.stderr}" except subprocess.TimeoutExpired: return "Nmap scan timed out." except Exception as e: return f"Error running nmap: {e}" def run_nmap_quickscan(target): """Runs a quick nmap scan and returns the output.""" try: # SECURITY WARNING: Sanitize the target input! Prevent command injection! # Example (basic, but not foolproof): if not target.replace(".", "").isdigit(): # Check if it's a valid IP-like string return "Invalid target. Must be an IP address." command = ["nmap", "-F", target] # Quick scan result = subprocess.run(command, capture_output=True, text=True, timeout=30) # Added timeout if result.returncode == 0: return result.stdout else: return f"Nmap scan failed: {result.stderr}" except subprocess.TimeoutExpired: return "Nmap scan timed out." except Exception as e: return f"Error running nmap: {e}" def main(): """Main server function.""" server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # Allow reuse of the address try: server_socket.bind((HOST, PORT)) server_socket.listen() print(f"Listening on {HOST}:{PORT}") while True: conn, addr = server_socket.accept() thread = threading.Thread(target=handle_client, args=(conn, addr)) thread.start() except Exception as e: print(f"Server error: {e}") finally: server_socket.close() if __name__ == "__main__": main() ``` **How to Run:** 1. **Save:** Save the code as a Python file (e.g., `mcp_server.py`). 2. **Install `nmap`:** Make sure `nmap` is installed on the system where you're running the server and that it's in your system's PATH. 3. **Run:** Execute the script from your terminal: `python mcp_server.py` 4. **Connect:** Use a simple TCP client (e.g., `netcat`, `telnet`, or a Python socket client) to connect to the server on `HOST` and `PORT`. **Example Client Interaction (using `netcat`):** 1. Open a terminal. 2. Connect to the server: `nc localhost 12345` (replace `localhost` with the server's IP if needed). 3. Send a command: `nmap_scan 192.168.1.1` (replace with a valid target). 4. You should see the `nmap` output in the `netcat` terminal. 5. Try other commands like `nmap_quickscan 192.168.1.1` or `help`. **Key Improvements and Explanations:** * **Threading:** The `threading` module is used to handle multiple client connections concurrently. Each client gets its own thread. * **`process_command()` Function:** This function parses the commands received from the client and calls the appropriate function to execute them. This makes the code more organized and easier to extend. * **`run_nmap_scan()` and `run_nmap_quickscan()` Functions:** These functions encapsulate the `nmap` execution logic. * **`subprocess.run()`:** This is the recommended way to execute external commands in Python. `capture_output=True` captures both stdout and stderr. `text=True` decodes the output as text. * **Error Handling:** Basic `try...except` blocks are used to catch potential errors. More comprehensive error handling is needed for a production system. * **Security Warning:** The code includes a *critical* security warning about sanitizing the target input. **Never** directly pass user-provided input to `subprocess.run()` without proper validation and sanitization. Command injection vulnerabilities can be devastating. The example provides a very basic check, but it's not sufficient for real-world use. Consider using regular expressions or a dedicated input validation library. * **Timeout:** Added a timeout to the `subprocess.run` calls to prevent scans from running indefinitely. * **Address Reuse:** `server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)` allows the server to reuse the address immediately after it's closed, which can be helpful during development. **Further Development:** * **Authentication/Authorization:** Implement a secure authentication mechanism (e.g., username/password, API keys) to restrict access to the server. Use authorization to control which users can execute which commands. * **Input Sanitization:** Implement robust input sanitization to prevent command injection vulnerabilities. Use regular expressions or a dedicated input validation library. Consider using a whitelist of allowed characters. * **Asynchronous Operations:** Use `asyncio` or threads with a queue to handle `nmap` scans asynchronously. This will prevent the server from blocking while scans are running. * **Data Serialization:** Use JSON or another serialization format to represent the `nmap` output in a structured way. This will make it easier for clients to parse and process the data. * **Logging:** Implement logging to track server activity and errors. * **Configuration:** Use a configuration file to store server settings (e.g., port number, allowed IP addresses). * **More `nmap` Options:** Allow clients to specify more `nmap` options (e.g., port ranges, scan types). Be very careful about security when allowing users to specify options. * **GUI/Web Interface:** Create a graphical user interface or a web interface to make it easier to interact with the server. **Translation to Portuguese:** ```python import socket import subprocess import threading # Para lidar com múltiplas conexões simultaneamente # Configuração HOST = '0.0.0.0' # Escutar em todas as interfaces PORT = 12345 # Porta para escutar BUFFER_SIZE = 1024 def handle_client(conn, addr): """Lida com a comunicação com um único cliente.""" print(f"Conectado por {addr}") try: while True: data = conn.recv(BUFFER_SIZE) if not data: break # Cliente desconectado message = data.decode().strip() print(f"Recebido de {addr}: {message}") response = process_command(message) conn.sendall(response.encode()) except Exception as e: print(f"Erro ao lidar com o cliente {addr}: {e}") finally: conn.close() print(f"Conexão fechada com {addr}") def process_command(command): """Processa os comandos recebidos do cliente.""" try: if command.startswith("nmap_scan"): target = command.split(" ")[1] # Ex: "nmap_scan 192.168.1.1" return run_nmap_scan(target) elif command.startswith("nmap_quickscan"): target = command.split(" ")[1] return run_nmap_quickscan(target) elif command == "help": return "Comandos disponíveis: nmap_scan <alvo>, nmap_quickscan <alvo>, help" else: return "Comando desconhecido. Digite 'help' para ver os comandos disponíveis." except IndexError: return "Formato de comando inválido. Digite 'help' para ver os comandos disponíveis." except Exception as e: return f"Erro ao processar o comando: {e}" def run_nmap_scan(target): """Executa uma varredura básica do nmap e retorna a saída.""" try: # AVISO DE SEGURANÇA: Sanitize a entrada do alvo! Evite injeção de comandos! # Exemplo (básico, mas não à prova de falhas): if not target.replace(".", "").isdigit(): # Verifica se é uma string parecida com um IP válido return "Alvo inválido. Deve ser um endereço IP." command = ["nmap", target] # Varredura básica result = subprocess.run(command, capture_output=True, text=True, timeout=60) # Adicionado timeout if result.returncode == 0: return result.stdout else: return f"A varredura do Nmap falhou: {result.stderr}" except subprocess.TimeoutExpired: return "A varredura do Nmap expirou." except Exception as e: return f"Erro ao executar o nmap: {e}" def run_nmap_quickscan(target): """Executa uma varredura rápida do nmap e retorna a saída.""" try: # AVISO DE SEGURANÇA: Sanitize a entrada do alvo! Evite injeção de comandos! # Exemplo (básico, mas não à prova de falhas): if not target.replace(".", "").isdigit(): # Verifica se é uma string parecida com um IP válido return "Alvo inválido. Deve ser um endereço IP." command = ["nmap", "-F", target] # Varredura rápida result = subprocess.run(command, capture_output=True, text=True, timeout=30) # Adicionado timeout if result.returncode == 0: return result.stdout else: return f"A varredura do Nmap falhou: {result.stderr}" except subprocess.TimeoutExpired: return "A varredura do Nmap expirou." except Exception as e: return f"Erro ao executar o nmap: {e}" def main(): """Função principal do servidor.""" server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # Permite a reutilização do endereço try: server_socket.bind((HOST, PORT)) server_socket.listen() print(f"Escutando em {HOST}:{PORT}") while True: conn, addr = server_socket.accept() thread = threading.Thread(target=handle_client, args=(conn, addr)) thread.start() except Exception as e: print(f"Erro no servidor: {e}") finally: server_socket.close() if __name__ == "__main__": main() ``` **Key changes in the Portuguese version:** * Comments and docstrings are translated to Portuguese. * Messages displayed to the user (e.g., error messages, help text) are translated. * Variable names remain in English for consistency with common programming practices. Remember to prioritize security and thorough testing when implementing 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.