Discover Awesome MCP Servers

Octagon VC Agents

An MCP server that runs AI-driven venture capitalist agents whose thinking is continuously enriched by Octagon Private Markets' real-time deals and intelligence for pitch feedback, diligence simulations, and term sheet negotiations.

Twilio MCP

Enables sending SMS text messages through Twilio's messaging service with a simple send_text tool that supports configurable recipients and messaging service integration.

Mcp Cassandra Server

Here's the translation of "Model Context Protocol for Cassandra database" into Portuguese: **Protocolo de Contexto de Modelo para banco de dados Cassandra** Here are a few alternative translations, depending on the specific nuance you want to convey: * **Protocolo de Contexto do Modelo para o banco de dados Cassandra:** (More formal, using "o" before "banco de dados") * **Protocolo de Contexto de Modelo para Bancos de Dados Cassandra:** (If you're referring to Cassandra databases in general, pluralizing "bancos de dados" might be appropriate) The first option, **Protocolo de Contexto de Modelo para banco de dados Cassandra**, is generally the most common and natural-sounding translation.

NervusDB MCP Server

Enables building and querying code knowledge graphs for project analysis, with tools for exploring code relationships, managing workflows, and automating development tasks. Integrates with Git and GitHub for branch management and pull request creation.

MCP Server Boilerplate

A starter template for building Model Context Protocol servers that can integrate with AI assistants like Claude or Cursor, providing custom tools, resource providers, and prompt templates.

sheet-music-mcp

Um servidor MCP para renderização de partituras.

MCP 만들면서 원리 파헤쳐보기

