Discover Awesome MCP Servers

Backstage MCP

A simple backstage mcp server using quarkus-backstage

EVM MCP Server

Um servidor abrangente que permite que agentes de IA interajam com múltiplas redes blockchain compatíveis com EVM através de uma interface unificada, suportando resolução ENS, operações com tokens e interações com contratos inteligentes.

OpenAPI MCP Server

Esta ferramenta cria um servidor de Protocolo de Contexto de Modelo (MCP) que atua como um proxy para qualquer API que tenha uma especificação OpenAPI v3.1. Isso permite que você use o Claude Desktop para interagir facilmente com APIs de servidor locais e remotas.

reddit-mcp

MCP server for reddit.

MCP Server Gateway

A gateway demo for MCP SSE Server

filesystem

Um servidor de Protocolo de Contexto de Modelo que estende as capacidades de IA, fornecendo acesso ao sistema de arquivos e funcionalidades de gerenciamento para o Claude ou outros assistentes de IA.

➡️ browser-use mcp server

Um servidor MCP que permite que assistentes de IA controlem um navegador web através de comandos em linguagem natural, permitindo-lhes navegar em websites e extrair informações via transporte SSE.

openpyxl_mcp_server

Um wrapper fino em torno da biblioteca Python OpenPyXl que expõe operações de arquivos Excel como um servidor Model Context Protocol (MCP), permitindo que Claude e outros clientes MCP busquem e analisem dados de arquivos Excel.

OneSignal MCP Server

Um servidor de Protocolo de Contexto de Modelo que envolve a API REST do OneSignal, permitindo o gerenciamento de notificações push, e-mails, SMS, dispositivos de usuário e segmentos em várias aplicações OneSignal.

quickchart-server MCP Server

Um servidor MCP para gerar visualizações de dados personalizáveis usando QuickChart.io, com suporte para múltiplos tipos de gráficos e configuração do Chart.js.

Dynamic Shell Server

A Model Context Protocol (MCP) server that enables secure execution of shell commands with a dynamic approval system. This server allows running arbitrary commands while maintaining security through user approval and audit logging.

Kafka MCP Server

Permite que modelos de IA publiquem e consumam mensagens de tópicos do Apache Kafka por meio de uma interface padronizada, facilitando a integração de mensagens do Kafka com LLMs e aplicações de agentes.

Linear MCP Server

Um servidor que permite que assistentes de IA acessem e recuperem dados de tickets do Linear através do padrão Model Context Protocol (MCP), atualmente focado em buscar os tickets "a fazer" de um usuário.

Legion MCP (Model Context Protocol) Server

Um servidor que ajuda as pessoas a acessar e consultar dados em bancos de dados usando o Query Runner com integração do SDK Python do Protocolo de Contexto de Modelo (MCP). Suporta bancos de dados, incluindo: PostgreSQL Redshift MySQL Microsoft SQL Server APIs do Google Amazon Web Services (via boto3) CockroachDB SQLite

perplexity-server MCP Server

Perplexity MCP Server for Cline

Fused MCP Agents: Setting up MCP Servers for Data

Um servidor MCP baseado em Python que permite que Claude e outros LLMs executem código Python arbitrário diretamente através do seu aplicativo Claude para desktop, permitindo que cientistas de dados conectem LLMs a APIs e código executável.

For the GitHub MCP

A LangGraph incorporating the Selector MCP Server and other MCP Servers as an example of a modern solution

Strava MCP Server

Um servidor de Protocolo de Contexto de Modelo que permite aos usuários acessar dados de condicionamento físico do Strava, incluindo atividades do usuário, detalhes das atividades, segmentos e placares de líderes por meio de uma interface de API estruturada.

MCP GO Tools

A Go-focused Model Context Protocol (MCP) server that provides idiomatic Go code generation, style guidelines, and best practices. This tool helps Language Models understand and generate high-quality Go code following established patterns and conventions.

Math-MCP

Um servidor de Protocolo de Contexto de Modelo que fornece funções matemáticas e estatísticas básicas para LLMs, permitindo que eles realizem cálculos numéricos precisos através de uma API simples.

Github Action Trigger Mcp

