Discover Awesome MCP Servers

SiteLint Auditor MCP

Runs WCAG accessibility, SEO, performance, and security audits on URLs or raw HTML via SiteLint Auditor. Enables LLM agents to audit web pages and check WCAG criteria through MCP tools.

yahoo-finance-mcp

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

Read Image MCP Server

MCP server using Google Gemini to read and describe image content, supporting single or multiple images and custom prompts.

thomas-klaushofer-mcp

MCP server that provides Thomas Klaushofer's professional profile including career history, skills, projects, and achievements, allowing AI assistants to answer questions about his background.

mcp-oracle-db

MCP server for Oracle Database enabling AI assistants to explore schemas, run queries, write data, and monitor sessions via natural language. Features read-only mode by default and uses Oracle Thin mode for zero-install connectivity.

Muse Dash Mod MCP

An MCP server for Muse Dash mod development. It scaffolds projects, builds and deploys mods, launches the game, checks environment info, and provides documentation and community repository access.

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.

azure-devops-mcp-remote

Enables AI assistants to interact with Azure DevOps projects through natural language, supporting work items, repositories, pipelines, wikis, and more, with remote HTTP/SSE transport and OBO authentication.

Claude Typer

A Windows MCP extension that allows Claude to type text into any active application with human-like keystroke timing, approval mode, configurable speed, and writing style presets.

Sessionize

MCP server for accessing Sessionize event data. Query speakers, sessions, and schedules from any Sessionize-powered conference using natural language.

SiYuan MCP Server

An MCP server for SiYuan Note that enables comprehensive management of notebooks, documents, and blocks through AI integration. It supports advanced operations like SQL querying, OCR, multi-format exports, and automated content searching for intelligent knowledge management.

bgagents

Enables turning AI code agents like Anthropic Claude and OpenAI Codex into background agents accessible via MCP protocol for code generation, branch creation, and PR automation.

DoorDash MCP Server

Enables AI agents to search restaurants, place delivery orders, and track real-time delivery status using the DoorDash Drive API. It includes a built-in mock data mode that allows for testing and demonstrating delivery lifecycles without requiring live API credentials.

Rootstock MCP Server

Enables Claude AI to interact with the Rootstock blockchain, including calling contracts, checking ERC20 token balances, transferring tokens, and querying gas prices.

gemini-mcp

MCP server providing Google Search grounding with source citations using Gemini Code Assist.

bruno-mcp

MCP server that executes requests from Bruno API collections via the Bruno CLI tool, enabling API request execution and collection management.

DocuSign MCP Server (patched)

Provides DocuSign eSignature operations via JWT Grant for headless AI agents, enabling envelope management, document signing, and template access through MCP tools.

JSON Contracts

JSON Contracts is a local MCP server for transforming natural language into Git-controlled JSON contracts, JSON Schema validation, and structured LLM/agent outputs.

ddq

Enables AI coding agents to retrieve QA cases from a curated knowledge base grounded in real bugs, supporting symptom search and feature-wide coverage for test planning.

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

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.

Azure Terraform MCP Server

Provides intelligent assistance for Azure Terraform development, including documentation retrieval, code validation, security scanning, and best practices guidance.

yonote-mcp

MCP server for managing Yonote workspace, providing 56 tools for documents, collections, users, groups, comments, sharing, favorites, revisions, events, and views via AI assistants.

My HTTP MCP Server

A Model Context Protocol server that provides cryptocurrency data tools and resources via an HTTP endpoint. It enables users to fetch real-time market data from Binance, track activity logs, and generate cryptocurrency executive summaries.

map-server

A minimal MCP server built on the official Python SDK, running over Streamable HTTP. It provides demo tools (echo, add) and a time resource for testing MCP clients.

Iconify-Icon

Provide access to Iconify's MCP server with over 200,000 open-source vector ICONS, supporting icon set browsing, searching, and obtaining multi-framework usage examples.

carapace-mcp

Enables AI agents to semantically search and contribute insights to a shared knowledge base built from other agents' experiences.

mcp-ctftime

Enables AI assistants to query CTF (Capture The Flag) cybersecurity competition data from CTFtime.org, including events, team rankings, results, and votes through the public CTFtime API.