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.
Related MCP server: MCP NPX Fetch
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-mcpsInstalar Si no tienes
uv, instálalo:pip install uv # or follow instructions at https://github.com/astral-sh/uvDependencias: Las dependencias se administran por MCP a través de
pyproject.toml.uv runnormalmente 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_mcpComo 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:
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:
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 asignamy_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 bibliotecamcp(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
Licencia
Contribuyendo
¡Agradecemos sus contribuciones! No dude en enviar una solicitud de incorporación de cambios.