Discover Awesome MCP Servers

Google Search Engine MCP Server

Enables Google search queries and webpage content extraction through an MCP server deployed on Cloudflare Workers. Supports single and batch webpage content extraction with integrated OAuth authentication.

ctxray

Context intelligence for AI coding sessions. 7 MCP tools to score, compare, compress, build, and scan prompts across 9 AI tools. Rule-based, <5ms/prompt, all analysis runs locally.

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.

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.

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).

KnowledgeBaseMCP

Enables AI assistants to extract and analyze text content from various document formats (PDF, DOCX, PPTX, XLSX) in local knowledge bases, and create new formatted Word and Excel documents with structured data and reports.

gapup-mcp

100+ agent-payable C-suite expertises with x402 micro-payments — competitive intel, SEC filings, sanctions, KYC, clinical evidence, real estate, ESG. 183 tools, free tier 100 calls/month.

trace-mcp

Framework-aware code intelligence MCP server that builds a cross-language dependency graph from source code. 53 integrations (Laravel, Django, Rails, Spring, NestJS, Next.js, and more) across 68 languages. 100+ tools for navigation, impact analysis, refactoring, security scanning, session memory, and CI/PR reports — up to 97% token reduction.

IBM ODM Decision MCP Server

Bridges IBM Operational Decision Manager with AI assistants, enabling decisions as tools for integration with platforms like Watson Orchestrate and Claude Desktop.

mcp-mdns

MCP server that exposes mDNS service discovery functionality via the Model Context Protocol, enabling LLMs to discover and query zero-configuration network services on the local network.

arXiv MCP Server

Enables searching and retrieving academic papers from arXiv with support for advanced filtering by author, category, and date, plus full paper content extraction.

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.

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

This is just a private project, for your reference.

MCP Chat

A command-line interface application that enables interactive chat with AI models through the Anthropic API, supporting document retrieval, command-based prompts, and extensible tool integrations.

music-mcp-server

A music MCP server that enables searching and playing songs with controls like play, pause, stop, and resume.

Agent Ready

Agent Ready is an AI agent readability scanner — point it at any public URL and get back a 0–100 score plus per-check remediation hints for every failing check. This package wraps the same engine that powers agent-ready.dev as an MCP server, so Claude Desktop, Claude Code, Cursor, Cline, VS Code, and Windsurf can run scans inline and explain the results.

eip-mcp

Gives AI assistants access to the Exploit Intelligence Platform for vulnerability and exploit intelligence. Supports searching CVEs, exploits, and generating pentest findings.

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.

Web Research Assistant

Comprehensive web research toolkit with 13 tools for searching (via SearXNG), crawling, package discovery, GitHub metrics, error translation, API documentation lookup, data extraction, technology comparison, and service status checking.

GPT Image MCP Server

An MCP server for image generation, editing, and analysis using OpenAI's gpt-image-1 model, with specialized templates for YouTube thumbnails, blog headers, social media, and more.

yahoo-finance-mcp

MCP server for Thai SET/MAI stock data via Yahoo Finance API, enabling stock scanning, quotes, history, and financial statements.

Rhombus MCP Server

Enables AI assistants to interact with Rhombus physical security systems, providing access to smart cameras, access control, IoT sensors, and alarm monitoring through the Rhombus API.

nextmove-mcp

Analyzes your repository and suggests the next tasks to work on, presented as numbered options with context, enabling immediate action.