LABSCO SUMMARY

Live answers about your ML pipelines, from ZenML itself.

It is mostly read: what ran, what failed, which stack it ran on, what is serving right now and what those deployments are logging. The one action it offers is triggering a pipeline from an existing snapshot, so a rerun does not need the original code in front of you.

What it is

ZenML's own MCP server over the ZenML API: live read access to pipelines, runs, steps, stacks, artifacts and deployments, plus triggering a pipeline from a snapshot.

What you get

Deployments listed, with status, URL and logs for any one of them
Snapshots — the frozen pipeline configurations — listed and read
A pipeline triggered from an existing snapshot
The active project reported, so calls land where you think they do
Read access to the core entities: users, stacks, stack components, flavors, service connectors
Pipeline runs, steps, step code, logs and schedules
Artifact metadata — the metadata, not the data — plus tags, builds and services

Requirements

A running ZenML server to point it at, and credentials for that server's API.

Setup effort

One command plus a key — docker pull zenmldocker/mcp-zenml:latest, then supply credentials

See installation options

USE CASES

01

Finding out why a deployment is unhealthy

List what is deployed, read that one's status and URL, then pull its logs — three calls instead of a dashboard tour.

list_deploymentsget_deploymentget_deployment_logs

02

Rerunning a pipeline someone else configured

Find the snapshot, read what it pins, then trigger it — the configuration is already frozen in the snapshot.

list_snapshotsget_snapshottrigger_pipeline

03

Checking what is currently serving

The deployment list with each one's status and URL answers 'is the model up' without opening the console.

list_deploymentsget_deployment

04

Making sure you are looking at the right project

Read the active project before acting, so a trigger does not land in someone else's workspace.

get_active_project

05

Reading the frozen configuration behind a run

The snapshot holds what was going to run — useful when the code has moved on since.

get_snapshot

50 tools

Listed in project docs. Your client may show a different list.

get_snapshot

list_snapshots

get_deployment

list_deployments

get_deployment_logs

trigger_pipeline

get_active_project

get_project

list_projects

get_tag

list_tags

get_build

list_builds

get_user

list_users

BEFORE YOU INSTALL

What to know first

Tools you get

50 tools named in the project's documentation.

Requires

docker on PATH (or uv and a clone of the repository)
A deployed ZenML server (ZenML >= 0.93.0): its URL as ZENML_STORE_URL and an API key as ZENML_STORE_API_KEY
ZENML_ACTIVE_PROJECT_ID for the pipeline run tools

INSTALLATION

Connect your client

Server setup

TERMINAL

docker pull zenmldocker/mcp-zenml:latest

MCP Clients

Any MCP client — Docker

ANY MCP CLIENT — DOCKER · JSON

{
  "mcpServers": {
    "zenml": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-e",
        "ZENML_STORE_URL=<YOUR_ZENML_STORE_URL>",
        "-e",
        "ZENML_STORE_API_KEY=<YOUR_ZENML_STORE_API_KEY>",
        "-e",
        "ZENML_ACTIVE_PROJECT_ID=<YOUR_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"
      ]
    }
  }
}

ZENML_STORE_URL is your ZenML server's URL, <YOUR_ZENML_STORE_API_KEY> is an API key for that server (ZenML recommends a service account), and ZENML_ACTIVE_PROJECT_ID is your project ID — without it the pipeline run tools fail. The dashboard's Settings → MCP page generates this snippet with your values filled in.

Any MCP client — uv

ANY MCP CLIENT — UV · TERMINAL

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

ANY MCP CLIENT — UV · JSON

{
  "mcpServers": {
    "zenml": {
      "command": "/usr/local/bin/uv",
      "args": [
        "run",
        "<YOUR_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": "<YOUR_ZENML_STORE_URL>",
        "ZENML_STORE_API_KEY": "<YOUR_ZENML_STORE_API_KEY>"
      }
    }
  }
}

command is the full path of your uv binary; which uv prints it. <YOUR_PATH_TO_SERVER> is the full path of the server folder inside your mcp-zenml clone, <YOUR_ZENML_STORE_URL> is your ZenML server's URL, and <YOUR_ZENML_STORE_API_KEY> an API key for that server. Also add ZENML_ACTIVE_PROJECT_ID with your project ID to env — without it the pipeline run tools fail. Cursor reads this block from .cursor/mcp.json in each repository.

ZenML