ZenML MCP Server

offiziell

Interagieren Sie mit Ihren MLOps- und LLMOps-Pipelines über Ihren ZenML MCP-Server.

Dokumentation

MCP-Server für ZenML

Dieses Projekt implementiert einen Model Context Protocol (MCP)-Server für die Interaktion mit der ZenML-API.

ZenML MCP Server

Was ist MCP?

Das Model Context Protocol (MCP) ist ein offenes Protokoll, das standardisiert, wie Anwendungen Large Language Models (LLMs) Kontext bereitstellen. Es fungiert wie ein „USB-C-Anschluss für KI-Anwendungen“ – es bietet eine standardisierte Möglichkeit, KI-Modelle mit verschiedenen Datenquellen und Werkzeugen zu verbinden.

MCP folgt einer Client-Server-Architektur, bei der:

MCP-Hosts: Programme wie Claude Desktop oder IDEs, die über MCP auf Daten zugreifen möchten
MCP-Clients: Protokoll-Clients, die 1:1-Verbindungen mit Servern aufrechterhalten
MCP-Server: Leichtgewichtige Programme, die bestimmte Fähigkeiten über das standardisierte Protokoll bereitstellen
Lokale Datenquellen: Dateien, Datenbanken und Dienste Ihres Computers, auf die MCP-Server sicher zugreifen können
Remote-Dienste: Externe Systeme, die über das Internet verfügbar sind und mit denen sich MCP-Server verbinden können

Was ist ZenML?

ZenML ist eine Open-Source-Plattform zum Erstellen und Verwalten von ML- und KI-Pipelines. Sie bietet eine einheitliche Schnittstelle zur Verwaltung von Daten, Modellen und Experimenten.

Weitere Informationen finden Sie auf der ZenML-Website und in unserer Dokumentation.

Funktionen

Der Server stellt MCP-Tools für den Zugriff auf zentrale Lesefunktionen des ZenML- Servers bereit und bietet so eine Möglichkeit, Live-Informationen zu folgenden Themen zu erhalten:

Kernentitäten

Benutzer – Benutzerkonten und Berechtigungen
Stacks – Infrastrukturkonfigurationen
Stack-Komponenten – einzelne Stack-Bausteine
Flavors – verfügbare Komponententypen
Service Connectors – Cloud-Authentifizierung

Pipeline-Ausführung

Pipelines – Pipeline-Definitionen
Pipeline Runs – Ausführungsverlauf und -status
Pipeline Steps – Details zu einzelnen Schritten, Code und Protokolle
Zeitpläne – automatisierte Ausführungszeitpläne
Artefakte – Metadaten zu Datenartefakten (nicht die Daten selbst)

Bereitstellung & Serving

Snapshots – eingefrorene Pipeline-Konfigurationen (das „Was ausführen/bereitstellen“-Artefakt)
Deployments – Laufzeit-Serving-Instanzen mit Status, URL und Protokollen
Dienste – Modell-Serving-Endpunkte

Organisation & Auffindbarkeit

Projekte – organisatorische Container für ZenML-Ressourcen
Tags – übergreifende Metadaten-Labels zur Auffindbarkeit
Builds – Pipeline-Build-Artefakte mit Image- und Code-Informationen

Modelle

Modelle – Einträge in der ML-Modellregistrierung
Modellversionen – versionierte Modellartefakte

Veraltet (Migration empfohlen)

~~Pipeline Run Templates~~ → stattdessen Snapshots verwenden (siehe Migrationsleitfaden)

Der Server ermöglicht es Ihnen auch, neue Pipeline Runs auszulösen, indem Sie Snapshots (bevorzugt) oder Run Templates (veraltet) verwenden.

Hinweis: Wir verbessern diese Integration kontinuierlich auf der Grundlage von Benutzerfeedback. Treten Sie bitte unserer Slack-Community bei, um Ihre Erfahrungen zu teilen und uns zu helfen, sie noch besser zu machen!

Verfügbare Tools

Der MCP-Server stellt die folgenden Tools bereit, gruppiert nach Kategorie:

Pipeline-Ausführung (Neu in v1.2)

Tool	Beschreibung
`get_snapshot`	Eine eingefrorene Pipeline-Konfiguration nach Name/ID abrufen
`list_snapshots`	Snapshots mit Filtern auflisten (ausführbar, bereitstellbar, bereitgestellt, Tag)
`get_deployment`	Laufzeitstatus und URL eines Deployments abrufen
`list_deployments`	Deployments mit Filtern auflisten (Status, Pipeline, Tag)
`get_deployment_logs`	Begrenzte Protokolle eines Deployments abrufen (tail=100 Standard, max. 1000)
`trigger_pipeline`	Einen Pipeline Run auslösen (Parameter `snapshot_name_or_id` bevorzugen)

