Discover Awesome MCP Servers

mbta-mpc-server

mbta-mpc-server

MCP MySQL Server

Enables secure read-only access to MySQL databases through SELECT queries via HTTP SSE interface. Provides safe database exploration and data retrieval with configurable timeout settings.

MyFirstMCP - Model Context Protocol Server Example

Esta é uma implementação simples em C# de um servidor de Protocolo de Contexto de Modelo (MCP) usando .NET 9. O projeto demonstra como criar um servidor MCP com funcionalidade básica, incluindo serviços de macaco e venda.

Bitcoin-MCP-Server

The first MCP Server dedicated to Bitcoin ecosystem

PyWeatherMCP

Provides weather information for US locations using the National Weather Service API. Offers weather alerts, 5-day forecasts, and location management with favorites and search history tracking.

Python MySQL MCP

A FastMCP-based server that enables interaction with MySQL databases, supporting client-server communication for querying and analyzing MySQL data.

VSCode Internal Command MCP Server

Converts VSCode into an MCP server that enables external clients to remotely execute VSCode internal commands, query workspace information, and interact with the editor through HTTP streaming. Built on the FastMCP framework with security controls and real-time monitoring.

Data Query MCP Server

Enables querying and analyzing user, product, and order data with filtering capabilities and real-time statistics. Supports WebSocket connections to XiaoZhi AI platform with automatic reconnection.

Registry Review MCP Server

Automates carbon credit project registration document review, transforming 6-8 hour manual reviews into 60-90 minute guided workflows with automated document discovery, evidence extraction, cross-validation, and compliance report generation.

Mevzuat MCP

A FastMCP server providing access to the Turkish Ministry of Justice's Legislative Information System, allowing LLM applications to search legislation, retrieve article lists, and get article contents in Markdown format.

Securities prices MCP server sample

