发现优秀的 MCP 服务器

EspoCRM-MCP

Open source MCP server for EspoCRM

Serveur MCP pour n8n

镜子 (jìng zi)

Claude Telemetry MCP

Provides comprehensive telemetry and usage analytics for Claude Code sessions, including token usage tracking, cost monitoring, and tool usage patterns. Enables users to monitor their Claude usage with detailed metrics, warnings, and trend analysis.

e-rechnung-mcp

MCP server for German e-invoicing with tools to generate and validate XRechnung CII XML locally, supporting German VAT rates and § 19 UStG.

discord-ops

A Discord MCP server with multi-guild project routing, enabling messaging, moderation, and notification management across multiple Discord servers via natural language.

urlscan-mcp

MCP server that exposes urlscan.io as tools for security investigations, with compact results optimized for context windows. Enables pivoting on indicators, searching scans, retrieving screenshots, DOM, and scan results, and submitting URLs.

structured-address-fix-mcp

An MCP server that exposes ISO 20022 postal-address classification, assessment, and remediation tools for AI agents, enabling them to prepare debtor/creditor addresses for the November 2026 structured-address cutover.

Shortcut MCP Server

一个模型上下文协议服务器，可以与 Shortcut (前身为 Clubhouse) 项目管理工具进行交互，允许用户查看和搜索项目、故事、史诗和目标，以及通过自然语言创建新项目。

Japanese Text Analyzer