Organisation (Neu in v1.2)

Tool	Beschreibung
`get_active_project`	Das aktuell aktive Projekt abrufen
`get_project`	Projektdetails nach Name/ID abrufen
`list_projects`	Alle Projekte auflisten
`get_tag`	Tag-Details abrufen (exklusiv, Farben)
`list_tags`	Tags mit Filtern auflisten (resource_type)
`get_build`	Build-Details abrufen (Image, Code-Einbettung)
`list_builds`	Builds mit Filtern auflisten (is_local, contains_code)

Kernentitäten

Tool	Beschreibung
`get_user`, `list_users`, `get_active_user`	Benutzerverwaltung
`get_stack`, `list_stacks`	Stack-Konfigurationen
`get_stack_component`, `list_stack_components`	Stack-Komponenten
`get_flavor`, `list_flavors`	Komponenten-Flavors
`get_service_connector`, `list_service_connectors`	Cloud-Connectors
`get_pipeline_run`, `list_pipeline_runs`	Pipeline Runs
`get_run_step`, `list_run_steps`	Schritt-Details
`get_step_logs`, `get_step_code`	Schritt-Protokolle und Quellcode
`list_pipelines`, `get_pipeline_details`	Pipeline-Definitionen
`get_schedule`, `list_schedules`	Zeitpläne
`list_artifacts`	Artefakt-Metadaten
`list_secrets`	Geheime Namen (keine Werte)
`get_service`, `list_services`	Modell-Dienste
`get_model`, `list_models`	Modellregistrierung
`get_model_version`, `list_model_versions`	Modellversionen

Interaktive Apps (Experimentell)

Tool	Beschreibung
`open_pipeline_run_dashboard`	Interaktives Pipeline-Runs-Dashboard öffnen (MCP App)
`open_run_activity_chart`	30-Tage-Ausführungsaktivitäts-Balkendiagramm öffnen (MCP App)

Analyse-Tools

Tool	Beschreibung
`stack_components_analysis`	Stack-Komponentennutzung analysieren
`recent_runs_analysis`	Aktuelle Pipeline Runs analysieren
`most_recent_runs`	Die N aktuellsten Runs abrufen

Diagnose

Tool	Beschreibung
`diagnose_zenml_setup`	Server-Setup diagnostizieren (Umgebungsvariablen, SDK, Konnektivität, Authentifizierung). Funktioniert auch bei Fehlkonfiguration.

Veraltete Tools

Tool	Ersatz
`get_run_template`	Stattdessen `get_snapshot` verwenden
`list_run_templates`	Stattdessen `list_snapshots` verwenden
`trigger_pipeline(template_id=...)`	Stattdessen `trigger_pipeline(snapshot_name_or_id=...)` verwenden

Migration: Run Templates → Snapshots

Warum die Änderung? ZenML hat sein Konzept des „ausführbaren Pipeline-Artefakts“ weiterentwickelt. Run Templates sind jetzt veraltete Wrapper, die intern nur auf Snapshots verweisen. Neuer Code sollte Snapshots direkt verwenden.

Kurzanleitung zur Migration

Altes Muster (Templates)	Neues Muster (Snapshots)
`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=...)`

Beispiel-Workflow (Snapshot-First)

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)

Hinweis: get_deployment_logs gibt eine begrenzte Ausgabe zurück (Standard 100 Zeilen, max. 1000, begrenzt auf 100 KB) und erfordert die Installation der entsprechenden Deployer-Integration.

Schnelleinrichtung über das Dashboard (Empfohlen)

Der einfachste Weg, den ZenML MCP-Server einzurichten, ist über die MCP-Einstellungsseite Ihres ZenML-Dashboards.

MCP Settings Page

Navigieren Sie in Ihrem ZenML-Dashboard zu Einstellungen → MCP, um Folgendes zu erhalten:

Vorkonfigurierte Snippets für Ihre spezifische Server-URL und Anmeldeinformationen
Ein-Klick-Installation über Deeplinks für unterstützte IDEs
Kopier-Einfüge-Konfigurationen für VS Code, Claude Desktop, Cursor, Claude Code, OpenAI Codex und mehr
Docker- und uv-Optionen je nach Präferenz

ZenML Pro-Benutzer

