ZenML

MCP-Server für ZenML

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

Was ist MCP?

Das Model Context Protocol (MCP) ist ein offenes Protokoll, das standardisiert, wie Anwendungen Large Language Models (LLMs) Kontext bereitstellen. Es funktioniert wie ein „USB-C-Anschluss für KI-Anwendungen" – es bietet eine standardisierte Möglichkeit, KI-Modelle mit verschiedenen Datenquellen und Tools 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 über das standardisierte Protokoll spezifische Fähigkeiten bereitstellen
• Lokale Datenquellen: Dateien, Datenbanken und Dienste auf Ihrem Computer, auf die MCP-Server sicher zugreifen können
• Remote-Dienste: Externe Systeme, die über das Internet erreichbar 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. Es bietet eine einheitliche Oberfläche 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 die grundlegenden Lesefunktionen des ZenML-Servers bereit und ermöglicht so den Zugriff auf Live-Informationen zu:

Kerneinheiten

• 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-Läufe – Ausführungsverlauf und -status
• Pipeline-Schritte – Details, Code und Protokolle einzelner Schritte
• Zeitpläne – automatisierte Ausführungszeitpläne
• Artefakte – Metadaten zu Datenartefakten (nicht die Daten selbst)

Bereitstellung und Serving

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

Organisation und Auffindbarkeit

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

Modelle

• Modelle – Einträge im ML-Modellregister
• Modellversionen – versionierte Modell-Artefakte

Kompatibilitäts-APIs (Migration empfohlen)

• Pipeline-Run-Templates bleiben in ZenML 0.97.0 verfügbar, während Snapshots für neue Workflows bevorzugt werden (siehe Migrationsleitfaden)

Der Server ermöglicht außerdem das Auslösen neuer Pipeline-Läufe mithilfe von Snapshots (bevorzugt) oder dem veralteten template-basierten Trigger-Parameter.

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

Tool-Profile und Schreibrichtlinie

Das Standardprofil compact bewirbt 16 Tools. Sieben generische Tools decken den Ressourcenkatalog, Lesezugriffe, gewöhnliche Mutationen und begrenzte Lebenszyklus-Aktionen ab:

Tool	Zweck
zenml_describe_resources	Unterstützte Ressourcentypen und begrenzte Operationsschemata ermitteln
zenml_list_resources	Einen Ressourcentyp mit validierten Filtern und Paginierung auflisten
zenml_get_resource	Eine Ressource abrufen, bei Bedarf mit übergeordnetem und Projektbereich
zenml_create_resource	Eine unterstützte Ressource aus einer typisierten Nutzlast erstellen
zenml_update_resource	Eine exakte Ressourcen-UUID aktualisieren
zenml_delete_resource	Eine exakte Ressourcen-UUID löschen oder archivieren
zenml_action_resource	Eine auf der Whitelist stehende Lebenszyklus- oder Beziehungsaktion ohne Wiederholungen ausführen

Neun fokussierte Tools bleiben erhalten, da sie Diagnosen, aktiven Kontext, gestreamte Protokolle oder Code, Pipeline-Ausführung oder eine interaktive App bereitstellen:

• diagnose_zenml_setup
• get_active_user und get_active_project
• trigger_pipeline
• get_step_logs, get_step_code und get_deployment_logs
• open_pipeline_run_dashboard und open_run_activity_chart

get_step_logs gibt höchstens 50.000 Einträge zurück, älteste zuerst, mit einem possibly_truncated-Flag sowie einer note-Angabe, welche Einträge fehlen und warum. Übergeben Sie tail, um nur die neuesten Einträge zu erhalten. Auf ZenML-0.97+-Servern paginieren Sie durch den Protokollspeicher; auf 0.96 wird der ältere Einzelanfrage-Endpunkt verwendet.

Verwenden Sie ZENML_MCP_PROFILE=legacy, wenn ein bestehender Client weiterhin von den alten entitätsspezifischen Namen wie list_pipeline_runs abhängt. Dadurch bleibt die charakterisierte Tool-Namen- und Schema-Kompatibilitätsschicht für ZenML 0.97.0 erhalten. Es fügt keine Unterstützung für ältere ZenML-Serverversionen hinzu. Verwenden Sie es nur während der Migration: Legacy-Antwortformen können mehr operative Metadaten offenlegen als die kompakten Tools, obwohl der Server in beiden Profilen credential-tragende Konfiguration und andere sensible Felder weglässt.

