ZenML MCP Server

oficial

Interactúa con tus pipelines de MLOps y LLMOps a través de tu servidor MCP de ZenML

Documentación

Servidor MCP para ZenML

Este proyecto implementa un servidor del Protocolo de Contexto del Modelo (MCP) para interactuar con la API de ZenML.

ZenML MCP Server

¿Qué es MCP?

El Protocolo de Contexto del Modelo (MCP) es un protocolo abierto que estandariza cómo las aplicaciones proporcionan contexto a los Modelos de Lenguaje de Gran Escala (LLMs). Actúa como un "puerto USB-C para aplicaciones de IA", proporcionando una forma estandarizada de conectar modelos de IA a diferentes fuentes de datos y herramientas.

MCP sigue una arquitectura cliente-servidor donde:

Hosts MCP: Programas como Claude Desktop o IDEs que desean acceder a datos a través de MCP
Clientes MCP: Clientes de protocolo que mantienen conexiones 1:1 con los servidores
Servidores MCP: Programas ligeros que exponen capacidades específicas a través del protocolo estandarizado
Fuentes de Datos Locales: Archivos, bases de datos y servicios de tu computadora a los que los servidores MCP pueden acceder de forma segura
Servicios Remotos: Sistemas externos disponibles a través de internet a los que los servidores MCP pueden conectarse

¿Qué es ZenML?

ZenML es una plataforma de código abierto para construir y gestionar pipelines de ML e IA. Proporciona una interfaz unificada para gestionar datos, modelos y experimentos.

Para más información, consulta el sitio web de ZenML y nuestra documentación.

Características

El servidor proporciona herramientas MCP para acceder a la funcionalidad principal de lectura del servidor ZenML, ofreciendo una forma de obtener información en vivo sobre:

Entidades Principales

Usuarios - cuentas de usuario y permisos
Stacks - configuraciones de infraestructura
Componentes de Stack - bloques de construcción individuales del stack
Sabores - tipos de componentes disponibles
Conectores de Servicio - autenticación en la nube

Ejecución de Pipelines

Pipelines - definiciones de pipeline
Ejecuciones de Pipeline - historial de ejecución y estado
Pasos de Pipeline - detalles de pasos individuales, código y logs
Programaciones - programaciones de ejecución automatizadas
Artefactos - metadatos sobre artefactos de datos (no los datos en sí)

Despliegue y Servicio

Instantáneas - configuraciones de pipeline congeladas (el artefacto "qué ejecutar/servir")
Despliegues - instancias de servicio en tiempo de ejecución con estado, URL y logs
Servicios - endpoints de servicio de modelos

Organización y Descubrimiento

Proyectos - contenedores organizativos para recursos de ZenML
Etiquetas - etiquetas de metadatos transversales para descubrimiento
Construcciones - artefactos de construcción de pipeline con información de imagen y código

Modelos

Modelos - entradas del registro de modelos de ML
Versiones de Modelo - artefactos de modelo versionados

Obsoleto (se recomienda migración)

~~Plantillas de ejecución de pipeline~~ → usa Instantáneas en su lugar (consulta la Guía de Migración)

El servidor también te permite desencadenar nuevas ejecuciones de pipeline usando instantáneas (preferido) o plantillas de ejecución (obsoleto).

Nota: Estamos mejorando continuamente esta integración basándonos en los comentarios de los usuarios. ¡Únete a nuestra comunidad de Slack para compartir tu experiencia y ayudarnos a hacerla aún mejor!

Herramientas Disponibles

El servidor MCP expone las siguientes herramientas, agrupadas por categoría:

Ejecución de Pipelines (Nuevo en v1.2)

