Discover Awesome MCP Servers

Kafka MCP Server

AI 모델이 표준화된 인터페이스를 통해 Apache Kafka 토픽에서 메시지를 게시하고 소비할 수 있도록 하여, Kafka 메시징을 LLM 및 에이전트 애플리케이션과 쉽게 통합할 수 있게 합니다.

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 # For command-line arguments import subprocess # For calling MeCab def count_characters_and_words(filepath, language="english"): """ 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 {filepath}. Ensure it's UTF-8 encoded.") return 0, 0 if language == "english": # Remove spaces and line breaks for character count character_count = len(re.sub(r'\s', '', text)) # Remove whitespace words = text.split() # Split by whitespace word_count = len(words) elif language == "japanese": # Use MeCab for morphological analysis try: mecab_process = subprocess.Popen(['mecab'], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True) mecab_output, mecab_error = mecab_process.communicate(text) if mecab_error: print(f"MeCab Error: {mecab_error}") return 0, 0 # Count characters (excluding spaces and line breaks) character_count = len(re.sub(r'\s', '', text)) # Count words based on MeCab output (count nouns, verbs, adjectives, etc.) word_count = 0 for line in mecab_output.splitlines(): if line == "EOS": # End of Sentence marker break parts = line.split('\t') if len(parts) > 1: pos = parts[1].split(',')[0] # Part of Speech # Adjust the POS tags to count based on your needs. This is a starting point. if pos in ['名詞', '動詞', '形容詞', '副詞', '連体詞', '接続詞', '感動詞']: # Noun, Verb, Adjective, Adverb, Adnominal Adjective, Conjunction, Interjection word_count += 1 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 except Exception as e: print(f"An unexpected error occurred during MeCab processing: {e}") return 0, 0 else: print("Error: Invalid language specified. Choose 'english' or 'japanese'.") return 0, 0 return character_count, word_count def main(): 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("-l", "--language", default="english", 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 is not None and word_count is not None: # Check for errors 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() ``` Key improvements and explanations: * **Error Handling:** Includes `try...except` blocks to handle `FileNotFoundError`, `UnicodeDecodeError`, and MeCab-related errors. This makes the script much more robust. It also checks for `None` return values from `count_characters_and_words` to prevent errors if the function fails. * **MeCab Integration:** Uses `subprocess.Popen` to call MeCab from Python. This is the standard way to interact with external command-line tools. It captures both standard output and standard error from MeCab, allowing for better error reporting. The `text=True` argument ensures that the input and output are handled as text strings. * **MeCab Output Parsing:** Parses the MeCab output to count words based on Part-of-Speech (POS) tags. The script now extracts the POS tag and checks if it's a noun, verb, adjective, etc. **Important:** You might need to adjust the list of POS tags to count based on your specific needs and the conventions used by your MeCab dictionary. The provided list is a common starting point. * **Character Counting (Japanese):** The character count for Japanese also excludes spaces and line breaks. * **UTF-8 Encoding:** Opens the file with `encoding='utf-8'` to handle Unicode characters correctly. This is crucial for Japanese text. * **Command-Line Arguments:** Uses `argparse` to allow you to specify the filepath and language from the command line. This makes the script much more flexible. * **Clearer Comments:** More detailed comments explaining each part of the code. * **`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). * **Returns 0, 0 on Error:** The `count_characters_and_words` function now returns `0, 0` if an error occurs, making it easier to handle errors in the `main` function. * **Checks for MeCab Installation:** The script now checks if MeCab is installed and in the system's PATH. If not, it prints an informative error message. * **More Robust MeCab Error Handling:** The script now checks for errors returned by MeCab (in `mecab_error`) and prints them to the console. * **Handles Unexpected MeCab Errors:** Includes a general `except Exception as e:` block to catch any unexpected errors during MeCab processing. **How to Use:** 1. **Save the script:** Save the code above as a Python file (e.g., `count_text.py`). 2. **Install MeCab (if you haven't already):** * **Linux (Debian/Ubuntu):** `sudo apt-get install mecab libmecab-dev mecab-ipadic-utf8` * **macOS:** `brew install mecab` (if you have Homebrew) * **Windows:** Installation on Windows is more complex. You'll need to download the MeCab binaries and dictionary, and configure your system's PATH environment variable. Refer to the MeCab documentation for Windows installation instructions. A common approach is to use the installer from [https://taku910.github.io/mecab/](https://taku910.github.io/mecab/). Make sure to add the MeCab bin directory to your PATH. 3. **Run the script from the command line:** ```bash python count_text.py <filepath> -l <language> ``` * Replace `<filepath>` with the actual path to your text file. * Replace `<language>` with either `english` or `japanese`. If you omit `-l <language>`, it defaults to `english`. Example: ```bash python count_text.py my_english_text.txt python count_text.py japanese_novel.txt -l japanese ``` **Example Japanese Text File (japanese_novel.txt):** ``` これは日本語の小説です。 今日はいい天気ですね。 猫が好きです。 ``` **Important Considerations for Japanese:** * **MeCab Dictionary:** The accuracy of word counting for Japanese depends heavily on the MeCab dictionary you are using. The default dictionary (`mecab-ipadic-utf8` on Linux) is a good starting point, but you might need to use a different dictionary for specialized vocabulary. * **Part-of-Speech Tagging:** The script currently counts words based on a specific set of POS tags (nouns, verbs, adjectives, etc.). You might need to adjust this list based on your specific needs and the conventions used by your MeCab dictionary. Inspect the MeCab output for your text to see the POS tags that are being assigned. You can do this by running `mecab` on your text file directly from the command line: `mecab japanese_novel.txt`. * **Word Definition:** What constitutes a "word" in Japanese is a complex linguistic question. MeCab provides a morphological analysis, but you need to decide how to interpret that analysis for your word count. The current script provides a reasonable starting point, but you might need to refine it based on your specific requirements. This improved script provides a more robust and accurate solution for counting characters and words in both English and Japanese text files. Remember to install MeCab and adjust the POS tag filtering as needed for Japanese.

