Discover Awesome MCP Servers

MCP SSH Server for Windsurf

MCP SSH server for Windsurf integration

MCP Compliance

Un servidor MCP para respaldar las operaciones de cumplimiento en agentes de IA.

dbx-mcp-server

Un servidor de Protocolo de Contexto de Modelo que permite a las aplicaciones de IA interactuar con Dropbox, proporcionando herramientas para operaciones de archivos, recuperación de metadatos, búsqueda y gestión de cuentas a través de la API de Dropbox.

mcp-server-cli

Model Context Protocol server to run shell scripts or commands

Backstage MCP

A simple backstage mcp server using quarkus-backstage

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

Un servidor MCP para generar visualizaciones de datos personalizables utilizando QuickChart.io, que admite múltiples tipos de gráficos y configuración de Chart.js.

reddit-mcp

MCP server for reddit.

For the GitHub MCP

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

Notion MCP Server

Un servidor de Protocolo de Contexto de Modelo que proporciona una interfaz estandarizada para que los modelos de IA accedan, consulten y modifiquen contenido en espacios de trabajo de Notion.

filesystem

Un servidor de Protocolo de Contexto de Modelo que extiende las capacidades de la IA al proporcionar acceso al sistema de archivos y funcionalidades de gestión a Claude u otros asistentes de IA.

openpyxl_mcp_server

Una capa delgada alrededor de la biblioteca de Python OpenPyXl que expone las operaciones de archivos de Excel como un servidor de Protocolo de Contexto de Modelo (MCP), permitiendo a Claude y otros clientes MCP obtener y analizar datos de archivos de Excel.

Legion MCP (Model Context Protocol) Server

Un servidor que ayuda a las personas a acceder y consultar datos en bases de datos utilizando Query Runner con la integración del SDK de Python del Protocolo de Contexto de Modelo (MCP). Admite bases de datos como: PostgreSQL Redshift MySQL Microsoft SQL Server Google APIs Amazon Web Services (a través de boto3) CockroachDB SQLite

OpenAPI MCP Server

Esta herramienta crea un servidor de Protocolo de Contexto de Modelo (MCP) que actúa como proxy para cualquier API que tenga una especificación OpenAPI v3.1. Esto te permite usar Claude Desktop para interactuar fácilmente con APIs de servidor locales y remotas.

EVM MCP Server

Un servidor integral que permite a los agentes de IA interactuar con múltiples redes blockchain compatibles con EVM a través de una interfaz unificada, que admite la resolución de ENS, operaciones con tokens e interacciones con contratos inteligentes.

OneSignal MCP Server

Un servidor de Protocolo de Contexto de Modelo que envuelve la API REST de OneSignal, permitiendo la gestión de notificaciones push, correos electrónicos, SMS, dispositivos de usuario y segmentos a través de múltiples aplicaciones de OneSignal.

Linear MCP Server

Un servidor que permite a los asistentes de IA acceder y recuperar datos de tickets de Linear a través del estándar Model Context Protocol (MCP), actualmente enfocado en obtener los tickets pendientes de un usuario.

Kafka MCP Server