Herramienta	Descripción
`get_snapshot`	Obtener una configuración de pipeline congelada por nombre/ID
`list_snapshots`	Listar instantáneas con filtros (ejecutable, desplegable, desplegado, etiqueta)
`get_deployment`	Obtener el estado de ejecución y la URL de un despliegue
`list_deployments`	Listar despliegues con filtros (estado, pipeline, etiqueta)
`get_deployment_logs`	Obtener logs acotados de un despliegue (cola=100 por defecto, máx 1000)
`trigger_pipeline`	Desencadenar una ejecución de pipeline (preferir parámetro `snapshot_name_or_id`)

Organización (Nuevo en v1.2)

Herramienta	Descripción
`get_active_project`	Obtener el proyecto actualmente activo
`get_project`	Obtener detalles del proyecto por nombre/ID
`list_projects`	Listar todos los proyectos
`get_tag`	Obtener detalles de etiqueta (exclusiva, colores)
`list_tags`	Listar etiquetas con filtros (tipo_recurso)
`get_build`	Obtener detalles de construcción (imagen, incrustación de código)
`list_builds`	Listar construcciones con filtros (es_local, contiene_código)

Entidades Principales

Herramienta	Descripción
`get_user`, `list_users`, `get_active_user`	Gestión de usuarios
`get_stack`, `list_stacks`	Configuraciones de stack
`get_stack_component`, `list_stack_components`	Componentes de stack
`get_flavor`, `list_flavors`	Sabores de componentes
`get_service_connector`, `list_service_connectors`	Conectores de nube
`get_pipeline_run`, `list_pipeline_runs`	Ejecuciones de pipeline
`get_run_step`, `list_run_steps`	Detalles de pasos
`get_step_logs`, `get_step_code`	Logs de pasos y código fuente
`list_pipelines`, `get_pipeline_details`	Definiciones de pipeline
`get_schedule`, `list_schedules`	Programaciones
`list_artifacts`	Metadatos de artefactos
`list_secrets`	Nombres de secretos (no valores)
`get_service`, `list_services`	Servicios de modelo
`get_model`, `list_models`	Registro de modelos
`get_model_version`, `list_model_versions`	Versiones de modelo

Aplicaciones Interactivas (Experimental)

Herramienta	Descripción
`open_pipeline_run_dashboard`	Abrir panel interactivo de ejecuciones de pipeline (MCP App)
`open_run_activity_chart`	Abrir gráfico de barras de actividad de ejecución de 30 días (MCP App)

Herramientas de Análisis

Herramienta	Descripción
`stack_components_analysis`	Analizar uso de componentes de stack
`recent_runs_analysis`	Analizar ejecuciones de pipeline recientes
`most_recent_runs`	Obtener N ejecuciones más recientes

Diagnósticos

Herramienta	Descripción
`diagnose_zenml_setup`	Diagnosticar configuración del servidor (vars de entorno, SDK, conectividad, autenticación). Funciona incluso cuando está mal configurado.

Herramientas Obsoletas

Herramienta	Reemplazo
`get_run_template`	Usar `get_snapshot` en su lugar
`list_run_templates`	Usar `list_snapshots` en su lugar
`trigger_pipeline(template_id=...)`	Usar `trigger_pipeline(snapshot_name_or_id=...)`

Migración: Plantillas de Ejecución → Instantáneas

¿Por qué el cambio? ZenML evolucionó su concepto de "artefacto de pipeline ejecutable". Las Plantillas de Ejecución ahora son envoltorios obsoletos que internamente solo apuntan a Instantáneas. El código nuevo debe usar Instantáneas directamente.

Guía Rápida de Migración

Patrón Antiguo (Plantillas)	Patrón Nuevo (Instantáneas)
`list_run_templates()`	`list_snapshots(runnable=True, named_only=True)`
`get_run_template(name)`	`get_snapshot(name, include_config_schema=True)`
`trigger_pipeline(template_id=...)`	`trigger_pipeline(snapshot_name_or_id=...)`

Flujo de Trabajo de Ejemplo (Primero Instantáneas)

1. Discover project context:
   → get_active_project()

2. Find runnable snapshots:
   → list_snapshots(runnable=True, named_only=True)

