Discover Awesome MCP Servers

Godot MCP Server

AI-powered development assistant that bridges AI assistants with Godot game projects, enabling intelligent project analysis, smart code generation, debugging, and performance optimization.

Google Jules MCP Server

Enables interaction with Google Jules API to automate software development tasks, such as managing sources, sessions, and activities for AI-powered coding assistance.

ERPNext MCP Server

A comprehensive MCP server for ERPNext providing generic, doctype-agnostic access to any ERPNext document type with robust permission controls, audit logging, and enterprise-grade security.

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.

Mosaic MCP Server

Provides 11 MCP tools for deterministic, local semantic search over your documents, including indexing, retrieval, exact-match facets, temporal truth, semantic diff, and agent-first JSON output. Enables LLMs and agents to search, retrieve, and analyze documents without cloud dependencies or per-query costs.

fylings-mcp

Search, verify and screen over 1 million African companies across 18 official government registries, along with the public contracts they have won and OFAC/UN sanctions screening. Every result carries its registry source, date and a confidence signal, and the server returns nulls rather than fabricating data.

@manansiingh/figma-react-mcp-server

Converts Figma designs into production-ready React components with design token extraction, widget registry integration, and micro-frontend module generation.

Hello3DMCP Server

An MCP server that bridges AI clients with a frontend 3D visualization application to control model properties, lighting, and camera settings via WebSocket. It enables real-time manipulation of 3D scenes through natural language commands for scaling, rotating, and coloring models.

OraLink MCP

Hosted MCP server that bridges MCP clients to Oracle Autonomous Database via OAuth 2.0, enabling SQL queries and schema management without local Oracle tooling.

Offramp MCP Server

Provides retirement planning computations for AI agents, including Monte Carlo simulations, tax burden modeling across all US states, Social Security claiming optimization, and cost-of-living comparisons.

DocGuard

DocGuard, an official, zero-dependency Node.js MCP server (npm: docguard-cli, docguard mcp) exposing 5 read-only doc-governance tools: guard, score, explain, verify-claims, diagnose.

Coordination Memory MCP

An append-only coordination memory for multi-agent and human work, backed by SQLite, with a local dashboard and acceptance contracts that enforce integrator review before work is considered accepted.

Redmine MCP Server

MCP server for Redmine project management, enabling tools for managing projects, issues, users, time entries, groups, memberships, versions, wiki, news, attachments, search, and Agile sprints via the Redmine REST API.

Epiphany MCP Server

Enables AI agents to automate Epiphany booking tasks, including checking availability and creating bookings.

codex-monitor

An MCP server that provides monitoring tools for Codex agents, allowing them to create and wait on conditions using commands, log files, file events, and custom probes, replacing polling loops with event-driven blocking.

LounasMCP

Enables retrieval of daily lunch menus for restaurants in Sello shopping center (Espoo) from lounaat.info.

mcp-comexstat

mcp-comexstat

Favro MCP

An MCP server for interacting with the Favro project management platform. It enables users to manage organizations, boards, columns, and cards through actions like task creation, assignment, and status updates.

GREB-MCP

A hybrid search MCP that enables users to find coding chunks like RAG without indexing their codebase, without any vector database. World's first context attention MCP. It gives results in below 5 seconds in a repository as big as VS Code.

semantic-search-mcp

Provides semantic code search over codebases using local embeddings with natural language queries. Supports hybrid search, file watching, and respects .gitignore.

db-mcp

Enables AI agents to safely interact with a SQLite shop database through schema discovery, read-only SQL queries, and pre-built analytics reports like top customers, top products, and revenue summaries.

sentry-mcp-rs

Fast and minimal Sentry MCP server written in Rust

mcp-feedback-enhanced-gw

Establishes feedback-oriented development workflows with Web UI and desktop application interfaces, enabling AI to confirm with users and consolidate tool calls into single feedback requests.

Telegram Bot MCP Server

Enables sending Telegram messages, photos, and documents, and retrieving bot information through the Telegram Bot API.

CodeMore MCP Server

Enables AI agents to scan code for security and quality issues and receive machine-readable reports with suggested fixes and verification criteria.

Kockatoos Shopify MCP Server

An MCP server providing AI agents with full access to the Shopify Admin API via 136 tools for managing products, orders, customers, collections, and more.

Congress.gov API MCP Server

Este é um servidor de Protocolo de Contexto de Modelo (MCP) projetado para fornecer acesso à API oficial Congress.gov (v3) usando uma abordagem híbrida.

M5 Petit Relations

Enables reading and updating relationship data (likes, dislikes, important info, feelings, closeness, notes) for characters in a multi-character system, supporting both private and public relations.

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.

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.