Discover Awesome MCP Servers

Video Content Summarization MCP Server

Extracts content from multiple video platforms (Douyin, Bilibili, Xiaohongshu, Zhihu) and generates intelligent knowledge graphs with OCR text recognition capabilities.

RAG Documentation

Uma implementação de servidor MCP que fornece ferramentas para recuperar e processar documentação através de pesquisa vetorial, permitindo que assistentes de IA aumentem suas respostas com contexto de documentação relevante.

Remote MCP Server

A Cloudflare Workers-based implementation of Model Context Protocol (MCP) server with OAuth login that allows tools like Claude to access external capabilities.

MCP-ShellJS

Um servidor MCP seguro que fornece acesso controlado ao ShellJS para LLMs, permitindo que sistemas de IA executem comandos shell com segurança e interajam com o sistema de arquivos dentro de um sandbox de segurança configurável.

Vulpes Spotify MCP Server

Um servidor de Protocolo de Contexto de Modelo que permite que assistentes de IA como o Claude interajam com o Spotify, permitindo que eles pesquisem faixas, controlem a reprodução e gerenciem playlists.

MCP Visual Language

Enables intelligent image analysis using GLM-4.5V model, specializing in extracting and analyzing code from screenshots with support for file paths and clipboard input.

MCP Docs RAG Server

Um servidor MCP em TypeScript que permite consultar documentos usando LLMs com contexto de repositórios e arquivos de texto armazenados localmente através de um sistema RAG (Geração Aumentada por Recuperação).

JSON-RPC クライアントツール

This is just a private project, for your reference.

Unicode Puzzles MCP

Cria e gerencia mensagens codificadas usando caracteres de largura zero e técnicas avançadas de esteganografia Unicode, permitindo a geração de quebra-cabeças com tema quântico com segredos ocultos.

Insights Knowledge Base MCP Server

A free, plug-and-play knowledge base server that provides access to 10,000+ insight reports with secure local data storage.

MCP Server Demo 项目文档

Um projeto de exemplo de um serviço MCP (Model Control Protocol) baseado em Spring Boot.

Basic MCP Server

A basic TypeScript implementation of the Model Context Protocol (MCP) server designed as a starting point for MCP development. Provides a minimal foundation for building custom MCP servers with stdio configuration for local integration with VS Code and GitHub Copilot.

MCP Server for Apache Gravitino

A FastMCP integration server that provides access to Apache Gravitino metadata management APIs, allowing users to manage catalog/schema/table metadata, tags, and user-role information through a structured interface.

CoolPC MCP Server

A Model Context Protocol server that enables Claude Desktop to query and analyze Taiwan CoolPC computer component prices, helping users generate custom PC quotes through AI assistance.

Nostr MCP Server

Mirror of

SQLite Database Demo

