Discover Awesome MCP Servers

Agents Library MCP Server

Enables access to agent instruction files and prompts for AI development workflows. Provides tools to retrieve and list development rules, security checks, and common prompts from an agents library through MCP protocol.

Groq MCP Server

An intelligent server that connects applications to Groq's AI models, enabling text completion, audio transcription, vision analysis, and batch processing through the Model Context Protocol.

JIRA MCP Server

Provides comprehensive access to Jira Cloud and Data Center instances for managing issues, epics, and attachments with AI-optimized data cleaning. It supports relationship tracking and dual transport modes via STDIO and Streamable HTTP.

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

Zen MCP Enhanced

An enhanced Model Context Protocol server that enables Claude to seamlessly collaborate with multiple AI models (Gemini, OpenAI, local models) for code analysis and development tasks, maintaining context across conversations.

EMC Regulations MCP Server

Provides instant access to EMC emission limits, frequency allocations, restricted bands, and compliance requirements including FCC Part 15, CISPR standards, LTE/5G cellular bands, and ISM equipment regulations for engineering compliance queries.

MariaDB Reader MCP Server

Fornece ferramentas para assistentes de IA explorarem e interagirem com bancos de dados MariaDB, permitindo que eles listem bancos de dados, visualizem tabelas, inspecionem definições de esquema e consultem dados.

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.

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.

Frontend Test Generation & Code Review MCP Server

Enables AI-powered frontend code review and unit test generation for Phabricator diffs, supporting React/TypeScript analysis, multi-dimensional code review (performance, security, accessibility, i18n), and intelligent test case generation with Vitest/Jest support.

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.

Bucket Feature Flags MCP Server

Flag features directly from chat in your code editor, including VS Code, Cursor, Windsurf, Claude Code—any IDE with MCP support.

Multi-Database SQL MCP Server

Enables interaction with SQLite, MySQL, PostgreSQL, and SQL Server databases through tools for connection management, parameterized query execution, and schema inspection.

EVM MCP Server

Provides comprehensive access to Ethereum Virtual Machine (EVM) JSON-RPC methods for querying blockchain data, executing smart contract calls, and interacting with any EVM-compatible network including Ethereum, Polygon, Arbitrum, and more. Enables users to check balances, analyze transactions, estimate gas, retrieve logs, and perform blockchain operations through natural language.

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.

Google Calendar MCP Server

Enables language models to interact with Google Calendar through OAuth2 authentication, allowing creation, retrieval, listing, updating, and deletion of calendar events.

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.

Dynamic Mockups

Enables AI assistants to generate product mockups by integrating with the Dynamic Mockups API. Supports browsing mockup catalogs, creating single or batch renders with design assets, and managing PSD templates.

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.

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.

PocketBase MCP Server

Um servidor MCP que permite a interação com bancos de dados PocketBase, possibilitando operações de registro (buscar, listar, criar, atualizar), gerenciamento de arquivos e migrações de esquema através de linguagem natural.

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.

Proto-Blocks MCP Server

Provides comprehensive AI guidance and tools for creating WordPress Gutenberg blocks using PHP templates instead of React. Includes 12 specialized tools covering documentation, examples, troubleshooting, and a block generator for Proto-Blocks development.

MCP Web Search Server

Enables privacy-focused web searches, social media lookups, and web archive retrieval across multiple engines including DuckDuckGo, Brave, Reddit, YouTube, and Wayback Machine with built-in caching and security features.

Twilio MCP Server

Enables AI assistants to interact with all Twilio APIs through the Model Context Protocol. Supports SMS, voice, messaging, and other Twilio services with secure authentication and configurable API filtering.

STAC MCP Server

Enables AI assistants to search and access geospatial datasets through STAC (SpatioTemporal Asset Catalog) APIs. Supports querying satellite imagery, weather data, and other geospatial assets with spatial, temporal, and attribute filters.

System Stats MCP Server

Provides real-time Linux system monitoring for CPU load, memory usage, disk space, and process activity. This server enables users to retrieve comprehensive performance metrics and resource utilization data through a standardized interface.

Screenshot MCP Server

A Model Context Protocol server that enables natural language-driven screenshot capture on macOS, allowing users to take full desktop screenshots, capture specific windows, or select custom screen areas through Claude Desktop.