ZenML MCP Server

officiel

Interagissez avec vos pipelines MLOps et LLMOps via votre serveur MCP ZenML.

Documentation

Serveur MCP pour ZenML

Ce projet implémente un serveur Model Context Protocol (MCP) pour interagir avec l'API ZenML.

ZenML MCP Server

Qu'est-ce que MCP ?

Le Model Context Protocol (MCP) est un protocole ouvert qui standardise la manière dont les applications fournissent du contexte aux grands modèles de langage (LLM). Il fonctionne comme un « port USB-C pour les applications d'IA » – offrant un moyen standardisé de connecter les modèles d'IA à différentes sources de données et outils.

MCP suit une architecture client-serveur où :

Hôtes MCP : Programmes comme Claude Desktop ou les IDE qui souhaitent accéder aux données via MCP
Clients MCP : Clients de protocole qui maintiennent des connexions 1:1 avec les serveurs
Serveurs MCP : Programmes légers qui exposent des capacités spécifiques via le protocole standardisé
Sources de données locales : Fichiers, bases de données et services de votre ordinateur auxquels les serveurs MCP peuvent accéder de manière sécurisée
Services distants : Systèmes externes disponibles sur Internet auxquels les serveurs MCP peuvent se connecter

Qu'est-ce que ZenML ?

ZenML est une plateforme open source pour la construction et la gestion de pipelines ML et IA. Elle fournit une interface unifiée pour gérer les données, les modèles et les expériences.

Pour plus d'informations, consultez le site Web ZenML et notre documentation.

Fonctionnalités

Le serveur fournit des outils MCP pour accéder aux fonctionnalités de lecture essentielles du serveur ZenML, offrant un moyen d'obtenir des informations en direct sur :

Entités principales

Utilisateurs – comptes utilisateur et autorisations
Stacks – configurations d'infrastructure
Composants de stack – blocs de construction individuels de la stack
Flavors – types de composants disponibles
Connecteurs de service – authentification cloud

Exécution de pipeline

Pipelines – définitions de pipeline
Exécutions de pipeline – historique d'exécution et statut
Étapes de pipeline – détails des étapes individuelles, code et journaux
Planifications – planifications d'exécution automatisées
Artefacts – métadonnées sur les artefacts de données (pas les données elles-mêmes)

Déploiement et service