Um servidor de Protocolo de Contexto de Modelo que permite a integração com o GitHub Actions, permitindo que os usuários busquem ações disponíveis, obtenham informações detalhadas sobre ações específicas, disparem eventos de despacho de fluxo de trabalho e busquem lançamentos de repositório.

MCP Demo

Okay, let's outline a basic example of an MCP (Microservice Communication Protocol) server in Python for fetching aviation weather data. This example will be simplified for clarity and demonstration purposes. It will use a hypothetical aviation weather API. Remember to replace the placeholder API URL with a real one. **Conceptual Overview** 1. **MCP Server:** This will be a simple server that listens for requests on a specific port. It will receive requests in a defined format (e.g., JSON) specifying the ICAO airport code for which weather data is desired. 2. **Weather Data Fetching:** The server will use the ICAO code to query an external aviation weather API (e.g., a METAR/TAF API). 3. **Response:** The server will format the weather data (e.g., as JSON) and send it back to the client. **Python Implementation (using Flask and `requests`)** ```python from flask import Flask, request, jsonify import requests import json app = Flask(__name__) # Replace with a real aviation weather API endpoint AVIATION_WEATHER_API_URL = "https://example.com/api/metar/" # Placeholder! def fetch_aviation_weather(icao_code): """ Fetches aviation weather data (METAR/TAF) for a given ICAO airport code. Args: icao_code (str): The ICAO airport code (e.g., "KJFK"). Returns: dict: A dictionary containing the weather data, or None if an error occurred. """ try: url = AVIATION_WEATHER_API_URL + icao_code response = requests.get(url) response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx) # Assuming the API returns JSON data weather_data = response.json() return weather_data except requests.exceptions.RequestException as e: print(f"Error fetching weather data: {e}") return None except json.JSONDecodeError as e: print(f"Error decoding JSON response: {e}") return None @app.route('/weather', methods=['POST']) def get_weather(): """ Endpoint to receive ICAO code and return weather data. Expects a JSON payload like: {"icao": "KJFK"} """ try: data = request.get_json() icao_code = data.get('icao') if not icao_code: return jsonify({"error": "ICAO code is required"}), 400 weather_data = fetch_aviation_weather(icao_code) if weather_data: return jsonify(weather_data), 200 else: return jsonify({"error": "Failed to retrieve weather data"}), 500 except Exception as e: print(f"An unexpected error occurred: {e}") return jsonify({"error": "Internal server error"}), 500 if __name__ == '__main__': app.run(debug=True, host='0.0.0.0', port=5000) # Listen on all interfaces ``` **Explanation:** 1. **Imports:** Imports necessary libraries: `Flask` for the web server, `requests` for making HTTP requests to the weather API, and `json` for handling JSON data. 2. **Flask App:** Creates a Flask application instance. 3. **`AVIATION_WEATHER_API_URL`:** **CRITICAL:** This is a placeholder. You *must* replace this with the actual URL of a real aviation weather API. Many free and paid APIs are available. You might need to register for an API key. 4. **`fetch_aviation_weather(icao_code)`:** * Takes the ICAO code as input. * Constructs the API URL using the ICAO code. * Uses `requests.get()` to make a GET request to the API. * `response.raise_for_status()`: This is important. It checks if the HTTP response code was successful (2xx). If it's an error code (4xx or 5xx), it raises an `HTTPError` exception, which is caught in the `except` block. * `response.json()`: Parses the JSON response from the API into a Python dictionary. * Error Handling: Includes `try...except` blocks to handle potential errors during the API request (e.g., network issues, invalid URL) and JSON decoding errors. Returns `None` if an error occurs. 5. **`@app.route('/weather', methods=['POST'])`:** * Defines a Flask route `/weather` that only accepts POST requests. This is a common pattern for APIs where you're sending data to the server. * `request.get_json()`: Parses the JSON data from the request body. The client will send the ICAO code in the JSON payload. * `data.get('icao')`: Retrieves the value associated with the key "icao" from the JSON data. The client should send JSON like `{"icao": "KJFK"}`. * Error Handling: Checks if the ICAO code is present in the request. If not, it returns a 400 Bad Request error. * Calls `fetch_aviation_weather()` to get the weather data. * Returns the weather data as a JSON response using `jsonify()`. Returns a 200 OK status code if successful, or a 500 Internal Server Error if there was a problem. 6. **`if __name__ == '__main__':`:** * This ensures that the Flask app is only run when the script is executed directly (not when it's imported as a module). * `app.run(debug=True, host='0.0.0.0', port=5000)`: Starts the Flask development server. * `debug=True`: Enables debug mode (useful for development, but disable in production). * `host='0.0.0.0'`: Makes the server accessible from any IP address (important if you want to access it from another machine). * `port=5000`: Specifies the port the server will listen on. **How to Run:** 1. **Install Dependencies:** ```bash pip install Flask requests ``` 2. **Save:** Save the code as a Python file (e.g., `aviation_weather_server.py`). 3. **Run:** ```bash python aviation_weather_server.py ``` **How to Test (using `curl`):** Open a terminal and use `curl` to send a POST request to the server: ```bash curl -X POST -H "Content-Type: application/json" -d '{"icao": "KJFK"}' http://localhost:5000/weather ``` Replace `"KJFK"` with the ICAO code you want to query. **Important Considerations and Improvements:** * **Error Handling:** The error handling in this example is basic. You should add more robust error handling, logging, and potentially retry mechanisms for API requests. * **API Rate Limiting:** Be aware of the API's rate limits. Implement mechanisms to avoid exceeding the limits (e.g., caching, throttling). * **Data Validation:** Validate the data returned by the API to ensure it's in the expected format. * **Security:** If you're deploying this server to a production environment, you'll need to consider security aspects such as authentication, authorization, and input validation. * **Configuration:** Use environment variables or a configuration file to store sensitive information like API keys and the API URL. * **Asynchronous Operations:** For better performance, especially if the API calls are slow, consider using asynchronous operations (e.g., with `asyncio` and `aiohttp`). * **Caching:** Implement caching to reduce the number of API calls and improve response times. You could use a simple in-memory cache or a more sophisticated caching system like Redis or Memcached. * **Data Transformation:** You might need to transform the data returned by the API into a format that's more suitable for your clients. * **Monitoring:** Implement monitoring to track the server's performance and identify potential issues. * **MCP Definition:** This example uses HTTP/JSON for communication, which is a common approach for microservices. For a more formal MCP, you might consider using a message queue (e.g., RabbitMQ, Kafka) or a service mesh (e.g., Istio). These provide more advanced features like message routing, service discovery, and fault tolerance. **Translation to Portuguese (Example Response):** If the API returned the following JSON: ```json { "icao": "KJFK", "metar": "KJFK 241251Z 11011KT 10SM FEW040 BKN050 OVC060 22/18 A3005 RMK AO2 SLP175 T02220178" } ``` A possible Portuguese translation of the `metar` field could be: ```json { "icao": "KJFK", "metar_pt": "KJFK 241251Z 11011KT 16km Poucas nuvens a 1200 metros, Nublado a 1500 metros, Encoberto a 1800 metros, Temperatura 22°C, Ponto de orvalho 18°C, Pressão atmosférica 1017.5 hPa" } ``` **Important Notes on Translation:** * **Automated Translation:** You can use a translation API (e.g., Google Translate API, DeepL API) to automatically translate the METAR text. However, automated translations may not always be accurate, especially for technical terms. * **Manual Translation:** For critical applications, it's best to have a human translator review the translations. * **METAR Decoding Libraries:** Consider using a METAR decoding library that can parse the METAR string and provide the information in a structured format. This will make it easier to translate the individual elements of the METAR. * **Localization:** Consider the target audience and adapt the translations to their specific dialect of Portuguese. This comprehensive example provides a solid foundation for building an MCP server for fetching aviation weather data. Remember to adapt it to your specific needs and the requirements of your chosen aviation weather API. Good luck!

NN-GitHubTestRepo

criado a partir da demonstração do servidor MCP

MCP Image Generation Server

Uma implementação em Go de ferramentas de servidor MCP (Model Context Protocol).

Selector Mcp Server

Um servidor de Protocolo de Contexto de Modelo (MCP) que permite bate-papo de IA interativo e em tempo real com o Selector AI através de um servidor com capacidade de streaming e um cliente baseado em Docker que se comunica via stdin/stdout.