ZenML

Servidor MCP para ZenML

Este projeto implementa um servidor Model Context Protocol (MCP) para interagir com a API do ZenML.

O que é MCP?

O Model Context Protocol (MCP) é um protocolo aberto que padroniza como as aplicações fornecem contexto para Modelos de Linguagem de Grande Escala (LLMs). Ele funciona como uma "porta USB-C para aplicações de IA" - fornecendo uma maneira padronizada de conectar modelos de IA a diferentes fontes de dados e ferramentas.

O MCP segue uma arquitetura cliente-servidor onde:

• Hosts MCP: Programas como Claude Desktop ou IDEs que desejam acessar dados através do MCP
• Clientes MCP: Clientes de protocolo que mantêm conexões 1:1 com servidores
• Servidores MCP: Programas leves que expõem capacidades específicas através do protocolo padronizado
• Fontes de Dados Locais: Arquivos, bancos de dados e serviços do seu computador que os servidores MCP podem acessar com segurança
• Serviços Remotos: Sistemas externos disponíveis pela internet aos quais os servidores MCP podem se conectar

O que é ZenML?

ZenML é uma plataforma de código aberto para construir e gerenciar pipelines de ML e IA. Ela fornece uma interface unificada para gerenciar dados, modelos e experimentos.

Para mais informações, consulte o site do ZenML e nossa documentação.

Funcionalidades

O servidor fornece ferramentas MCP para acessar funcionalidades essenciais de leitura do servidor ZenML, oferecendo uma maneira de obter informações ao vivo sobre:

Entidades Principais

• Usuários - contas de usuário e permissões
• Stacks - configurações de infraestrutura
• Componentes de Stack - blocos de construção individuais de stack
• Flavors - tipos de componentes disponíveis
• Conectores de Serviço - autenticação em nuvem

Execução de Pipeline

• Pipelines - definições de pipeline
• Execuções de Pipeline - histórico de execução e status
• Etapas de Pipeline - detalhes individuais de etapas, código e logs
• Agendamentos - agendamentos de execução automatizada
• Artefatos - metadados sobre artefatos de dados (não os dados em si)

Deploy & Serving

• Snapshots - configurações de pipeline congeladas (o artefato "o que executar/servir")
• Deployments - instâncias de serving em tempo de execução com status, URL e logs
• Serviços - endpoints de serving de modelo

Organização & Descoberta

• Projetos - contêineres organizacionais para recursos do ZenML
• Tags - rótulos de metadados transversais para descoberta
• Builds - artefatos de build de pipeline com informações de imagem e código

Modelos

• Modelos - entradas do registro de modelos de ML
• Versões de Modelo - artefatos de modelo versionados

Obsoleto (migração recomendada)

• Modelos de execução de pipeline → use Snapshots em vez disso (consulte o Guia de Migração)

O servidor também permite que você ative novas execuções de pipeline usando snapshots (preferencial) ou modelos de execução (obsoleto).

Nota: Estamos continuamente melhorando esta integração com base no feedback dos usuários. Junte-se à nossa comunidade Slack para compartilhar sua experiência e nos ajudar a torná-la ainda melhor!

Ferramentas Disponíveis

O servidor MCP expõe as seguintes ferramentas, agrupadas por categoria:

Execução de Pipeline (Novo na v1.2)

Ferramenta	Descrição
get_snapshot	Obter uma configuração de pipeline congelada por nome/ID
list_snapshots	Listar snapshots com filtros (executável, implantável, implantado, tag)
get_deployment	Obter o status de tempo de execução e a URL de um deployment
list_deployments	Listar deployments com filtros (status, pipeline, tag)
get_deployment_logs	Obter logs limitados de um deployment (padrão tail=100, máx. 1000)
trigger_pipeline	Acionar uma execução de pipeline (prefira o parâmetro snapshot_name_or_id)

Organização (Novo na v1.2)

Ferramenta	Descrição
get_active_project	Obter o projeto atualmente ativo
get_project	Obter detalhes do projeto por nome/ID
list_projects	Listar todos os projetos
get_tag	Obter detalhes da tag (exclusiva, cores)
list_tags	Listar tags com filtros (resource_type)
get_build	Obter detalhes do build (imagem, incorporação de código)
list_builds	Listar builds com filtros (is_local, contains_code)

Entidades Principais

