Discover Awesome MCP Servers

ConferenceSearcher

Allows users to search for academic conferences and events from WikiCFP by keywords, providing details such as event name, description, dates, location, and submission deadlines.

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.

MCP Naver Maps

A server that connects to Naver Maps and Search APIs, enabling geocoding and local search functionality for Korean locations.

n8n MCP Server

Espelho de

Adobe Analytics MCP Server by CData

Adobe Analytics MCP Server by CData

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.

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!

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.

MCP Design System Bridge

Enables bidirectional synchronization between IDEs and Figma for Design System management, allowing developers to generate React components and synchronize design tokens, icons, and components across platforms.

AWS Nova Canvas

Oferece capacidades de geração de imagens usando o Amazon Nova Canvas através do Amazon Bedrock, permitindo a criação de visuais a partir de prompts de texto e paletas de cores — perfeito para mockups, diagramas e conceitos de design de UI.

Cloudsword

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

MCP Outlook Scheduler

Enables AI assistants to intelligently schedule meetings by checking Microsoft Outlook calendars, finding available time slots across multiple participants, and automatically booking meetings with Teams integration. Uses Microsoft Graph API with smart fallback logic for optimal scheduling.

MySQL MCP Server

Enables AI assistants to manage MySQL databases through natural language commands. Supports database operations, table management, data queries, and import/export functionality with built-in security features.

Amplify Data API MCP Server

This MCP server enables users to interact with AWS Amplify Gen2 application data through natural language, allowing AI assistants like Claude to perform operations on Amplify data models using conversational language instead of complex code.

MCP Remote Server for Kubernetes

Provides Kubernetes cluster management capabilities through natural language via MCP protocol over HTTP/SSE. Supports Pod, Service, Deployment operations, log retrieval, and resource management with JWT authentication and RBAC permissions.

MCP Server SPARQL

Um servidor MCP para consultar um endpoint SPARQL.

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.

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.

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.

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.

MCP Notes

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

Mcp Server Aibd Devcontainer

Servidor MCP para desenvolvimento aprimorado por IA em VS Code DevContainers.