Discover Awesome MCP Servers

CoinGecko API Server MCP

Um servidor Node.js Express que fornece acesso aos dados de criptomoedas da CoinGecko através de uma interface de API abrangente, suportando APIs gratuitas e Pro com funcionalidade de fallback automático.

Ethereum RPC MPC Server

Um servidor MCP TypeScript que utiliza o SDK MCP para suportar todas as chamadas JSON-RPC do Ethereum, permitindo que modelos de IA interajam com dados blockchain.

Multi Database MCP Server

O Servidor Multi DB MCP é uma implementação de alto desempenho do Protocolo de Contexto de Modelo de Banco de Dados (Database Model Context Protocol) projetado para revolucionar a forma como agentes de IA interagem com bancos de dados. Atualmente, oferece suporte a bancos de dados MySQL e PostgreSQL.

OmniLLM: Universal LLM Bridge for Claude

OmniLLM: Um servidor de Protocolo de Contexto de Modelo (MCP) que permite que o Claude acesse e integre respostas de múltiplos LLMs, incluindo ChatGPT, Azure OpenAI e Google Gemini, criando um hub de conhecimento de IA unificado.

solana-docs-server MCP Server

Mirror of

MCP Server for Iaptic

Mirror of

MCP Servers Schemas

Este documento fornece uma lista de diferentes servidores MCP. Para cada servidor, fornecemos uma definição de esquema que inclui as informações básicas mais recentes e as definições de ferramentas.

MCP Tunnel

Um servidor MCP simples que permite acessar e executar comandos shell em uma máquina virtual através de uma interface de terminal baseada na web, com tunelamento automático para tornar a VM acessível de qualquer lugar.

🚀 MCP Client-Server Repository

An MCP Server that's also an MCP Client. Useful for letting Claude develop and test MCPs without needing to reset the application.

MCP Marketplace

This is the official repository for submitting MCP servers to be included in Cline's MCP Marketplace. If you’ve built an MCP server and want it to be discoverable and easily installable by millions of developers using Cline, submit your server here.

GitHub MCP (Model Context Protocol) server

Um servidor MCP que permite que o Claude e outros LLMs compatíveis interajam com a API do GitHub, suportando funcionalidades como criar issues, recuperar informações do repositório, listar issues e pesquisar repositórios.

optimized-memory-mcp-serverv2

Mirror of

mcp-gnews

Servidor MCP para dar ao cliente a capacidade de pesquisar notícias relacionadas na internet.

MCPilled

MCPilled.com é uma coleção de notícias selecionadas sobre servidores MCP, clientes, atualizações de protocolo e tudo mais relacionado ao MCP.

MCP Apple NotesMCP Apple Notes

Permite a pesquisa semântica e RAG (Geração Aumentada por Recuperação) nas suas Notas da Apple.

Perplexity AI MCP Server

Espelho de

Apifox MCP Server

Um servidor que conecta assistentes de codificação de IA, como Cursor e Cline, a definições de API do Apifox, permitindo que desenvolvedores implementem interfaces de API através de comandos em linguagem natural.

JIRA MCP Server

the mcp server with jira integrates

SimpleMCP

Proof of concept for cloudflare worker mcp server

Skynet-MCP (THIS PROJECT IS A WORK IN PROGRESS)

Um servidor MCP que atua como um agente e que pode gerar mais Agentes, usando MCP... Inception MCP!

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.

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.

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.

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

PHP MCP Protocol Server

Servidor MCP para PHP Universal - integra PHP com o protocolo Model Context Protocol

MCP Image Generation Server

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