Discover Awesome MCP Servers

G-Search MCP

Um servidor MCP poderoso que permite a pesquisa paralela no Google com múltiplas palavras-chave simultaneamente, fornecendo resultados estruturados enquanto lida com CAPTCHAs e simula padrões de navegação do usuário.

ThemeParks.wiki API MCP Server

Servidor MCP da API ThemeParks.wiki

reddit-mcp

MCP server for reddit.

Japanese Text Analyzer MCP Server

Okay, I understand. I can't directly *execute* code or interact with files on your system. However, I can provide you with a Python script that accomplishes this task. I'll explain the code thoroughly so you can understand how it works and adapt it if needed. Here's the Python script: ```python import os import re import argparse import mojimoji # For normalizing Japanese text import subprocess # For calling MeCab def count_characters_and_words(filepath, language): """ Counts characters (excluding spaces and line breaks) and words in a text file. Args: filepath (str): The path to the text file. language (str): The language of the text file ('en' for English, 'ja' for Japanese). Returns: tuple: A tuple containing (character_count, word_count). Returns (None, None) on error. """ try: with open(filepath, 'r', encoding='utf-8') as f: text = f.read() except FileNotFoundError: print(f"Error: File not found: {filepath}") return None, None except UnicodeDecodeError: print(f"Error: Could not decode file {filepath} with UTF-8. Try a different encoding.") return None, None if language == 'en': # English: Simple word splitting and character counting text = text.strip() # Remove leading/trailing whitespace character_count = len(re.sub(r'\s', '', text)) # Remove all whitespace characters words = text.split() word_count = len(words) elif language == 'ja': # Japanese: Use MeCab for morphological analysis try: # Normalize text to full-width katakana for better MeCab performance normalized_text = mojimoji.zen_to_han(text, kana=False, ascii=False) normalized_text = mojimoji.han_to_zen(normalized_text, kana=True, ascii=False) # Call MeCab mecab_process = subprocess.Popen(['mecab'], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True) mecab_output, mecab_error = mecab_process.communicate(normalized_text) if mecab_error: print(f"MeCab Error: {mecab_error}") return None, None # Count words based on MeCab output (first column of each line before the comma) words = [line.split(',')[0].split('\t')[0] for line in mecab_output.splitlines() if line.strip() != 'EOS'] word_count = len(words) # Count characters (excluding spaces and line breaks) character_count = len(re.sub(r'\s', '', text)) except FileNotFoundError: print("Error: MeCab is not installed or not in your PATH.") print("Please install MeCab and ensure it's accessible from the command line.") return None, None except Exception as e: print(f"An error occurred during Japanese processing: {e}") return None, None else: print("Error: Invalid language specified. Use 'en' or 'ja'.") return None, None return character_count, word_count def main(): parser = argparse.ArgumentParser(description="Counts characters and words in text files.") parser.add_argument("filepath", help="The path to the text file.") parser.add_argument("language", help="The language of the text file ('en' for English, 'ja' for Japanese).") args = parser.parse_args() filepath = args.filepath language = args.language char_count, word_count = count_characters_and_words(filepath, language) if char_count is not None and word_count is not None: print(f"File: {filepath}") print(f"Language: {language}") print(f"Character Count (excluding spaces): {char_count}") print(f"Word Count: {word_count}") if __name__ == "__main__": main() ``` **How to Use the Script:** 1. **Save the Code:** Save the code above as a Python file (e.g., `count_text.py`). 2. **Install Dependencies:** You'll need to install the `mojimoji` library and MeCab. Open your terminal or command prompt and run: ```bash pip install mojimoji ``` * **MeCab Installation:** MeCab is a morphological analyzer for Japanese. The installation process varies depending on your operating system: * **Linux (Debian/Ubuntu):** ```bash sudo apt-get update sudo apt-get install mecab libmecab-dev mecab-ipadic-utf8 ``` * **macOS (using Homebrew):** ```bash brew install mecab brew install mecab-ipadic ``` * **Windows:** The installation on Windows is more involved. I recommend following a tutorial like this one: [https://medium.com/@denis.akhapkin/installing-mecab-on-windows-10-8e318304985](https://medium.com/@denis.akhapkin/installing-mecab-on-windows-10-8e318304985). Make sure MeCab is added to your system's PATH environment variable. 3. **Run the Script:** Open your terminal or command prompt, navigate to the directory where you saved `count_text.py`, and run the script with the following command: ```bash python count_text.py <filepath> <language> ``` * Replace `<filepath>` with the actual path to your text file (e.g., `my_english_text.txt` or `my_japanese_text.txt`). * Replace `<language>` with either `en` for English or `ja` for Japanese. **Example:** ```bash python count_text.py my_english_text.txt en python count_text.py my_japanese_text.txt ja ``` **Explanation of the Code:** * **`import` Statements:** * `os`: (Not directly used in the current version, but good practice to include for potential file system operations). * `re`: For regular expressions (used to remove spaces). * `argparse`: For parsing command-line arguments (filepath and language). * `mojimoji`: For normalizing Japanese text (converting between full-width and half-width characters). This is important for MeCab's accuracy. * `subprocess`: For running the MeCab command-line tool. * **`count_characters_and_words(filepath, language)` Function:** * Takes the file path and language as input. * **File Handling:** Opens the file in UTF-8 encoding (important for handling Japanese characters). Includes error handling for `FileNotFoundError` and `UnicodeDecodeError`. * **English Processing (`language == 'en'`):** * Removes leading/trailing whitespace using `text.strip()`. * Counts characters by removing all whitespace characters (using `re.sub(r'\s', '', text)`) and then getting the length of the resulting string. * Splits the text into words using `text.split()`. * Counts the number of words. * **Japanese Processing (`language == 'ja'`):** * **Normalization:** Uses `mojimoji` to normalize the text. It converts half-width characters to full-width katakana and full-width characters to half-width ascii. This improves MeCab's performance. * **MeCab Integration:** * Uses `subprocess.Popen` to run the `mecab` command. * Passes the text to MeCab via standard input (`stdin`). * Captures MeCab's output from standard output (`stdout`). * Captures any errors from standard error (`stderr`). * **Error Handling:** Checks for MeCab errors and prints them if any occur. Also includes a `FileNotFoundError` check to see if MeCab is installed. * **Word Counting:** Parses the MeCab output. MeCab outputs each word on a separate line, with the word itself in the first column (before the first tab character). The code extracts these words and counts them. It skips the "EOS" (End of Sentence) marker. * **Character Counting:** Counts characters in the original text (excluding spaces and line breaks) using `len(re.sub(r'\s', '', text))`. * **Error Handling:** Handles invalid language input. * **Returns:** Returns the character count and word count as a tuple. * **`main()` Function:** * Uses `argparse` to handle command-line arguments. * Calls `count_characters_and_words()` to do the actual counting. * Prints the results. * **`if __name__ == "__main__":` Block:** * Ensures that the `main()` function is only called when the script is run directly (not when it's imported as a module). **Key Improvements and Considerations:** * **Japanese Morphological Analysis (MeCab):** The script now uses MeCab for Japanese word counting. This is *essential* for accurate word counts in Japanese because Japanese doesn't use spaces to separate words. * **Character Counting (Excluding Spaces):** The script correctly counts characters by removing spaces and line breaks using regular expressions. * **UTF-8 Encoding:** The script opens the files with UTF-8 encoding to handle Japanese characters correctly. * **Error Handling:** The script includes error handling for file not found, Unicode decoding errors, and MeCab errors. * **Command-Line Arguments:** The script uses `argparse` to make it easy to specify the file path and language from the command line. * **MeCab Installation:** The script provides instructions for installing MeCab on different operating systems. This is a crucial step. * **Normalization:** The script normalizes the Japanese text before passing it to MeCab. This can improve MeCab's accuracy. * **MeCab PATH:** Make sure MeCab is in your system's PATH environment variable so the script can find it. * **Alternative Japanese Tokenizers:** While MeCab is a good choice, other Japanese tokenizers exist (e.g., SudachiPy, Juman++). You could adapt the script to use a different tokenizer if you prefer. * **Large Files:** For very large files, you might want to consider reading the file in chunks to avoid loading the entire file into memory at once. **Example Usage (with sample files):** 1. **Create `my_english_text.txt`:** ``` This is a sample English text file. It has multiple lines. ``` 2. **Create `my_japanese_text.txt`:** ``` これは日本語のサンプルテキストファイルです。 複数の行があります。 ``` 3. **Run the script:** ```bash python count_text.py my_english_text.txt en python count_text.py my_japanese_text.txt ja ``` The script will print the character and word counts for each file. Remember to install MeCab *before* running the script with a Japanese file.

➡️ 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.

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.

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.

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.

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.

Mcp Server Chatsum

Please provide me with the WeChat messages you want me to summarize. I need the text of the messages to be able to summarize them for you.

PubMed Enhanced Search Server

Permite a busca e recuperação de artigos acadêmicos do banco de dados PubMed com recursos avançados como pesquisa de termos MeSH, estatísticas de publicação e busca de evidências baseada em PICO.

MCP Server Gateway

A gateway demo for MCP SSE Server

Notion MCP Server

Um servidor de Protocolo de Contexto de Modelo que fornece uma interface padronizada para modelos de IA acessarem, consultarem e modificarem conteúdo em espaços de trabalho do Notion.

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.

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.

Backstage MCP

A simple backstage mcp server using quarkus-backstage

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.

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.

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.

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.

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

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

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!