Ferramenta	Descrição
get_user, list_users, get_active_user	Gerenciamento de usuários
get_stack, list_stacks	Configurações de stack
get_stack_component, list_stack_components	Componentes de stack
get_flavor, list_flavors	Flavors de componentes
get_service_connector, list_service_connectors	Conectores de nuvem
get_pipeline_run, list_pipeline_runs	Execuções de pipeline
get_run_step, list_run_steps	Detalhes da etapa
get_step_logs, get_step_code	Logs da etapa e código fonte
list_pipelines, get_pipeline_details	Definições de pipeline
get_schedule, list_schedules	Agendamentos
list_artifacts	Metadados de artefato
list_secrets	Nomes de segredos (não valores)
get_service, list_services	Serviços de modelo
get_model, list_models	Registro de modelos
get_model_version, list_model_versions	Versões de modelo

Aplicativos Interativos (Experimental)

Ferramenta	Descrição
open_pipeline_run_dashboard	Abrir painel interativo de execuções de pipeline (MCP App)
open_run_activity_chart	Abrir gráfico de barras de atividade de execução de 30 dias (MCP App)

Ferramentas de Análise

Ferramenta	Descrição
stack_components_analysis	Analisar uso de componentes de stack
recent_runs_analysis	Analisar execuções de pipeline recentes
most_recent_runs	Obter as N execuções mais recentes

Diagnóstico

Ferramenta	Descrição
diagnose_zenml_setup	Diagnosticar configuração do servidor (variáveis de ambiente, SDK, conectividade, autenticação). Funciona mesmo quando mal configurado.

Ferramentas Obsoletas

Ferramenta	Substituição
get_run_template	Use get_snapshot em vez disso
list_run_templates	Use list_snapshots em vez disso
trigger_pipeline(template_id=...)	Use trigger_pipeline(snapshot_name_or_id=...)

Migração: Modelos de Execução → Snapshots

Por que a mudança? O ZenML evoluiu seu conceito de "artefato de pipeline executável". Modelos de Execução agora são wrappers obsoletos que internamente apenas apontam para Snapshots. Código novo deve usar Snapshots diretamente.

Guia Rápido de Migração

Padrão Antigo (Modelos)	Padrão Novo (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=...)

Exemplo de Fluxo de Trabalho (Prioridade Snapshots)

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 retorna saída limitada (padrão 100 linhas, máx. 1000, limitado a 100KB) e requer que a integração do deployer apropriada esteja instalada.

Configuração Rápida via Painel (Recomendado)

A maneira mais fácil de configurar o Servidor MCP ZenML é através da página de Configurações MCP do seu painel ZenML.

Navegue até Configurações → MCP no seu painel ZenML para obter:

• Trechos pré-configurados para sua URL de servidor e credenciais específicas
• Instalação com um clique via deep links para IDEs suportadas
• Configurações para copiar e colar para VS Code, Claude Desktop, Cursor, Claude Code, OpenAI Codex e mais
• Opções Docker e uv com base na sua preferência

Usuários ZenML Pro

A página de Configurações MCP permite gerar um Token de Acesso Pessoal (PAT) com um único clique. O token é automaticamente incluído em todos os trechos de configuração gerados.

Usuários ZenML OSS

1. Primeiro, crie um token de conta de serviço via Configurações → Contas de Serviço
2. Cole o token na página de Configurações MCP
3. Copie a configuração gerada para sua IDE

---

Prefere configuração manual? Veja as instruções detalhadas abaixo.

MCP Apps (Experimental)

O que são MCP Apps? MCP Apps são UIs HTML interativas que servidores MCP podem servir diretamente em clientes de IA. Elas renderizam em iframes isolados e podem chamar ferramentas do servidor bidirecionalmente. Veja o anúncio oficial para detalhes completos.

Este servidor inclui dois MCP Apps experimentais:

App	Ferramenta	Descrição
Painel de Execuções de Pipeline	open_pipeline_run_dashboard	Tabela interativa de execuções de pipeline recentes com status, detalhes da etapa e logs
Gráfico de Atividade de Execução	open_run_activity_chart	Gráfico de barras da atividade de execução de pipeline nos últimos 30 dias com divisão por status

Estes apps estão incluídos como exemplos de prova de conceito. Aceitamos feedback e contribuições para mais MCP Apps. Ainda é cedo para esta nova funcionalidade, então teremos que ver como ela evolui. Esperamos oferecer suporte mais completo no futuro.

Clientes Suportados

