Discover Awesome MCP Servers

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.

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.

Pica MCP Server

Uma implementação em TypeScript do servidor do Protocolo de Contexto de Modelo para Pica, que permite aos usuários do Claude Desktop interagir com plataformas conectadas como Gmail, Google Sheets, Slack e bancos de dados por meio de comandos em linguagem natural.

Certinia MCP Server by CData

This project builds a read-only MCP server. For full read, write, update, delete, and action capabilities and a simplified setup, check out our free CData MCP Server for Certinia (beta): https://www.cdata.com/download/download.aspx?sku=HFZK-V&type=beta

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.

FastMCP PostgreSQL Query Service

A database query service that enables users to search and retrieve data from PostgreSQL tables for Cheery Exeedcars FAQs and system menus through multiple connection methods (STDIO, HTTP, SSE).

MCP Server SPARQL

Um servidor MCP para consultar um endpoint SPARQL.

Bear Notes MCP Server with RAG

Connects Bear Notes to AI assistants using semantic search and RAG (Retrieval-Augmented Generation), allowing AI systems to access and understand your personal knowledge base through meaningful search rather than just keyword matching.

Memory MCP Server

Um sistema de armazenamento de memória de longo prazo para LLMs que os ajuda a lembrar o contexto em várias sessões, usando pesquisa semântica com embeddings para fornecer informações históricas relevantes de interações passadas e decisões de desenvolvimento.

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.

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

Integração com a API de pesquisa Kagi

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

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.

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!

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

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.

Cloudsword

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

Dify MCP Server

A simple note storage system that enables Claude to create, access, and summarize plain text notes with customizable detail levels.

mcp

servidor mcp

GraphQL API Integration

Um servidor de Protocolo de Contexto de Modelo que permite que LLMs interajam com APIs GraphQL, fornecendo introspecção de esquema e capacidades de execução de consultas.

AI MCP Server of Blockchain

Um servidor MCP de blockchain que suporta Ethereum, Bitcoin e VeChain.

mcp-taskade

mcp-taskade

Dokploy MCP Server

A middleware service that allows LLMs and AI assistants to directly interact with the Dokploy platform through a standardized interface, providing access to Docker, project, and application management capabilities.