Aqui estão alguns exemplos de como construir testes de servidor e cliente no contexto do protocolo de modelo (MCP). Infelizmente, a frase original em vietnamita ("Một số ví dụ sử dụng MCP") é muito genérica. Para fornecer exemplos mais úteis, vou assumir que você está interessado em testar um servidor e um cliente que se comunicam usando um protocolo específico, e que esse protocolo é modelado de alguma forma (talvez usando máquinas de estado, diagramas de sequência, etc.). **Considerações Gerais:** * **Escolha da Linguagem/Framework:** A escolha da linguagem de programação e do framework de teste depende muito do seu ambiente e das suas preferências. Python com `pytest` e `unittest` são escolhas populares para testes. Java com JUnit também é comum. * **Simulação do Protocolo:** A chave para testar o MCP é simular o comportamento do protocolo em seus testes. Isso significa criar objetos que representem as mensagens, os estados e as transições do protocolo. * **Testes Unitários vs. Testes de Integração:** * **Testes Unitários:** Concentram-se em testar unidades individuais de código (por exemplo, funções que codificam/decodificam mensagens, classes que representam estados do protocolo). * **Testes de Integração:** Testam a interação entre diferentes componentes (por exemplo, o servidor e o cliente se comunicando). * **Mocks e Stubs:** Em testes unitários, você frequentemente usará mocks e stubs para isolar a unidade que está sendo testada e simular o comportamento de dependências externas (por exemplo, a rede). * **Cobertura de Código:** Use ferramentas de cobertura de código para garantir que seus testes cubram uma porção significativa do seu código. **Exemplo Simplificado (Conceitual) em Python com `pytest`:** Vamos imaginar um protocolo muito simples: * **Mensagens:** * `HELLO`: O cliente envia para o servidor para iniciar a conexão. * `ACK`: O servidor envia para o cliente para confirmar o recebimento de `HELLO`. * `DATA: <data>`: O cliente envia dados para o servidor. * `OK`: O servidor envia para o cliente para confirmar o recebimento dos dados. * `ERROR: <message>`: O servidor envia para o cliente em caso de erro. ```python import pytest import socket import threading # --- Código do Servidor (Simplificado) --- class SimpleServer: def __init__(self, host, port): self.host = host self.port = port self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.server_socket.bind((self.host, self.port)) self.server_socket.listen(1) # Aceita apenas uma conexão def handle_client(self, client_socket, client_address): try: message = client_socket.recv(1024).decode() if message == "HELLO": client_socket.sendall("ACK".encode()) data = client_socket.recv(1024).decode() if data.startswith("DATA:"): client_socket.sendall("OK".encode()) else: client_socket.sendall("ERROR: Invalid data format".encode()) else: client_socket.sendall("ERROR: Expected HELLO".encode()) except Exception as e: print(f"Erro ao lidar com o cliente: {e}") finally: client_socket.close() def start(self): print(f"Servidor ouvindo em {self.host}:{self.port}") while True: client_socket, client_address = self.server_socket.accept() print(f"Conexão de {client_address}") client_thread = threading.Thread(target=self.handle_client, args=(client_socket, client_address)) client_thread.start() # --- Código do Cliente (Simplificado) --- class SimpleClient: def __init__(self, host, port): self.host = host self.port = port self.client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) def connect(self): self.client_socket.connect((self.host, self.port)) def send_message(self, message): self.client_socket.sendall(message.encode()) def receive_message(self): return self.client_socket.recv(1024).decode() def close(self): self.client_socket.close() # --- Testes com pytest --- @pytest.fixture(scope="module") def server(): host = "localhost" port = 12345 server = SimpleServer(host, port) server_thread = threading.Thread(target=server.start, daemon=True) # Daemon para terminar com o teste server_thread.start() yield host, port server.server_socket.close() # Limpeza após os testes def test_successful_handshake_and_data_transfer(server): host, port = server client = SimpleClient(host, port) client.connect() client.send_message("HELLO") response = client.receive_message() assert response == "ACK" client.send_message("DATA: Some data") response = client.receive_message() assert response == "OK" client.close() def test_server_rejects_invalid_initial_message(server): host, port = server client = SimpleClient(host, port) client.connect() client.send_message("INVALID") response = client.receive_message() assert response == "ERROR: Expected HELLO" client.close() def test_server_rejects_invalid_data_format(server): host, port = server client = SimpleClient(host, port) client.connect() client.send_message("HELLO") response = client.receive_message() assert response == "ACK" client.send_message("BAD_DATA") response = client.receive_message() assert response == "ERROR: Invalid data format" client.close() ``` **Explicação do Exemplo:** 1. **`SimpleServer` e `SimpleClient`:** Implementações muito básicas de um servidor e um cliente que se comunicam usando sockets. 2. **`pytest.fixture`:** A função `server()` é um fixture do `pytest`. Ela cria uma instância do `SimpleServer`, inicia-o em uma thread separada (para não bloquear os testes) e retorna o host e a porta. O `yield` permite que o servidor seja executado durante os testes e, após a conclusão dos testes, o código após o `yield` é executado para limpar (fechar o socket do servidor). O `daemon=True` garante que a thread do servidor termine quando o processo de teste terminar. 3. **Testes:** * `test_successful_handshake_and_data_transfer`: Testa o cenário feliz, onde o cliente envia `HELLO`, recebe `ACK`, envia `DATA`, e recebe `OK`. * `test_server_rejects_invalid_initial_message`: Testa o caso em que o cliente envia uma mensagem inicial inválida (diferente de `HELLO`). * `test_server_rejects_invalid_data_format`: Testa o caso em que o cliente envia dados em um formato inválido. **Pontos Importantes:** * **Threads:** O servidor é executado em uma thread separada para que os testes não fiquem bloqueados esperando por conexões. * **Sockets:** O exemplo usa sockets para comunicação de rede. * **Asserções:** Os testes usam asserções (`assert`) para verificar se o comportamento do servidor e do cliente é o esperado. * **Limpeza:** O fixture `server()` garante que o servidor seja desligado após a conclusão dos testes. **Como Adaptar para o Seu MCP:** 1. **Defina o seu Protocolo:** Documente completamente o seu protocolo, incluindo os tipos de mensagens, os estados, as transições e as regras de validação. 2. **Modele o Protocolo:** Use diagramas de estado, diagramas de sequência ou outras técnicas de modelagem para visualizar o comportamento do protocolo. 3. **Implemente as Classes de Mensagem:** Crie classes para representar cada tipo de mensagem no seu protocolo. Essas classes devem ter métodos para codificar e decodificar as mensagens. 4. **Implemente o Servidor e o Cliente:** Implemente o servidor e o cliente, usando as classes de mensagem e seguindo o modelo do protocolo. 5. **Escreva os Testes:** * **Testes Unitários:** Teste as classes de mensagem, as funções de codificação/decodificação e outras unidades de código individualmente. * **Testes de Integração:** Teste a interação entre o servidor e o cliente, simulando diferentes cenários e verificando se o comportamento é o esperado. Use mocks e stubs para isolar os componentes que estão sendo testados. 6. **Cobertura de Código:** Use ferramentas de cobertura de código para garantir que seus testes cubram uma porção significativa do seu código. **Exemplo de Teste Unitário (Classe de Mensagem):** Suponha que você tenha uma classe `DataMessage` que representa uma mensagem de dados: ```python class DataMessage: def __init__(self, data): self.data = data def encode(self): return f"DATA: {self.data}".encode() @staticmethod def decode(message): if message.startswith("DATA: "): return DataMessage(message[6:]) else: raise ValueError("Invalid data message format") ``` Um teste unitário para essa classe poderia ser: ```python def test_data_message_encode_decode(): message = DataMessage("Some data") encoded_message = message.encode() decoded_message = DataMessage.decode(encoded_message.decode()) assert decoded_message.data == "Some data" ``` **Ferramentas Úteis:** * **`pytest` (Python):** Um framework de teste poderoso e flexível. * **`unittest` (Python):** O framework de teste padrão do Python. * **JUnit (Java):** Um framework de teste popular para Java. * **Mockito (Java):** Um framework de mocking para Java. * **Wireshark:** Um analisador de pacotes de rede que pode ser usado para inspecionar o tráfego entre o servidor e o cliente. Lembre-se de que este é um exemplo muito simplificado. A complexidade dos seus testes dependerá da complexidade do seu protocolo. O mais importante é entender o seu protocolo e modelá-lo corretamente.