MCP Apps requerem transporte HTTP Transmissível (não stdio). Os seguintes clientes atualmente suportam MCP Apps:

• ✅ VS Code (Edição Insiders)
• ✅ Goose
• ✅ ChatGPT (lançamento em breve)
• ⚠️ Claude Desktop -- até o final de janeiro de 2026, ainda não renderiza Apps.
• ⚠️ Claude.ai (web) — até o final de janeiro de 2026, ainda não renderiza Apps.

Nota: Não foi possível testar exaustivamente com Claude Desktop ou Claude.ai no momento da redação. Se encontrar problemas, por favor relate-os.

Executando MCP Apps com Docker

MCP Apps requerem transporte HTTP Transmissível e uma URL publicamente acessível (para clientes hospedados na nuvem como Claude.ai). A configuração mais simples usa Docker + túnel Cloudflare:

1. Construir e executar o contêiner 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 um túnel Cloudflare (para clientes na nuvem):

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

Isso imprime uma URL pública como https://random-words.trycloudflare.com.

3. Conectar seu cliente:

• No Claude Desktop ou outros clientes, adicione o servidor MCP com a URL: https://random-words.trycloudflare.com/mcp por exemplo:

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

• Peça à IA para "abrir o painel de execuções de pipeline" ou "mostrar o gráfico de atividade de execução"

Notas importantes:

• ZENML_ACTIVE_PROJECT_ID é obrigatório — sem ele, as ferramentas de execução de pipeline falharão com "Nenhum projeto está definido como ativo"
• A flag --disable-dns-rebinding-protection é necessária ao executar atrás de proxies reversos (cloudflared, ngrok) — é segura quando o proxy lida com a segurança
• A URL do túnel muda a cada reinicialização — atualize a integração do seu cliente de acordo

Testes & Garantia de Qualidade

Este projeto inclui testes automatizados para garantir que o servidor MCP permaneça funcional:

• 🔄 Testes de Fumaça Automatizados: Um teste de fumaça abrangente é executado a cada 3 dias via GitHub Actions
• 🚨 Criação de Issues: Testes com falha criam automaticamente issues no GitHub com informações detalhadas de depuração
• ⚡ CI Rápido: Usa UV com cache para instalação rápida de dependências e testes
• 🧪 Teste Manual: Você pode executar o teste de fumaça localmente usando uv run scripts/test_mcp_server.py server/zenml_server.py

Os testes automatizados verificam:

• Conexão e handshake do protocolo MCP
• Inicialização do servidor e descoberta de ferramentas
• Funcionalidade básica da ferramenta (quando o servidor ZenML está acessível)
• Enumeração de recursos e prompts
• diagnose_zenml_setup retorna diagnósticos estruturados mesmo em ambientes restritos

Depuração com MCP Inspector

Para depuração interativa, use o MCP Inspector — uma ferramenta baseada na web que permite testar ferramentas MCP em tempo 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

Isso abre uma UI web com suas credenciais pré-preenchidas — basta clicar em Conectar e usar a aba Ferramentas para testar qualquer ferramenta interativamente.

Veja CLAUDE.md para instruções de depuração mais detalhadas.

Privacidade & Analytics

O Servidor MCP ZenML coleta análises de uso anônimas para nos ajudar a melhorar o produto.

Rastreamos:

• Quais ferramentas são usadas e com que frequência
• Taxas e tipos de erro (apenas tipo de erro, sem mensagens)
• Informações básicas do ambiente (SO, versão do Python e se está rodando em Docker/CI)
• Duração da sessão e padrões de uso de ferramentas

NÃO coletamos:

• Sua URL do servidor ZenML ou chave de API
• Nomes de pipeline, nomes de modelo ou quaisquer dados de negócio
• Mensagens de erro ou stack traces
• Qualquer informação pessoalmente identificável

Para desativar as análises:

# Option 1
export ZENML_MCP_ANALYTICS_ENABLED=false

# Option 2
export ZENML_MCP_DISABLE_ANALYTICS=true

Para depuração/teste (registra eventos no stderr em vez de enviar):

export ZENML_MCP_ANALYTICS_DEV=true

Para usuários do Docker: Você pode definir ZENML_MCP_ANALYTICS_ID (deve ser um UUID válido) para manter um ID anônimo consistente entre reinicializações do contêiner. Se você não defini-lo e o sistema de arquivos do contêiner não puder persistir o arquivo de ID de análise, o servidor usará um UUID anônimo determinístico derivado de um hash de ZENML_STORE_URL (a URL em si nunca é enviada como propriedade de evento).