Registrierung und Schreibzugriff sind unabhängig:

Profil	Richtlinie	Beworbene Tools
compact	read_write	16
compact	read_only	11
legacy	read_write	57
legacy	read_only	52

Setzen Sie ZENML_MCP_WRITE_POLICY=read_only, um alle vier generischen Mutations-Tools zu entfernen und trigger_pipeline aus der MCP-Erkennung und -Verteilung. Die Ressourcenerkennung lässt auch Create-, Update-, Delete- und Aktionsschemata aus. Die ältere ZENML_MCP_READ_ONLY=true-Einstellung bleibt akzeptiert; ungültige Richtlinienwerte schlagen im geschlossenen Zustand in den Nur-Lese-Modus um. Eine ungültige ZENML_MCP_PROFILE stoppt den Start mit einem Konfigurationsfehler.

Version 2.0.0 erfordert MCP Python SDK 2.2.0 und ZenML 0.96.4. Das kompakte Profil ist die neue Standardeinstellung und eine bahnbrechende Erkennungsänderung für Clients, die entitätsspezifische Tool-Namen aufrufen. Setzen Sie ZENML_MCP_PROFILE=legacy während der Migration dieser Clients und verschieben Sie dann jeden Aufruf auf die generischen Ressourcen-Tools.

Mutationsergebnisse unterscheiden completed, accepted und unknown-Ergebnisse. Der Server wiederholt eine Mutation nicht, nachdem sie ZenML möglicherweise erreicht hat. Für ein akzeptiertes oder unbekanntes Ergebnis befolgen Sie die Abgleichsanweisungen in der Antwort, bevor Sie entscheiden, ob Sie erneut aufrufen möchten. Verwenden Sie den benannten Lesezugriff, wenn einer verfügbar ist. Die Webhook-Erstellung und die Rotierung von Geheimnissen können ein neues Signing-Secret zurückgeben; spätere Lesezugriffe lassen es aus. Löschschemata geben an, ob eine Operation Metadaten archiviert, Metadaten entfernt, eine Live-Ressource außer Betrieb nimmt oder gespeicherte Artefaktdaten löschen kann.

Die erste 2.0-Version deckt gewöhnliche Operationen für Projekte, Stacks und Komponenten, Flavors, Dienste, Pipelines und Läufe, Snapshots und Templates, Bereitstellungen, Artefakte und Versionen, Modelle und Versionen, Tags, Connectors, Code-Repositorys, Webhooks, Trigger, Wartebedingungen und Hook-Aufrufe ab. Benutzer, Zeitpläne, Service-Connector-Typen, Geheimnisse und Ressourcenanfragen haben die Nur-Lese-Abdeckung, die durch zenml_describe_resources angezeigt wird. Es schließt die ZenML-Cloud-Control-Plane-Verwaltung, die Resource-Manager-Verwaltung, die Benutzer- und Anmeldedatenverwaltung, die CRUD-Operationen für Geheimniswerte, die Connector-Anmeldung und -Verifizierung, rohe Webhook-Ereignisse sowie aggregierte Debugging- oder Lineage-Tools aus.

Starten Sie einen generischen Workflow, indem Sie das genaue Schema ermitteln und es dann aufrufen:

zenml_describe_resources(resource_type="pipeline_run", operation="list")
zenml_list_resources(
    resource_type="pipeline_run",
    filters={"status": "completed", "sort_by": "desc:created"},
    page=1,
    size=10,
)

Prompts und Ressourcen bleiben in beiden Profilen verfügbar. Die Analyse-Prompts, die begrenzten Ressourcen-Schema-Endpunkte und most_recent_runs sind MCP-Prompts oder -Ressourcen und keine Tools.

Run-Template-Kompatibilität

ZenML 0.97.0 behält die CRUD-APIs für Run-Templates bei. Snapshots werden für neue Workflows bevorzugt. Die komfortable Pipeline-Erstellung und der template-basierte Trigger- Parameter sind veraltet. Im Legacy-Profil bleiben get_run_template und list_run_templates für bestehende Clients verfügbar.