Aqui está um exemplo de um servidor MCP (Market Connectivity Platform) para preços de títulos, informações históricas, etc.: (Note: This is a conceptual outline. Building a full MCP server requires significant development effort and depends heavily on the specific technologies and protocols you intend to support.) ```python # Conceptual MCP Server (Python Example) import asyncio import websockets import json import datetime # --- Data Sources (Replace with actual data feeds) --- # Mock historical data (replace with database or API calls) historical_data = { "AAPL": { "2023-10-26": {"open": 170.00, "high": 171.50, "low": 168.75, "close": 170.45}, "2023-10-27": {"open": 171.00, "high": 172.00, "low": 169.50, "close": 171.75}, # ... more historical data }, "GOOG": { "2023-10-26": {"open": 130.00, "high": 131.50, "low": 128.75, "close": 130.45}, "2023-10-27": {"open": 131.00, "high": 132.00, "low": 129.50, "close": 131.75}, # ... more historical data } } # Mock real-time prices (replace with a real-time data feed) realtime_prices = { "AAPL": 172.50, "GOOG": 132.25, "MSFT": 330.00 } # --- MCP Server Logic --- async def handle_client(websocket, path): """Handles a client connection.""" try: async for message in websocket: try: request = json.loads(message) print(f"Received request: {request}") request_type = request.get("type") if request_type == "get_price": symbol = request.get("symbol") if symbol in realtime_prices: response = {"type": "price", "symbol": symbol, "price": realtime_prices[symbol]} await websocket.send(json.dumps(response)) else: response = {"type": "error", "message": f"Symbol {symbol} not found."} await websocket.send(json.dumps(response)) elif request_type == "get_historical_data": symbol = request.get("symbol") start_date = request.get("start_date") end_date = request.get("end_date") if symbol in historical_data: # Basic date filtering (improve this for real-world use) filtered_data = { date: data for date, data in historical_data[symbol].items() if start_date <= date <= end_date } response = {"type": "historical_data", "symbol": symbol, "data": filtered_data} await websocket.send(json.dumps(response)) else: response = {"type": "error", "message": f"Symbol {symbol} not found."} await websocket.send(json.dumps(response)) elif request_type == "subscribe_price": # Simulate price updates (replace with a real-time feed integration) symbol = request.get("symbol") if symbol in realtime_prices: while True: # Simulate price change realtime_prices[symbol] += (random.random() - 0.5) * 0.1 # Small random change response = {"type": "price_update", "symbol": symbol, "price": realtime_prices[symbol]} await websocket.send(json.dumps(response)) await asyncio.sleep(1) # Send update every 1 second else: response = {"type": "error", "message": f"Symbol {symbol} not found."} await websocket.send(json.dumps(response)) else: response = {"type": "error", "message": "Invalid request type."} await websocket.send(json.dumps(response)) except json.JSONDecodeError: response = {"type": "error", "message": "Invalid JSON format."} await websocket.send(json.dumps(response)) except websockets.exceptions.ConnectionClosedError as e: print(f"Connection closed: {e}") except Exception as e: print(f"Error handling client: {e}") # --- Main --- async def main(): """Starts the WebSocket server.""" import random # Import here for use in subscribe_price start_server = websockets.serve(handle_client, "localhost", 8765) # Host and port print("MCP Server started on ws://localhost:8765") await start_server await asyncio.Future() # Run forever if __name__ == "__main__": asyncio.run(main()) ``` **Key Concepts and Explanations:** * **MCP (Market Connectivity Platform):** A system that provides access to market data (prices, historical data, news, etc.) from various sources. It acts as a central point for clients to connect and retrieve information. The goal is to abstract away the complexities of dealing with multiple data vendors and protocols. * **Data Sources:** The example uses mock data. In a real system, you would integrate with: * **Real-time Data Feeds:** Bloomberg, Refinitiv, IEX, Polygon.io, etc. These provide streaming prices. You'll need to handle their specific APIs and protocols (often proprietary). * **Historical Data Providers:** The same vendors often provide historical data. You might also use databases or specialized historical data services. * **WebSocket Server (using `websockets` library):** WebSockets provide a persistent, bidirectional communication channel between the server and clients. This is ideal for real-time data updates. * **JSON (JavaScript Object Notation):** A common format for exchanging data between the server and clients. It's human-readable and easy to parse. * **Request Handling (`handle_client` function):** * Receives JSON messages from clients. * Parses the `type` field to determine the requested action (e.g., `get_price`, `get_historical_data`, `subscribe_price`). * Retrieves data from the appropriate data source. * Formats the response as JSON and sends it back to the client. * Includes error handling. * **Request Types:** * `get_price`: Retrieves the current price for a given symbol. * `get_historical_data`: Retrieves historical price data for a given symbol within a specified date range. * `subscribe_price`: Subscribes to real-time price updates for a symbol. The server will push updates to the client whenever the price changes. * **Error Handling:** The server should handle errors gracefully and provide informative error messages to the client. * **Asynchronous Programming (using `asyncio`):** `asyncio` allows the server to handle multiple client connections concurrently without blocking. This is essential for performance. **How to Run the Example:** 1. **Install `websockets`:** ```bash pip install websockets ``` 2. **Save the code:** Save the code as a Python file (e.g., `mcp_server.py`). 3. **Run the server:** ```bash python mcp_server.py ``` 4. **Create a client:** You'll need to write a client application (in Python, JavaScript, or another language) to connect to the server and send requests. Here's a simple Python client example: ```python # Simple MCP Client (Python) import asyncio import websockets import json async def connect_and_request(): uri = "ws://localhost:8765" async with websockets.connect(uri) as websocket: # Example 1: Get current price request1 = {"type": "get_price", "symbol": "AAPL"} await websocket.send(json.dumps(request1)) response1 = await websocket.recv() print(f"Received: {response1}") # Example 2: Get historical data request2 = {"type": "get_historical_data", "symbol": "AAPL", "start_date": "2023-10-26", "end_date": "2023-10-27"} await websocket.send(json.dumps(request2)) response2 = await websocket.recv() print(f"Received: {response2}") # Example 3: Subscribe to price updates request3 = {"type": "subscribe_price", "symbol": "GOOG"} await websocket.send(json.dumps(request3)) for _ in range(5): # Receive 5 updates response3 = await websocket.recv() print(f"Received price update: {response3}") await asyncio.sleep(0.5) # Wait a bit if __name__ == "__main__": asyncio.run(connect_and_request()) ``` Save this client code as `mcp_client.py` and run it in a separate terminal: ```bash python mcp_client.py ``` **Important Considerations for a Real-World MCP:** * **Authentication and Authorization:** Implement security measures to control access to the data. Clients should authenticate themselves, and the server should authorize them to access specific data feeds. * **Data Normalization:** Data from different vendors may have different formats and conventions. Normalize the data into a consistent format before providing it to clients. * **Error Handling and Resilience:** Implement robust error handling to deal with data feed outages, network problems, and other issues. Consider using retry mechanisms and failover strategies. * **Scalability:** Design the MCP to handle a large number of concurrent client connections and high data volumes. Consider using load balancing and distributed caching. * **Data Caching:** Cache frequently accessed data to improve performance and reduce the load on data sources. * **API Design:** Design a clear and well-documented API for clients to access the data. Consider using RESTful APIs or GraphQL in addition to WebSockets. * **Monitoring and Logging:** Implement monitoring and logging to track the performance of the MCP and identify potential problems. * **Data Quality:** Implement data quality checks to ensure the accuracy and completeness of the data. * **Protocol Support:** Support multiple protocols (e.g., FIX, WebSocket, REST) to accommodate different client requirements. * **Entitlements:** Manage data entitlements to ensure that clients only have access to the data they are authorized to receive. This is often tied to licensing agreements with data vendors. * **Market Data Standards:** Consider using industry-standard market data formats and protocols (e.g., FIX/FAST). This example provides a basic foundation for building an MCP server. You'll need to expand upon it to meet the specific requirements of your application. Remember to replace the mock data with real data feeds and implement the necessary security, error handling, and scalability features. **Tradução para Português:** Aqui está um exemplo de um servidor MCP (Market Connectivity Platform - Plataforma de Conectividade de Mercado) para preços de títulos, informações históricas, etc.: (Observação: Este é um esboço conceitual. Construir um servidor MCP completo requer um esforço de desenvolvimento significativo e depende muito das tecnologias e protocolos específicos que você pretende suportar.) ```python # Servidor MCP Conceitual (Exemplo em Python) import asyncio import websockets import json import datetime # --- Fontes de Dados (Substitua por feeds de dados reais) --- # Dados históricos simulados (substitua por banco de dados ou chamadas de API) historical_data = { "AAPL": { "2023-10-26": {"open": 170.00, "high": 171.50, "low": 168.75, "close": 170.45}, "2023-10-27": {"open": 171.00, "high": 172.00, "low": 169.50, "close": 171.75}, # ... mais dados históricos }, "GOOG": { "2023-10-26": {"open": 130.00, "high": 131.50, "low": 128.75, "close": 130.45}, "2023-10-27": {"open": 131.00, "high": 132.00, "low": 129.50, "close": 131.75}, # ... mais dados históricos } } # Preços em tempo real simulados (substitua por um feed de dados em tempo real) realtime_prices = { "AAPL": 172.50, "GOOG": 132.25, "MSFT": 330.00 } # --- Lógica do Servidor MCP --- async def handle_client(websocket, path): """Lida com uma conexão de cliente.""" try: async for message in websocket: try: request = json.loads(message) print(f"Requisição recebida: {request}") request_type = request.get("type") if request_type == "get_price": symbol = request.get("symbol") if symbol in realtime_prices: response = {"type": "price", "symbol": symbol, "price": realtime_prices[symbol]} await websocket.send(json.dumps(response)) else: response = {"type": "error", "message": f"Símbolo {symbol} não encontrado."} await websocket.send(json.dumps(response)) elif request_type == "get_historical_data": symbol = request.get("symbol") start_date = request.get("start_date") end_date = request.get("end_date") if symbol in historical_data: # Filtragem básica de datas (melhore isso para uso no mundo real) filtered_data = { date: data for date, data in historical_data[symbol].items() if start_date <= date <= end_date } response = {"type": "historical_data", "symbol": symbol, "data": filtered_data} await websocket.send(json.dumps(response)) else: response = {"type": "error", "message": f"Símbolo {symbol} não encontrado."} await websocket.send(json.dumps(response)) elif request_type == "subscribe_price": # Simula atualizações de preços (substitua por uma integração de feed em tempo real) symbol = request.get("symbol") if symbol in realtime_prices: while True: # Simula mudança de preço realtime_prices[symbol] += (random.random() - 0.5) * 0.1 # Pequena mudança aleatória response = {"type": "price_update", "symbol": symbol, "price": realtime_prices[symbol]} await websocket.send(json.dumps(response)) await asyncio.sleep(1) # Envia atualização a cada 1 segundo else: response = {"type": "error", "message": f"Símbolo {symbol} não encontrado."} await websocket.send(json.dumps(response)) else: response = {"type": "error", "message": "Tipo de requisição inválido."} await websocket.send(json.dumps(response)) except json.JSONDecodeError: response = {"type": "error", "message": "Formato JSON inválido."} await websocket.send(json.dumps(response)) except websockets.exceptions.ConnectionClosedError as e: print(f"Conexão fechada: {e}") except Exception as e: print(f"Erro ao lidar com o cliente: {e}") # --- Principal --- async def main(): """Inicia o servidor WebSocket.""" import random # Importe aqui para usar em subscribe_price start_server = websockets.serve(handle_client, "localhost", 8765) # Host e porta print("Servidor MCP iniciado em ws://localhost:8765") await start_server await asyncio.Future() # Executa para sempre if __name__ == "__main__": asyncio.run(main()) ``` **Conceitos Chave e Explicações:** * **MCP (Market Connectivity Platform - Plataforma de Conectividade de Mercado):** Um sistema que fornece acesso a dados de mercado (preços, dados históricos, notícias, etc.) de várias fontes. Ele atua como um ponto central para os clientes se conectarem e recuperarem informações. O objetivo é abstrair as complexidades de lidar com vários fornecedores de dados e protocolos. * **Fontes de Dados:** O exemplo usa dados simulados. Em um sistema real, você integraria com: * **Feeds de Dados em Tempo Real:** Bloomberg, Refinitiv, IEX, Polygon.io, etc. Estes fornecem preços de streaming. Você precisará lidar com suas APIs e protocolos específicos (geralmente proprietários). * **Provedores de Dados Históricos:** Os mesmos fornecedores geralmente fornecem dados históricos. Você também pode usar bancos de dados ou serviços especializados de dados históricos. * **Servidor WebSocket (usando a biblioteca `websockets`):** WebSockets fornecem um canal de comunicação persistente e bidirecional entre o servidor e os clientes. Isso é ideal para atualizações de dados em tempo real. * **JSON (JavaScript Object Notation):** Um formato comum para trocar dados entre o servidor e os clientes. É legível por humanos e fácil de analisar. * **Tratamento de Requisições (função `handle_client`):** * Recebe mensagens JSON dos clientes. * Analisa o campo `type` para determinar a ação solicitada (por exemplo, `get_price`, `get_historical_data`, `subscribe_price`). * Recupera dados da fonte de dados apropriada. * Formata a resposta como JSON e a envia de volta ao cliente. * Inclui tratamento de erros. * **Tipos de Requisição:** * `get_price`: Recupera o preço atual para um determinado símbolo. * `get_historical_data`: Recupera dados históricos de preços para um determinado símbolo dentro de um intervalo de datas especificado. * `subscribe_price`: Assina atualizações de preços em tempo real para um símbolo. O servidor enviará atualizações para o cliente sempre que o preço mudar. * **Tratamento de Erros:** O servidor deve lidar com erros de forma elegante e fornecer mensagens de erro informativas ao cliente. * **Programação Assíncrona (usando `asyncio`):** `asyncio` permite que o servidor lide com várias conexões de clientes simultaneamente sem bloquear. Isso é essencial para o desempenho. **Como Executar o Exemplo:** 1. **Instale `websockets`:** ```bash pip install websockets ``` 2. **Salve o código:** Salve o código como um arquivo Python (por exemplo, `mcp_server.py`). 3. **Execute o servidor:** ```bash python mcp_server.py ``` 4. **Crie um cliente:** Você precisará escrever um aplicativo cliente (em Python, JavaScript ou outra linguagem) para se conectar ao servidor e enviar requisições. Aqui está um exemplo simples de cliente Python: ```python # Cliente MCP Simples (Python) import asyncio import websockets import json async def connect_and_request(): uri = "ws://localhost:8765" async with websockets.connect(uri) as websocket: # Exemplo 1: Obter preço atual request1 = {"type": "get_price", "symbol": "AAPL"} await websocket.send(json.dumps(request1)) response1 = await websocket.recv() print(f"Recebido: {response1}") # Exemplo 2: Obter dados históricos request2 = {"type": "get_historical_data", "symbol": "AAPL", "start_date": "2023-10-26", "end_date": "2023-10-27"} await websocket.send(json.dumps(request2)) response2 = await websocket.recv() print(f"Recebido: {response2}") # Exemplo 3: Assinar atualizações de preços request3 = {"type": "subscribe_price", "symbol": "GOOG"} await websocket.send(json.dumps(request3)) for _ in range(5): # Receber 5 atualizações response3 = await websocket.recv() print(f"Atualização de preço recebida: {response3}") await asyncio.sleep(0.5) # Esperar um pouco if __name__ == "__main__": asyncio.run(connect_and_request()) ``` Salve este código do cliente como `mcp_client.py` e execute-o em um terminal separado: ```bash python mcp_client.py ``` **Considerações Importantes para um MCP no Mundo Real:** * **Autenticação e Autorização:** Implemente medidas de segurança para controlar o acesso aos dados. Os clientes devem se autenticar e o servidor deve autorizá-los a acessar feeds de dados específicos. * **Normalização de Dados:** Os dados de diferentes fornecedores podem ter formatos e convenções diferentes. Normalize os dados em um formato consistente antes de fornecê-los aos clientes. * **Tratamento de Erros e Resiliência:** Implemente um tratamento de erros robusto para lidar com interrupções de feeds de dados, problemas de rede e outros problemas. Considere o uso de mecanismos de repetição e estratégias de failover. * **Escalabilidade:** Projete o MCP para lidar com um grande número de conexões de clientes simultâneas e altos volumes de dados. Considere o uso de balanceamento de carga e cache distribuído. * **Cache de Dados:** Armazene em cache os dados acessados ​​com frequência para melhorar o desempenho e reduzir a carga nas fontes de dados. * **Design de API:** Projete uma API clara e bem documentada para os clientes acessarem os dados. Considere o uso de APIs RESTful ou GraphQL, além de WebSockets. * **Monitoramento e Registro:** Implemente monitoramento e registro para rastrear o desempenho do MCP e identificar problemas potenciais. * **Qualidade dos Dados:** Implemente verificações de qualidade dos dados para garantir a precisão e integridade dos dados. * **Suporte a Protocolos:** Suporte a vários protocolos (por exemplo, FIX, WebSocket, REST) para acomodar diferentes requisitos do cliente. * **Entitlements (Direitos):** Gerencie os direitos de dados para garantir que os clientes tenham acesso apenas aos dados que estão autorizados a receber. Isso geralmente está vinculado a acordos de licenciamento com fornecedores de dados. * **Padrões de Dados de Mercado:** Considere o uso de formatos e protocolos de dados de mercado padrão do setor (por exemplo, FIX/FAST). Este exemplo fornece uma base básica para a construção de um servidor MCP. Você precisará expandi-lo para atender aos requisitos específicos de sua aplicação. Lembre-se de substituir os dados simulados por feeds de dados reais e implementar os recursos de segurança, tratamento de erros e escalabilidade necessários.