Okay, here's a breakdown of the server and client implementation for a Master Control Program (MCP), along with considerations and potential approaches. Keep in mind that "Master Control Program" is a very broad term, and the specific requirements will heavily influence the design. I'll provide a general framework and then discuss some common scenarios. **General Concepts** The MCP, in this context, typically refers to a central system that manages and controls other systems (clients). It's a common architecture in distributed systems, industrial automation, and even some software applications. * **Server (MCP Server):** The central authority. It receives requests from clients, processes them, and potentially sends commands or data back to the clients. It often maintains a global view of the system's state. * **Client:** A system or application that is managed by the MCP. It communicates with the MCP server to report its status, request resources, or execute commands. **Key Considerations Before Implementation** Before diving into code, consider these factors: * **Communication Protocol:** How will the server and clients communicate? Common choices include: * **TCP/IP:** Reliable, connection-oriented. Good for guaranteed delivery and persistent connections. Suitable for command-and-control scenarios. * **UDP:** Faster, connectionless. Good for real-time data streaming or situations where occasional packet loss is acceptable. * **HTTP/HTTPS:** Simple to implement, uses standard web infrastructure. Good for RESTful APIs and web-based control panels. * **Message Queues (e.g., RabbitMQ, Kafka):** Asynchronous communication. Good for decoupling the server and clients and handling high volumes of messages. * **gRPC:** High-performance, uses Protocol Buffers for serialization. Good for microservices and demanding applications. * **Data Serialization:** How will data be encoded for transmission? * **JSON:** Human-readable, widely supported. * **XML:** More verbose than JSON, but still widely used. * **Protocol Buffers:** Binary format, efficient and supports schema evolution. Excellent for gRPC. * **MessagePack:** Binary format, similar to JSON but more compact. * **Security:** How will you authenticate clients and protect data in transit? * **TLS/SSL:** Encrypts communication. * **Authentication (e.g., API keys, OAuth):** Verifies the identity of clients. * **Authorization:** Controls what actions clients are allowed to perform. * **Scalability:** How many clients will the MCP need to support? Will it need to handle a high volume of requests? * **Fault Tolerance:** What happens if the MCP server fails? Will there be a backup? How will clients handle disconnections? * **Real-time Requirements:** Does the MCP need to respond to events in real-time? * **Complexity:** How complex are the commands and data structures that need to be exchanged? * **Existing Infrastructure:** Are there existing systems or libraries that you can leverage? * **Programming Languages:** Choose languages suitable for both server and client. Python, Java, Go, C++, and C# are common choices. **Example Implementation (Python with TCP/IP and JSON)** This is a simplified example to illustrate the basic concepts. It's not production-ready, but it provides a starting point. **Server (mcp_server.py):** ```python import socket import json import threading HOST = '127.0.0.1' # Standard loopback interface address (localhost) PORT = 65432 # Port to listen on (non-privileged ports are > 1023) # Global dictionary to store client states (example) client_states = {} def handle_client(conn, addr): print(f"Connected by {addr}") while True: try: data = conn.recv(1024) # Receive data in 1024-byte chunks if not data: break # Client disconnected try: request = json.loads(data.decode('utf-8')) print(f"Received from {addr}: {request}") # Process the request (example) if 'command' in request: command = request['command'] if command == 'report_status': client_id = request.get('client_id') status = request.get('status') if client_id and status: client_states[client_id] = status print(f"Client {client_id} status updated: {status}") response = {'status': 'ok', 'message': 'Status received'} else: response = {'status': 'error', 'message': 'Missing client_id or status'} elif command == 'get_all_statuses': response = {'status': 'ok', 'statuses': client_states} else: response = {'status': 'error', 'message': 'Unknown command'} else: response = {'status': 'error', 'message': 'No command specified'} conn.sendall(json.dumps(response).encode('utf-8')) except json.JSONDecodeError: print(f"Invalid JSON received from {addr}") conn.sendall(json.dumps({'status': 'error', 'message': 'Invalid JSON'}).encode('utf-8')) except ConnectionResetError: print(f"Client {addr} disconnected abruptly.") break except Exception as e: print(f"Error handling client {addr}: {e}") break print(f"Disconnected from {addr}") conn.close() with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) s.listen() print(f"Listening on {HOST}:{PORT}") while True: conn, addr = s.accept() thread = threading.Thread(target=handle_client, args=(conn, addr)) thread.start() ``` **Client (mcp_client.py):** ```python import socket import json import time HOST = '127.0.0.1' # The server's hostname or IP address PORT = 65432 # The port used by the server def send_request(command, data=None): with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: try: s.connect((HOST, PORT)) request = {'command': command} if data: request.update(data) s.sendall(json.dumps(request).encode('utf-8')) response_data = s.recv(1024) response = json.loads(response_data.decode('utf-8')) return response except ConnectionRefusedError: print("Connection refused. Is the server running?") return None except Exception as e: print(f"Error: {e}") return None if __name__ == "__main__": client_id = "client_123" # Unique identifier for this client # Example: Report status to the server status_report = {'client_id': client_id, 'status': 'idle'} response = send_request('report_status', status_report) if response and response['status'] == 'ok': print("Status reported successfully.") else: print("Failed to report status:", response) time.sleep(2) # Example: Get all statuses from the server response = send_request('get_all_statuses') if response and response['status'] == 'ok': print("All statuses:", response['statuses']) else: print("Failed to get statuses:", response) ``` **How to Run:** 1. Save the code as `mcp_server.py` and `mcp_client.py`. 2. Open two terminal windows. 3. In the first terminal, run the server: `python mcp_server.py` 4. In the second terminal, run the client: `python mcp_client.py` **Explanation:** * **Server:** * Creates a TCP socket and listens for incoming connections. * Accepts connections in a loop. * Spawns a new thread for each client connection to handle it concurrently. * Receives data from the client, decodes it as JSON, and processes the request. * Sends a JSON-encoded response back to the client. * Handles potential errors (e.g., invalid JSON, client disconnection). * **Client:** * Creates a TCP socket and connects to the server. * Constructs a JSON request with a `command` and optional `data`. * Sends the request to the server. * Receives the response from the server, decodes it as JSON, and prints the result. * Includes error handling for connection issues. **Important Considerations for Production:** * **Error Handling:** The example has basic error handling, but you'll need more robust error handling in a production environment. Log errors, implement retry mechanisms, and handle unexpected exceptions gracefully. * **Logging:** Implement comprehensive logging to track events, errors, and performance metrics. * **Configuration:** Use configuration files (e.g., YAML, JSON) to store settings like the server address, port, and logging level. Avoid hardcoding these values. * **Thread Safety:** If the server needs to access shared resources (like the `client_states` dictionary in the example), use appropriate locking mechanisms (e.g., `threading.Lock`) to prevent race conditions. * **Connection Pooling:** For high-volume scenarios, consider using connection pooling on the client side to reuse connections and reduce overhead. * **Heartbeats:** Implement heartbeats (periodic messages from clients to the server) to detect disconnected clients. * **Command Queueing:** If the server needs to handle a large number of commands, consider using a command queue to process them asynchronously. * **Monitoring:** Monitor the server's performance (CPU usage, memory usage, network traffic) to identify potential bottlenecks. * **Deployment:** Consider how you will deploy the server and clients (e.g., Docker containers, virtual machines). * **Security Best Practices:** Follow security best practices to protect the MCP from unauthorized access and attacks. This includes using strong authentication, encrypting communication, and regularly patching vulnerabilities. **Alternative Architectures and Technologies** * **Message Queues (RabbitMQ, Kafka):** Instead of direct TCP/IP connections, clients can send messages to a message queue, and the MCP server can consume messages from the queue. This provides decoupling and allows for asynchronous communication. * **RESTful API (HTTP/HTTPS):** The MCP server can expose a RESTful API that clients can use to send requests. This is a good option if you need to integrate with web-based applications. Frameworks like Flask (Python), Spring Boot (Java), and ASP.NET Core (C#) can be used to build RESTful APIs. * **gRPC:** For high-performance communication, gRPC is a good choice. It uses Protocol Buffers for serialization and supports bidirectional streaming. * **WebSockets:** For real-time, bidirectional communication between the server and clients, WebSockets are a good option. **Example Scenarios and Specific Considerations** * **Industrial Automation:** The MCP might control robots, sensors, and other devices on a factory floor. Real-time performance and reliability are critical. Consider using a real-time operating system (RTOS) for the server and clients. Protocols like Modbus or OPC UA might be used for communication. * **Game Server Management:** The MCP might manage multiple game servers, allocating resources, monitoring their status, and handling player authentication. Scalability and fault tolerance are important. Consider using a distributed database to store game server state. * **Cloud Resource Management:** The MCP might manage virtual machines, containers, and other cloud resources. Integration with cloud APIs (e.g., AWS, Azure, GCP) is essential. * **Software Application Management:** The MCP might manage the deployment, configuration, and monitoring of software applications. **Translation to Portuguese** Here's the translation of the above explanation into Portuguese: **Implementação do Servidor e Cliente para MCP (Master Control Program)** Aqui está uma análise da implementação do servidor e cliente para um Master Control Program (MCP), juntamente com considerações e abordagens potenciais. Lembre-se de que "Master Control Program" é um termo muito amplo, e os requisitos específicos influenciarão fortemente o design. Fornecerei uma estrutura geral e, em seguida, discutirei alguns cenários comuns. **Conceitos Gerais** O MCP, neste contexto, normalmente se refere a um sistema central que gerencia e controla outros sistemas (clientes). É uma arquitetura comum em sistemas distribuídos, automação industrial e até mesmo em alguns aplicativos de software. * **Servidor (Servidor MCP):** A autoridade central. Ele recebe solicitações de clientes, as processa e, potencialmente, envia comandos ou dados de volta para os clientes. Ele geralmente mantém uma visão global do estado do sistema. * **Cliente:** Um sistema ou aplicativo que é gerenciado pelo MCP. Ele se comunica com o servidor MCP para relatar seu status, solicitar recursos ou executar comandos. **Considerações Chave Antes da Implementação** Antes de mergulhar no código, considere estes fatores: * **Protocolo de Comunicação:** Como o servidor e os clientes se comunicarão? As opções comuns incluem: * **TCP/IP:** Confiável, orientado à conexão. Bom para entrega garantida e conexões persistentes. Adequado para cenários de comando e controle. * **UDP:** Mais rápido, sem conexão. Bom para streaming de dados em tempo real ou situações em que a perda ocasional de pacotes é aceitável. * **HTTP/HTTPS:** Simples de implementar, usa infraestrutura web padrão. Bom para APIs RESTful e painéis de controle baseados na web. * **Filas de Mensagens (por exemplo, RabbitMQ, Kafka):** Comunicação assíncrona. Bom para desacoplar o servidor e os clientes e lidar com grandes volumes de mensagens. * **gRPC:** Alto desempenho, usa Protocol Buffers para serialização. Bom para microsserviços e aplicações exigentes. * **Serialização de Dados:** Como os dados serão codificados para transmissão? * **JSON:** Legível por humanos, amplamente suportado. * **XML:** Mais verboso que JSON, mas ainda amplamente utilizado. * **Protocol Buffers:** Formato binário, eficiente e suporta evolução de esquema. Excelente para gRPC. * **MessagePack:** Formato binário, semelhante ao JSON, mas mais compacto. * **Segurança:** Como você autenticará os clientes e protegerá os dados em trânsito? * **TLS/SSL:** Criptografa a comunicação. * **Autenticação (por exemplo, chaves de API, OAuth):** Verifica a identidade dos clientes. * **Autorização:** Controla quais ações os clientes podem executar. * **Escalabilidade:** Quantos clientes o MCP precisará suportar? Ele precisará lidar com um grande volume de solicitações? * **Tolerância a Falhas:** O que acontece se o servidor MCP falhar? Haverá um backup? Como os clientes lidarão com as desconexões? * **Requisitos de Tempo Real:** O MCP precisa responder a eventos em tempo real? * **Complexidade:** Quão complexos são os comandos e as estruturas de dados que precisam ser trocados? * **Infraestrutura Existente:** Existem sistemas ou bibliotecas existentes que você pode aproveitar? * **Linguagens de Programação:** Escolha linguagens adequadas para servidor e cliente. Python, Java, Go, C++ e C# são escolhas comuns. **Exemplo de Implementação (Python com TCP/IP e JSON)** Este é um exemplo simplificado para ilustrar os conceitos básicos. Não está pronto para produção, mas fornece um ponto de partida. **Servidor (mcp_server.py):** ```python import socket import json import threading HOST = '127.0.0.1' # Endereço de interface de loopback padrão (localhost) PORT = 65432 # Porta para escutar (portas não privilegiadas são > 1023) # Dicionário global para armazenar estados do cliente (exemplo) client_states = {} def handle_client(conn, addr): print(f"Conectado por {addr}") while True: try: data = conn.recv(1024) # Recebe dados em blocos de 1024 bytes if not data: break # Cliente desconectado try: request = json.loads(data.decode('utf-8')) print(f"Recebido de {addr}: {request}") # Processa a solicitação (exemplo) if 'command' in request: command = request['command'] if command == 'report_status': client_id = request.get('client_id') status = request.get('status') if client_id and status: client_states[client_id] = status print(f"Status do cliente {client_id} atualizado: {status}") response = {'status': 'ok', 'message': 'Status recebido'} else: response = {'status': 'error', 'message': 'client_id ou status ausente'} elif command == 'get_all_statuses': response = {'status': 'ok', 'statuses': client_states} else: response = {'status': 'error', 'message': 'Comando desconhecido'} else: response = {'status': 'error', 'message': 'Nenhum comando especificado'} conn.sendall(json.dumps(response).encode('utf-8')) except json.JSONDecodeError: print(f"JSON inválido recebido de {addr}") conn.sendall(json.dumps({'status': 'error', 'message': 'JSON inválido'}).encode('utf-8')) except ConnectionResetError: print(f"Cliente {addr} desconectado abruptamente.") break except Exception as e: print(f"Erro ao lidar com o cliente {addr}: {e}") break print(f"Desconectado de {addr}") conn.close() with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) s.listen() print(f"Escutando em {HOST}:{PORT}") while True: conn, addr = s.accept() thread = threading.Thread(target=handle_client, args=(conn, addr)) thread.start() ``` **Cliente (mcp_client.py):** ```python import socket import json import time HOST = '127.0.0.1' # O nome do host ou endereço IP do servidor PORT = 65432 # A porta usada pelo servidor def send_request(command, data=None): with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: try: s.connect((HOST, PORT)) request = {'command': command} if data: request.update(data) s.sendall(json.dumps(request).encode('utf-8')) response_data = s.recv(1024) response = json.loads(response_data.decode('utf-8')) return response except ConnectionRefusedError: print("Conexão recusada. O servidor está em execução?") return None except Exception as e: print(f"Erro: {e}") return None if __name__ == "__main__": client_id = "client_123" # Identificador único para este cliente # Exemplo: Relatar o status para o servidor status_report = {'client_id': client_id, 'status': 'idle'} response = send_request('report_status', status_report) if response and response['status'] == 'ok': print("Status relatado com sucesso.") else: print("Falha ao relatar o status:", response) time.sleep(2) # Exemplo: Obter todos os status do servidor response = send_request('get_all_statuses') if response and response['status'] == 'ok': print("Todos os status:", response['statuses']) else: print("Falha ao obter os status:", response) ``` **Como Executar:** 1. Salve o código como `mcp_server.py` e `mcp_client.py`. 2. Abra duas janelas de terminal. 3. No primeiro terminal, execute o servidor: `python mcp_server.py` 4. No segundo terminal, execute o cliente: `python mcp_client.py` **Explicação:** * **Servidor:** * Cria um socket TCP e escuta por conexões de entrada. * Aceita conexões em um loop. * Gera uma nova thread para cada conexão de cliente para lidar com ela simultaneamente. * Recebe dados do cliente, decodifica-os como JSON e processa a solicitação. * Envia uma resposta codificada em JSON de volta para o cliente. * Lida com possíveis erros (por exemplo, JSON inválido, desconexão do cliente). * **Cliente:** * Cria um socket TCP e se conecta ao servidor. * Constrói uma solicitação JSON com um `command` e `data` opcional. * Envia a solicitação para o servidor. * Recebe a resposta do servidor, decodifica-a como JSON e imprime o resultado. * Inclui tratamento de erros para problemas de conexão. **Considerações Importantes para Produção:** * **Tratamento de Erros:** O exemplo tem tratamento de erros básico, mas você precisará de um tratamento de erros mais robusto em um ambiente de produção. Registre erros, implemente mecanismos de repetição e lide com exceções inesperadas de forma elegante. * **Registro (Logging):** Implemente um registro abrangente para rastrear eventos, erros e métricas de desempenho. * **Configuração:** Use arquivos de configuração (por exemplo, YAML, JSON) para armazenar configurações como o endereço do servidor, a porta e o nível de registro. Evite codificar esses valores. * **Segurança de Thread:** Se o servidor precisar acessar recursos compartilhados (como o dicionário `client_states` no exemplo), use mecanismos de bloqueio apropriados (por exemplo, `threading.Lock`) para evitar condições de corrida. * **Pool de Conexões:** Para cenários de alto volume, considere usar um pool de conexões no lado do cliente para reutilizar conexões e reduzir a sobrecarga. * **Heartbeats:** Implemente heartbeats (mensagens periódicas de clientes para o servidor) para detectar clientes desconectados. * **Fila de Comandos:** Se o servidor precisar lidar com um grande número de comandos, considere usar uma fila de comandos para processá-los de forma assíncrona. * **Monitoramento:** Monitore o desempenho do servidor (uso de CPU, uso de memória, tráfego de rede) para identificar possíveis gargalos. * **Implantação:** Considere como você implantará o servidor e os clientes (por exemplo, contêineres Docker, máquinas virtuais). * **Práticas Recomendadas de Segurança:** Siga as práticas recomendadas de segurança para proteger o MCP contra acesso não autorizado e ataques. Isso inclui o uso de autenticação forte, criptografia de comunicação e aplicação regular de patches de vulnerabilidades. **Arquiteturas e Tecnologias Alternativas** * **Filas de Mensagens (RabbitMQ, Kafka):** Em vez de conexões TCP/IP diretas, os clientes podem enviar mensagens para uma fila de mensagens e o servidor MCP pode consumir mensagens da fila. Isso fornece desacoplamento e permite a comunicação assíncrona. * **API RESTful (HTTP/HTTPS):** O servidor MCP pode expor uma API RESTful que os clientes podem usar para enviar solicitações. Esta é uma boa opção se você precisar integrar com aplicativos baseados na web. Frameworks como Flask (Python), Spring Boot (Java) e ASP.NET Core (C#) podem ser usados para construir APIs RESTful. * **gRPC:** Para comunicação de alto desempenho, o gRPC é uma boa escolha. Ele usa Protocol Buffers para serialização e suporta streaming bidirecional. * **WebSockets:** Para comunicação bidirecional em tempo real entre o servidor e os clientes, os WebSockets são uma boa opção. **Cenários de Exemplo e Considerações Específicas** * **Automação Industrial:** O MCP pode controlar robôs, sensores e outros dispositivos em uma fábrica. O desempenho em tempo real e a confiabilidade são críticos. Considere usar um sistema operacional em tempo real (RTOS) para o servidor e os clientes. Protocolos como Modbus ou OPC UA podem ser usados para comunicação. * **Gerenciamento de Servidores de Jogos:** O MCP pode gerenciar vários servidores de jogos, alocando recursos, monitorando seu status e lidando com a autenticação do jogador. Escalabilidade e tolerância a falhas são importantes. Considere usar um banco de dados distribuído para armazenar o estado do servidor de jogos. * **Gerenciamento de Recursos na Nuvem:** O MCP pode gerenciar máquinas virtuais, contêineres e outros recursos na nuvem. A integração com APIs de nuvem (por exemplo, AWS, Azure, GCP) é essencial. * **Gerenciamento de Aplicações de Software:** O MCP pode gerenciar a implantação, configuração e monitoramento de aplicações de software. This translation aims to be accurate and understandable. Let me know if you have any other questions.

