Discover Awesome MCP Servers

Filesystem MCP Server

Enables secure filesystem operations with directory sandboxing and optional read-only mode. Supports file reading/writing, directory management, file searching, and text operations while restricting access to specified directories.

Log Analyzer MCP

A Python-based MCP server that enables AI-assisted log file analysis with features for filtering, parsing, and interpreting log outputs, plus executing and analyzing test runs with varying verbosity levels.

Zen MCP Server

A Model Context Protocol server that gives Claude access to multiple AI models (Gemini, OpenAI, OpenRouter) for enhanced code analysis, problem-solving, and collaborative development through AI orchestration with conversations that continue across tasks.

nUniversal-Robots-MCP

Servidor MCP da Universal Robots

SSH MCP Server

Enables remote server management through SSH and SFTP, supporting command execution, file transfers, and interactive shell sessions. It allows for multiple concurrent connections using either password or SSH key authentication.

Windows MCP Server

Exposes Windows system information and control tools including hardware stats, network details, and process monitoring. It enables AI applications to retrieve real-time data about CPU, memory, drives, and active system processes.

Slack MCP Server

Enables AI assistants to interact with Slack workspaces through the Model Context Protocol, providing tools for reading/sending messages, managing channels, and accessing Slack API functionality.

Ambient Code Platform MCP Server

Delegates expensive or long-running AI tasks to Kubernetes-hosted Claude agents running on OpenShift. Enables creating, managing, and monitoring remote agentic sessions for complex work like codebase analysis and security audits.

Auralis Commander

A lightweight Windows-native MCP server providing a consolidated suite of 14 tools for shell execution, file operations, and interactive process management. It optimizes efficiency through batch file operations and smart process handling to minimize context window overhead.

Zoho Projects MCP Server

Enables AI assistants to interact with Zoho Projects for managing projects, tasks, issues, milestones, users, and performing searches. Supports comprehensive project management operations through natural language with automatic OAuth token handling.

OpenAlex MCP Server

Provides access to OpenAlex's catalog of 240M+ scholarly works, enabling search and retrieval of research papers, authors, institutions, journals, concepts, and funders with advanced filtering and classification capabilities.

DeviceMCP

Provides cross-platform device information including system specs, battery status, storage, and memory details for Windows, macOS, Linux, and Android through a Model Context Protocol server.

MT Content Refactor MCP Server

Enables AI-driven batch refactoring of Movable Type content via the MT Data API using natural language instructions. It provides a secure workflow featuring automated backups, visual diff reports, and rollback capabilities for safe HTML transformations.

Apple MCP

A collection of Apple-native tools for the MCP protocol that enables AI assistants to interact with Apple applications including Messages, Notes, Contacts, Mail, Reminders, Calendar, and Maps.

Youtube Mp36 MCP Server

Enables users to convert YouTube videos to MP3 format with optional trimming capabilities through the Youtube Mp36 API.

MCP Server Demo

A Model Context Protocol server implementation that can be run directly or through Docker, enabling AI assistants to interact with external systems through the MCP standard.

KiCad MCP Server

Enables analysis of KiCad electronic schematics through natural language queries to search components, trace signal paths, explore connections, and analyze multi-board systems.

FirstCycling MCP Server

Fornece dados profissionais de ciclismo do FirstCycling, permitindo que os usuários recuperem informações abrangentes sobre ciclistas, resultados de corridas, dados históricos de ciclismo e informações de equipes por meio de consultas em linguagem natural.

Everything Search MCP Server

Integrates with Everything Search Engine to provide lightning-fast file search capabilities across Windows systems using natural language queries and advanced filtering options through MCP-compatible applications.

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.

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.

astro-airflow-mcp

An MCP server that enables AI assistants to interact with Apache Airflow's REST API for DAG management, task monitoring, and system diagnostics. It provides comprehensive tools for triggering workflows, retrieving logs, and inspecting system health across Airflow 2.x and 3.x versions.

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.

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.

Enrichr MCP Server

Enables gene set enrichment analysis using the Enrichr API across hundreds of gene set libraries including Gene Ontology, pathways, diseases, tissues, drugs, and transcription factors. Returns only statistically significant results for interpretation.

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.

MCP Time Server

Provides current time information with support for multiple IANA timezones, defaulting to Asia/Shanghai timezone.

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.