3. Trigger a run:
   → trigger_pipeline(pipeline_name_or_id="my-pipeline", snapshot_name_or_id="my-snapshot")

4. Check deployments:
   → list_deployments(status="running")
   → get_deployment_logs(name_id_or_prefix="my-deployment", tail=100)

Nota: get_deployment_logs devuelve salida acotada (por defecto 100 líneas, máx 1000, limitado a 100KB) y requiere que la integración del desplegador apropiado esté instalada.

Configuración Rápida a través del Panel (Recomendado)

La forma más fácil de configurar el Servidor MCP de ZenML es a través de la página de Configuración MCP de tu panel de ZenML.

MCP Settings Page

Navega a Configuración → MCP en tu panel de ZenML para obtener:

Fragmentos preconfigurados para tu URL de servidor y credenciales específicas
Instalación con un clic a través de enlaces profundos para IDEs compatibles
Configuraciones para copiar y pegar para VS Code, Claude Desktop, Cursor, Claude Code, OpenAI Codex y más
Opciones de Docker y uv según tu preferencia

Usuarios de ZenML Pro

La página de Configuración MCP te permite generar un Token de Acceso Personal (PAT) con un solo clic. El token se incluye automáticamente en todos los fragmentos de configuración generados.

Usuarios de ZenML OSS

Primero crea un token de cuenta de servicio a través de Configuración → Cuentas de Servicio
Pega el token en la página de Configuración MCP
Copia la configuración generada para tu IDE

¿Prefieres la configuración manual? Consulta las instrucciones detalladas a continuación.

MCP Apps (Experimental)

¿Qué son las MCP Apps? Las MCP Apps son interfaces de usuario HTML interactivas que los servidores MCP pueden servir directamente en los clientes de IA. Se renderizan en iframes aislados y pueden llamar herramientas del servidor de forma bidireccional. Consulta el anuncio oficial para más detalles.

Run Activity Chart

Este servidor incluye dos MCP Apps experimentales:

App	Herramienta	Descripción
Panel de Ejecuciones de Pipeline	`open_pipeline_run_dashboard`	Tabla interactiva de ejecuciones de pipeline recientes con estado, detalles de pasos y logs
Gráfico de Actividad de Ejecución	`open_run_activity_chart`	Gráfico de barras de actividad de ejecución de pipeline de los últimos 30 días con desglose de estado

Pipeline Runs Dashboard

Estas aplicaciones se incluyen como ejemplos de prueba de concepto. Agradecemos comentarios y contribuciones para más MCP Apps. Aún es pronto para esta nueva característica, así que tendremos que ver cómo evoluciona. Esperamos darle un soporte más completo en el futuro.

Clientes Compatibles

Las MCP Apps requieren transporte HTTP Transmisible (no stdio). Los siguientes clientes actualmente soportan MCP Apps:

✅ VS Code (Edición Insiders)
✅ Goose
✅ ChatGPT (próximamente)
⚠️ Claude Desktop -- a finales de enero de 2026, aún no renderiza Apps.
⚠️ Claude.ai (web) — a finales de enero de 2026, aún no renderiza Apps.

Nota: No pudimos probar exhaustivamente con Claude Desktop o Claude.ai en el momento de escribir esto. Si encuentras problemas, por favor repórtalos.

Ejecutar MCP Apps con Docker

Las MCP Apps requieren transporte HTTP Transmisible y una URL públicamente accesible (para clientes alojados en la nube como Claude.ai). La configuración más simple usa Docker + túnel de Cloudflare:

1. Construir y ejecutar el contenedor Docker:

docker build -t mcp-zenml:apps .

docker run --rm -d --name mcp-zenml-apps -p 8001:8001 \
  -e ZENML_STORE_URL="https://your-zenml-server.example.com" \
  -e ZENML_STORE_API_KEY="your-api-key" \
  -e ZENML_ACTIVE_PROJECT_ID="your-project-id" \
  mcp-zenml:apps --transport streamable-http --host 0.0.0.0 --port 8001 \
  --disable-dns-rebinding-protection