Die Legacy-Eingabe tag bleibt in list_run_templates aus Schema-Kompatibilitätsgründen erhalten, aber ZenML 0.97.0 hat keinen entsprechenden serverseitigen Filter. Ein Nicht-Null-Wert wird vor dem SDK-Aufruf abgelehnt. Die Snapshot-Tag-Filterung bleibt verfügbar.

Migration: Run-Templates → Snapshots

Warum die Änderung? Snapshots ersetzten Run-Templates als ZenMLs bevorzugtes ausführbares Pipeline-Artefakt. Das 0.97.0-SDK unterstützt weiterhin die CRUD-Operationen für Run-Templates, während neuer Code Snapshots verwenden sollte.

Kurzanleitung zur Migration

Legacy-Muster (Templates)	Kompaktes Muster (Snapshots)
list_run_templates()	zenml_list_resources(resource_type="snapshot", filters={"runnable": true, "named_only": true})
get_run_template(name)	zenml_get_resource(resource_type="snapshot", resource_id=id)
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:
   → zenml_list_resources(resource_type="snapshot", filters={"runnable": true, "named_only": true})

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

4. Check deployments:
   → zenml_list_resources(resource_type="deployment", filters={"status": "running"})
   → get_deployment_logs(name_id_or_prefix="my-deployment", tail=100)

Hinweis: get_deployment_logs gibt begrenzte Ausgaben zurück (Standard 100 Zeilen, maximal 1000, begrenzt auf 100 KB) und erfordert, dass die entsprechende Deployer-Integration installiert ist.

Schnelle Einrichtung über das Dashboard (empfohlen)

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

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

• Vorkonfigurierte Snippets für Ihre spezifische Server-URL und Anmeldedaten
• Ein-Klick-Installation über Deep Links für unterstützte IDEs
• Copy-Paste-Konfigurationen für VS Code, Claude Desktop, Cursor, Claude Code, OpenAI Codex und mehr
• Docker- und uv-Optionen basierend auf Ihrer Präferenz

ZenML-Pro-Benutzer

Über die MCP-Einstellungsseite können Sie mit einem Klick ein Personal Access Token (PAT) generieren. Das Token wird automatisch in alle generierten Konfigurations-Snippets aufgenommen.

ZenML-OSS-Benutzer

1. Erstellen Sie zuerst ein Service-Account-Token über Einstellungen → Service-Accounts
2. Fügen Sie das Token in die MCP-Einstellungsseite ein
3. Kopieren Sie die generierte Konfiguration für Ihre IDE

---

Bevorzugen Sie die manuelle Einrichtung? Detaillierte Anweisungen finden Sie unten.

MCP-Apps (experimentell)

Was sind MCP-Apps? MCP-Apps sind interaktive HTML-Benutzeroberflächen, die MCP-Server direkt in KI-Clients ausliefern 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.

Dieser Server enthält zwei experimentelle MCP-Apps:

App	Tool	Beschreibung
Pipeline-Runs-Dashboard	open_pipeline_run_dashboard	Interaktive Tabelle der letzten Pipeline-Läufe mit Status, Schrittdetails und Protokollen
Run-Aktivitätsdiagramm	open_run_activity_chart	Balkendiagramm der Pipeline-Run-Aktivität der letzten 30 Tage mit Statusaufschlüsselung

Diese Apps sind als Proof-of-Concept-Beispiele enthalten. Wir freuen uns über Feedback und Beiträge für weitere MCP-Apps. Für dieses neue Feature ist es noch früh, daher müssen wir abwarten, wie es sich entwickelt. Wir erwarten, es 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 (Start in Kürze)
• ⚠️ Claude Desktop – rendert Stand Ende Januar 2026 noch keine Apps.
• ⚠️ Claude.ai (Web) – rendert Stand Ende Januar 2026 noch keine Apps.

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

Ausführen von MCP-Apps mit Docker

MCP-Apps verwenden Streamable HTTP. Binden Sie den Container-Port an Loopback und setzen Sie einen authentifizierten Reverse-Proxy oder einen identitätsbewussten Zugriffsdienst davor, bevor Sie Remote-Zugriff zulassen. Host- und Origin-Validierung schützen vor DNS-Rebinding; sie authentifizieren keine Aufrufer.