Auf der MCP-Einstellungsseite können Sie mit einem einzigen Klick ein persönliches Zugriffstoken (PAT) generieren. Das Token wird automatisch in alle generierten Konfigurations-Snippets aufgenommen.

ZenML OSS-Benutzer

Erstellen Sie zunächst ein Dienstkonto-Token über Einstellungen → Dienstkonten
Fügen Sie das Token in die MCP-Einstellungsseite ein
Kopieren Sie die generierte Konfiguration für Ihre IDE

Bevorzugen Sie die manuelle Einrichtung? Siehe die detaillierten Anweisungen unten.

MCP Apps (Experimentell)

Was sind MCP Apps? MCP Apps sind interaktive HTML-Benutzeroberflächen, die MCP-Server direkt in KI-Clients bereitstellen können. Sie werden in Sandbox-iframes gerendert und können bidirektional Server-Tools aufrufen. Siehe die offizielle Ankündigung für vollständige Details.

Run Activity Chart

Dieser Server enthält zwei experimentelle MCP Apps:

App	Tool	Beschreibung
Pipeline Runs Dashboard	`open_pipeline_run_dashboard`	Interaktive Tabelle der letzten Pipeline Runs mit Status, Schritt-Details und Protokollen
Run Activity Chart	`open_run_activity_chart`	Balkendiagramm der Pipeline-Run-Aktivität der letzten 30 Tage mit Statusaufschlüsselung

Pipeline Runs Dashboard

Diese Apps sind als Proof-of-Concept-Beispiele enthalten. Wir freuen uns über Feedback und Beiträge für weitere MCP Apps. Es ist noch früh für diese neue Funktion, daher müssen wir abwarten, wie sie sich entwickelt. Wir gehen davon aus, sie in Zukunft umfassender zu unterstützen.

Unterstützte Clients

MCP Apps erfordern Streamable HTTP-Transport (nicht stdio). Die folgenden Clients unterstützen derzeit MCP Apps:

✅ VS Code (Insiders Edition)
✅ Goose
✅ ChatGPT (demnächst verfügbar)
⚠️ Claude Desktop – rendert Apps ab Ende Januar 2026 noch nicht.
⚠️ Claude.ai (Web) – rendert Apps ab Ende Januar 2026 noch nicht.

Hinweis: Wir konnten zum Zeitpunkt der Erstellung dieses Dokuments nicht gründlich mit Claude Desktop oder Claude.ai testen. Wenn Sie auf Probleme stoßen, melden Sie diese bitte hier.

Ausführen von MCP Apps mit Docker

MCP Apps erfordern Streamable HTTP-Transport und eine öffentlich erreichbare URL (für cloud-gehostete Clients wie Claude.ai). Das einfachste Setup verwendet Docker + Cloudflare-Tunnel:

1. Docker-Container erstellen und ausführen:

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. Cloudflare-Tunnel starten (für Cloud-Clients):

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

Dies gibt eine öffentliche URL wie https://random-words.trycloudflare.com aus.

3. Client verbinden:

Fügen Sie in Claude Desktop oder anderen Clients den MCP-Server mit URL hinzu: https://random-words.trycloudflare.com/mcp z. B.:

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

Bitten Sie die KI, „das Pipeline Runs Dashboard zu öffnen“ oder „das Run Activity Chart anzuzeigen“

Wichtige Hinweise:

ZENML_ACTIVE_PROJECT_ID ist erforderlich – ohne sie schlagen Pipeline-Run-Tools mit „Kein Projekt ist derzeit als aktiv festgelegt“ fehl
Das Flag --disable-dns-rebinding-protection wird benötigt, wenn der Server hinter Reverse-Proxys (cloudflared, ngrok) ausgeführt wird – es ist sicher, wenn der Proxy die Sicherheit übernimmt
Die Tunnel-URL ändert sich bei jedem Neustart – aktualisieren Sie Ihre Client-Integration entsprechend

Testen & Qualitätssicherung

Dieses Projekt umfasst automatisierte Tests, um sicherzustellen, dass der MCP-Server funktionsfähig bleibt:

🔄 Automatisierte Smoke-Tests: Ein umfassender Smoke-Test wird alle 3 Tage über GitHub Actions ausgeführt
🚨 Issue-Erstellung: Fehlgeschlagene Tests erstellen automatisch GitHub-Issues mit detaillierten Debugging-Informationen
⚡ Schnelle CI: Verwendet UV mit Caching für schnelle Abhängigkeitsinstallation und Tests
🧪 Manuelles Testen: Sie können den Smoke-Test lokal mit uv run scripts/test_mcp_server.py server/zenml_server.py ausführen

