Discover Awesome MCP Servers

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).

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.

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.

Data.gov MCP Server

Espelho de

Model Context Protocol (MCP)

The Model Context Protocol is an open standard that enables developers to build secure, two-way connections between their data sources and AI-powered tools. The architecture is straightforward: developers can either expose their data through MCP servers or build AI applications (MCP clients) that connect to these servers.

MCP Server Playground

Um servidor MCP baseado em TypeScript, projetado para experimentação e integração com o Calude Desktop e o Cursor IDE, oferecendo um ambiente modular para estender as capacidades do servidor.

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.

repo-to-txt-mcp

Servidor MCP para analisar e converter repositórios Git em arquivos de texto para contexto de LLM.

Google Home MCP Server

Mirror of

mcp-server-restart

Mirror of

Semantic Scholar MCP Server

Espelho de

PHP MCP Protocol Server

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

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.

HANA Cloud MCP Server

Espelho de

better-auth-mcp-server MCP Server

Mirror of

MCP Mistral OCR

Okay, I understand. You want to use the Mistral OCR API (which is a paid service) to perform OCR on images or PDFs, either from local files or from URLs, and you want to do this programmatically. To give you the best possible guidance, I need a little more information about what you're trying to achieve and your technical background. However, I can provide a general outline and some code snippets to get you started. **General Outline:** 1. **Sign up for a Mistral OCR API Account:** You'll need to create an account and obtain an API key from Mistral. This is essential for authenticating your requests. Refer to the Mistral OCR API documentation for their sign-up process and pricing. 2. **Choose a Programming Language:** Python is a popular choice for working with APIs due to its ease of use and available libraries. I'll provide examples in Python. 3. **Install Necessary Libraries:** You'll likely need the `requests` library for making HTTP requests to the API. You might also need libraries like `PIL` (Pillow) for image manipulation or `PyPDF2` for working with PDFs. 4. **Implement the OCR Logic:** This involves: * Reading the image or PDF data (either from a local file or downloading from a URL). * Constructing the API request with the appropriate headers and data (including your API key and the image/PDF data). * Sending the request to the Mistral OCR API endpoint. * Handling the API response (checking for errors, parsing the OCR'd text). 5. **Error Handling:** Implement robust error handling to deal with potential issues like network errors, invalid API keys, incorrect file formats, or API rate limits. **Python Example (Illustrative - Requires Adaptation):** ```python import requests import io # For handling in-memory file-like objects from PIL import Image # For image handling (optional) #from PyPDF2 import PdfReader # For PDF handling (optional) # Replace with your actual Mistral OCR API key and endpoint API_KEY = "YOUR_MISTRAL_API_KEY" API_ENDPOINT = "YOUR_MISTRAL_OCR_API_ENDPOINT" # Check Mistral's documentation def ocr_image_from_url(image_url): """Performs OCR on an image from a URL using the Mistral OCR API.""" try: response = requests.get(image_url, stream=True) response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx) # Open the image using Pillow (PIL) image = Image.open(response.raw) # Convert the image to bytes (e.g., JPEG or PNG) img_byte_arr = io.BytesIO() image.save(img_byte_arr, format='JPEG') # Or 'PNG' img_byte_arr = img_byte_arr.getvalue() headers = { "Authorization": f"Bearer {API_KEY}", # Or however Mistral requires authentication } files = { "image": ("image.jpg", img_byte_arr, "image/jpeg"), # Adjust filename and MIME type } api_response = requests.post(API_ENDPOINT, headers=headers, files=files) api_response.raise_for_status() result = api_response.json() # Assuming the API returns JSON return result.get("text") # Adjust based on the API's response format except requests.exceptions.RequestException as e: print(f"Error during request: {e}") return None except Exception as e: print(f"An error occurred: {e}") return None def ocr_image_from_file(image_path): """Performs OCR on a local image file.""" try: with open(image_path, "rb") as image_file: headers = { "Authorization": f"Bearer {API_KEY}", # Or however Mistral requires authentication } files = { "image": (image_path, image_file, "image/jpeg"), # Adjust MIME type } api_response = requests.post(API_ENDPOINT, headers=headers, files=files) api_response.raise_for_status() result = api_response.json() # Assuming the API returns JSON return result.get("text") # Adjust based on the API's response format except FileNotFoundError: print(f"Error: File not found at {image_path}") return None except requests.exceptions.RequestException as e: print(f"Error during request: {e}") return None except Exception as e: print(f"An error occurred: {e}") return None def ocr_pdf_from_url(pdf_url): """Performs OCR on a PDF from a URL using the Mistral OCR API.""" try: response = requests.get(pdf_url, stream=True) response.raise_for_status() headers = { "Authorization": f"Bearer {API_KEY}", # Or however Mistral requires authentication } files = { "pdf": ("document.pdf", response.raw, "application/pdf"), # Adjust filename and MIME type } api_response = requests.post(API_ENDPOINT, headers=headers, files=files) api_response.raise_for_status() result = api_response.json() # Assuming the API returns JSON return result.get("text") # Adjust based on the API's response format except requests.exceptions.RequestException as e: print(f"Error during request: {e}") return None except Exception as e: print(f"An error occurred: {e}") return None def ocr_pdf_from_file(pdf_path): """Performs OCR on a local PDF file.""" try: with open(pdf_path, "rb") as pdf_file: headers = { "Authorization": f"Bearer {API_KEY}", # Or however Mistral requires authentication } files = { "pdf": (pdf_path, pdf_file, "application/pdf"), # Adjust MIME type } api_response = requests.post(API_ENDPOINT, headers=headers, files=files) api_response.raise_for_status() result = api_response.json() # Assuming the API returns JSON return result.get("text") # Adjust based on the API's response format except FileNotFoundError: print(f"Error: File not found at {pdf_path}") return None except requests.exceptions.RequestException as e: print(f"Error during request: {e}") return None except Exception as e: print(f"An error occurred: {e}") return None # Example usage: # image_url = "https://example.com/image.jpg" # extracted_text = ocr_image_from_url(image_url) image_path = "path/to/your/image.jpg" # Replace with your image path extracted_text = ocr_image_from_file(image_path) # pdf_url = "https://example.com/document.pdf" # extracted_text = ocr_pdf_from_url(pdf_url) # pdf_path = "path/to/your/document.pdf" # Replace with your PDF path # extracted_text = ocr_pdf_from_file(pdf_path) if extracted_text: print("Extracted Text:\n", extracted_text) else: print("OCR failed.") ``` **Important Considerations and Next Steps:** * **Mistral OCR API Documentation:** The most important thing is to **carefully read the Mistral OCR API documentation.** This will tell you: * The exact API endpoint URL. * How to authenticate your requests (the format of the `Authorization` header). * The expected format for sending image/PDF data (e.g., as a file upload, as base64 encoded data, etc.). * The format of the API response (how the OCR'd text is returned). * Any limitations on file size, image formats, or API usage. * **Error Handling:** The example code includes basic error handling, but you should expand this to handle specific API error codes and implement retry logic if necessary. * **File Formats:** Ensure that the image or PDF is in a format supported by the Mistral OCR API. You might need to convert files to a supported format before sending them. * **Rate Limiting:** Be aware of any rate limits imposed by the Mistral OCR API and implement appropriate delays or throttling in your code to avoid exceeding those limits. * **PDF Handling:** For PDFs, you might need to extract individual pages as images if the API doesn't directly support multi-page PDFs. The `PyPDF2` library can help with this. * **Portuguese Language Support:** Check if the Mistral OCR API has specific options or parameters for specifying the language of the text in the image/PDF. This can improve the accuracy of the OCR results. Look for a `language` parameter or similar in the API documentation. **To help me give you more specific advice, please tell me:** * **What programming language are you using?** (If not Python) * **Do you have a specific use case in mind?** (e.g., processing a large batch of documents, real-time OCR, etc.) * **Have you already tried anything?** (If so, what were the results?) * **Can you share a link to the Mistral OCR API documentation?** (This is crucial for accurate code.) Once I have this information, I can provide more tailored code examples and guidance.

Clover MCP (Model Context Protocol) Server

Permite que agentes de IA acessem e interajam com dados de comerciantes, inventário e pedidos do Clover por meio de um servidor MCP autenticado por OAuth seguro.

GraphQL MCP Server

Um servidor TypeScript que fornece à IA Claude acesso contínuo a qualquer API GraphQL através do Protocolo de Contexto de Modelo.

beeper_mcp MCP server

Um servidor MCP simples para criar e gerenciar notas com suporte à funcionalidade de sumarização.

MCP with Gemini Tutorial

Construindo Servidores MCP com Google Gemini

Filesystem MCP Server

Servidor MCP de Sistema de Arquivos Aprimorado