Modular MCP Server

A scalable, auto-discovering Model Context Protocol server that dynamically loads tools from the tools directory, enabling LLMs to access various capabilities through a standardized interface.

AI Develop Assistant

Assists AI developers with intelligent requirement analysis and architecture design through guided clarification questions, branch-aware management, and automated architecture generation with persistent storage.

Hugging Face Hub Semantic Search MCP

An unofficial MCP server that provides semantic search capabilities for Hugging Face models and datasets, enabling Claude and other MCP-compatible clients to search, discover, and explore the Hugging Face ecosystem using natural language queries.

Awesome MCP ZH

Seleção de recursos MCP, Guia MCP, Claude MCP, Servidores MCP, Clientes MCP

aptos-dex-mcp

MCP server for Dex on Aptos

ML Lab MCP

Transforms AI assistants into a full ML engineering environment for training and fine-tuning models across multiple backends (local GPU, Mistral, Together AI, OpenAI) and cloud providers (Lambda Labs, RunPod, SSH-accessible VPS), with dataset management, experiment tracking, cost estimation, and deployment to Ollama/Open WebUI.

beeper-mcp

Um serviço de backend para executar transações Beeper na Binance Smart Chain.

mcp-shoten-url

Enables creation of shortened URLs using the x.gd URL shortening service through its API.