Die automatisierten Tests überprüfen:

MCP-Protokollverbindung und Handshake
Server-Initialisierung und Tool-Erkennung
Grundlegende Tool-Funktionalität (wenn der ZenML-Server erreichbar ist)
Ressourcen- und Prompt-Enumeration
diagnose_zenml_setup liefert strukturierte Diagnosen auch in eingeschränkten Umgebungen

Debugging mit MCP Inspector

Verwenden Sie für interaktives Debugging den MCP Inspector – ein webbasiertes Tool, mit dem Sie MCP-Tools in Echtzeit testen können:

# 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

Dies öffnet eine Web-Benutzeroberfläche mit Ihren vorausgefüllten Anmeldeinformationen – klicken Sie einfach auf Verbinden und verwenden Sie die Registerkarte Tools, um jedes Tool interaktiv zu testen.

Siehe CLAUDE.md für detailliertere Debugging-Anweisungen.

Datenschutz & Analyse

Der ZenML MCP-Server sammelt anonyme Nutzungsanalysen, um uns bei der Verbesserung des Produkts zu helfen.

Wir verfolgen:

Welche Tools verwendet werden und wie oft
Fehlerraten und -typen (nur Fehlertyp, keine Meldungen)
Grundlegende Umgebungsinformationen (Betriebssystem, Python-Version und ob in Docker/CI ausgeführt)
Sitzungsdauer und Tool-Nutzungsmuster

Wir sammeln NICHT:

Ihre ZenML-Server-URL oder Ihren API-Schlüssel
Pipeline-Namen, Modellnamen oder jegliche Geschäftsdaten
Fehlermeldungen oder Stack-Traces
Personenbezogene Daten

So deaktivieren Sie die Analyse:

# Option 1
export ZENML_MCP_ANALYTICS_ENABLED=false

# Option 2
export ZENML_MCP_DISABLE_ANALYTICS=true

Zum Debuggen/Testen (protokolliert Ereignisse auf stderr, anstatt sie zu senden):

export ZENML_MCP_ANALYTICS_DEV=true

Für Docker-Benutzer: Sie können ZENML_MCP_ANALYTICS_ID setzen (muss eine gültige UUID sein), um eine konsistente anonyme ID über Container-Neustarts hinweg beizubehalten. Wenn Sie sie nicht setzen und das Container-Dateisystem die Analytics-ID-Datei nicht persistent speichern kann, greift der Server auf eine deterministische anonyme UUID zurück, die von einem Hash von ZENML_STORE_URL abgeleitet wird (die URL selbst wird niemals als Ereigniseigenschaft gesendet).

Zusätzliche Analytics-Optionen:

ZENML_MCP_ANALYTICS_SHUTDOWN_TIMEOUT_S — maximale Zeit (Sekunden), um Analytics beim Herunterfahren synchron zu flushen (Standard: 1.0)

Hinweis zum Shutdown-Tracking: Shutdown-Ereignisse werden synchron mit einem begrenzten Timeout gesendet, um eine bestmögliche Zustellzuverlässigkeit zu gewährleisten. Wenn ein Container jedoch mit SIGKILL beendet wird (z. B. docker kill), können Shutdown-Handler nicht ausgelöst werden – dies ist eine Docker/OS-Einschränkung, kein Fehler.

Startup-Validierung

Sie können eine leichtgewichtige Startup-Diagnoseprüfung aktivieren:

# 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

Sie können dies auch über die Umgebungsvariable setzen: ZENML_MCP_STARTUP_VALIDATION=warn.

Das diagnose_zenml_setup-Tool ist auch als MCP-Tool für die Laufzeit-Fehlerbehebung verfügbar – es funktioniert sogar, wenn das ZenML SDK nicht installiert ist oder Umgebungsvariablen fehlen.

Manuelle Einrichtung

Voraussetzungen

Sie benötigen Zugriff auf einen bereitgestellten ZenML-Server. Falls Sie keinen haben, können Sie sich für eine kostenlose Testversion bei ZenML Pro anmelden, und wir übernehmen die Bereitstellung für Sie.

Tipp: Sobald Sie einen ZenML-Server haben, besuchen Sie die MCP-Einstellungsseite in Ihrem Dashboard für die einfachste Einrichtung.

Kompatibilität: Dieser MCP-Server wurde mit ZenML >= 0.93.0 getestet und wird dafür empfohlen. Wenn Sie eine ältere ZenML-Version verwenden, nutzen Sie bitte einen früheren Release dieses MCP-Servers.

