Discover Awesome MCP Servers

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.

TexasSolver MCP Server

Enables interaction with the TexasSolver poker solver to run game theory optimal (GTO) poker calculations, load preflop ranges, and build game trees with structured parameters for analyzing poker hands and strategies.

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.

ASG Card

Virtual MasterCards for AI agents. Issue and manage cards via MCP.

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.

Thunder Client License Manager MCP Server

Provides tools for managing Thunder Client licenses through their API, enabling users to add, retrieve, and remove licenses with simple commands.

Gemini MCP Server

Enables multi-turn conversations with Google Gemini AI models, supporting file and image analysis, automatic model selection, deep thinking mode, and Google Search integration through the AIStudioProxyAPI backend.

Nagoya Bus MCP

Provides access to Nagoya bus system information and schedules. Enables users to query bus routes, stops, and real-time transit data for Nagoya's public transportation network.

Azure Usage MCP Server

Enables natural language analysis of Azure usage data from CSV files, providing cost summaries, visualizations, and insights about service and regional spending patterns.

postman-mcp

mcp-PostmanV3

Google Cloud DNS MCP Server

Enables AI assistants to manage Google Cloud DNS zones and records, supporting full CRUD operations for various record types and DNSSEC management. It provides secure service account authentication to interact directly with Google Cloud's global DNS infrastructure.

Microservice Control Panel (MCP)

Uma plataforma que integra e gerencia APIs da plataforma de publicidade Ocean Engine (巨量引擎) da ByteDance, fornecendo interfaces de acesso unificadas para cenários de aquisição de tráfego de e-commerce.

MCP Server Starter (TypeScript)

A minimal, production-ready TypeScript template for building Model Context Protocol servers with auto-loading architecture for tools, resources, and prompts, supporting both stdio and HTTP transports.

granola-mcp

Enables semantic search and insight extraction across Granola meeting notes, categorizing content into themes like pain points and decisions. It provides AI assistants with tools to query meeting transcripts, summaries, and speaker-attributed quotes via a local vector index.

MCP Prompt Cleaner

Enhances and cleans raw prompts using AI to make them more clear, actionable, and effective. Provides quality assessment, suggestions, and supports both general and code-specific optimization modes.

ovh-api-mcp

Code Mode MCP server for the OVH API. Two tools (search + execute) give LLMs access to all OVH endpoints via sandboxed JavaScript.

MCP Jira

Enables AI assistants to interact with Jira Cloud and Server/Data Center deployments for issue management, project tracking, and workflow automation. Supports multiple authentication methods including API tokens, OAuth 2.0, and personal access tokens.

ExpenseTracker MCP Server

Enables AI assistants to manage personal finances by storing, analyzing, and exporting expense data using a persistent PostgreSQL database. Supports adding/editing expenses, generating spending summaries, detecting top categories, and creating monthly reports.

Fuel Network & Sway Language MCP Server

Um servidor Fuel MCP que oferece suporte para a documentação do Fuel e várias IDEs de programação, como o Cursor.

Docker MCP Server

Enables secure execution of shell commands and file operations within isolated Docker containers. Provides process management, interactive input handling, and comprehensive file system operations for containerized development environments.

Qdrant MCP Server

Provides semantic memory capabilities using Qdrant vector database with configurable embedding providers, allowing storage and retrieval of information using vector similarity.

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.

Software Management MCP Server

Enables AI agents to automate local software management workflows including installation, uninstallation, updates, and environment recommendations. It provides a standardized, non-interactive interface for managing system applications and tracking software versions safely.

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.

Semantic Search MCP Server

Provides hybrid semantic and keyword code search for Claude Code using BM25 and vector retrieval. It enables indexing and searching local codebases with language-aware chunking and local embeddings.

mcp-openapi

Turn any OpenAPI/Swagger spec into MCP tools. Zero config, zero code. Supports Swagger 2.0, OpenAPI 3.x, Bearer/API-key/OAuth2 auth, flat parameter schemas for better LLM accuracy, and smart response truncation.

Forge MCP Server

Integrates with the Laravel Forge API to provide comprehensive management of servers and sites. It enables users to perform health checks, monitor logs, create resources, and execute deployment tasks through MCP-compliant tools.