InfluxDB MCP Server

Um servidor de Protocolo de Contexto de Modelo que fornece ao Claude acesso a instâncias de banco de dados de séries temporais InfluxDB, permitindo a escrita, consulta e gerenciamento de dados de organizações e buckets por meio de linguagem natural.

MCP Minecraft Remote

Permite que assistentes de IA se conectem e controlem jogadores de Minecraft em servidores remotos, possibilitando navegação, construção, mineração, gerenciamento de inventário, interação com entidades e comunicação por chat através de comandos em linguagem natural.

FullScope-MCP

A comprehensive Model Context Protocol server for content summarization that supports web scraping, file reading, content summarization, and topic-based summarization features.

Serper Google Search Server

Permite a integração da funcionalidade de pesquisa do Google em aplicações habilitadas para MCP usando a API Serper, fornecendo resultados de pesquisa ricos, parâmetros configuráveis e tratamento eficiente de respostas.

Remote MCP Server Authless

A serverless MCP implementation on Cloudflare Workers that doesn't require authentication, allowing you to deploy custom AI tools that can be accessed from Cloudflare AI Playground or Claude Desktop.

MCP Memory

An MCP server implementing memory solutions for data-rich applications using HippoRAG for efficient knowledge graph capabilities, enabling search across multiple sources including uploaded files.

Text Editor MCP Server

Uma implementação de código aberto das versões da ferramenta de editor de texto integrada do Claude: text\_editor\_20241022 (Claude 3.5 Sonnet) text\_editor\_20250124 (Claude 3.7 Sonnet)

🎓 Canvas LMS MCP Server 🎓

Servidor MCP para acessar o Canvas LMS para estudantes.

Wizlights MCP Server

Servidor de Protocolo de Contexto de Modelo (MCP) para permitir que LLMs controlem dispositivos WiZ.

mcp-server-test

"MCP function learning" translates to: **Aprendizagem da função MCP** Or, depending on the context, it could also be: **Aprendizado da função MCP** Both "aprendizagem" and "aprendizado" are valid translations of "learning." "Aprendizagem" is generally considered more formal.

espresso-mcp

espresso-mcp

Giphy MCP Server

This MCP server enables interaction with the Giphy API through natural language, allowing users to search, retrieve, and manage GIFs through the Multi-Agent Conversation Protocol.