Discover Awesome MCP Servers

Chris MCP

A context provider that serves as an AI version of Chris's programming knowledge and practices. Enables AI utilities like Claude and Cline to search and access coding guidelines, rules, and context for JavaScript, TypeScript, React, and various development frameworks.

MCP Apple Calendars

Um servidor de Protocolo de Contexto de Modelo para que modelos de IA acessem e manipulem dados do Calendário da Apple no macOS através de uma interface padronizada.

MCP Server for Danmarks Statistik

Expõe a API do Departamento de Estatística da Dinamarca como recursos programáveis, facilitando a integração com modelos de linguagem e aplicações modernas de IA para permitir consultas em linguagem natural para dados estatísticos.

Arithmo MCP Server pypi Package

pacote pypi

mcp-remote-macos-use

O primeiro servidor MCP de código aberto que permite que a IA controle totalmente sistemas macOS remotos.

NHL MCP Server

Fornece acesso estruturado a dados da NHL, incluindo equipes, jogadores, classificações, calendários e estatísticas, através do padrão Model-Context Protocol.

raydium-launchlab-mcp

raydium-launchlab-mcp

Brave Search MCP

Brave Search MCP

PDF Knowledgebase MCP Server

A Model Context Protocol server that enables intelligent document search and retrieval from PDF collections, providing semantic search capabilities powered by OpenAI embeddings and ChromaDB vector storage.

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.

Loki MCP Server

Uma interface MCP que permite que assistentes de IA consultem e analisem logs do Grafana Loki usando LogQL, com suporte para autenticação e vários formatos de saída.

PlayMCP Browser Automation Server

A comprehensive MCP server that provides powerful web automation tools using Playwright, enabling web scraping, testing, and browser interaction through natural language commands.

QMT-MCP-Server

Um aplicativo de servidor que permite que grandes modelos de linguagem executem operações de negociação de ações através do sistema de negociação QMT, fornecendo funcionalidades para consultas de conta, gerenciamento de posições e envio de ordens.

Sakura Cloud MCP Server

Uma implementação de servidor MCP que permite que assistentes de IA interajam e gerenciem a infraestrutura Sakura Cloud, incluindo servidores, discos, redes e aplicações em contêineres.

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.

Container MCP Server

Enables weather lookups, mathematical calculations, and context-aware operations through a containerized MCP server with HTTP transport. Optimized for Docker/Kubernetes deployment with health checks and no external dependencies.

OpenZeppelin Contracts MCP Server

A Model Context Protocol (MCP) server that allows AI agents to generate smart contracts using OpenZeppelin Contracts libraries.

Symbol Blockchain MCP Server (REST API tools)

Servidor MCP Blockchain Symbol (Ferramentas de API REST)

Physics MCP Server

Enables physicists to perform computer algebra calculations, create scientific plots, solve differential equations, work with tensor algebra and quantum mechanics, and parse natural language physics problems. Supports unit conversion, physical constants, and generates comprehensive reports with optional GPU acceleration.

Demo HTTP MCP Server

A demonstration MCP server that provides example tools for weather queries, time retrieval, and request handling, along with advice prompts. Supports both HTTP and stdio modes for testing MCP client integrations.

Excel MCP Server

Um servidor MCP que oferece operações abrangentes em arquivos Excel, análise de dados e recursos de visualização para trabalhar com vários formatos de planilhas, como XLSX, CSV e JSON.

habitat

Este é um conjunto de componentes que colaboram entre si e que, juntos, facilitam o gerenciamento, desenvolvimento, uso e migração de servidores MCP, tanto localmente quanto na rede.

mediawiki-mcp-server

Um servidor MCP que permite pesquisar e recuperar conteúdo em qualquer site wiki que use MediaWiki com LLMs 🤖. wikipedia.org, fandom.com, wiki.gg e mais sites que usam Mediawiki são suportados!

LLV Helix Framework

Implements the Lines-Loops-Vibes creativity operating system with tools for building strategic flows, creating iterative loops, and managing energy states. Provides pre-built templates for innovation, strategic design, narrative strategy, and creative intelligence workflows.