NS Lookup MCP Server

Um servidor MCP simples que expõe a funcionalidade do comando nslookup.

ProofStream MCP Server

Enables AI agents to dispatch human verifiers for physical world tasks like product authentication, property inspection, and document verification, returning timestamped evidence reports.

GitLab MCP Server

Integrates GitLab with AI assistants to manage merge requests, analyze CI/CD pipelines, and create Architecture Decision Records. It enables seamless code searching, pipeline triggering, and deployment management through the Model Context Protocol.

Terminal Control MCP

Enables AI agents to interact with terminal-based TUI applications by capturing visual terminal output as PNG screenshots and simulating keyboard input through a virtual X11 display.

agoda-review-mcp

Servidor MCP para encontrar avaliações de hotéis na Agoda.

Jokes MCP Server

Provides access to various joke APIs including Chuck Norris jokes, Dad jokes, and Yo Mama jokes. Integrates with Microsoft Copilot Studio to create humor-focused agents that can deliver jokes on demand.

Accessibility Testing MCP

Enables accessibility testing of websites and HTML content using axe-core and IBM Equal Access engines. Supports WCAG compliance checking, multi-viewport testing, and provides detailed violation reports with remediation guidance.

ChatGPT Apps EdgeOne Pages Starter

A minimal MCP server template for deploying to Tencent Cloud EdgeOne Pages using Next.js and edge functions. Demonstrates tool registration and widget rendering with the hello_stat example tool.

