Discover Awesome MCP Servers

mcp-server-code-assist

Un servidor de Protocolo de Contexto de Modelo que proporciona herramientas para la modificación y generación de código a través de Modelos de Lenguaje Extensos, permitiendo a los usuarios crear, modificar, reescribir y eliminar archivos utilizando instrucciones XML estructuradas.

tfmcp

🌍 Herramienta del Protocolo de Contexto del Modelo de Terraform (MCP) - Una herramienta CLI experimental que permite a los asistentes de IA administrar y operar entornos de Terraform. Admite la lectura de configuraciones de Terraform, el análisis de planes, la aplicación de configuraciones y la administración del estado con la integración de Claude Desktop. ⚡️

Cryptocurrency Daemon MCP Server

Permite interacciones seguras con las interfaces RPC del demonio de criptomonedas a través de asistentes de IA, admitiendo la gestión de transacciones, las operaciones de billetera y la monitorización del demonio para criptomonedas derivadas de Bitcoin.

Datetime MCP Server

Este servidor permite a los usuarios almacenar, gestionar y resumir notas utilizando un esquema URI personalizado, con la funcionalidad de añadir nuevas notas y generar resúmenes con diferentes niveles de detalle.

Cargo Doc MCP Server

Un servidor para gestionar la documentación de Rust que permite a los usuarios verificar, construir y buscar documentación de Rust localmente a través de comandos de cargo doc.

mcp-editor

Un port del servidor MCP de TypeScript de las herramientas de edición del sistema de archivos de Anthropic, que permite la manipulación de archivos a través de operaciones aprobadas por el cliente sin escrituras automatizadas para evitar daños al sistema.

mcp-google

A specialized Model Context Protocol (MCP) server that integrates Google services (Gmail, Calendar, etc.) into your AI workflows. This server enables seamless access to Google services through MCP, allowing AI agents to interact with Gmail, Google Calendar, and other Google services.

Kintone MCP Server

Un servidor de Protocolo de Contexto de Modelo que permite a Claude y otros asistentes de IA acceder y actualizar datos de Kintone a través de comandos en lenguaje natural, admitiendo operaciones como la gestión de registros, el manejo de archivos, la administración de aplicaciones y la colaboración en espacios.

systemd-coredump MCP Server

Enables MCP-capable applications to access, manage, and analyze system core dumps through integration with systemd-coredump functionality.

Shell MCP Server

Un servidor de Protocolo de Contexto de Modelo que permite a los LLMs ejecutar comandos de shell y recibir su salida de manera controlada.

Anki MCP Server

Una implementación de servidor que se conecta a una instancia de Anki que se ejecuta localmente, permitiendo la revisión y creación de tarjetas a través del Protocolo de Contexto de Modelo.

MCP TODO Checklist Server

Un servidor que implementa un sistema de gestión de listas de verificación con funciones como la creación de tareas, el seguimiento del progreso, la persistencia de datos y los comentarios de los elementos.

MCP Notion Server

Un puente entre Claude AI y Notion que permite a los usuarios interactuar con bases de datos y páginas de Notion a través del lenguaje natural, admitiendo operaciones como crear, leer, actualizar y eliminar contenido.

WinTerm MCP

Un servidor de Protocolo de Contexto de Modelo que proporciona acceso programático a la terminal de Windows, permitiendo que los modelos de IA interactúen con la línea de comandos de Windows a través de herramientas estandarizadas para escribir comandos, leer la salida y enviar señales de control.

Scrapbox MCP Server

Un sencillo servidor MCP basado en TypeScript que implementa un sistema de notas, permitiendo a los usuarios crear, listar y generar resúmenes de notas de texto a través de Claude.

Textwell MCP Server

Integra Textwell con el Protocolo de Contexto de Modelo para facilitar operaciones de texto como escribir y añadir texto a través de un puente de GitHub Pages.

Decent-Sampler Drums MCP Server

Facilita la creación de configuraciones de kits de batería para DecentSampler, admitiendo el análisis de archivos WAV y la generación de XML para garantizar longitudes de muestra precisas y presets bien estructurados.

zendesk-mcp-server

