Discover Awesome MCP Servers

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.

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.

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.

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

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.

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.

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.

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.

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.

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

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.

MCP Pytest Server

Un servidor Node.js que se integra con pytest para facilitar las herramientas de servicio del Protocolo de Contexto del Modelo (MCP), permitiendo el registro de la ejecución de pruebas y el seguimiento del entorno.

Gel Database MCP Server

Un servidor MCP basado en TypeScript que permite a los agentes LLM interactuar con bases de datos Gel a través del lenguaje natural, proporcionando herramientas para aprender esquemas de bases de datos, validar y ejecutar consultas EdgeQL.

Code MCP

Un servidor MCP que proporciona herramientas para leer, escribir y editar archivos en el sistema de archivos local.

Smart Photo Journal MCP Server

Este servidor MCP ayuda a los usuarios a buscar y analizar su biblioteca de fotos por ubicación, etiquetas y personas, ofreciendo funcionalidades como análisis de fotos y coincidencia difusa para una gestión de fotos mejorada.

Everything Search MCP Server

Proporciona integración con el motor de búsqueda Everything, lo que permite capacidades de búsqueda de archivos potentes a través del Protocolo de Contexto del Modelo con opciones de búsqueda avanzadas como expresiones regulares, distinción entre mayúsculas y minúsculas y ordenación.

Model Control Plane (MCP) Server

Una implementación de servidor que proporciona una interfaz unificada para los servicios de OpenAI, el análisis de repositorios Git y las operaciones del sistema de archivos local a través de endpoints de la API REST.

MCP Apple Notes

Un servidor de Protocolo de Contexto de Modelo que permite la búsqueda y recuperación semántica del contenido de Apple Notes, permitiendo a los asistentes de IA acceder, buscar y crear notas utilizando incrustaciones en el dispositivo.

Binary Reader MCP

Un servidor de Protocolo de Contexto de Modelo para leer y analizar archivos binarios, con soporte inicial para archivos de recursos de Unreal Engine (.uasset).

Macrostrat MCP Server

Permite a Claude consultar datos geológicos exhaustivos de la API de Macrostrat, incluyendo unidades geológicas, columnas, minerales y escalas de tiempo a través del lenguaje natural.

Voice Recorder MCP Server

Permite grabar audio desde un micrófono y transcribirlo utilizando el modelo Whisper de OpenAI. Funciona tanto como un servidor MCP independiente como una extensión de agente de Goose AI.

Blender MCP Server

Un servidor de Protocolo de Contexto de Modelo que permite la gestión y ejecución de scripts de Python de Blender, permitiendo a los usuarios crear, editar y ejecutar scripts en un entorno Blender sin interfaz gráfica a través de interfaces de lenguaje natural.

kubernetes-mcp-server

Una implementación de servidor MCP de Kubernetes potente y flexible con soporte para OpenShift.

MCP Documentation Service

Una implementación de Protocolo de Contexto de Modelo que permite a los asistentes de IA interactuar con archivos de documentación Markdown, proporcionando capacidades para la gestión de documentos, el manejo de metadatos, la búsqueda y el análisis del estado de la documentación.

Spotify MCP Server

Un servidor que conecta a Claude con Spotify, permitiendo a los usuarios controlar la reproducción, buscar contenido, obtener información sobre canciones/álbumes/artistas/listas de reproducción y gestionar la cola de Spotify.

mcp-installer

Este servidor es un servidor que instala otros servidores MCP por ti. Instálalo, y podrás pedirle a Claude que instale servidores MCP alojados en npm o PyPi por ti. Requiere que npx y uv estén instalados para servidores de Node y Python respectivamente.

Node Omnibus MCP Server

Un servidor de Protocolo de Contexto de Modelo integral que proporciona herramientas avanzadas de desarrollo de Node.js para automatizar la creación de proyectos, la generación de componentes, la gestión de paquetes y la documentación con asistencia impulsada por IA.