Servidores de protocolo de contexto de modelo útiles (MCPS)

Una colección de scripts Python independientes que implementan servidores del Protocolo de Contexto de Modelo (MCP) para diversas funciones de utilidad. Cada servidor proporciona herramientas especializadas que pueden ser utilizadas por asistentes de IA u otras aplicaciones compatibles con el protocolo MCP.

¿Qué es MCP?

El Protocolo de Contexto de Modelo (MCP) es una forma estandarizada para que los asistentes de IA interactúen con herramientas y servicios externos. Permite a los modelos de IA ampliar sus capacidades mediante la invocación de funciones especializadas proporcionadas por los servidores MCP. La comunicación se realiza mediante entrada/salida estándar (stdio) mediante mensajes JSON.

Servidores disponibles

Cada servidor MCP está diseñado para ejecutarse utilizando un administrador de entorno Python como uv .

Extractor de datos de YouTube ( `ytdlp` )

Un servidor que extrae información de los vídeos de YouTube utilizando yt-dlp.

Herramientas:

Extraer capítulos : obtenga información del capítulo de un video de YouTube.
Extraer subtítulos : obtén subtítulos de un video de YouTube para capítulos específicos o para todo el video.

Configuración del servidor MCP:

"mcpServers": {
  "ytdlp": {
    "name": "youtube", // Optional friendly name for the client
    "command": "uv",
    "args": [
      "run",
      "--directory", "<path/to/repo>/useful-mcps/ytdlp", // Path to the MCP directory containing pyproject.toml
      "--", // Separator before script arguments, if any
      "ytdlp_mcp" // Match the script name defined in pyproject.toml [project.scripts]
    ]
    // 'cwd' is not needed when using --directory
  }
}

Procesador de documentos de Word ( `docx_replace` )

Un servidor para manipular documentos de Word, incluido el procesamiento de plantillas y la conversión de PDF.

Herramientas:

Plantilla de proceso : reemplace marcadores de posición en plantillas de Word y administre bloques de contenido.
Obtener claves de plantilla : extrae todas las claves de reemplazo de una plantilla de documento de Word.
Convertir a PDF : convierte un documento de Word (docx) al formato PDF.

Configuración del servidor MCP:

"mcpServers": {
  "docx_replace": {
    "name": "docx", // Optional friendly name
    "command": "uv",
    "args": [
      "run",
      "--directory", "<path/to/repo>/useful-mcps/docx_replace", // Path to the MCP directory
      "--",
      "docx_replace_mcp" // Match the script name defined in pyproject.toml
    ]
  }
}

Representador PlantUML ( `plantuml` )

Un servidor para representar diagramas PlantUML utilizando un servidor PlantUML (a menudo ejecutado a través de Docker).

Herramientas:

Diagrama de renderizado : convierte texto PlantUML en imágenes de diagrama (por ejemplo, PNG).

Configuración del servidor MCP:

"mcpServers": {
  "plantuml": {
    "name": "plantuml", // Optional friendly name
    "command": "uv",
    "args": [
      "run",
      "--directory", "<path/to/repo>/useful-mcps/plantuml", // Path to the MCP directory
      "--",
      "plantuml_server" // Match the script name defined in pyproject.toml
    ]
  }
}

(Nota: Requiere un servidor PlantUML en ejecución accesible, potencialmente administrado a través de Docker como se implementa en el servicio).

Renderizador de sirena ( `mermaid` )

Un servidor para renderizar diagramas de Mermaid utilizando la API de mermaidchart.com.

Herramientas:

Renderizar gráfico de sirena : convierta el código de sirena en una imagen PNG creando un documento en mermaidchart.com.

Configuración del servidor MCP:

"mcpServers": {
  "mermaid": {
    "name": "mermaid", // Optional friendly name
    "command": "uv",
    "args": [
      "run",
      "--directory", "<path/to/repo>/useful-mcps/mermaid", // Path to the MCP directory
      "--",
      "mermaid_mcp" // Match the script name defined in pyproject.toml
    ],
    "env": { // Environment variables needed by the MCP
        "MERMAID_CHART_ACCESS_TOKEN": "YOUR_API_TOKEN_HERE"
    }
  }
}

(Nota: Requiere un token de acceso a la API de Mermaid Chart establecido como una variable de entorno).

Fuente RSS a Markdown ( `rss2md` )

Un servidor para convertir el contenido de fuentes RSS al formato Markdown con filtrado de fechas.

Herramientas:

fetch_rss_to_markdown : obtiene una fuente RSS, filtra artículos por fecha y devuelve artículos coincidentes formateados como una lista Markdown.

Configuración del servidor MCP:

"mcpServers": {
  "mermaid": {
    "name": "rss2md", // Optional friendly name
    "command": "uv",
    "args": [
      "run",
      "--directory", "<path/to/repo>/useful-mcps/rss2md", // Path to the MCP directory
      "--",
      "rss2md_mcp" // Match the script name defined in pyproject.toml
    ],
    "env": { // Environment variables needed by the MCP
    }
  }
}

Instalación