Sie benötigen (wahrscheinlich) auch eine lokale Installation von uv. Weitere Informationen finden Sie in der uv-Dokumentation. Wir empfehlen die Installation über deren Installationsskript oder über brew, wenn Sie einen Mac verwenden. (Technisch gesehen brauchen Sie es nicht, aber es erleichtert die Installation und Einrichtung.)

Sie müssen dieses Repository auch lokal klonen:

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

Ihre MCP-Konfigurationsdatei

Die MCP-Konfigurationsdatei ist eine JSON-Datei, die dem MCP-Client mitteilt, wie er sich mit Ihrem MCP-Server verbinden soll. Verschiedene MCP-Clients verwenden oder spezifizieren dies unterschiedlich. Zwei häufig verwendete MCP-Clients sind Claude Desktop und Cursor, für die wir unten Installationsanweisungen bereitstellen.

Sie müssen Ihren ZenML MCP-Server im folgenden Format angeben:

{
    "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"
            }
        }
    }
}

Es gibt vier Platzhalterwerte, die Sie ersetzen müssen:

den Pfad zu Ihrer lokal installierten uv (der oben aufgeführte Pfad ist der, an dem sie sich auf einem Mac befinden würde, wenn Sie sie über brew installiert haben)
den Pfad zur zenml_server.py-Datei (dies ist die Datei, die ausgeführt wird, wenn Sie sich mit dem MCP-Server verbinden). Diese Datei befindet sich im Stammverzeichnis dieses Repositorys. Sie müssen den genauen vollständigen Pfad zu dieser Datei angeben.
die ZenML-Server-URL (dies ist die URL Ihres ZenML-Servers. Sie finden diese in der ZenML Cloud-Benutzeroberfläche). Sie sieht etwa so aus: https://d534d987a-zenml.cloudinfra.zenml.io.
den ZenML-Server-API-Schlüssel (dies ist der API-Schlüssel für Ihren ZenML-Server. Sie finden diesen in der ZenML Cloud-Benutzeroberfläche oder lesen Sie diese Dokumentation zur Erstellung eines solchen. Für die Zwecke des ZenML MCP-Servers empfehlen wir die Verwendung eines Dienstkontos.)

Es steht Ihnen frei, die Art und Weise zu ändern, wie Sie die Python-Datei des MCP-Servers ausführen, aber die Verwendung von uv ist wahrscheinlich die einfachste Option, da sie die Umgebung und die Abhängigkeitsinstallation für Sie übernimmt.

Installation zur Verwendung mit Claude Desktop

Schnelle Alternative: Verwenden Sie die MCP-Einstellungsseite in Ihrem ZenML-Dashboard (Einstellungen → MCP), um vorkonfigurierte Installationsanweisungen und Deeplinks für Claude Desktop zu erhalten.

Sie müssen die neueste Version von Claude Desktop installiert haben.

Sie können einfach das Einstellungsmenü öffnen und die mcp-zenml.mcpb-Datei aus dem Stammverzeichnis dieses Repositorys auf das Menü ziehen, und es führt Sie durch den Installations- und Einrichtungsprozess. Sie müssen Ihre ZenML-Server-URL und den API-Schlüssel hinzufügen.

Hinweis: MCP-Bundles (.mcpb) ersetzen das ältere Desktop Extensions (.dxt)-Format; vorhandene .dxt-Dateien funktionieren weiterhin in Claude Desktop.

Optional: Verbesserung der Anzeige von ZenML-Tool-Ausgaben

Für eine bessere Erfahrung mit ZenML-Tool-Ergebnissen können Sie Claude so konfigurieren, dass die JSON-Antworten in einem besser lesbaren Format angezeigt werden. Gehen Sie in Claude Desktop zu Einstellungen → Profil und fügen Sie im Abschnitt "Welche persönlichen Präferenzen sollte Claude bei Antworten berücksichtigen?" etwas wie das Folgende hinzu (oder verwenden Sie genau diese Worte!):

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!

Dies ermutigt Claude, ZenML-Tool-Ausgaben als Markdown-Tabellen zu formatieren, wodurch die Informationen viel einfacher zu lesen und zu verstehen sind.

Installation zur Verwendung mit Cursor

Schnelle Alternative: Die MCP-Einstellungsseite in Ihrem ZenML-Dashboard (Einstellungen → MCP) kann den genauen mcp.json-Inhalt mit Ihren vorausgefüllten Anmeldeinformationen generieren.