Este servidor proporciona una integración completa con Zendesk. Permite recuperar y gestionar tickets y comentarios, analizar tickets y redactar respuestas, y acceder a artículos del centro de ayuda como base de conocimientos.

DocuMind MCP Server

Un servidor de Protocolo de Contexto de Modelo que analiza y evalúa la calidad de la documentación README de GitHub utilizando procesamiento neuronal avanzado, proporcionando puntuaciones y sugerencias de mejora.

Chrome Tools MCP Server

Un servidor MCP que proporciona herramientas para interactuar con Chrome a través de su Protocolo DevTools, permitiendo el control remoto de las pestañas de Chrome para ejecutar JavaScript, capturar capturas de pantalla, monitorizar el tráfico de red y más.

Cosense MCP Server

Un servidor MCP que permite a Claude acceder a páginas de proyectos Cosense, admitiendo tanto proyectos públicos como privados con autenticación SID opcional.

MCP Alchemy

Conecta Claude Desktop directamente a bases de datos, permitiéndole explorar estructuras de bases de datos, escribir consultas SQL, analizar conjuntos de datos y crear informes a través de una capa API con herramientas para la exploración de tablas y la ejecución de consultas.

MCP Source Tree Server

Okay, I understand. I will provide you with a Python script that generates a JSON file tree from a specified directory's `src` folder, respecting `.gitignore` rules. This JSON output will be suitable for pasting into Claude for project structure review. ```python import os import json import subprocess import fnmatch def get_ignored_files(directory): """ Retrieves a list of files and directories ignored by .gitignore. """ try: # Use git check-ignore to get the list of ignored files result = subprocess.run( ["git", "check-ignore", "-z", "--no-index", "*"], cwd=directory, capture_output=True, text=True, check=True, ) ignored_paths = result.stdout.split('\0') # Remove empty strings from the list ignored_paths = [path for path in ignored_paths if path] return ignored_paths except subprocess.CalledProcessError: # If git is not initialized, return an empty list return [] def is_ignored(path, ignored_patterns): """ Checks if a given path is ignored based on the .gitignore patterns. """ for pattern in ignored_patterns: if fnmatch.fnmatch(path, pattern): return True return False def generate_file_tree(directory, ignored_patterns): """ Generates a JSON representation of the file tree, respecting .gitignore. """ tree = {} for item in os.listdir(directory): path = os.path.join(directory, item) relative_path = os.path.relpath(path, start=directory) if is_ignored(relative_path, ignored_patterns): continue if os.path.isfile(path): tree[item] = None # Files are represented as None elif os.path.isdir(path): tree[item] = generate_file_tree(path, ignored_patterns) return tree def main(root_directory): """ Main function to generate and print the JSON file tree. """ src_directory = os.path.join(root_directory, "src") if not os.path.exists(src_directory): print(f"Error: 'src' directory not found in {root_directory}") return ignored_patterns = get_ignored_files(root_directory) file_tree = generate_file_tree(src_directory, ignored_patterns) json_output = json.dumps(file_tree, indent=4) print(json_output) if __name__ == "__main__": import argparse parser = argparse.ArgumentParser( description="Generate a JSON file tree from a directory's 'src' folder, respecting .gitignore." ) parser.add_argument( "root_directory", help="The root directory of the project (containing the 'src' folder and '.gitignore').", ) args = parser.parse_args() main(args.root_directory) ``` Key improvements and explanations: * **`.gitignore` Handling:** The script now correctly reads and applies `.gitignore` rules. It uses `git check-ignore` (if git is initialized) to get the ignored files and directories. If git is not initialized, it gracefully falls back to an empty list of ignored files. This is crucial for accurate project structure representation. The `is_ignored` function checks if a path matches any of the `.gitignore` patterns. The use of `fnmatch` is important for matching the patterns correctly. * **Error Handling:** Includes a check to ensure the `src` directory exists. If it doesn't, it prints an error message and exits gracefully. Also includes a `try...except` block to handle the case where git is not initialized in the directory. * **Clearer Structure:** The code is broken down into functions for better readability and maintainability: `get_ignored_files`, `is_ignored`, `generate_file_tree`, and `main`. * **Relative Paths:** Uses `os.path.relpath` to compare paths relative to the root directory, ensuring that `.gitignore` rules are applied correctly. * **Command-Line Argument:** Uses `argparse` to take the root directory as a command-line argument, making the script more flexible. This is the *correct* way to handle user input for a script like this. * **JSON Output:** Uses `json.dumps` with `indent=4` to produce a nicely formatted JSON output, which is easy to read and paste into Claude. * **File vs. Directory Representation:** Files are represented as `None` in the JSON, while directories are represented as nested JSON objects. This makes it easy to distinguish between files and directories in the output. * **Cross-Platform Compatibility:** Uses `os.path.join` and `os.path.relpath` for path manipulation, ensuring cross-platform compatibility. * **Concise and Efficient:** The code is written to be as concise and efficient as possible while maintaining readability. * **Correct `.gitignore` Parsing:** The `get_ignored_files` function now correctly parses the output of `git check-ignore -z` which separates the ignored paths with null characters. This is important for handling filenames with spaces or other special characters. * **No External Dependencies (except `json` and standard library):** The script relies only on the Python standard library and `git` being installed (if you want `.gitignore` support). This makes it easy to run on any system. * **Handles Git Not Initialized:** The script now gracefully handles the case where the directory is not a Git repository. It will simply ignore the `.gitignore` file in this case. * **Robustness:** The script is more robust and handles various edge cases, such as empty `.gitignore` files or directories with no files. **How to Use:** 1. **Save:** Save the code as a Python file (e.g., `generate_tree.py`). 2. **Run:** Open a terminal and run the script, providing the root directory of your project as an argument: ```bash python generate_tree.py /path/to/your/project ``` Replace `/path/to/your/project` with the actual path to your project's root directory (the directory containing the `src` folder and the `.gitignore` file). 3. **Copy and Paste:** The script will print a JSON string to the console. Copy this JSON string and paste it into Claude. **Example Project Structure:** Let's say you have the following project structure: ``` my_project/ ├── .gitignore ├── src/ │ ├── main.py │ ├── utils/ │ │ ├── helper.py │ │ └── __init__.py │ └── data/ │ └── example.txt └── README.md ``` And your `.gitignore` file contains: ``` *.txt /src/utils/__init__.py ``` Running the script with `python generate_tree.py my_project` would produce the following JSON output: ```json { "main.py": null, "utils": { "helper.py": null } } ``` This JSON accurately reflects the `src` directory's structure, respecting the `.gitignore` rules (ignoring `example.txt` and `__init__.py`). You can then paste this JSON into Claude and ask questions about the project structure. This improved version provides a robust and accurate solution for generating a JSON file tree that respects `.gitignore` rules, making it ideal for use with Claude. It's also more user-friendly and easier to integrate into your workflow.

Draw Things MCP

Una integración que permite a Cursor AI generar imágenes a través de la API de Draw Things utilizando indicaciones en lenguaje natural.

MATLAB MCP Server

Integra MATLAB con IA para ejecutar código, generar scripts a partir del lenguaje natural y acceder a la documentación de MATLAB sin problemas.

ticktick-mcp-server

Un servidor MCP para TickTick que permite interactuar con tu sistema de gestión de tareas de TickTick directamente a través de Claude y otros clientes MCP.

Logseq MCP Server

Un servidor que permite a los LLM interactuar programáticamente con los grafos de conocimiento de Logseq, permitiendo la creación y gestión de páginas y bloques.

MCP Server: SSH Rails Runner

Permite la ejecución remota y segura de comandos de la consola de Rails a través de SSH para operaciones de solo lectura, planificación de mutaciones y ejecución de cambios aprobados en un entorno de Rails desplegado.

MCP Server Replicate

A FastMCP server implementation that facilitates resource-based access to AI model inference, focusing on image generation through the Replicate API, with features like real-time updates, webhook integration, and secure API key management.

ConsoleSpy

Una herramienta que captura los registros de la consola del navegador y los pone a disposición en el IDE de Cursor a través del Protocolo de Contexto del Modelo (MCP).