Clonar el repositorio:
git clone https://github.com/daltonnyx/useful-mcps.git # Replace with the actual repo URL if different cd useful-mcps
Instalar uv : Si no tienes uv , instálalo:
pip install uv # or follow instructions at https://github.com/astral-sh/uv
Dependencias: Las dependencias se administran por MCP a través de pyproject.toml . uv run normalmente se encargará de instalarlas automáticamente en un entorno virtual cuando ejecuta un MCP por primera vez usando --directory .

Uso

Ejecución de un servidor

Se recomienda ejecutar cada servidor MCP utilizando uv run --directory <path> apuntando al directorio del MCP específico. uv maneja el entorno virtual y las dependencias basándose en el pyproject.toml que se encuentra allí.

Ejemplo (del directorio raíz useful-mcps ):

# Run the YouTube MCP
uv run --directory ./ytdlp ytdlp_mcp

# Run the Mermaid MCP (ensure token is set in environment)
uv run --directory ./mermaid mermaid_mcp

Como alternativa, configure su cliente MCP (como las configuraciones JSON de ejemplo anteriores) para ejecutar el comando uv run --directory ... directamente.

Conectarse a un servidor

Configure su aplicación cliente MCP para iniciar el servidor deseado usando la estructura de command y args que se muestra en los ejemplos de "Configuración del servidor MCP" para cada servidor. Asegúrese de que el command apunte a su ejecutable uv y que los args especifiquen correctamente --directory con la ruta a la carpeta de MCP y el nombre del script que se ejecutará. Pase las variables de entorno necesarias (como los tokens de API) usando la propiedad env .

Ejemplos de uso de herramientas específicas

Estos muestran ejemplos arguments que enviaría a la función call_tool del servidor MCP respectivo.

Extractor de datos de YouTube

Extraer capítulos

{
  "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
}

Extraer subtítulos

{
  "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
  "language": "en",
  "chapters": [
    {
      "title": "Introduction",
      "start_time": "00:00:00",
      "end_time": "00:01:30"
    }
  ]
}

Procesador de documentos de Word

Plantilla de proceso

{
  "template_file": "/path/to/template.docx",
  "replacements": {
    "name": "John Doe",
    "date": "2023-05-15"
  },
  "blocks": {
    "optional_section": true,
    "alternative_section": false
  },
  "output_filename": "/path/to/output.docx"
}

(Nota: template_file y docx_file también pueden aceptar cadenas codificadas en base64 en lugar de rutas)

Obtener claves de plantilla

{
  "template_file": "/path/to/template.docx"
}

Convertir a PDF

{
  "docx_file": "/path/to/document.docx",
  "pdf_output": "/path/to/output.pdf"
}

Renderizador PlantUML

Diagrama de renderizado

{
  "input": "participant User\nUser -> Server: Request\nServer --> User: Response",
  "output_path": "/path/to/save/diagram.png"
}

(Nota: input también puede ser una ruta a un archivo .puml )

Renderizador de sirena

Gráfico de sirena renderizado

{
  "mermaid_code": "graph TD;\n    A-->B;\n    A-->C;\n    B-->D;\n    C-->D;",
  "output_path": "/path/to/save/mermaid.png",
  "theme": "default" // Optional, e.g., "default", "dark", "neutral", "forest"
}

Desarrollo

Agregar un nuevo servidor MCP

Cree un nuevo directorio para su MCP (por ejemplo, my_new_mcp ).
Dentro del directorio, crea:
- pyproject.toml : define los metadatos del proyecto, las dependencias y el punto de entrada del script (por ejemplo, la sección [project.scripts] que asigna my_new_mcp = "my_new_mcp:main" ).
- pyrightconfig.json : (opcional) para verificación de tipos.
- Su archivo Python principal (por ejemplo, my_new_mcp.py ): implemente la lógica MCP utilizando la biblioteca mcp (ver la plantilla a continuación).
Implementar las clases y funciones requeridas ( serve , list_tools , call_tool ).

Plantilla básica ( my_new_mcp.py ):

import json
import logging
import asyncio
from typing import List, Dict, Any, Optional
# Assuming mcp library is installed or available
# from mcp import Server, Tool, TextContent, stdio_server
# Placeholder imports if mcp library structure is different
from typing import Protocol # Using Protocol as placeholder

# Placeholder definitions if mcp library isn't directly importable here
class Tool(Protocol):
    name: str
    description: str
    inputSchema: dict

class TextContent(Protocol):
    type: str
    text: str

class Server:
    def __init__(self, name: str): pass
    def list_tools(self): pass # Decorator
    def call_tool(self): pass # Decorator
    def create_initialization_options(self): pass
    async def run(self, read_stream, write_stream, options): pass

# Placeholder context manager
class stdio_server:
    async def __aenter__(self): return (None, None) # Dummy streams
    async def __aexit__(self, exc_type, exc, tb): pass


# Pydantic is often used for schema definition
# from pydantic import BaseModel
# class MyInput(BaseModel):
#     param1: str
#     param2: int