Sie müssen Cursor installiert haben.

Cursor funktioniert etwas anders als Claude Desktop, da Sie die Konfigurationsdatei pro Repository angeben. Das bedeutet, wenn Sie den ZenML MCP-Server in mehreren Repos verwenden möchten, müssen Sie die Konfigurationsdatei in jedem davon angeben.

Um es für ein einzelnes Repository einzurichten, müssen Sie:

einen .cursor-Ordner im Stammverzeichnis Ihres Repositorys erstellen
darin eine mcp.json-Datei mit dem obigen Inhalt erstellen
in Ihre Cursor-Einstellungen gehen und auf den ZenML-Server klicken, um ihn zu 'aktivieren'.

Unserer Erfahrung nach zeigt es manchmal eine rote Fehleranzeige, obwohl es funktioniert. Sie können es ausprobieren, indem Sie im Cursor-Chatfenster chatten. Es wird Ihnen mitteilen, ob es auf die ZenML-Tools zugreifen kann oder nicht.

Docker-Image

Sie können den Server als Docker-Container ausführen. Der Prozess kommuniziert über stdio und wartet daher auf eine MCP-Client-Verbindung. Übergeben Sie Ihre ZenML-Anmeldeinformationen über Umgebungsvariablen.

Vorgefertigte Images (Docker Hub)

Laden Sie das neueste Multi-Arch-Image herunter:

docker pull zenmldocker/mcp-zenml:latest

Versionierte Releases werden als X.Y.Z getaggt:

docker pull zenmldocker/mcp-zenml:1.0.8

Führen Sie es mit Ihren ZenML-Anmeldeinformationen aus (stdio-Modus):

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

Kanonische MCP-Konfiguration mit 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"
      ]
    }
  }
}

Lokal bauen

Vom Repository-Stammverzeichnis aus:

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

Führen Sie das lokal gebaute Image aus:

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

MCP-Bundles (.mcpb)

Dieses Projekt verwendet MCP-Bundles (.mcpb) – den Nachfolger von Anthropics Desktop Extensions (DXT). MCP-Bundles packen einen gesamten MCP-Server (einschließlich Abhängigkeiten) in eine einzige Datei mit benutzerfreundlicher Konfiguration.

Hinweis zur Umbenennung: MCP-Bundles ersetzen das ältere .dxt-Format. Claude Desktop bleibt abwärtskompatibel mit vorhandenen .dxt-Dateien, aber wir liefern jetzt mcp-zenml.mcpb aus und empfehlen die zukünftige Verwendung.

Die mcp-zenml.mcpb-Datei im Repository-Stammverzeichnis enthält alles, was zum Ausführen des ZenML MCP-Servers benötigt wird, und macht komplexe manuelle Installationsschritte überflüssig. Dies macht leistungsstarke ZenML-Integrationen für Benutzer ohne technisches Setup-Fachwissen zugänglich.

Wenn Sie die .mcpb-Datei per Drag & Drop in die Einstellungen von Claude Desktop ziehen, übernimmt sie automatisch:

Installation von Laufzeitabhängigkeiten
Sicheres Konfigurationsmanagement
Plattformübergreifende Kompatibilität
Benutzerfreundlichen Einrichtungsprozess

Weitere Informationen finden Sie in Anthropics Ankündigung zu Desktop Extensions (DXT) und der zugehörigen MCP-Bundle-Packaging-Anleitung in deren Dokumentation: https://www.anthropic.com/engineering/desktop-extensions

Veröffentlicht in der Anthropic MCP-Registry

Dieser MCP-Server ist in der offiziellen Anthropic MCP-Registry veröffentlicht und für kompatible Hosts auffindbar. Bei jedem getaggten Release aktualisiert unsere CI den Registry-Eintrag über die mcp-publisher CLI der Registry unter Verwendung von GitHub OIDC, sodass Sie den ZenML MCP Server direkt überall dort installieren oder entdecken können, wo die Registry unterstützt wird (z. B. im Erweiterungskatalog von Claude Desktop).

Immer aktuell: Der Registry-Eintrag wird bei jedem Release aus den manifest.json und server.json des getaggten Commits aktualisiert.
Alternative Installationspfade: Sie können weiterhin lokal über das gepackte .mcpb-Bundle installieren (siehe oben) oder das Docker-Image ausführen.

Erfahren Sie hier mehr über die Registry:

Anthropic MCP Registry (Community-Repo): https://github.com/modelcontextprotocol/registry