1. Docker-Container erstellen und ausführen:

docker build -t mcp-zenml:apps .

docker run --rm -d --name mcp-zenml-apps -p 127.0.0.1:8001:8001 \
  -e ZENML_STORE_URL="https://your-zenml-server.example.com" \
  -e ZENML_STORE_API_KEY="your-api-key" \
  -e ZENML_MCP_PROFILE="compact" \
  -e ZENML_MCP_WRITE_POLICY="read_write" \
  -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. Authentifizierten Remote-Zugriff konfigurieren: Erstellen Sie einen benannten Cloudflare-Tunnel, Tailscale Funnel mit Zugriffskontrollen oder einen gleichwertigen authentifizierten Reverse-Proxy. Richten Sie seinen privaten Ursprung auf http://127.0.0.1:8001 aus, verlangen Sie eine Identitäts- oder Dienstberechtigung für den öffentlichen Hostnamen und leiten Sie nur authentifizierte Anfragen an den Ursprung weiter. Konfigurieren Sie Ihren MCP-Client so, dass er den vom Anbieter unterstützten OAuth-Flow oder Autorisierungs-Header verwendet.

Bevor Sie ZenML-Anmeldeinformationen zum Container hinzufügen, vergewissern Sie sich, dass eine nicht authentifizierte Anfrage MCP nicht erreichen kann:

curl -i https://mcp.example.com/mcp

Die Antwort muss die 401, 403 oder die Login-Weiterleitung des Zugriffsanbieters sein. Eine JSON-RPC- oder MCP-Antwort bedeutet, dass der Perimeter offen ist und zuerst behoben werden muss.

3. Verbinden Sie Ihren authentifizierten Client:

{
	"servers": {
		"ZenML": {
			"url": "https://mcp.example.com/mcp",
			"type": "http"
		}
	},
	"inputs": []
}

• Bitten Sie die KI, „das Pipeline-Runs-Dashboard zu öffnen“ oder „das Run-Aktivitätsdiagramm anzuzeigen“

Wichtige Hinweise:

• ZENML_ACTIVE_PROJECT_ID ist erforderlich — ohne sie schlagen Pipeline-Run-Tools mit „Kein Projekt ist derzeit als aktiv festgelegt“ fehl
• --disable-dns-rebinding-protection ist nur geeignet, wenn der authentifizierte Proxy den öffentlichen Host validiert und der Container-Port nur auf Loopback beschränkt bleibt
• Beschränken Sie den ZenML-API-Schlüssel auf die Berechtigungen, die der MCP-Client benötigt; verwenden Sie ZENML_MCP_WRITE_POLICY=read_only für reine Inspektions-Clients

Tests & Qualitätssicherung

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

• 🔄 Automatisierte Smoke-Tests: Ein umfassender Smoke-Test läuft alle 3 Tage über GitHub Actions
• 🚨 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
• 🧪 Manuelle Tests: Sie können den Smoke-Test lokal mit uv run scripts/test_mcp_server.py server/zenml_server.py ausführen

Die automatisierten Tests verifizieren:

• MCP-Protokollverbindung und Handshake
• Serverinitialisierung und Tool-Erkennung
• Grundlegende Tool-Funktionalität (wenn der ZenML-Server erreichbar ist)
• Ressourcen- und Prompt-Aufzählung
• diagnose_zenml_setup gibt strukturierte Diagnosen auch in eingeschränkten Umgebungen zurück

CI ohne Anmeldeinformationen deckt jeden Adapter über das MCP-Protokoll ab. PR- und Release-CI starten außerdem einen frischen ZenML 0.97.0 OSS-Server auf einer Loopback-Adresse und führen persistierte CRUD- und Same-Name-Projektisolations-Receipts aus. Der Server verwendet eine temporäre Konfiguration und Datenbank, die entfernt werden, wenn der Job beendet wird; keine Repository-Umgebung, kein selbstgehosteter Runner und keine ZenML-Anmeldeinformationen sind erforderlich.