Linear Issues MCP Server

An MCP server providing read-only access to Linear issues for language models, allowing them to fetch issue details and comments using a Linear API token.

Tavily MCP Load Balancer

A multi-API key load balancing MCP server for Tavily that automatically rotates between multiple API keys to provide high availability and increased request limits.

VayuChat MCP

A FastMCP server for natural language data analysis that allows users to load CSV files, execute Python code with pandas and numpy, and generate matplotlib visualizations. It provides a suite of tools for data exploration, statistical summaries, and querying datasets through MCP-compatible clients.

MCP Claude Desktop

Enables Claude Code to send prompts to Claude Desktop using macOS automation and AppleScript. Supports conversation management and configurable response polling, though reading responses back is limited by Electron's accessibility APIs.

AI Makerspace MCP Server

An MCP server providing tools for web searching via the Tavily API, dice rolling using standard notation, and cryptocurrency market data through the CoinGecko API. It is designed to integrate these capabilities into AI workflows using a standard input/output transport mode.

Sumanshu Arora

MCP aggregator with many existing NCP templates and allows running external MCP servers too

mc-mcp-server

🚧 Servidor Java MCP para Minecraft

Worksona MCP Server

Integrates 100+ specialized AI agents with Claude Desktop, providing automated agent discovery, multi-agent coordination, and ready-to-use task templates for complex development and business workflows. Enables users to leverage enterprise-level AI capabilities through actionable resources and intelligent agent matching.

Repsona MCP Server

Enables integration with Repsona project management platform, allowing users to manage tasks, projects, notes, files, and inbox through natural language interactions with the Repsona API.

superFetch MCP Server

An MCP server that fetches web pages and extracts clean, AI-friendly Markdown content using Mozilla Readability. It provides secure web access for LLMs with built-in SSRF protection and automated content cleaning for improved context retrieval and summarization.