Opções adicionais de análise:

• ZENML_MCP_ANALYTICS_SHUTDOWN_TIMEOUT_S — tempo máximo (segundos) para enviar análises de forma síncrona durante o desligamento (padrão: 1.0)

Nota sobre rastreamento de desligamento: Eventos de desligamento são enviados de forma síncrona com um tempo limite limitado para melhor confiabilidade de entrega. No entanto, se um contêiner for encerrado com SIGKILL (por exemplo, docker kill), os manipuladores de desligamento não podem ser acionados — esta é uma limitação do Docker/OS, não um bug.

Validação de Inicialização

Você pode habilitar uma verificação de diagnóstico leve na inicialização:

# 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

Você também pode definir isso via variável de ambiente: ZENML_MCP_STARTUP_VALIDATION=warn.

A ferramenta diagnose_zenml_setup também está disponível como uma ferramenta MCP para solução de problemas em tempo de execução — funciona mesmo quando o ZenML SDK não está instalado ou as variáveis de ambiente estão ausentes.

Configuração Manual

Pré-requisitos

Você precisará ter acesso a um servidor ZenML implantado. Se você não tiver um, pode se inscrever para um teste gratuito no ZenML Pro e nós gerenciaremos a implantação para você.

Dica: Assim que tiver um servidor ZenML, confira a página de Configurações MCP no seu painel para a experiência de configuração mais fácil.

Compatibilidade: Este servidor MCP é testado e recomendado para ZenML >= 0.93.0. Se você estiver executando uma versão mais antiga do ZenML, use uma versão anterior deste servidor MCP.

Você também (provavelmente) precisará ter o uv instalado localmente. Para mais informações, consulte a documentação do uv. Recomendamos a instalação via script de instalação deles ou via brew se estiver usando um Mac. (Tecnicamente você não precisa dele, mas facilita a instalação e configuração.)

Você também precisará clonar este repositório em algum lugar localmente:

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

Seu arquivo de configuração MCP

O arquivo de configuração MCP é um arquivo JSON que informa ao cliente MCP como se conectar ao seu servidor MCP. Diferentes clientes MCP usarão ou especificarão isso de forma diferente. Dois clientes MCP comumente usados são Claude Desktop e Cursor, para os quais fornecemos instruções de instalação abaixo.

Você precisará especificar seu servidor ZenML MCP no seguinte 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"
            }
        }
    }
}

Existem quatro valores fictícios que você precisará substituir:

• o caminho para o seu uv instalado localmente (o caminho listado acima é onde ele estaria em um Mac se você o instalou via brew)
• o caminho para o arquivo zenml_server.py (este é o arquivo que será executado quando você se conectar ao servidor MCP). Este arquivo está localizado dentro deste repositório na raiz. Você precisará especificar o caminho completo exato para este arquivo.
• a URL do servidor ZenML (esta é a URL do seu servidor ZenML. Você pode encontrá-la na interface de nuvem do ZenML). Será algo como https://d534d987a-zenml.cloudinfra.zenml.io.
• a chave de API do servidor ZenML (esta é a chave de API para o seu servidor ZenML. Você pode encontrá-la na interface de nuvem do ZenML ou ler estes documentos sobre como criar uma. Para os propósitos do servidor ZenML MCP, recomendamos usar uma conta de serviço.)

Você é livre para mudar a forma como executa o arquivo Python do servidor MCP, mas usar uv provavelmente será a opção mais fácil, pois ele cuida do ambiente e da instalação de dependências para você.

Instalação para uso com Claude Desktop

Alternativa rápida: Use a página de Configurações MCP no seu painel ZenML (Configurações → MCP) para obter instruções de instalação pré-configuradas e links diretos para o Claude Desktop.

Você precisará ter a versão mais recente do Claude Desktop instalada.

Você pode simplesmente abrir o menu Configurações e arrastar o arquivo mcp-zenml.mcpb da raiz deste repositório para o menu e ele o guiará pelo processo de instalação e configuração. Você precisará adicionar a URL do seu servidor ZenML e a chave de API.

Nota: Pacotes MCP (.mcpb) substituem o formato mais antigo de Extensões de Desktop (.dxt); arquivos .dxt existentes ainda funcionam no Claude Desktop.

Opcional: Melhorando a Exibição dos Resultados das Ferramentas ZenML