Okay, I understand. I can't directly *execute* code or access files on your system. However, I can provide you with Python code that accomplishes this task. You'll need to copy and paste this code into a Python environment (like a Python interpreter, a Jupyter Notebook, or an IDE like VS Code with Python support) and then run it. Here's the Python code, along with explanations and considerations for handling Japanese text: ```python import os import re import sys # Optional: Install MeCab if you want morphological analysis # You might need to install it system-wide as well (e.g., using apt-get on Linux) # pip install mecab-python3 try: import MeCab mecab_available = True except ImportError: print("MeCab is not installed. Morphological analysis will be skipped.") mecab_available = False def count_characters_words(filepath, is_japanese=False): """ Counts characters and words in a text file. Args: filepath (str): The path to the text file. is_japanese (bool): Whether the file contains Japanese text. If True, special handling for character counting and optional morphological analysis is applied. Returns: tuple: A tuple containing (character_count, word_count) """ try: with open(filepath, 'r', encoding='utf-8') as f: # Important: Use UTF-8 encoding 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 at {filepath}. Ensure it's UTF-8 encoded.") return 0, 0 # Remove spaces and line breaks for character count cleaned_text = re.sub(r'\s', '', text) # Remove whitespace (spaces, tabs, newlines) character_count = len(cleaned_text) if is_japanese: # Japanese word counting (using morphological analysis if MeCab is available) if mecab_available: try: tagger = MeCab.Tagger() # Initialize MeCab tagger node = tagger.parseToNode(text) word_count = 0 while node: if node.feature.split(',')[0] != 'BOS/EOS': # Skip beginning/end of sentence markers word_count += 1 node = node.next except Exception as e: print(f"MeCab error: {e}. Falling back to simple space-based splitting.") words = text.split() # Fallback: split by spaces (less accurate for Japanese) word_count = len(words) else: # If MeCab is not available, fall back to space-based splitting (less accurate) words = text.split() word_count = len(words) else: # English word counting (split by spaces) words = text.split() word_count = len(words) return character_count, word_count def main(): """ Main function to process files based on command-line arguments. """ if len(sys.argv) < 2: print("Usage: python your_script_name.py <filepath1> [filepath2 ...] [-j <filepath3> ...]") print(" -j: Indicates that the following file(s) are Japanese text.") return filepaths = [] japanese_filepaths = [] i = 1 while i < len(sys.argv): if sys.argv[i] == '-j': i += 1 while i < len(sys.argv) and sys.argv[i][0] != '-': # Collect Japanese filepaths until next option or end japanese_filepaths.append(sys.argv[i]) i += 1 else: filepaths.append(sys.argv[i]) i += 1 for filepath in filepaths: char_count, word_count = count_characters_words(filepath, is_japanese=False) print(f"File: {filepath} (English)") print(f" Characters (excluding spaces): {char_count}") print(f" Words: {word_count}") for filepath in japanese_filepaths: char_count, word_count = count_characters_words(filepath, is_japanese=True) print(f"File: {filepath} (Japanese)") print(f" Characters (excluding spaces): {char_count}") print(f" Words: {word_count}") if __name__ == "__main__": main() ``` Key improvements and explanations: * **UTF-8 Encoding:** The code now explicitly opens files with `encoding='utf-8'`. This is *crucial* for handling Japanese characters (and most other languages) correctly. If your files are in a different encoding, you'll need to change this. * **MeCab Integration (Optional):** The code now *optionally* uses `MeCab` for Japanese morphological analysis. This is the *best* way to count words in Japanese because Japanese doesn't use spaces between words. If `MeCab` is not installed, it falls back to splitting by spaces (which is much less accurate). The code includes instructions on how to install `MeCab`. It also handles potential `MeCab` errors gracefully. * **Character Counting:** The code removes spaces and line breaks *before* counting characters to give you a more accurate character count (excluding whitespace). * **Error Handling:** Includes `try...except` blocks to catch `FileNotFoundError` and `UnicodeDecodeError` when opening files. This makes the script more robust. Also includes error handling for MeCab. * **Command-Line Arguments:** The `main()` function now uses `sys.argv` to accept filepaths as command-line arguments. This makes the script much more flexible. It also includes a `-j` flag to indicate that a file is Japanese. * **Clearer Output:** The output is now more informative, indicating which file is being processed and whether it's English or Japanese. * **Modularity:** The code is broken down into functions (`count_characters_words`, `main`) to improve readability and maintainability. * **Comments:** The code is well-commented to explain what each part does. * **`re.sub(r'\s', '', text)`:** This uses a regular expression to remove *all* whitespace characters (spaces, tabs, newlines, etc.) from the text before counting characters. This is more robust than just removing spaces. * **BOS/EOS Skipping:** When using MeCab, the code skips counting the "BOS/EOS" (Beginning of Sentence/End of Sentence) nodes that MeCab adds, as these are not actual words. * **Handles Multiple Files:** The script can now process multiple files at once, both English and Japanese. * **Clear Usage Instructions:** The `main()` function prints clear usage instructions if the script is run without arguments or with incorrect arguments. **How to Use:** 1. **Save the Code:** Save the code above as a Python file (e.g., `count_words.py`). 2. **Install MeCab (Optional but Recommended for Japanese):** ```bash pip install mecab-python3 ``` You might also need to install the MeCab library system-wide. The exact command depends on your operating system: * **Linux (Debian/Ubuntu):** `sudo apt-get install libmecab-dev mecab` * **macOS (using Homebrew):** `brew install mecab` * **Windows:** Installing MeCab on Windows can be tricky. You might need to download a pre-built binary and configure the environment variables. Search online for "install mecab windows" for detailed instructions. 3. **Run from the Command Line:** ```bash python count_words.py file1.txt file2.txt -j japanese_file1.txt japanese_file2.txt ``` * Replace `file1.txt`, `file2.txt`, `japanese_file1.txt`, and `japanese_file2.txt` with the actual paths to your files. * Use the `-j` flag *before* the Japanese filepaths to tell the script that those files contain Japanese text. **Example:** Let's say you have these files: * `english.txt`: ``` This is a test. It has some words. ``` * `japanese.txt`: ``` 今日は 良い 天気 です。 これはテストです。 ``` You would run: ```bash python count_words.py english.txt -j japanese.txt ``` The output would be similar to: ``` File: english.txt (English) Characters (excluding spaces): 30 Words: 10 File: japanese.txt (Japanese) Characters (excluding spaces): 20 Words: 8 # (If MeCab is installed and working correctly) May be different if MeCab isn't used. ``` **Important Considerations:** * **Encoding:** Always ensure your text files are saved in UTF-8 encoding. This is the most common and widely compatible encoding. * **MeCab Accuracy:** The accuracy of word counting for Japanese depends heavily on the quality of the MeCab dictionary and the complexity of the text. * **Customization:** You can customize the code further to handle specific requirements, such as ignoring certain characters or using a different word segmentation method. * **Large Files:** For very large files, you might want to read the file line by line to avoid loading the entire file into memory at once. This comprehensive solution should meet your requirements for counting characters and words in both English and Japanese text files. Remember to install MeCab for the best results with Japanese. Let me know if you have any other questions.

MCP GameBoy Server

A Model Context Protocol server that enables LLMs to interact with a GameBoy emulator, providing tools for controlling the GameBoy, loading ROMs, and retrieving screen frames.

ANTT: Produtos Perigosos

Read-only MCP server for querying official Brazilian ANTT data on dangerous goods, with pay-per-use hosted access.

opengrok-mcp

Enables LLMs to query OpenGrok for source code searches, including definitions, symbols, and project listings, returning clickable URLs.

semamerge

MCP server that detects semantic (non-textual) merge conflicts between Git branches using AST-level analysis. Catches incompatible changes that Git merges cleanly — signature changes, removed exports, parameter changes, interface breaks, and cross-file dependency conflicts.

Open Ephemeris

Open Ephemeris is a high-precision astrology API with an MCP server exposing 116+ endpoints across natal charts, transits, synastry, Human Design, BaZi, solar returns, and much more.

uefn-verse-mcp

A two-process MCP bridge that lets Claude Code, Cursor, and other MCP clients safely drive a live Unreal Editor for Fortnite (UEFN) through an external FastMCP server and an in-editor HTTP listener.

tbro-mcp

An MCP server that provides web_search and web_fetch tools returning plain text via the tbro terminal browser to reduce token usage, with the trade-off of no JavaScript support.

Calendly MCP Server

Exposes personal Calendly account as MCP tools, allowing users to manage events, view availability, and handle bookings through natural language.

Shopify MCP Server

Enables interaction with Shopify store data via the GraphQL Admin API for managing products, customers, and orders. It allows users to search, retrieve, create, and update store records through natural language commands.

MCP OpenMetadata

提供 OpenMetadata API 的 MCP 服务器

Kerneldev MCP

An MCP server for intelligent Linux kernel configuration management and building. Enables AI assistants to generate, manage, and optimize kernel configurations and build kernels with comprehensive error detection.

Backstage MCP

一个使用 quarkus-backstage 的简单后台 MCP 服务器。

mcp-captcha-solver

Provides browser automation and reCAPTCHA v2 solving tools for AI agents, integrating Selenium and 2Captcha.

claude-code-relay

Relay messages between Claude Code sessions over MCP without stealing window focus, enabling background communication between parallel sessions.

obsidian-vault-mcp

An MCP server that enables Claude Desktop to read and write an Obsidian vault hosted on a VPS, using SSH or HTTP transport with OAuth authentication.

Audit Bridge MCP

MCP server for orchestrating Windows system auditing tools, supporting system checks, configuration adjustments, and security operations via a standardized interface.

Jira MCP Server

Enables creating Jira issues and listing issue types for a Jira Cloud project using Basic Auth credentials.

Gmail-SAP-MCP-Assistant

MCP server that exposes Gmail and SAP tools, enabling natural-language email management and SAP data browsing through a Mistral-powered AI assistant.

FogBugz MCP Server

Enables interaction with FogBugz issue tracking system through its XML API, allowing users to search, create, update, and manage cases, comments, and attachments directly from their MCP client.

MCP Weather Server

Provides real-time weather information for any location using FastMCP.

ESA MCP Server

通过模型上下文协议启用与 esa.io API 的交互，支持文章搜索和检索，并提供兼容的 MCP 接口。