Snapshots – configurations de pipeline figées (l'artefact « quoi exécuter/servir »)
Déploiements – instances de service en cours d'exécution avec statut, URL et journaux
Services – points de terminaison de service de modèle

Organisation et découverte

Projets – conteneurs organisationnels pour les ressources ZenML
Tags – étiquettes de métadonnées transversales pour la découverte
Builds – artefacts de build de pipeline avec informations sur l'image et le code

Modèles

Modèles – entrées du registre de modèles ML
Versions de modèle – artefacts de modèle versionnés

Obsolète (migration recommandée)

~~Modèles d'exécution de pipeline~~ → utilisez les Snapshots à la place (voir le Guide de migration)

Le serveur vous permet également de déclencher de nouvelles exécutions de pipeline en utilisant des snapshots (recommandé) ou des modèles d'exécution (obsolète).

Remarque : Nous améliorons continuellement cette intégration en fonction des retours des utilisateurs. Rejoignez notre communauté Slack pour partager votre expérience et nous aider à l'améliorer encore !

Outils disponibles

Le serveur MCP expose les outils suivants, regroupés par catégorie :

Exécution de pipeline (Nouveau dans la v1.2)

Outil	Description
`get_snapshot`	Obtenir une configuration de pipeline figée par nom/ID
`list_snapshots`	Lister les snapshots avec filtres (exécutable, déployable, déployé, tag)
`get_deployment`	Obtenir le statut d'exécution et l'URL d'un déploiement
`list_deployments`	Lister les déploiements avec filtres (statut, pipeline, tag)
`get_deployment_logs`	Obtenir les journaux bornés d'un déploiement (tail=100 par défaut, max 1000)
`trigger_pipeline`	Déclencher une exécution de pipeline (préférer le paramètre `snapshot_name_or_id`)

Organisation (Nouveau dans la v1.2)

Outil	Description
`get_active_project`	Obtenir le projet actuellement actif
`get_project`	Obtenir les détails du projet par nom/ID
`list_projects`	Lister tous les projets
`get_tag`	Obtenir les détails du tag (exclusif, couleurs)
`list_tags`	Lister les tags avec filtres (resource_type)
`get_build`	Obtenir les détails du build (image, intégration de code)
`list_builds`	Lister les builds avec filtres (is_local, contains_code)

Entités principales

Outil	Description
`get_user`, `list_users`, `get_active_user`	Gestion des utilisateurs
`get_stack`, `list_stacks`	Configurations de stack
`get_stack_component`, `list_stack_components`	Composants de stack
`get_flavor`, `list_flavors`	Flavors de composants
`get_service_connector`, `list_service_connectors`	Connecteurs cloud
`get_pipeline_run`, `list_pipeline_runs`	Exécutions de pipeline
`get_run_step`, `list_run_steps`	Détails des étapes
`get_step_logs`, `get_step_code`	Journaux d'étape et code source
`list_pipelines`, `get_pipeline_details`	Définitions de pipeline
`get_schedule`, `list_schedules`	Planifications
`list_artifacts`	Métadonnées d'artefact
`list_secrets`	Noms des secrets (pas les valeurs)
`get_service`, `list_services`	Services de modèle
`get_model`, `list_models`	Registre de modèles
`get_model_version`, `list_model_versions`	Versions de modèle

Applications interactives (Expérimental)

Outil	Description
`open_pipeline_run_dashboard`	Ouvrir le tableau de bord interactif des exécutions de pipeline (MCP App)
`open_run_activity_chart`	Ouvrir le graphique à barres d'activité des exécutions sur 30 jours (MCP App)

Outils d'analyse

Outil	Description
`stack_components_analysis`	Analyser l'utilisation des composants de stack
`recent_runs_analysis`	Analyser les exécutions de pipeline récentes
`most_recent_runs`	Obtenir les N exécutions les plus récentes

Diagnostics

Outil	Description
`diagnose_zenml_setup`	Diagnostiquer la configuration du serveur (variables d'env, SDK, connectivité, auth). Fonctionne même en cas de mauvaise configuration.

Outils obsolètes

Outil	Remplacement
`get_run_template`	Utilisez `get_snapshot` à la place
`list_run_templates`	Utilisez `list_snapshots` à la place
`trigger_pipeline(template_id=...)`	Utilisez `trigger_pipeline(snapshot_name_or_id=...)`

Migration : Modèles d'exécution → Snapshots

Pourquoi ce changement ? ZenML a fait évoluer son concept d'« artefact de pipeline exécutable ». Les modèles d'exécution sont désormais des wrappers obsolètes qui pointent en interne simplement vers des Snapshots. Le nouveau code doit utiliser directement les Snapshots.

Guide de migration rapide

Ancien modèle (Templates)	Nouveau modèle (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=...)`

Exemple de flux de travail (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)

Remarque : get_deployment_logs renvoie une sortie bornée (100 lignes par défaut, max 1000, plafonnée à 100 Ko) et nécessite l'installation de l'intégration de déploiement appropriée.

Configuration rapide via le tableau de bord (Recommandé)

Le moyen le plus simple de configurer le serveur MCP ZenML est via la page Paramètres MCP de votre tableau de bord ZenML.

MCP Settings Page

Accédez à Paramètres → MCP dans votre tableau de bord ZenML pour obtenir :

Des extraits préconfigurés pour votre URL de serveur et vos identifiants spécifiques
Une installation en un clic via des liens profonds pour les IDE pris en charge
Des configurations copier-coller pour VS Code, Claude Desktop, Cursor, Claude Code, OpenAI Codex, et plus encore
Des options Docker et uv selon votre préférence

Utilisateurs ZenML Pro

La page Paramètres MCP vous permet de générer un jeton d'accès personnel (PAT) en un seul clic. Le jeton est automatiquement inclus dans tous les extraits de configuration générés.

Utilisateurs ZenML OSS

Créez d'abord un jeton de compte de service via Paramètres → Comptes de service
Collez le jeton dans la page Paramètres MCP
Copiez la configuration générée pour votre IDE

Vous préférez une configuration manuelle ? Consultez les instructions détaillées ci-dessous.

Applications MCP (Expérimental)

Que sont les applications MCP ? Les applications MCP sont des interfaces utilisateur HTML interactives que les serveurs MCP peuvent servir directement dans les clients IA. Elles s'affichent dans des iframes en bac à sable et peuvent appeler les outils du serveur de manière bidirectionnelle. Voir l'annonce officielle pour plus de détails.

Run Activity Chart

Ce serveur inclut deux applications MCP expérimentales :

Application	Outil	Description
Tableau de bord des exécutions de pipeline	`open_pipeline_run_dashboard`	Tableau interactif des exécutions de pipeline récentes avec statut, détails des étapes et journaux
Graphique d'activité des exécutions	`open_run_activity_chart`	Graphique à barres de l'activité des exécutions de pipeline sur les 30 derniers jours avec répartition par statut

Pipeline Runs Dashboard

Ces applications sont incluses comme exemples de preuve de concept. Nous accueillons les retours et les contributions pour plus d'applications MCP. C'est encore le début pour cette nouvelle fonctionnalité, nous verrons donc comment elle évolue. Nous prévoyons de la prendre en charge plus complètement à l'avenir.

Clients pris en charge

Les applications MCP nécessitent le transport HTTP streamable (pas stdio). Les clients suivants prennent actuellement en charge les applications MCP :

✅ VS Code (Édition Insiders)
✅ Goose
✅ ChatGPT (lancement prochain)
⚠️ Claude Desktop -- fin janvier 2026, ne rend pas encore les applications.
⚠️ Claude.ai (web) — fin janvier 2026, ne rend pas encore les applications.

Remarque : Nous n'avons pas pu tester de manière approfondie avec Claude Desktop ou Claude.ai au moment de la rédaction. Si vous rencontrez des problèmes, veuillez les signaler.

Exécuter les applications MCP avec Docker

Les applications MCP nécessitent le transport HTTP streamable et une URL accessible publiquement (pour les clients hébergés dans le cloud comme Claude.ai). La configuration la plus simple utilise Docker + tunnel Cloudflare :

1. Construire et exécuter le conteneur 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. Démarrer un tunnel Cloudflare (pour les clients cloud) :

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

Cela affiche une URL publique comme https://random-words.trycloudflare.com.

3. Connecter votre client :

Dans Claude Desktop ou d'autres clients, ajoutez le serveur MCP avec l'URL : https://random-words.trycloudflare.com/mcp par exemple :

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

Demandez à l'IA d'« ouvrir le tableau de bord des exécutions de pipeline » ou d'« afficher le graphique d'activité des exécutions »

Remarques importantes :

ZENML_ACTIVE_PROJECT_ID est requis — sans cela, les outils d'exécution de pipeline échoueront avec « Aucun projet n'est actuellement défini comme actif »
Le drapeau --disable-dns-rebinding-protection est nécessaire lors de l'exécution derrière des proxys inverses (cloudflared, ngrok) — il est sûr lorsque le proxy gère la sécurité
L'URL du tunnel change à chaque redémarrage — mettez à jour votre intégration client en conséquence

Tests et assurance qualité

Ce projet inclut des tests automatisés pour garantir que le serveur MCP reste fonctionnel :

🔄 Tests de fumée automatisés : Un test de fumée complet s'exécute tous les 3 jours via GitHub Actions
🚨 Création de tickets : Les tests échoués créent automatiquement des tickets GitHub avec des informations de débogage détaillées
⚡ CI rapide : Utilise UV avec mise en cache pour une installation rapide des dépendances et des tests
🧪 Tests manuels : Vous pouvez exécuter le test de fumée localement en utilisant uv run scripts/test_mcp_server.py server/zenml_server.py

Les tests automatisés vérifient :

La connexion et la poignée de main du protocole MCP
L'initialisation du serveur et la découverte des outils
La fonctionnalité de base des outils (lorsque le serveur ZenML est accessible)
L'énumération des ressources et des invites
diagnose_zenml_setup renvoie des diagnostics structurés même dans des environnements contraints

Débogage avec MCP Inspector

Pour le débogage interactif, utilisez MCP Inspector — un outil web qui vous permet de tester les outils MCP en temps réel :

# 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

Cela ouvre une interface utilisateur web avec vos identifiants pré-remplis — cliquez simplement sur Connecter et utilisez l'onglet Outils pour tester n'importe quel outil de manière interactive.

Voir CLAUDE.md pour des instructions de débogage plus détaillées.

Confidentialité et analyses

Le serveur MCP ZenML collecte des analyses d'utilisation anonymes pour nous aider à améliorer le produit.

Nous suivons :

Quels outils sont utilisés et à quelle fréquence
Les taux et types d'erreurs (type d'erreur uniquement, pas de messages)
Les informations de base sur l'environnement (OS, version Python, et si exécuté dans Docker/CI)
La durée de la session et les modèles d'utilisation des outils

Nous ne collectons PAS :

Votre URL de serveur ZenML ou votre clé API
Les noms de pipeline, de modèle ou toute donnée métier
Les messages d'erreur ou les traces de pile
Toute information personnellement identifiable

Pour désactiver les analyses :

# Option 1
export ZENML_MCP_ANALYTICS_ENABLED=false

# Option 2
export ZENML_MCP_DISABLE_ANALYTICS=true

Pour le débogage/test (enregistre les événements dans stderr au lieu d'envoyer) :

export ZENML_MCP_ANALYTICS_DEV=true

Pour les utilisateurs de Docker : Vous pouvez définir ZENML_MCP_ANALYTICS_ID (doit être un UUID valide) pour conserver un identifiant anonyme cohérent entre les redémarrages de conteneur. Si vous ne le définissez pas et que le système de fichiers du conteneur ne peut pas conserver le fichier d'ID analytique, le serveur utilise un UUID anonyme déterministe dérivé d'un hachage de ZENML_STORE_URL (l'URL elle-même n'est jamais envoyée comme propriété d'événement).

Options d'analyse supplémentaires :

ZENML_MCP_ANALYTICS_SHUTDOWN_TIMEOUT_S — temps maximum (en secondes) pour vider les analyses de manière synchrone lors de l'arrêt (par défaut : 1.0)

Remarque sur le suivi des arrêts : Les événements d'arrêt sont envoyés de manière synchrone avec un délai limité pour une meilleure fiabilité de livraison. Cependant, si un conteneur est tué avec SIGKILL (par exemple, docker kill), les gestionnaires d'arrêt ne peuvent pas s'exécuter — il s'agit d'une limitation de Docker/OS, pas d'un bug.

Validation au démarrage

Vous pouvez activer une vérification de diagnostic légère au démarrage :

# 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

Vous pouvez également définir cela via la variable d'environnement : ZENML_MCP_STARTUP_VALIDATION=warn.

L'outil diagnose_zenml_setup est également disponible en tant qu'outil MCP pour le dépannage à l'exécution — il fonctionne même lorsque le SDK ZenML n'est pas installé ou que des variables d'environnement sont manquantes.

Configuration manuelle

Prérequis

Vous aurez besoin d'avoir accès à un serveur ZenML déployé. Si vous n'en avez pas, vous pouvez vous inscrire pour un essai gratuit sur ZenML Pro et nous gérerons le déploiement pour vous.

Astuce : Une fois que vous avez un serveur ZenML, consultez la page des paramètres MCP dans votre tableau de bord pour l'expérience de configuration la plus simple.

Compatibilité : Ce serveur MCP est testé avec et recommandé pour ZenML >= 0.93.0. Si vous utilisez une version plus ancienne de ZenML, veuillez utiliser une version antérieure de ce serveur MCP.

Vous aurez également (probablement) besoin d'avoir uv installé localement. Pour plus d'informations, consultez la documentation de uv. Nous recommandons l'installation via leur script d'installation ou via brew si vous utilisez un Mac. (Techniquement, vous n'en avez pas besoin, mais cela facilite l'installation et la configuration.)

Vous devrez également cloner ce dépôt quelque part localement :

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

Votre fichier de configuration MCP

Le fichier de configuration MCP est un fichier JSON qui indique au client MCP comment se connecter à votre serveur MCP. Différents clients MCP l'utiliseront ou le spécifieront différemment. Deux clients MCP couramment utilisés sont Claude Desktop et Cursor, pour lesquels nous fournissons des instructions d'installation ci-dessous.

Vous devrez spécifier votre serveur MCP ZenML dans le format suivant :

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

Il y a quatre valeurs factices que vous devrez remplacer :

le chemin vers votre uv installé localement (le chemin indiqué ci-dessus est celui où il se trouverait sur un Mac si vous l'installiez via brew)
le chemin vers le fichier zenml_server.py (c'est le fichier qui sera exécuté lorsque vous vous connecterez au serveur MCP). Ce fichier se trouve à l'intérieur de ce dépôt à la racine. Vous devrez spécifier le chemin complet exact vers ce fichier.
l'URL du serveur ZenML (c'est l'URL de votre serveur ZenML. Vous pouvez la trouver dans l'interface cloud ZenML). Elle ressemblera à quelque chose comme https://d534d987a-zenml.cloudinfra.zenml.io.
la clé API du serveur ZenML (c'est la clé API pour votre serveur ZenML. Vous pouvez la trouver dans l'interface cloud ZenML ou lire ces docs sur la façon d'en créer une. Pour les besoins du serveur MCP ZenML, nous recommandons d'utiliser un compte de service.)

Vous êtes libre de changer la façon dont vous exécutez le fichier Python du serveur MCP, mais utiliser uv sera probablement l'option la plus simple car il gère l'environnement et l'installation des dépendances pour vous.

Installation pour une utilisation avec Claude Desktop

Alternative rapide : Utilisez la page des paramètres MCP dans votre tableau de bord ZenML (Paramètres → MCP) pour obtenir des instructions d'installation préconfigurées et des liens profonds pour Claude Desktop.

Vous aurez besoin d'avoir la dernière version de Claude Desktop installée.

Vous pouvez simplement ouvrir le menu Paramètres et faire glisser le fichier mcp-zenml.mcpb depuis la racine de ce dépôt sur le menu et il vous guidera tout au long du processus d'installation et de configuration. Vous devrez ajouter l'URL de votre serveur ZenML et votre clé API.

Remarque : Les bundles MCP (.mcpb) remplacent l'ancien format Desktop Extensions (.dxt) ; les fichiers .dxt existants fonctionnent toujours dans Claude Desktop.

Optionnel : Améliorer l'affichage des résultats des outils ZenML

Pour une meilleure expérience avec les résultats des outils ZenML, vous pouvez configurer Claude pour afficher les réponses JSON dans un format plus lisible. Dans Claude Desktop, allez dans Paramètres → Profil, et dans la section "Quelles préférences personnelles Claude devrait-il prendre en compte dans ses réponses ?", ajoutez quelque chose comme ce qui suit (ou utilisez ces mots exacts !) :

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!

Cela encouragera Claude à formater les sorties des outils ZenML sous forme de tableaux markdown, rendant l'information beaucoup plus facile à lire et à comprendre.

Installation pour une utilisation avec Cursor

Alternative rapide : La page des paramètres MCP dans votre tableau de bord ZenML (Paramètres → MCP) peut générer le contenu exact de mcp.json avec vos identifiants pré-remplis.

Vous aurez besoin d'avoir Cursor installé.

Cursor fonctionne légèrement différemment de Claude Desktop en ce sens que vous spécifiez le fichier de configuration par dépôt. Cela signifie que si vous voulez utiliser le serveur MCP ZenML dans plusieurs dépôts, vous devrez spécifier le fichier de configuration dans chacun d'eux.

Pour le configurer pour un seul dépôt, vous devrez :

créer un dossier .cursor à la racine de votre dépôt
à l'intérieur, créer un fichier mcp.json avec le contenu ci-dessus
aller dans vos paramètres Cursor et cliquer sur le serveur ZenML pour l'activer.

D'après notre expérience, il affiche parfois un indicateur d'erreur rouge même s'il fonctionne. Vous pouvez essayer en discutant dans la fenêtre de chat de Cursor. Il vous dira s'il est capable d'accéder aux outils ZenML ou non.

Image Docker

Vous pouvez exécuter le serveur en tant que conteneur Docker. Le processus communique via stdio, il attendra donc une connexion client MCP. Passez vos identifiants ZenML via des variables d'environnement.

Images pré-construites (Docker Hub)

Récupérez la dernière image multi-arch :

docker pull zenmldocker/mcp-zenml:latest

Les versions publiées sont étiquetées comme X.Y.Z :

docker pull zenmldocker/mcp-zenml:1.0.8

Exécutez avec vos identifiants ZenML (mode 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

Configuration MCP canonique utilisant 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"
      ]
    }
  }
}

Construction locale

Depuis la racine du dépôt :

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

Exécutez l'image construite localement :

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

Bundles MCP (.mcpb)

Ce projet utilise les Bundles MCP (.mcpb) — le successeur des Desktop Extensions (DXT) d'Anthropic. Les Bundles MCP empaquettent un serveur MCP entier (dépendances incluses) dans un seul fichier avec une configuration conviviale.

Remarque sur le changement de nom : Les Bundles MCP remplacent l'ancien format .dxt. Claude Desktop reste rétrocompatible avec les fichiers .dxt existants, mais nous livrons désormais mcp-zenml.mcpb et recommandons de l'utiliser à l'avenir.

Le fichier mcp-zenml.mcpb à la racine du dépôt contient tout le nécessaire pour exécuter le serveur MCP ZenML, éliminant le besoin d'étapes d'installation manuelle complexes. Cela rend les intégrations ZenML puissantes accessibles aux utilisateurs sans nécessiter d'expertise technique en configuration.

Lorsque vous faites glisser et déposez le fichier .mcpb dans les paramètres de Claude Desktop, il gère automatiquement :

L'installation des dépendances d'exécution
La gestion sécurisée de la configuration
La compatibilité multiplateforme
Un processus de configuration convivial

Pour plus d'informations, consultez l'annonce d'Anthropic sur les Desktop Extensions (DXT) et les conseils associés sur l'empaquetage des bundles MCP dans leur documentation : https://www.anthropic.com/engineering/desktop-extensions

Publié sur le registre MCP d'Anthropic

Ce serveur MCP est publié sur le registre MCP officiel d'Anthropic et est découvrable par les hôtes compatibles. À chaque version étiquetée, notre CI met à jour l'entrée du registre via la CLI mcp-publisher du registre en utilisant GitHub OIDC, afin que vous puissiez installer ou découvrir le serveur MCP ZenML directement partout où le registre est pris en charge (par exemple, le catalogue Extensions de Claude Desktop).

Toujours à jour : l'entrée du registre est actualisée à chaque version à partir du manifest.json et du server.json du commit étiqueté.
Chemins d'installation alternatifs : vous pouvez toujours installer localement via le bundle .mcpb empaqueté (voir ci-dessus) ou exécuter l'image Docker.

Apprenez-en plus sur le registre ici :

Registre MCP d'Anthropic (dépôt communautaire) : https://github.com/modelcontextprotocol/registry