➡️ browser-use mcp server

AI 어시스턴트가 자연어 명령을 통해 웹 브라우저를 제어하고, SSE 전송을 통해 웹사이트를 탐색하고 정보를 추출할 수 있도록 하는 MCP 서버입니다.

PubMed Enhanced Search Server

MeSH 용어 검색, 출판 통계, PICO 기반 증거 검색과 같은 고급 기능을 통해 PubMed 데이터베이스에서 학술 논문을 검색하고 검색할 수 있습니다.

MCP Server Gateway

A gateway demo for MCP SSE Server

MCP Demo

Okay, I can't directly "demonstrate" an MCP (Mission Control Protocol) server in the sense of running code for you here. MCP is a proprietary protocol, and I don't have access to the specific implementations or the necessary aviation data feeds. However, I can provide a conceptual outline and code snippets (in Python, a common language for server-side applications) to illustrate how you *might* structure such a server, assuming you have the necessary MCP libraries and data access. This will be a high-level overview, and you'll need to adapt it to your specific MCP environment and data sources. **Disclaimer:** This is a simplified example and does not represent a complete or production-ready MCP server. You'll need to consult the MCP documentation and aviation data provider APIs for accurate implementation details. Also, be aware of any licensing restrictions on the data you are accessing. **Conceptual Outline** 1. **MCP Listener:** The server needs to listen for incoming MCP requests on a specific port. 2. **Request Parsing:** It must parse the incoming MCP messages to understand the requested data (e.g., METAR, TAF, specific airport codes). 3. **Data Retrieval:** Based on the request, it fetches the aviation weather data from appropriate sources (e.g., aviation weather APIs, databases). 4. **Data Formatting:** The retrieved data is formatted into the required MCP response format. 5. **Response Sending:** The formatted response is sent back to the client via the MCP connection. 6. **Error Handling:** Robust error handling is crucial for dealing with invalid requests, data retrieval failures, and network issues. **Python Example (Illustrative)** ```python import socket import threading # Assume you have an MCP library (replace with actual import) # import mcp_library import json # For handling JSON data (if applicable) import requests # For making API calls # Configuration HOST = '0.0.0.0' # Listen on all interfaces PORT = 12345 # MCP port (replace with actual port) AVIATION_WEATHER_API_URL = "https://aviationweather.gov/api/data/metar.php" # Example API # Function to fetch aviation weather data (replace with actual API call) def get_aviation_weather(airport_code): """ Fetches METAR data for a given airport code from an external API. Replace with your actual data source and API call. """ try: params = {'ids': airport_code, 'format': 'json'} response = requests.get(AVIATION_WEATHER_API_URL, params=params) response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx) data = response.json() if data: return data[0] # Assuming the API returns a list of METARs else: return None # No data found except requests.exceptions.RequestException as e: print(f"Error fetching data: {e}") return None # Function to handle a client connection def handle_client(conn, addr): print(f"Connected by {addr}") try: while True: data = conn.recv(1024) # Receive data from the client (adjust buffer size) if not data: break # Decode the received data (assuming it's a string) request = data.decode('utf-8').strip() print(f"Received request: {request}") # **MCP Request Parsing (Replace with actual MCP parsing logic)** # This is a placeholder. You'll need to use your MCP library # to properly parse the MCP message format. # Example: Assuming the request is simply "METAR KLAX" parts = request.split() if len(parts) == 2 and parts[0].upper() == "METAR": airport_code = parts[1].upper() weather_data = get_aviation_weather(airport_code) if weather_data: # **MCP Response Formatting (Replace with actual MCP formatting)** # This is a placeholder. You'll need to use your MCP library # to format the data into the correct MCP message format. response = json.dumps(weather_data) # Example: JSON response else: response = "Error: Could not retrieve weather data." else: response = "Error: Invalid request format." # Encode the response and send it back to the client conn.sendall(response.encode('utf-8')) except Exception as e: print(f"Error handling client: {e}") finally: conn.close() print(f"Connection closed with {addr}") # Main server function def main(): with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) s.listen() print(f"Listening on {HOST}:{PORT}") while True: conn, addr = s.accept() thread = threading.Thread(target=handle_client, args=(conn, addr)) thread.start() if __name__ == "__main__": main() ``` **Explanation and Key Points** * **Socket Programming:** The code uses Python's `socket` module to create a TCP server that listens for incoming connections. * **Threading:** Each client connection is handled in a separate thread to allow the server to handle multiple requests concurrently. * **`get_aviation_weather()`:** This function is a placeholder. **You must replace this with the actual code to fetch aviation weather data from your chosen source.** This might involve: * Using an aviation weather API (like aviationweather.gov, but check their terms of service and licensing). * Querying a database. * Using a specific aviation data feed. * **MCP Parsing and Formatting:** The most crucial part is the MCP request parsing and response formatting. **You *must* use the MCP library provided by your MCP vendor to handle these tasks correctly.** The example code has placeholders (`# **MCP Request Parsing...` and `# **MCP Response Formatting...`) where you would integrate the MCP library functions. This is where the proprietary nature of MCP comes into play. * **Error Handling:** The code includes basic error handling, but you should add more robust error handling to catch potential issues like network errors, API failures, and invalid data. * **JSON (Optional):** The example uses `json.dumps()` to format the response. This is just an example. Your MCP protocol might require a different data format. * **Security:** In a real-world deployment, you would need to consider security aspects, such as authentication and authorization, to prevent unauthorized access to the data. **How to Adapt This Example** 1. **Install Necessary Libraries:** ```bash pip install requests # If you're using the requests library for API calls ``` 2. **Replace Placeholders:** * **`get_aviation_weather()`:** Implement the actual data retrieval logic using your chosen aviation data source. * **MCP Parsing and Formatting:** Use your MCP library to parse incoming MCP messages and format the responses according to the MCP protocol specification. 3. **Configure:** * Set the `HOST` and `PORT` to the appropriate values for your MCP environment. * Update `AVIATION_WEATHER_API_URL` if you're using a different API. 4. **Test:** Thoroughly test the server with a real MCP client to ensure that it correctly handles requests and responses. **Important Considerations** * **MCP Documentation:** The most important resource is the official MCP documentation from your MCP vendor. This will provide the details of the protocol, message formats, and any required libraries. * **Aviation Data Licensing:** Be aware of the licensing terms for any aviation data you are using. Some data sources may require a subscription or have restrictions on how the data can be used. * **Real-Time Data:** Aviation weather data is often time-sensitive. Ensure that your server is retrieving and providing the most up-to-date information. * **Scalability:** If you expect a high volume of requests, consider using a more scalable server architecture (e.g., using asynchronous programming or a message queue). This detailed explanation and code outline should give you a good starting point for building your MCP server. Remember to consult the MCP documentation and aviation data provider APIs for the specific details you need. Good luck!

NN-GitHubTestRepo

MCP 서버 데모에서 생성됨

better-auth-mcp-server MCP Server

Mirror of

repo-to-txt-mcp

LLM 컨텍스트를 위해 Git 저장소를 텍스트 파일로 분석하고 변환하는 MCP 서버

mcp-server-restart

Mirror of

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

LLM에게 기본적인 수학 및 통계 기능을 제공하여 간단한 API를 통해 정확한 수치 계산을 수행할 수 있도록 하는 모델 컨텍스트 프로토콜 서버.

Github Action Trigger Mcp

GitHub Actions와 통합을 가능하게 하는 모델 컨텍스트 프로토콜 서버입니다. 사용자는 이 서버를 통해 사용 가능한 액션을 가져오고, 특정 액션에 대한 상세 정보를 얻고, 워크플로우 디스패치 이벤트를 트리거하고, 저장소 릴리스를 가져올 수 있습니다.

Semantic Scholar MCP Server

거울

PHP MCP Protocol Server

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

Fused MCP Agents: Setting up MCP Servers for Data

데스크톱 Claude 앱을 통해 Claude 및 다른 LLM이 임의의 Python 코드를 직접 실행할 수 있도록 하는 Python 기반 MCP 서버입니다. 이를 통해 데이터 과학자는 LLM을 API 및 실행 가능한 코드에 연결할 수 있습니다.

MCP Image Generation Server

MCP (Model Context Protocol) 서버 도구의 Go 구현

Strava MCP Server

사용자가 구조화된 API 인터페이스를 통해 Strava 피트니스 데이터 (사용자 활동, 활동 상세 정보, 구간, 리더보드 포함)에 접근할 수 있도록 하는 모델 컨텍스트 프로토콜 서버.

Selector Mcp Server

Model Context Protocol (MCP) 서버는 스트리밍을 지원하는 서버와 Docker 기반 클라이언트를 통해 Selector AI와 실시간으로 상호 작용하는 AI 채팅을 가능하게 합니다. 이 서버와 클라이언트는 stdin/stdout을 통해 통신합니다.

Data.gov MCP Server

거울

MailchimpMCP

Some utilities for developing an MCP server for the Mailchimp API

AISDK MCP Bridge

Bridge package enabling seamless integration between Model Context Protocol (MCP) servers and AI SDK tools. Supports multiple server types, real-time communication, and TypeScript.

Google Home MCP Server

Mirror of