Discover Awesome MCP Servers

Remote MCP Server on Cloudflare (Without Auth)

Enables deployment of a remote Model Context Protocol server on Cloudflare Workers without authentication. Allows custom tool definitions and connection from MCP clients like Claude Desktop or Cloudflare AI Playground.

Moz Da Pa1 MCP Server

Enables access to Moz API to retrieve Domain Authority, Page Authority, external URLs, and Spam Score metrics for website analysis.

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.

Total Development Toolkit MCP

An all-in-one development toolkit that integrates 10 popular MCPs with comprehensive features for solo developers, supporting frontend, backend, mobile development, database management, testing, and deployment automation.

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

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

CNKI Search MCP Server

An MCP server for searching Chinese academic papers and core journal information across multiple free platforms like Baidu Scholar and the National Center for Philosophy and Social Sciences. It enables users to retrieve metadata for social science and STEM research papers without requiring API keys.

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.

open-context

A high-performance MCP server providing up-to-date documentation for Go, npm, Python, Rust, Docker, Kubernetes, Terraform, and more — fetched from official sources, not training data.

MCP Codebase Symbols Server

Analyzes codebases and extracts all symbols (functions, classes, methods, interfaces, etc.) from 10+ programming languages into LLM-optimized markdown format. Enables AI assistants to understand entire project structures efficiently without processing full source code.

AI MCP Server of Blockchain

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

Remote MCP Server

A Cloudflare Workers implementation of a Model Context Protocol server with OAuth login that enables AI assistants like Claude to access external tools.

Project Creator MCP

Enables rapid creation of new projects from predefined templates including React, Node.js, Django, Flask, and more. Provides comprehensive project scaffolding with file system operations, template management, and command execution capabilities.

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.

BLT-MCP

Provides AI agents with structured access to the OWASP Bug Logging Tool (BLT) ecosystem for logging bugs, triaging issues, and managing security workflows. It enables actions like submitting vulnerabilities, tracking contributor leaderboards, and awarding gamified bacon points through a unified interface.

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!

Shopify Storefront MCP Server

Enables interaction with multiple Shopify stores simultaneously through the Storefront API. Supports product search, cart management, and store operations across configured Shopify stores through natural language.

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.

Traffic MCP Server

Provides traffic prediction and route optimization tools that consume a REST API to get traffic station data, predict Speed Performance Index using LSTM models, and suggest optimal routes between stations using Dijkstra's algorithm.

QuickChart MCP Server

Enables generation of various chart types (bar, line, pie, radar, etc.) using QuickChart.io and Chart.js configurations, with options to generate chart URLs or download images locally.

MCP Trade Plan Service

A minimal REST service designed for managing and executing automated trading plans. It enables users to create, monitor, and close trade positions with detailed configurations for signals, entry rules, and take-profit strategies.

Interleaved Learning MCP Server

Implements cognitive science-backed interleaved learning techniques to create study plans, generate mixed-topic quizzes, manage flashcard decks, and track learning progress for optimal knowledge retention.

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.

Canvas MCP Server

Provides read-only access to Canvas LMS for students to retrieve courses, assignments, grades, files, discussions, and planner items. Includes optional NotebookLM integration for uploading course content to AI-powered study notebooks.

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.