Discover Awesome MCP Servers

Stellastra MCP Server

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

sequential-thinking-claude-code

sequential-thinking-claude-code

Clicky MCP Server

Enables users to retrieve website traffic analytics data from Clicky, including visitor counts, top pages, traffic sources, and domain-specific visitor data. Provides comprehensive web analytics insights through natural language queries with support for date range filtering and detailed traffic breakdowns.

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.

MCP Code Sandbox Server

Um servidor de Protocolo de Comunicação de Mensagens (MCP) extensível que oferece capacidades de execução de código seguro em ambientes de sandbox isolados, compatível com Claude para Desktop e outros clientes MCP.

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

Um servidor MCP (Protocolo de Contexto de Modelo) para fornecer definições de tipo TypeScript como Recursos MCP.

Webflow

Interaja com sites, páginas e coleções do Webflow.

Git Prompts MCP Server

Um servidor de Protocolo de Contexto de Modelo que gera prompts com base no conteúdo de um repositório Git, incluindo um comando para gerar descrições de PRs 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

Um servidor que fornece dados de criptomoedas em tempo real através do Protocolo de Contexto de Modelo, permitindo o acesso a informações detalhadas de exchanges e taxas de criptomoedas atuais da API CoinCap.

Steam MCP Server (Node.js/TypeScript)

Servidor MCP para Estatísticas de Jogos da API Web do Steam

SettleMint

Aproveite o servidor Model Context Protocol da SettleMint para interagir perfeitamente com a infraestrutura blockchain empresarial. Crie, implemente e gerencie contratos inteligentes por meio de assistentes com tecnologia de IA, otimizando seu fluxo de trabalho de desenvolvimento blockchain para máxima eficiência.

Confluence MCP Server

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

Home Depot MCP Server

Provides comprehensive investment research and analysis for The Home Depot, Inc. (HD) including real-time stock data, news sentiment analysis, economic indicators, SEC filings, and investment thesis generation. Enables users to perform complete financial analysis and market intelligence gathering through natural language queries.

IoTDB MCP Server

Um servidor de Protocolo de Contexto de Modelo que permite que assistentes de IA interajam de forma segura com bancos de dados Apache IoTDB através de uma interface controlada para listar tabelas, ler dados e executar consultas SQL.

Advanced Hasura GraphQL MCP Server

Um servidor de Protocolo de Contexto de Modelo que permite que agentes de IA interajam dinamicamente com endpoints Hasura GraphQL através de linguagem natural, suportando descoberta de esquema, consulta/manipulação de dados e agregações.

Code Context Provider MCP

Servidor MCP que fornece contexto de código e análise para assistentes de IA. Extrai a estrutura de diretórios e símbolos de código usando analisadores Tree-sitter WebAssembly com Zero Dependências Nativas.

code2prompt

Uma ferramenta de ingestão de código que transforma seu código em prompts otimizados para IA instantaneamente. Reúna o contexto relevante com code2prompt por baixo dos panos. Saiba mais em code2prompt.dev

AI Surge MCP

An open-source MCP server that tracks premier global AI information from sources like X and podcasts, enabling users to access relevant AI updates in their daily LLM conversations without searching multiple channels.

即梦AI图片生成 MCP

A MCP server that generates high-quality images using Volcano Engine's JiMeng AI API, supporting various aspect ratios and compatible with different MCP clients.

PyMCP Sum Server

A simple MCP server that provides integer addition functionality. Enables users to perform basic arithmetic operations by adding two integers together through natural language interactions.

Terraform Cloud Integration

Um servidor de Protocolo de Contexto de Modelo (MCP) que integra o Claude com a API do Terraform Cloud, permitindo que o Claude gerencie sua infraestrutura Terraform por meio de conversas naturais.

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.

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 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!

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

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.