Der lokale OSS-Server von ZenML deaktiviert die Authentifizierung und sein SQL-Speicher unterstützt kein Pipeline-Replay oder externe Bereitstellungsinfrastruktur. Eingeschränkter Zugriff und funktionsaktivierte Trigger-, Replay-, Bereitstellungs-, Wartebedingungs- und Ressourcenanfrage-Receipts bleiben daher separate Opt-in-Gates. Sie erfordern ZENML_MCP_RESTRICTED_INTEGRATION=1 mit ZENML_MCP_RESTRICTED_API_KEY bzw. ZENML_MCP_ACTION_INTEGRATION=1 mit den exakten Wegwerf-Fixture-UUIDs in ZENML_MCP_ACTION_FIXTURE. Ein Gate-Überspringen ist kein Beweis dafür, dass diese Fähigkeiten bestanden haben. Ein Operator kann ZENML_MCP_REQUIRE_COMPLETE_INTEGRATION=1 setzen, um ein fehlendes Opt-in-Gate in einen Fehler umzuwandeln. Die Bereitstellung von Cloud-Infrastruktur ist niemals Teil des Standard-Testlaufs.

Debugging mit MCP Inspector

Für interaktives Debugging verwenden Sie 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 Weboberfläche mit Ihren vorausgefüllten Anmeldeinformationen — klicken Sie einfach auf Verbinden und verwenden Sie den Tab Tools, um jedes Tool interaktiv zu testen.

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

Datenschutz & Analytik

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 Nachrichten)
• 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 Geschäftsdaten
• Fehlermeldungen oder Stack-Traces
• Personenbezogene Informationen

So deaktivieren Sie Analytik:

# Option 1
export ZENML_MCP_ANALYTICS_ENABLED=false

# Option 2
export ZENML_MCP_DISABLE_ANALYTICS=true

Für Debugging/Tests (protokolliert Ereignisse auf stderr statt sie zu senden):

export ZENML_MCP_ANALYTICS_DEV=true

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

Zusätzliche Analytik-Optionen:

• ZENML_MCP_ANALYTICS_SHUTDOWN_TIMEOUT_S — maximale Zeit (Sekunden) zum synchronen Leeren der Analytik während des Herunterfahrens (Standard: 1,0)

Hinweis zur Herunterfahr-Verfolgung: Herunterfahr-Ereignisse werden synchron mit einem begrenzten Timeout für beste Zustellzuverlässigkeit gesendet. Wenn ein Container jedoch mit SIGKILL beendet wird (z. B. docker kill), können Herunterfahr-Handler nicht ausgelöst werden — dies ist eine Docker/OS-Einschränkung, kein Fehler.

Startvalidierung

Sie können eine leichtgewichtige Startdiagnoseprü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 ZENML_MCP_STARTUP_VALIDATION=warn festlegen.

Das diagnose_zenml_setup-Tool ist auch als MCP-Tool für 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. Wenn Sie keinen haben, können Sie sich für eine kostenlose Testversion bei ZenML Pro anmelden, und wir verwalten die Bereitstellung für Sie.

Tipp: Sobald Sie einen ZenML-Server haben, schauen Sie sich die MCP-Einstellungsseite in Ihrem Dashboard für die einfachste Einrichtungserfahrung an.

Kompatibilität: Die aktuelle Version ist gegen ZenML 0.97.0 getestet. Wenn Sie eine ältere ZenML-Version ausführen, verwenden Sie bitte eine frühere Version dieses MCP-Servers.

Sie müssen außerdem (wahrscheinlich) uv lokal installiert haben. 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 unbedingt, aber es macht Installation und Einrichtung einfach.)

Sie müssen dieses Repository außerdem irgendwo 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",
                "ZENML_MCP_PROFILE": "compact",
                "ZENML_MCP_WRITE_POLICY": "read_write",
                "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 Ihrem lokal installierten uv (der oben aufgeführte Pfad ist der Ort, an dem er auf einem Mac wäre, wenn Sie ihn ü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 sie in der ZenML Cloud-Benutzeroberfläche). Sie sieht ungefähr wie https://d534d987a-zenml.cloudinfra.zenml.io aus.