class MyInputSchema: # Placeholder if not using Pydantic
    @staticmethod
    def model_json_schema():
      return {"type": "object", "properties": {"param1": {"type": "string"}, "param2": {"type": "integer"}}, "required": ["param1", "param2"]}


class MyTools:
    TOOL_NAME = "my.tool"

class MyService:
    def __init__(self):
        # Initialize resources if needed
        pass

    def my_function(self, param1: str, param2: int) -> dict:
        # Implement your tool functionality
        logging.info(f"Running my_function with {param1=}, {param2=}")
        # Replace with actual logic
        result_content = f"Result: processed {param1} and {param2}"
        return {"content": result_content}

async def serve() -> None:
    logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
    server = Server("mcp-my-service")
    service = MyService()

    @server.list_tools()
    async def list_tools() -> list[Tool]:
        logging.info("list_tools called")
        return [
            Tool(
                name=MyTools.TOOL_NAME,
                description="Description of my tool",
                # Use Pydantic's schema or manually define
                inputSchema=MyInputSchema.model_json_schema(),
            ),
        ]

    @server.call_tool()
    async def call_tool(name: str, arguments: dict) -> list[TextContent]:
        logging.info(f"call_tool called with {name=}, {arguments=}")
        try:
            if name == MyTools.TOOL_NAME:
                # Add validation here if not using Pydantic
                param1 = arguments.get("param1")
                param2 = arguments.get("param2")
                if param1 is None or param2 is None:
                     raise ValueError("Missing required arguments")

                result = service.my_function(param1, int(param2)) # Ensure type conversion if needed
                logging.info(f"Tool executed successfully: {result=}")
                return [TextContent(type="text", text=json.dumps(result))] # Return JSON string
            else:
                logging.warning(f"Unknown tool requested: {name}")
                raise ValueError(f"Unknown tool: {name}")
        except Exception as e:
            logging.error(f"Error executing tool {name}: {e}", exc_info=True)
            # Return error as JSON
            error_payload = json.dumps({"error": str(e)})
            return [TextContent(type="text", text=error_payload)]

    options = server.create_initialization_options()
    logging.info("Starting MCP server...")
    async with stdio_server() as (read_stream, write_stream):
        await server.run(read_stream, write_stream, options)
    logging.info("MCP server stopped.")

def main():
    # Entry point defined in pyproject.toml `[project.scripts]`
    try:
        asyncio.run(serve())
    except KeyboardInterrupt:
        logging.info("Server interrupted by user.")

if __name__ == "__main__":
    # Allows running directly via `python my_new_mcp.py` for debugging
    main()

Pruebas

Ejecute pruebas usando pytest desde el directorio raíz:

pytest tests/

(Asegúrese de que las dependencias de prueba estén instaladas, posiblemente mediante uv pip install pytest o agregando pytest a las dependencias de desarrollo en uno de los archivos pyproject.toml ).

Licencia

Licencia MIT

Contribuyendo

¡Agradecemos sus contribuciones! No dude en enviar una solicitud de incorporación de cambios.

Useful-mcps

Integrations

Servidores de protocolo de contexto de modelo útiles (MCPS)

¿Qué es MCP?

Servidores disponibles

Extractor de datos de YouTube ( `ytdlp` )

Procesador de documentos de Word ( `docx_replace` )

Representador PlantUML ( `plantuml` )

Renderizador de sirena ( `mermaid` )

Fuente RSS a Markdown ( `rss2md` )

Instalación

Uso

Ejecución de un servidor

Conectarse a un servidor

Ejemplos de uso de herramientas específicas

Extractor de datos de YouTube

Extraer capítulos

Extraer subtítulos

Procesador de documentos de Word

Plantilla de proceso

Obtener claves de plantilla

Convertir a PDF

Renderizador PlantUML

Diagrama de renderizado

Renderizador de sirena

Gráfico de sirena renderizado

Desarrollo

Agregar un nuevo servidor MCP

Pruebas

Licencia

Contribuyendo

Integrations

Servidores de protocolo de contexto de modelo útiles (MCPS)

¿Qué es MCP?

Servidores disponibles

Extractor de datos de YouTube ( ytdlp )

Procesador de documentos de Word ( docx_replace )

Representador PlantUML ( plantuml )

Renderizador de sirena ( mermaid )

Fuente RSS a Markdown ( rss2md )

Instalación

Uso

Ejecución de un servidor

Conectarse a un servidor

Ejemplos de uso de herramientas específicas

Extractor de datos de YouTube

Extraer capítulos

Extraer subtítulos

Procesador de documentos de Word

Plantilla de proceso

Obtener claves de plantilla

Convertir a PDF

Renderizador PlantUML

Diagrama de renderizado

Renderizador de sirena

Gráfico de sirena renderizado

Desarrollo

Agregar un nuevo servidor MCP

Pruebas

Licencia

Contribuyendo

Extractor de datos de YouTube ( `ytdlp` )

Procesador de documentos de Word ( `docx_replace` )

Representador PlantUML ( `plantuml` )

Renderizador de sirena ( `mermaid` )

Fuente RSS a Markdown ( `rss2md` )