Discover Awesome MCP Servers

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.

OpenAPI to MCP Server Converter

Uma ferramenta para converter automaticamente especificações OpenAPI em um Servidor de Protocolo de Contexto de Modelo (MCP).

Kayzen Analytics MCP Server

Uma implementação que permite que modelos de IA acessem e analisem dados de campanhas publicitárias da Kayzen por meio de uma interface padronizada, com recursos como autenticação automatizada e gerenciamento de relatórios.

Coding Todo Server

Um servidor MCP que fornece ferramentas e recursos para gerenciar a lista de tarefas pendentes de um projeto de programação, permitindo que os usuários visualizem, adicionem, atualizem e excluam itens de tarefas com detalhes como prioridade, status e tags.

mcp-inscription

Permitir que assistentes de IA interajam diretamente com inscrições Bitcoin Ordinals. Integra-se perfeitamente com Goose e Claude Desktop para recuperar e exibir o conteúdo da inscrição a partir de transações.

ardour-mcp

Servidor MCP para conectar ao DAW Ardour 9

PDF.co MCP Server

Provides PDF.co API functionality through the Model Context Protocol, enabling AI assistants to perform various PDF processing tasks like conversion, editing, searching, and security operations.

Python Apple MCP

Um servidor Python que permite a interação com aplicativos nativos do macOS (Contatos, Notas, Mail, Mensagens, Lembretes, Calendário e Mapas) através de AppleScript, apresentando operações assíncronas e interfaces com segurança de tipo.

Mercado Pago MCP Server

Mercado Pago's Official MCP Server offers tools so that developers can easily interact with our API using natural language, which simplifies tasks and product integration. Remotely hosted by Mercadolibre supporting Streamable HTTP Transport. Details on how to connect: https://mcp.mercadopago.com/

QuickBooks Online MCP Server

Enables interaction with QuickBooks Online through OAuth authentication. Supports CRUD operations for financial entities like customers, invoices, bills, estimates, and accounting records through natural language.

Oxylabs MCP

Uma ferramenta de scraping que utiliza a API Web Scraper da Oxylabs para buscar e processar conteúdo da web com opções flexíveis para analisar e renderizar páginas, permitindo a extração eficiente de conteúdo de websites complexos.

Jira MCP Server

Um servidor MCP compatível com as APIs Jira V2 e V3 e campos personalizados.

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.

MCP Multi-Context Hook Generator

Automatically generates typed React hooks for Next.js projects by crawling API routes, GraphQL queries, and components. Analyzes pages to suggest optimal render modes (SSR/CSR/ISR) and produces comprehensive documentation with AI-powered guidance.

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.

exif-mcp

An offline MCP server that allows LLMs or humans to extract and analyze metadata from images using the exifr library, supporting various image formats and metadata segments without external tools.

WeRead MCP Server

A lightweight bridge server that connects WeChat Reading (WeRead) data with Claude Desktop, allowing seamless access to reading notes and book collections through natural language interactions.

Breez MCP Server

Enables Lightning Network wallet operations through the Breez SDK, allowing users to check balances, send/receive payments, create invoices, and manage Bitcoin Lightning transactions via natural language.

MCP Video Parser

A video analysis system that uses AI vision models to process, analyze, and query video content through natural language, enabling users to search videos by time, location, and content.

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.

IntelliGlow

A Model Context Protocol (MCP) server that allows AI assistants like Claude to control real smart bulbs via UDP network communication, featuring voice commands, AI reasoning, and direct hardware control.

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)