Permite que los modelos de IA publiquen y consuman mensajes de temas de Apache Kafka a través de una interfaz estandarizada, facilitando la integración de la mensajería de Kafka con aplicaciones LLM y 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 help you.

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 the task you've described. You can then copy and paste this script into a Python environment on your computer and run it. Here's the Python script, along with explanations: ```python import os import re import argparse # For command-line arguments import subprocess # For calling MeCab import sys def count_characters_and_words(filepath, language): """ Counts characters (excluding spaces and line breaks) and words in a text file. Handles Japanese text with morphological analysis using MeCab. 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} with 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": try: # Use MeCab for morphological analysis 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 # Extract words from MeCab output (first element of each line before the tab) words = [line.split('\t')[0] for line in mecab_output.splitlines() if line.strip() != 'EOS'] word_count = len(words) # Count characters (excluding spaces and line breaks) characters = re.sub(r'\s', '', text) character_count = len(characters) except FileNotFoundError: print("Error: MeCab is not installed or not in your PATH.") return 0, 0 except Exception as e: print(f"An error occurred during MeCab processing: {e}") 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 parse command-line arguments and process files. """ parser = argparse.ArgumentParser(description="Count characters and words in text files.") 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/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 potential errors like `FileNotFoundError`, `UnicodeDecodeError` (if the file isn't UTF-8 encoded), and errors related to MeCab. This makes the script much more robust. It also checks for invalid language input. * **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 the standard output and standard error from MeCab, allowing for error reporting. The code now correctly parses the MeCab output to extract the words. It also checks if MeCab is installed. * **Character Counting:** Uses `re.sub(r'\s', '', text)` to remove all whitespace (spaces, tabs, newlines) before counting characters. This ensures accurate character counts as requested. * **UTF-8 Encoding:** Opens the file with `encoding='utf-8'` to handle Unicode characters correctly, which is essential for Japanese text. It also includes a check for `UnicodeDecodeError` and suggests trying a different encoding if UTF-8 fails. * **Command-Line Arguments:** Uses `argparse` to handle command-line arguments. This makes the script much more user-friendly. The user can specify the filepath and language directly when running the script. * **Clearer Output:** Prints the filename, language, character count, and word count in a clear and organized format. * **`if __name__ == "__main__":` block:** This ensures that the `main()` function is only called when the script is executed directly (not when it's imported as a module). * **Comments:** Includes detailed comments to explain the code. * **Handles Empty Files:** The `if char_count != 0 or word_count != 0:` check prevents printing output if the file was empty or an error occurred. * **MeCab Error Handling:** Specifically checks for errors returned by MeCab and prints them to the console. * **Correct MeCab Word Extraction:** The code now correctly extracts the words from the MeCab output by splitting each line at the tab character (`\t`) and taking the first element. It also filters out the "EOS" (End of Sentence) marker. 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 you haven't already):** * **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'll need to download the MeCab binaries and dictionaries. Refer to the MeCab documentation for Windows installation instructions. You might also need to set the `MECABRC` 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_file.txt english python count_text.py my_japanese_file.txt japanese ``` **Example:** Let's say you have a file named `japanese_text.txt` with the following content: ``` 今日は良い天気です。 明日はどうですか？ ``` And you run: ```bash python count_text.py japanese_text.txt japanese ``` The output would be similar to: ``` File: japanese_text.txt Language: japanese Character Count (excluding spaces/line breaks): 14 Word Count: 7 ``` **Important Considerations:** * **MeCab Installation:** Make sure MeCab is correctly installed and that the `mecab` command is accessible from your command line. If you get a "FileNotFoundError" for MeCab, it means Python can't find the MeCab executable. You might need to add the MeCab directory to your system's `PATH` environment variable. * **Encoding:** The script assumes UTF-8 encoding. If your file uses a different encoding, you'll need to change the `encoding='utf-8'` argument in the `open()` function accordingly. * **MeCab Dictionaries:** MeCab relies on dictionaries for morphological analysis. Make sure you have the appropriate dictionaries installed for Japanese. The `mecab-ipadic-utf8` package (on Debian/Ubuntu) provides a standard dictionary. * **Customization:** You can customize the script further to handle different languages, use different tokenizers, or perform more advanced text analysis. This comprehensive solution should meet your requirements for counting characters and words in both English and Japanese text files, with proper handling of Japanese morphological analysis and error handling. Remember to install MeCab and adjust the encoding if necessary.

➡️ browser-use mcp server

Un servidor MCP que permite a los asistentes de IA controlar un navegador web a través de comandos en lenguaje natural, permitiéndoles navegar por sitios web y extraer información mediante transporte SSE.

PubMed Enhanced Search Server

Permite la búsqueda y recuperación de artículos académicos de la base de datos PubMed con funciones avanzadas como la búsqueda de términos MeSH, estadísticas de publicación y búsqueda de evidencia basada en PICO.

MCP Server Gateway

A gateway demo for MCP SSE Server

Math-MCP

Un servidor de Protocolo de Contexto de Modelo que proporciona funciones matemáticas y estadísticas básicas a los LLM, permitiéndoles realizar cálculos numéricos precisos a través de una API sencilla.