easy-mysql-mcp

Enables AI assistants to inspect and query a MySQL database through safe, structured tools, including schema discovery and read-only queries.

Simple MCP Server with upstream auth via local rest endpoint

Um ambiente de testes para prototipagem de servidores MCP.

k8s-pilot

A lightweight, centralized control plane server that enables management of multiple Kubernetes clusters simultaneously, supporting context switching and CRUD operations on common Kubernetes resources.

mcp-remote-py

A minimal Python-based proxy that bridges local MCP STDIO clients with remote MCP SSE servers. It enables bidirectional JSON-RPC message passing between standard command-line tools and web-based remote endpoints.

Kastell

Server security auditing (413 checks, 29 categories), production hardening, and fleet management. Supports Hetzner, DigitalOcean, Vultr, and Linode.

Symbol Blockchain MCP Server (REST API tools)

Servidor MCP Blockchain Symbol (Ferramentas de API REST)

SendGrid MCP Server

Enables comprehensive email marketing and transactional email operations through SendGrid's API v3. Supports contact management, campaign creation, email automation, list management, and email sending with built-in read-only safety mode.

Smartsheet MCP Server

Enables interaction with Smartsheet API to search, retrieve, create, update, and manage sheets, rows, webhooks, sharing permissions, cross-sheet references, and perform bulk operations through the Model Context Protocol.

CData Sync MCP Server

Enables AI assistants to manage CData Sync operations, including data synchronization jobs, connections, and ETL processes through stdio or HTTP transports. It provides tools for executing jobs, monitoring real-time progress via Server-Sent Events, and handling comprehensive workspace configurations.

Gemini Audio MCP

Gemini Audio MCP is a high-performance Model Context Protocol (MCP) server that leverages the power of the Gemini 2.0 Multimodal Live API to generate high-fidelity, environmental soundscapes on-demand.

search-mcp

Enables web search capabilities using DuckDuckGo's free API without requiring authentication or API keys.

Domain Tools (WHOIS + DNS)

Domain Tools (WHOIS + DNS)

Crypto Portfolio MCP

Um servidor MCP para rastrear e gerenciar alocações de portfólio de criptomoedas.

DVID MCP Server

MCP server for mostly read-only access to DVID