2. Iniciar un túnel de Cloudflare (para clientes en la nube):

npx cloudflared tunnel --url http://localhost:8001

Esto imprime una URL pública como https://random-words.trycloudflare.com.

3. Conectar tu cliente:

En Claude Desktop u otros clientes, añade el servidor MCP con la URL: https://random-words.trycloudflare.com/mcp p.ej.:

{
	"servers": {
		"ZenML": {
			"url": "https://USE-YOUR-OWN-URL.trycloudflare.com/mcp",
			"type": "http"
		}
	},
	"inputs": []
}

Pide a la IA que "abra el panel de ejecuciones de pipeline" o "muestre el gráfico de actividad de ejecución"

Notas importantes:

ZENML_ACTIVE_PROJECT_ID es obligatorio — sin él, las herramientas de ejecución de pipeline fallarán con "No hay un proyecto establecido como activo"
El flag --disable-dns-rebinding-protection es necesario cuando se ejecuta detrás de proxies inversos (cloudflared, ngrok) — es seguro cuando el proxy maneja la seguridad
La URL del túnel cambia en cada reinicio — actualiza la integración de tu cliente en consecuencia

Pruebas y Aseguramiento de Calidad

Este proyecto incluye pruebas automatizadas para asegurar que el servidor MCP permanezca funcional:

🔄 Pruebas de Humo Automatizadas: Una prueba de humo integral se ejecuta cada 3 días a través de GitHub Actions
🚨 Creación de Issues: Las pruebas fallidas crean automáticamente issues de GitHub con información detallada de depuración
⚡ CI Rápido: Usa UV con caché para instalación rápida de dependencias y pruebas
🧪 Pruebas Manuales: Puedes ejecutar la prueba de humo localmente usando uv run scripts/test_mcp_server.py server/zenml_server.py

Las pruebas automatizadas verifican:

Conexión del protocolo MCP y handshake
Inicialización del servidor y descubrimiento de herramientas
Funcionalidad básica de herramientas (cuando el servidor ZenML es accesible)
Enumeración de recursos y prompts
diagnose_zenml_setup devuelve diagnósticos estructurados incluso en entornos restringidos

Depuración con MCP Inspector

Para depuración interactiva, usa el MCP Inspector — una herramienta basada en web que te permite probar herramientas MCP en tiempo real:

# Using .env.local (recommended for development)
cp .env.local.example .env.local  # Then edit with your credentials
source .env.local && npx @modelcontextprotocol/inspector \
  -e ZENML_STORE_URL=$ZENML_STORE_URL \
  -e ZENML_STORE_API_KEY=$ZENML_STORE_API_KEY \
  -- uv run server/zenml_server.py

Esto abre una interfaz web con tus credenciales pre-rellenadas — solo haz clic en Conectar y usa la pestaña Herramientas para probar cualquier herramienta de forma interactiva.

Consulta CLAUDE.md para instrucciones de depuración más detalladas.

Privacidad y Analíticas

El Servidor MCP de ZenML recopila analíticas de uso anónimas para ayudarnos a mejorar el producto.

Rastreamos:

Qué herramientas se usan y con qué frecuencia
Tasas y tipos de error (solo tipo de error, sin mensajes)
Información básica del entorno (SO, versión de Python, y si se ejecuta en Docker/CI)
Duración de la sesión y patrones de uso de herramientas

NO recopilamos:

Tu URL del servidor ZenML o clave API
Nombres de pipelines, nombres de modelos o cualquier dato de negocio
Mensajes de error o trazas de pila
Cualquier información personal identificable

Para deshabilitar las analíticas:

# Option 1
export ZENML_MCP_ANALYTICS_ENABLED=false

# Option 2
export ZENML_MCP_DISABLE_ANALYTICS=true

Para depuración/pruebas (registra eventos en stderr en lugar de enviar):

export ZENML_MCP_ANALYTICS_DEV=true