• den ZenML-Server-API-Schlüssel (dies ist der API-Schlüssel für Ihren ZenML-Server. Sie finden ihn in der ZenML Cloud-Benutzeroberfläche oder lesen Sie diese Dokumentation zur Erstellung eines solchen. Für den ZenML MCP-Server empfehlen wir die Verwendung eines Dienstkontos.)

Sie können die Art und Weise, wie Sie die MCP-Server-Python-Datei ausführen, frei ändern, aber die Verwendung von uv wird wahrscheinlich die einfachste Option sein, da es die Umgebung und Abhängigkeitsinstallation für Sie übernimmt.

Installation für die Verwendung mit Claude Desktop

Schnelle Alternative: Verwenden Sie die MCP-Einstellungsseite in Ihrem ZenML-Dashboard (Einstellungen → MCP), um vorkonfigurierte Installationsanweisungen und Deep-Links 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 Ihren API-Schlüssel hinzufügen.

Hinweis: MCP-Bundles (.mcpb) ersetzen das ältere Desktop-Erweiterungen-Format (.dxt); 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 diese genauen 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, was die Informationen viel einfacher zu lesen und zu verstehen macht.

Installation für die 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. Dies bedeutet, dass Sie, wenn Sie den ZenML MCP-Server in mehreren Repos verwenden möchten, die Konfigurationsdatei in jedem davon angeben müssen.

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“.

In unserer Erfahrung zeigt es manchmal einen roten Fehlerindikator, 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, sodass er auf eine MCP-Client-Verbindung wartet. Übergeben Sie Ihre ZenML-Anmeldeinformationen über Umgebungsvariablen.

Vorgefertigte Images (Docker Hub)

Ziehen Sie das neueste Multi-Arch-Image:

docker pull zenmldocker/mcp-zenml:latest

Versionsveröffentlichte Releases sind als X.Y.Z getaggt:

docker pull zenmldocker/mcp-zenml:2.0.0

Führen Sie 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", "ZENML_MCP_PROFILE=compact",
        "-e", "ZENML_MCP_WRITE_POLICY=read_write",
        "-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 erstellen

Vom Repository-Stammverzeichnis aus:

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

Führen Sie das lokal erstellte 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 Anythrops Desktop-Erweiterungen (DXT). MCP-Bundles verpacken 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 Verwendung in Zukunft.

Die mcp-zenml.mcpb-Datei im Repository-Stammverzeichnis verwendet die MCPB 0.4 UV-Laufzeit. Der Host installiert die festgelegten Python-Abhängigkeiten für das aktuelle Betriebssystem, sodass dasselbe Bundle auf macOS, Windows und Linux funktioniert, ohne plattformspezifische native Erweiterungen einzubetten. Die Installation benötigt Netzwerkzugriff beim ersten Mal, wenn UV die gebündelte Umgebung auflöst.

Bundle-Builds verwenden die festgeschriebene mcpb-uv.lock wieder und lösen deren Python- Abhängigkeitsgraph im Offline-Modus auf. Die Abhängigkeitsliste des Bundles stammt aus [project].dependencies in pyproject.toml. Nachdem Sie diese Liste geändert haben, setzen Sie MCPB_REFRESH_LOCK=1, um online neu aufzulösen, während jeder Pin erhalten bleibt, der noch passt; MCPB_REFRESH_LOCK=upgrade verschiebt jeden Pin auf seine neueste Version.

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

• Installation der Laufzeitabhängigkeiten
• Sichere Konfigurationsverwaltung
• Plattformübergreifende Kompatibilität
• Benutzerfreundlicher Einrichtungsprozess

Weitere Informationen finden Sie in der Ankündigung von Anthropic zu Desktop Extensions (DXT) und den zugehörigen Richtlinien zur Paketerstellung von MCP-Bundles in deren Dokumentation: https://www.anthropic.com/engineering/desktop-extensions

Veröffentlicht im Anthropic MCP Registry

Dieser MCP-Server ist im 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 des Registries unter Verwendung von GitHub OIDC, sodass Sie den ZenML MCP Server direkt überall dort installieren oder entdecken können, wo das Registry unterstützt wird (z. B. im Erweiterungskatalog von Claude Desktop).

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

Erfahren Sie hier mehr über das Registry:

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