Para uma melhor experiência com os resultados das ferramentas ZenML, você pode configurar o Claude para exibir as respostas JSON em um formato mais legível. No Claude Desktop, vá para Configurações → Perfil e, na seção "Quais preferências pessoais o Claude deve considerar nas respostas?", adicione algo como o seguinte (ou use exatamente estas palavras!):

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!

Isso incentivará o Claude a formatar as saídas das ferramentas ZenML como tabelas markdown, tornando as informações muito mais fáceis de ler e entender.

Instalação para uso com Cursor

Alternativa rápida: A página de Configurações MCP no seu painel ZenML (Configurações → MCP) pode gerar o conteúdo exato do mcp.json com suas credenciais pré-preenchidas.

Você precisará ter o Cursor instalado.

O Cursor funciona de forma um pouco diferente do Claude Desktop, pois você especifica o arquivo de configuração por repositório. Isso significa que, se você quiser usar o servidor ZenML MCP em vários repositórios, precisará especificar o arquivo de configuração em cada um deles.

Para configurá-lo para um único repositório, você precisará:

• criar uma pasta .cursor na raiz do seu repositório
• dentro dela, criar um arquivo mcp.json com o conteúdo acima
• acessar as configurações do Cursor e clicar no servidor ZenML para 'ativá-lo'.

Em nossa experiência, às vezes ele mostra um indicador de erro vermelho mesmo quando está funcionando. Você pode testar conversando na janela de chat do Cursor. Ele informará se consegue acessar as ferramentas ZenML ou não.

Imagem Docker

Você pode executar o servidor como um contêiner Docker. O processo se comunica via stdio, então aguardará uma conexão do cliente MCP. Passe suas credenciais ZenML via variáveis de ambiente.

Imagens Pré-construídas (Docker Hub)

Baixe a imagem multi-arquitetura mais recente:

docker pull zenmldocker/mcp-zenml:latest

Versões de lançamento são marcadas como X.Y.Z:

docker pull zenmldocker/mcp-zenml:1.0.8

Execute com suas credenciais 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

Configuração 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"
      ]
    }
  }
}

Compilação Local

A partir da raiz do repositório:

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

Execute a imagem compilada 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

Pacotes MCP (.mcpb)

Este projeto usa Pacotes MCP (.mcpb) — o sucessor das Extensões de Desktop (DXT) da Anthropic. Pacotes MCP empacotam um servidor MCP inteiro (incluindo dependências) em um único arquivo com configuração amigável ao usuário.

Nota sobre renomeação: Pacotes MCP substituem o formato mais antigo .dxt. O Claude Desktop permanece compatível com arquivos .dxt existentes, mas agora distribuímos mcp-zenml.mcpb e recomendamos seu uso daqui para frente.

O arquivo mcp-zenml.mcpb na raiz do repositório contém tudo o que é necessário para executar o servidor ZenML MCP, eliminando a necessidade de etapas complexas de instalação manual. Isso torna as integrações poderosas do ZenML acessíveis a usuários sem exigir conhecimento técnico de configuração.

Quando você arrasta e solta o arquivo .mcpb nas configurações do Claude Desktop, ele lida automaticamente com:

• Instalação de dependências em tempo de execução
• Gerenciamento seguro de configuração
• Compatibilidade entre plataformas
• Processo de configuração amigável

Para mais informações, consulte o anúncio da Anthropic sobre Extensões de Desktop (DXT) e orientações relacionadas ao empacotamento de pacotes MCP em sua documentação: https://www.anthropic.com/engineering/desktop-extensions

Publicado no Registro MCP da Anthropic

Este servidor MCP está publicado no Registro MCP oficial da Anthropic e pode ser descoberto por hosts compatíveis. A cada lançamento com tag, nosso CI atualiza a entrada do registro via a CLI mcp-publisher do registro usando GitHub OIDC, para que você possa instalar ou descobrir o Servidor ZenML MCP diretamente onde o registro for suportado (por exemplo, catálogo de Extensões do Claude Desktop).

• Sempre atualizado: a entrada do registro é atualizada a cada lançamento a partir do manifest.json e server.json do commit com tag.
• Caminhos de instalação alternativos: você ainda pode instalar localmente via o pacote .mcpb (veja acima) ou executar a imagem Docker.

Saiba mais sobre o registro aqui:

• Registro MCP da Anthropic (repositório da comunidade): https://github.com/modelcontextprotocol/registry