Para usuarios de Docker: Puedes establecer ZENML_MCP_ANALYTICS_ID (debe ser un UUID válido) para mantener un ID anónimo consistente entre reinicios del contenedor. Si no lo estableces y el sistema de archivos del contenedor no puede persistir el archivo de ID de analítica, el servidor recurre a un UUID anónimo determinista derivado de un hash de ZENML_STORE_URL (la URL en sí nunca se envía como propiedad de evento).

Opciones adicionales de analítica:

ZENML_MCP_ANALYTICS_SHUTDOWN_TIMEOUT_S — tiempo máximo (segundos) para vaciar la analítica sincrónicamente durante el apagado (predeterminado: 1.0)

Nota sobre el seguimiento de apagado: Los eventos de apagado se envían sincrónicamente con un tiempo de espera limitado para una mejor fiabilidad de entrega. Sin embargo, si un contenedor se mata con SIGKILL (por ejemplo, docker kill), los manejadores de apagado no pueden ejecutarse — esto es una limitación de Docker/SO, no un error.

Validación de Inicio

Puedes habilitar una verificación de diagnóstico ligera al inicio:

# Print warnings but start normally
uv run server/zenml_server.py --startup-validation warn

# Exit non-zero if required setup is missing (useful in Docker/CI)
uv run server/zenml_server.py --startup-validation strict

También puedes establecer esto mediante la variable de entorno: ZENML_MCP_STARTUP_VALIDATION=warn.

La herramienta diagnose_zenml_setup también está disponible como herramienta MCP para solución de problemas en tiempo de ejecución — funciona incluso cuando el SDK de ZenML no está instalado o faltan variables de entorno.

Configuración Manual

Prerrequisitos

Necesitarás tener acceso a un servidor ZenML desplegado. Si no tienes uno, puedes registrarte para una prueba gratuita en ZenML Pro y nosotros gestionaremos el despliegue por ti.

Consejo: Una vez que tengas un servidor ZenML, consulta la página de Configuración de MCP en tu panel para la experiencia de configuración más sencilla.

Compatibilidad: Este servidor MCP está probado y recomendado para ZenML >= 0.93.0. Si estás ejecutando una versión anterior de ZenML, por favor usa una versión anterior de este servidor MCP.

También necesitarás (probablemente) tener uv instalado localmente. Para más información, consulta la documentación de uv. Recomendamos la instalación a través de su script de instalación o mediante brew si usas Mac. (Técnicamente no lo necesitas, pero facilita la instalación y configuración.)

También necesitarás clonar este repositorio en algún lugar local:

git clone https://github.com/zenml-io/mcp-zenml.git

Tu archivo de configuración MCP

El archivo de configuración MCP es un archivo JSON que le dice al cliente MCP cómo conectarse a tu servidor MCP. Diferentes clientes MCP usarán o especificarán esto de manera diferente. Dos clientes MCP comúnmente usados son Claude Desktop y Cursor, para los cuales proporcionamos instrucciones de instalación a continuación.

Necesitarás especificar tu servidor ZenML MCP en el siguiente formato:

{
    "mcpServers": {
        "zenml": {
            "command": "/usr/local/bin/uv",
            "args": ["run", "path/to/server/zenml_server.py"],
            "env": {
                "LOGLEVEL": "WARNING",
                "NO_COLOR": "1",
                "ZENML_LOGGING_COLORS_DISABLED": "true",
                "ZENML_LOGGING_VERBOSITY": "WARN",
                "ZENML_ENABLE_RICH_TRACEBACK": "false",
                "PYTHONUNBUFFERED": "1",
                "PYTHONIOENCODING": "UTF-8",
                "ZENML_STORE_URL": "https://your-zenml-server-goes-here.com",
                "ZENML_STORE_API_KEY": "your-api-key-here"
            }
        }
    }
}

Hay cuatro valores ficticios que necesitarás reemplazar:

la ruta a tu uv instalado localmente (la ruta listada arriba es donde estaría en un Mac si lo instalaste mediante brew)
la ruta al archivo zenml_server.py (este es el archivo que se ejecutará cuando te conectes al servidor MCP). Este archivo se encuentra dentro de este repositorio en la raíz. Necesitarás especificar la ruta completa exacta a este archivo.
la URL del servidor ZenML (esta es la URL de tu servidor ZenML. Puedes encontrarla en la UI de ZenML Cloud). Se verá algo como https://d534d987a-zenml.cloudinfra.zenml.io.
la clave API del servidor ZenML (esta es la clave API para tu servidor ZenML. Puedes encontrarla en la UI de ZenML Cloud o leer estos documentos sobre cómo crear una. Para los propósitos del servidor ZenML MCP recomendamos usar una cuenta de servicio.)

Eres libre de cambiar la forma en que ejecutas el archivo Python del servidor MCP, pero usar uv probablemente será la opción más fácil ya que maneja el entorno y la instalación de dependencias por ti.

Instalación para usar con Claude Desktop

Alternativa rápida: Usa la página de Configuración de MCP en tu panel de ZenML (Configuración → MCP) para obtener instrucciones de instalación preconfiguradas y enlaces profundos para Claude Desktop.

Necesitarás tener instalada la última versión de Claude Desktop.

Simplemente puedes abrir el menú de Configuración y arrastrar el archivo mcp-zenml.mcpb desde la raíz de este repositorio al menú y te guiará a través del proceso de instalación y configuración. Necesitarás añadir tu URL del servidor ZenML y clave API.

Nota: Los paquetes MCP (.mcpb) reemplazan el formato anterior de Extensiones de Escritorio (.dxt); los archivos .dxt existentes aún funcionan en Claude Desktop.

Opcional: Mejorar la Visualización de Salida de Herramientas ZenML

Para una mejor experiencia con los resultados de las herramientas ZenML, puedes configurar Claude para que muestre las respuestas JSON en un formato más legible. En Claude Desktop, ve a Configuración → Perfil, y en la sección "¿Qué preferencias personales debería considerar Claude en las respuestas?", añade algo como lo siguiente (¡o usa estas palabras exactas!):

When using zenml tools which return JSON strings and you're asked a question, you might want to consider using markdown tables to summarize the results or make them easier to view!

Esto animará a Claude a formatear las salidas de las herramientas ZenML como tablas markdown, haciendo la información mucho más fácil de leer y entender.

Instalación para usar con Cursor

Alternativa rápida: La página de Configuración de MCP en tu panel de ZenML (Configuración → MCP) puede generar el contenido exacto de mcp.json con tus credenciales pre-llenadas.

Necesitarás tener instalado Cursor.

Cursor funciona de manera ligeramente diferente a Claude Desktop en el sentido de que especificas el archivo de configuración por repositorio. Esto significa que si quieres usar el servidor ZenML MCP en múltiples repositorios, necesitarás especificar el archivo de configuración en cada uno de ellos.

Para configurarlo para un solo repositorio, necesitarás:

crear una carpeta .cursor en la raíz de tu repositorio
dentro de ella, crear un archivo mcp.json con el contenido anterior
ir a la configuración de Cursor y hacer clic en el servidor ZenML para 'habilitarlo'.

En nuestra experiencia, a veces muestra un indicador de error rojo aunque esté funcionando. Puedes probarlo chateando en la ventana de chat de Cursor. Te hará saber si puede acceder a las herramientas ZenML o no.

Imagen Docker

Puedes ejecutar el servidor como un contenedor Docker. El proceso se comunica a través de stdio, por lo que esperará una conexión de cliente MCP. Pasa tus credenciales ZenML mediante variables de entorno.

Imágenes Preconstruidas (Docker Hub)

Descarga la última imagen multi-arquitectura:

docker pull zenmldocker/mcp-zenml:latest

Las versiones lanzadas se etiquetan como X.Y.Z:

docker pull zenmldocker/mcp-zenml:1.0.8

Ejecuta con tus credenciales ZenML (modo stdio):

docker run -i --rm \
  -e ZENML_STORE_URL="https://your-zenml-server.example.com" \
  -e ZENML_STORE_API_KEY="your-api-key" \
  zenmldocker/mcp-zenml:latest

Configuración MCP canónica usando Docker

{
  "mcpServers": {
    "zenml": {
      "command": "docker",
      "args": [
        "run", "-i", "--rm",
        "-e", "ZENML_STORE_URL=https://...",
        "-e", "ZENML_STORE_API_KEY=ZENKEY_...",
        "-e", "ZENML_ACTIVE_PROJECT_ID=...",
        "-e", "LOGLEVEL=WARNING",
        "-e", "NO_COLOR=1",
        "-e", "ZENML_LOGGING_COLORS_DISABLED=true",
        "-e", "ZENML_LOGGING_VERBOSITY=WARN",
        "-e", "ZENML_ENABLE_RICH_TRACEBACK=false",
        "-e", "PYTHONUNBUFFERED=1",
        "-e", "PYTHONIOENCODING=UTF-8",
        "zenmldocker/mcp-zenml:latest"
      ]
    }
  }
}

Construir Localmente

Desde la raíz del repositorio:

docker build -t zenmldocker/mcp-zenml:local .

Ejecuta la imagen construida localmente:

docker run -i --rm \
  -e ZENML_STORE_URL="https://your-zenml-server.example.com" \
  -e ZENML_STORE_API_KEY="your-api-key" \
  zenmldocker/mcp-zenml:local

Paquetes MCP (.mcpb)

Este proyecto utiliza Paquetes MCP (.mcpb) — el sucesor de las Extensiones de Escritorio (DXT) de Anthropic. Los Paquetes MCP empaquetan un servidor MCP completo (incluyendo dependencias) en un solo archivo con configuración amigable para el usuario.

Nota sobre el renombramiento: Los Paquetes MCP reemplazan el formato anterior .dxt. Claude Desktop sigue siendo retrocompatible con los archivos .dxt existentes, pero ahora distribuimos mcp-zenml.mcpb y recomendamos usarlo de ahora en adelante.

El archivo mcp-zenml.mcpb en la raíz del repositorio contiene todo lo necesario para ejecutar el servidor ZenML MCP, eliminando la necesidad de pasos de instalación manual complejos. Esto hace que las potentes integraciones de ZenML sean accesibles para usuarios sin requerir experiencia técnica en configuración.

Cuando arrastras y sueltas el archivo .mcpb en la configuración de Claude Desktop, maneja automáticamente:

Instalación de dependencias en tiempo de ejecución
Gestión segura de configuración
Compatibilidad multiplataforma
Proceso de configuración amigable para el usuario

Para más información, consulta el anuncio de Anthropic sobre Extensiones de Escritorio (DXT) y la guía de empaquetado de paquetes MCP relacionada en su documentación: https://www.anthropic.com/engineering/desktop-extensions

Publicado en el Registro MCP de Anthropic

Este servidor MCP está publicado en el Registro MCP oficial de Anthropic y es detectable por hosts compatibles. En cada lanzamiento etiquetado, nuestro CI actualiza la entrada del registro a través de la CLI mcp-publisher del registro usando GitHub OIDC, para que puedas instalar o descubrir el Servidor ZenML MCP directamente donde sea que el registro sea compatible (por ejemplo, el catálogo de Extensiones de Claude Desktop).

Siempre actualizado: la entrada del registro se actualiza con cada lanzamiento desde el manifest.json y server.json del commit etiquetado.
Rutas de instalación alternativas: aún puedes instalar localmente a través del paquete .mcpb empaquetado (ver arriba) o ejecutar la imagen Docker.

Aprende más sobre el registro aquí:

Registro MCP de Anthropic (repositorio comunitario): https://github.com/modelcontextprotocol/registry