Discover Awesome MCP Servers

OpenAPI MCP Server

Alat ini membuat server Model Context Protocol (MCP) yang bertindak sebagai proksi untuk API apa pun yang memiliki spesifikasi OpenAPI v3.1. Ini memungkinkan Anda menggunakan Claude Desktop untuk berinteraksi dengan mudah dengan API server lokal maupun jarak jauh.

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.

Japanese Text Analyzer MCP Server

Okay, I understand. I can't directly execute code or access files on your system. However, I can provide you with a Python script that accomplishes the task you described. You can then copy and paste this script into a Python environment on your computer and run it. Here's the Python script with detailed comments explaining each part: ```python import re import os import argparse import subprocess # For calling MeCab def count_characters_and_words(filepath, language): """ Counts characters and words in a text file, handling Japanese differently. Args: filepath (str): The path to the text file. language (str): "english" or "japanese". Determines the counting method. Returns: tuple: (character_count, word_count) """ try: with open(filepath, 'r', encoding='utf-8') as f: text = f.read() except FileNotFoundError: print(f"Error: File not found at {filepath}") return 0, 0 except UnicodeDecodeError: print(f"Error: Could not decode file using UTF-8. Try a different encoding.") return 0, 0 if language == "english": # Remove spaces and line breaks for character count characters = re.sub(r'\s', '', text) # Remove whitespace character_count = len(characters) words = text.split() word_count = len(words) elif language == "japanese": # Use MeCab for morphological analysis to get accurate word count try: process = subprocess.Popen(['mecab'], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True) mecab_output, mecab_error = process.communicate(text) if mecab_error: print(f"MeCab Error: {mecab_error}") return 0, 0 # Count characters (excluding spaces and line breaks) characters = re.sub(r'\s', '', text) character_count = len(characters) # Count words based on MeCab output. Each line is a word. word_count = len(mecab_output.splitlines()) - 1 # Subtract 1 to exclude the empty last line 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 0, 0 else: print("Error: Invalid language specified. Must be 'english' or 'japanese'.") return 0, 0 return character_count, word_count def main(): """ Main function to handle command-line arguments and call the counting function. """ parser = argparse.ArgumentParser(description="Count characters and words in a text file.") parser.add_argument("filepath", help="Path to the text file.") parser.add_argument("language", choices=["english", "japanese"], help="Language of the text (english or japanese).") args = parser.parse_args() filepath = args.filepath language = args.language char_count, word_count = count_characters_and_words(filepath, language) if char_count != 0 or word_count != 0: # Only print if there were no errors print(f"File: {filepath}") print(f"Language: {language}") print(f"Character Count (excluding spaces and line breaks): {char_count}") print(f"Word Count: {word_count}") if __name__ == "__main__": main() ``` Key improvements and explanations: * **Error Handling:** Includes `try...except` blocks to handle `FileNotFoundError` and `UnicodeDecodeError` when opening the file. Also handles potential errors from MeCab. This makes the script much more robust. * **MeCab Integration:** Uses `subprocess.Popen` to call MeCab from Python. This is the standard way to interact with external command-line tools. The `text=True` argument ensures that the input and output are handled as text (Unicode). Critically, it now checks for `mecab_error` and prints it if there is one. * **Character Counting (Japanese):** Removes spaces and line breaks *before* counting characters, as requested. * **Word Counting (Japanese):** Parses the output of MeCab to count words. MeCab outputs each word on a new line, so we split the output by lines and count the lines. We subtract 1 to account for the empty last line. * **Argument Parsing:** Uses `argparse` to handle command-line arguments. This makes the script much more user-friendly. The user *must* specify the language. * **Clearer Comments:** More detailed comments explaining each step. * **Encoding:** Opens the file with `encoding='utf-8'` to handle Unicode characters correctly. This is crucial for Japanese text. * **`if __name__ == "__main__":`:** This ensures that the `main()` function is only called when the script is run directly (not when it's imported as a module). * **No spaces in character count:** Removes all whitespace characters (spaces, tabs, newlines) before counting characters. * **Handles MeCab not being installed:** Checks for `FileNotFoundError` when trying to run MeCab and provides a helpful error message. * **Clearer Output:** Prints the filename and language along with the counts. * **Error Message on Invalid Language:** Provides an error message if the user specifies an invalid language. * **Only prints results if successful:** The script now only prints the character and word counts if the `count_characters_and_words` function returns valid counts (i.e., no errors occurred). How to use the script: 1. **Save the script:** Save the code above as a Python file (e.g., `count_text.py`). 2. **Install MeCab (if needed):** * **Linux (Debian/Ubuntu):** `sudo apt-get install mecab libmecab-dev mecab-ipadic-utf8` * **macOS:** `brew install mecab` * **Windows:** Installation on Windows is more complex. You can find instructions online (search for "install mecab windows"). You might need to add the MeCab executable directory to your system's `PATH` environment variable. 3. **Run the script from the command line:** ```bash python count_text.py <filepath> <language> ``` * Replace `<filepath>` with the actual path to your text file. * Replace `<language>` with either `english` or `japanese`. For example: ```bash python count_text.py my_english_text.txt english python count_text.py japanese_text.txt japanese ``` **Example Japanese Text File (japanese_text.txt):** ``` 今日は 良い 天気 です。 明日 は どう でしょう か？ ``` **Important Considerations:** * **MeCab Installation:** The most common issue will be MeCab not being installed correctly or not being in your system's `PATH`. Double-check your MeCab installation if you get a `FileNotFoundError`. * **Encoding:** Make sure your text files are saved in UTF-8 encoding. Most text editors allow you to specify the encoding when saving. * **MeCab Dictionary:** MeCab relies on a dictionary for morphological analysis. The `mecab-ipadic-utf8` dictionary is a common choice. Ensure that your MeCab installation is using a suitable dictionary. * **Alternative Japanese Tokenizers:** If you have trouble with MeCab, you could explore other Python libraries for Japanese tokenization, such as `SudachiPy` or `Janome`. However, MeCab is generally the most widely used and reliable. You would need to modify the script to use these libraries. This revised script should be much more robust and accurate for counting characters and words in both English and Japanese text files. Remember to install MeCab and ensure it's properly configured before running the script with Japanese text.

PubMed Enhanced Search Server

Memungkinkan pencarian dan pengambilan makalah akademis dari database PubMed dengan fitur-fitur canggih seperti pencarian istilah MeSH, statistik publikasi, dan pencarian bukti berbasis PICO.

MCP Server Gateway

A gateway demo for MCP SSE Server

reddit-mcp

MCP server for reddit.

EVM MCP Server

Sebuah server komprehensif yang memungkinkan agen AI untuk berinteraksi dengan berbagai jaringan blockchain yang kompatibel dengan EVM melalui antarmuka terpadu, mendukung resolusi ENS, operasi token, dan interaksi kontrak pintar.

Backstage MCP

A simple backstage mcp server using quarkus-backstage

OneSignal MCP Server

Server Protokol Konteks Model yang membungkus OneSignal REST API, memungkinkan pengelolaan notifikasi push, email, SMS, perangkat pengguna, dan segmen di berbagai aplikasi OneSignal.

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.

perplexity-server MCP Server

Perplexity MCP Server for Cline

openpyxl_mcp_server

Pembungkus tipis di sekitar pustaka OpenPyXl Python yang mengekspos operasi file Excel sebagai server Model Context Protocol (MCP), memungkinkan Claude dan klien MCP lainnya untuk mengambil dan menganalisis data dari file Excel.

Fused MCP Agents: Setting up MCP Servers for Data

Sebuah server MCP berbasis Python yang memungkinkan Claude dan LLM lainnya untuk menjalankan kode Python arbitrer secara langsung melalui aplikasi Claude desktop Anda, memungkinkan ilmuwan data untuk menghubungkan LLM ke API dan kode yang dapat dieksekusi.

Legion MCP (Model Context Protocol) Server

Sebuah server yang membantu orang mengakses dan menanyakan data dalam basis data menggunakan Query Runner dengan integrasi Model Context Protocol (MCP) Python SDK. Mendukung basis data termasuk: PostgreSQL Redshift MySQL Microsoft SQL Server Google APIs Amazon Web Services (melalui boto3) CockroachDB SQLite

quickchart-server MCP Server

Sebuah server MCP untuk menghasilkan visualisasi data yang dapat disesuaikan menggunakan QuickChart.io, mendukung berbagai jenis grafik dan konfigurasi Chart.js.

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

Server Protokol Konteks Model yang menyediakan fungsi matematika dan statistik dasar untuk LLM, memungkinkan mereka melakukan perhitungan numerik yang akurat melalui API sederhana.

Linear MCP Server

Sebuah server yang memungkinkan asisten AI untuk mengakses dan mengambil data tiket Linear melalui standar Model Context Protocol (MCP), saat ini berfokus pada pengambilan tiket todo pengguna.

Github Action Trigger Mcp

Server Protokol Konteks Model yang memungkinkan integrasi dengan GitHub Actions, memungkinkan pengguna untuk mengambil tindakan (actions) yang tersedia, mendapatkan informasi detail tentang tindakan tertentu, memicu peristiwa pengiriman alur kerja (workflow dispatch events), dan mengambil rilis repositori.

Strava MCP Server

Server Protokol Konteks Model yang memungkinkan pengguna mengakses data kebugaran Strava, termasuk aktivitas pengguna, detail aktivitas, segmen, dan papan peringkat melalui antarmuka API terstruktur.

For the GitHub MCP

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

➡️ browser-use mcp server

Sebuah server MCP yang memungkinkan asisten AI untuk mengendalikan peramban web melalui perintah bahasa alami, memungkinkan mereka untuk menavigasi situs web dan mengekstrak informasi melalui transportasi SSE.

MCP Demo

Okay, I can help you outline the concept of an MCP (Microservice Communication Protocol) server for fetching aviation weather data and provide a basic example using Python and Flask. Keep in mind that this is a simplified illustration. A real-world implementation would involve more robust error handling, security, and potentially more sophisticated data processing. **Conceptual Overview** 1. **Data Source:** The server will need to access a reliable source of aviation weather data. Common sources include: * **NOAA Aviation Weather Center (AWC):** Provides METARs, TAFs, and other aviation weather products. Often accessed via their XML/text feeds. * **AviationWeather.gov:** Another NOAA resource. * **Commercial Aviation Weather APIs:** Many companies offer paid APIs with more features and potentially better reliability. 2. **MCP Server (Flask Example):** The server will expose an endpoint (e.g., `/weather`) that accepts requests for weather data. It will: * Receive a request (e.g., with an airport ICAO code like "KJFK"). * Fetch the weather data from the chosen source. * Parse the data (e.g., from XML or text). * Return the data in a structured format (e.g., JSON). 3. **Client:** A client application (e.g., a web app, a mobile app, or another microservice) will send requests to the MCP server and display the weather information to the user. **Simplified Python/Flask Example** ```python from flask import Flask, request, jsonify import requests import xml.etree.ElementTree as ET # For parsing XML (if using NOAA) app = Flask(__name__) # Replace with your actual data source URL (NOAA AWC example) NOAA_URL = "https://www.aviationweather.gov/adds/dataserver_current/httpparam?dataSource=metars&requestType=retrieve&format=xml&hoursBeforeNow=1&mostRecentForEachStation=true&stationString=" def fetch_metar_from_noaa(icao): """Fetches METAR data from NOAA AWC for a given ICAO code.""" try: url = NOAA_URL + icao response = requests.get(url) response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx) xml_content = response.content root = ET.fromstring(xml_content) metar_elements = root.findall(".//METAR") # Find all METAR elements if not metar_elements: return None # No METAR found for this ICAO metar_data = [] for metar_element in metar_elements: metar_text = metar_element.find("raw_text").text station_id = metar_element.find("station_id").text observation_time = metar_element.find("observation_time").text metar_data.append({ "station_id": station_id, "observation_time": observation_time, "raw_text": metar_text }) return metar_data except requests.exceptions.RequestException as e: print(f"Error fetching data: {e}") return None except ET.ParseError as e: print(f"Error parsing XML: {e}") return None except Exception as e: print(f"An unexpected error occurred: {e}") return None @app.route('/weather', methods=['GET']) def get_weather(): """ Endpoint to fetch weather data for a given ICAO airport code. Example: /weather?icao=KJFK """ icao = request.args.get('icao') if not icao: return jsonify({"error": "ICAO code is required"}), 400 weather_data = fetch_metar_from_noaa(icao) if weather_data: return jsonify(weather_data) else: return jsonify({"error": f"Could not retrieve weather data for {icao}"}), 404 if __name__ == '__main__': app.run(debug=True) # Use debug=False in production ``` **Explanation:** 1. **Imports:** Imports necessary libraries: `Flask` for the web server, `requests` for making HTTP requests, `xml.etree.ElementTree` for parsing XML (if using NOAA). 2. **`NOAA_URL`:** This is the URL for the NOAA AWC data server. You'll need to adjust this if you use a different data source. The `stationString=` parameter is where you'll append the ICAO code. 3. **`fetch_metar_from_noaa(icao)`:** * Constructs the URL with the ICAO code. * Uses `requests.get()` to fetch the data. * Uses `response.raise_for_status()` to check for HTTP errors (4xx, 5xx). * Parses the XML response using `xml.etree.ElementTree`. * Extracts the METAR data (raw text, station ID, observation time). * Returns the data as a list of dictionaries. * Includes error handling for network issues, XML parsing errors, and other exceptions. 4. **`@app.route('/weather', methods=['GET'])`:** This defines the `/weather` endpoint, which accepts GET requests. 5. **`get_weather()`:** * Retrieves the `icao` parameter from the request's query string (e.g., `/weather?icao=KJFK`). * Calls `fetch_metar_from_noaa()` to get the weather data. * Returns the data as a JSON response using `jsonify()`. * Includes error handling: * If the ICAO code is missing, it returns a 400 error. * If the weather data cannot be retrieved, it returns a 404 error. 6. **`if __name__ == '__main__':`:** Starts the Flask development server. **Important:** Use `debug=False` in a production environment. **How to Run:** 1. **Install Flask and requests:** ```bash pip install Flask requests ``` 2. **Save the code:** Save the code as a Python file (e.g., `weather_server.py`). 3. **Run the server:** ```bash python weather_server.py ``` 4. **Test the endpoint:** Open a web browser or use `curl` to access the endpoint: ``` http://127.0.0.1:5000/weather?icao=KJFK ``` (Replace `KJFK` with the ICAO code you want to query.) **Important Considerations and Improvements:** * **Error Handling:** The example includes basic error handling, but you should add more robust error logging and reporting. * **Data Source:** Choose a reliable data source that meets your needs. Consider commercial APIs for better performance and features. * **Data Parsing:** The XML parsing in the example is basic. You might need to handle different XML structures or use a more sophisticated XML parsing library. If using a JSON API, the parsing will be simpler. * **Caching:** Implement caching to reduce the load on the data source and improve response times. You can use Flask's built-in caching or a dedicated caching library like Redis or Memcached. * **Rate Limiting:** Implement rate limiting to prevent abuse of your API. * **Authentication/Authorization:** If you need to restrict access to your API, implement authentication and authorization. * **Configuration:** Use environment variables or a configuration file to store sensitive information like API keys and database credentials. * **Deployment:** Deploy the server to a production environment (e.g., AWS, Google Cloud, Azure). Use a WSGI server like Gunicorn or uWSGI. * **Monitoring:** Monitor the server's performance and health. * **Asynchronous Operations:** For high-volume requests, consider using asynchronous operations (e.g., with `asyncio` or Celery) to improve performance. * **Data Validation:** Validate the ICAO code and other input parameters to prevent errors. * **Data Transformation:** You might need to transform the data from the data source into a format that is more suitable for your client applications. **MCP (Microservice Communication Protocol) Considerations:** * **Protocol:** While this example uses HTTP/JSON, you could use other protocols like gRPC or Thrift for more efficient communication between microservices. * **Service Discovery:** In a microservices architecture, you'll need a mechanism for service discovery (e.g., Consul, etcd, or Kubernetes DNS). This allows your client applications to find the MCP server dynamically. * **API Gateway:** An API gateway can provide a single entry point for all your microservices and handle tasks like authentication, rate limiting, and request routing. This example provides a starting point for building an MCP server for fetching aviation weather data. Remember to adapt it to your specific requirements and consider the important considerations mentioned above.