ZenML - Bridging the gap between ML & Ops

ZenML

• Welcome to ZenML: Discover resources to build, deploy, and scale your ML pipelines with ZenML.
• Installation: Installing ZenML and getting started.
• Hello World: Your first ML pipeline with ZenML - from local development to cloud deployment in minutes.
• Your First AI Pipeline: Choose your path and build your first pipeline with ZenML in minutes.
• Core Concepts: Discovering the core concepts behind ZenML.
• System Architecture: Different variations of the ZenML architecture depending on your needs.
• Deploy: Why do we need to deploy ZenML?
• Deploy with Docker: Deploying ZenML in a Docker container.
• Deploy with Helm: Deploying ZenML in a Kubernetes cluster with Helm.
• Migrate to Gateway API: Migrate ZenML Helm deployments from Ingress to Kubernetes Gateway API.
• Deploy using HuggingFace Spaces: Deploying ZenML to Huggingface Spaces.
• Deploy with custom images: Deploying ZenML with custom Docker images.
• Secret management: Configuring the secrets store.
• Custom secret stores: Learning how to develop a custom secret store.
• Live event streaming: Enable live event streaming on the ZenML server and consume the HTTP/SSE feed.
• Connect: Various means of connecting to ZenML.
• with your User (interactive): Connect to the ZenML server using the ZenML CLI and the web based login.
• with your User (programmatic): Connect to the ZenML server using a Personal Access Token.
• with a Service Account: Connect to the ZenML server using a service account and an API key.
• Manage: Learn how to upgrade your server to a new version of ZenML for the different deployment options.
• Best practices for upgrading: Simple, step-by-step guide for keeping your ZenML workspaces (servers) up to date without breaking your teams.
• Using ZenML server in production: Learn about best practices for using ZenML server in production environments.
• Troubleshoot your ZenML server: Troubleshooting tips for your ZenML deployment
• Migration guide: How to migrate your ZenML code to the newest version.
• Migration guide 0.13.2 → 0.20.0: How to migrate from ZenML <=0.13.2 to 0.20.0.
• Migration guide 0.23.0 → 0.30.0: How to migrate from ZenML 0.20.0-0.23.0 to 0.30.0-0.39.1.
• Migration guide 0.39.1 → 0.41.0: How to migrate your ZenML pipelines and steps from version <=0.39.1 to 0.41.0.
• Migration guide 0.58.2 → 0.60.0: How to migrate from ZenML 0.58.2 to 0.60.0 (Pydantic 2 edition).
• Steps & Pipelines: Steps and Pipelines are the core building blocks of ZenML
• Configuration: Configuring and customizing your pipeline runs.
• Scheduling: Learn how to create, update, activate, deactivate, and delete schedules for pipelines.
• Logging: Learn how to control and customize logging behavior in ZenML pipelines.
• YAML Configuration: Learn how to configure ZenML pipelines using YAML configuration files.
• Source Code and Imports: Understanding source roots and source paths
• Execution: Step and pipeline execution.
• Wait for External Input: Pause a dynamic pipeline for external input and resume it after the input is resolved.
• Advanced Features: Advanced features and capabilities of ZenML pipelines and steps
• Dynamic Pipelines: Write dynamic pipelines
• Streaming Events: Publish live events from inside a step to subscribed clients.
• Artifacts: Learn how ZenML manages data artifacts, tracks versioning and lineage, and enables effective data flow between steps.
• Materializers: Understanding and creating materializers to handle custom data types in ZenML pipelines
• Visualizations: Learn how to visualize the data artifacts produced by your ZenML pipelines.
• Stack & Components: Understanding and working with ZenML Stacks and Stack Components
• Service Connectors: Managing authentication to cloud services and resources with Service Connectors
• Pipeline Snapshots: Create and run pipeline snapshots.
• Pipeline Deployments: Deploy pipelines as HTTP services for real-time execution
• Deployment Settings: Customize the pipeline deployment ASGI application with DeploymentSettings.
• Containerization: Customize Docker builds to run your pipelines in isolated, well-defined environments.
• Code Repositories: Tracking your code and avoiding unnecessary Docker builds by connecting your git repo.
• Secrets: Registering and using secrets.
• Environment Variables: Configuring environment variables.
• Tags: Use tags to organize tags in ZenML.
• Metadata: Enrich your ML workflow with contextual information using ZenML metadata.
• Models: Managing ML models throughout their lifecycle with ZenML
• Dashboard: Explore the features and capabilities of the ZenML dashboard
• Templates: Create and run templates in ZenML to standardize execution.
• Community & content: All possible ways for our community to get in touch with ZenML.
• Environment Variables: How to control ZenML behavior with environmental variables.
• LLM Tooling: LLM tooling for ZenML - MCP servers, llms.txt, and Agent Skills
• FAQ: Find answers to the most frequently asked questions about ZenML.
• Global settings: Understanding the global settings of your ZenML installation.
• Legacy docs: All legacy docs of ZenML

Kitaru

• Welcome to Kitaru: The runtime layer underneath your agent stack.
• Installation: Install Kitaru with uv or pip
• Quickstart: Run your first durable agent flow with Kitaru
• Deploy: Move from local development to running agents in production
• Examples: Runnable Kitaru examples — start with the Agent Harness Platform tour, or jump to a feature-focused example
• Troubleshooting: Diagnose problems and reset Kitaru state
• Overview: A runnable reference architecture for building an internal agent harness platform with Kitaru and PydanticAI
• Durable Agent: PydanticAI runs the agent loop. Kitaru keeps a durable record of the work that finished before a crash.
• Sandbox: Run the agent's shell commands inside a Docker sandbox, so a mistaken command hits a throwaway container instead of your host.
• Skills: Move the agent's procedure out of the system prompt and into a markdown file an operator can edit without changing code.
• Credential Proxy: A separate proxy container holds the service credentials and injects auth headers; the worker never holds them
• Typed Services: Add exec_service for structured host-side calls (look up a record, create a ticket, publish a summary) when a shell command is the wrong shape
• Human in the Loop: ask_question, a freeform HITL tool that pauses the flow until an operator answers from any surface
• Production Notes: Which pieces of the Agent Harness Platform tour are teaching stand-ins, where each one plugs into production, and what to harden before you rely on the pattern
• Overview: The mental model behind Kitaru's durable execution primitives.
• Harness, Runtime, Platform: Where Kitaru fits — and doesn't — in an agent stack.
• How It Works: What runs where when you execute a Kitaru flow — server, runner, execution targets, and the contract between them.
• Flows: Define durable execution boundaries for your AI agent workflows.
• Deployments: Version and share durable flow entrypoints for remote invocation.
• Checkpoints: Durable work units with persistence and concurrency support.
• Wait, Input, and Resume: Pause flows for human or agent input, then resume from where they left off.
• Logging and Metadata: Attach structured data to executions and checkpoints.
• Configuration: Kitaru config directory, execution defaults, environment variables, and precedence
• Authentication: Service accounts, API keys, and short-lived bearer tokens for Kitaru servers
• Deploy and Invoke Flows: A practical producer-consumer guide to deploying Kitaru flows, moving tags, and invoking stable or canary routes
• Containerization: How Kitaru builds and configures container images for remote execution
• Execution Management: Inspect execution status, fetch runtime logs, resolve waits, and manage lifecycle actions
• View Execution Runtime Logs: Retrieve execution and checkpoint runtime logs from the SDK, CLI, and MCP
• Checkpoint Live Events: Publish and watch best-effort live progress and custom events from running checkpoints
• Replay and Overrides: Replay executions from checkpoints with flow and checkpoint overrides
• Wait, Input, and Resume: Suspend a flow for external input and continue the same execution
• Artifacts: Persist named values in checkpoints and reuse them across executions
• Error Handling: Understand Kitaru exception types and failure journaling
• Tracked LLM Calls: Use kitaru.llm() with model aliases, transported runtime config, and optional secret-backed credentials
• Secrets and Model Registration: Store provider credentials, register a model alias, and use kitaru.llm() inside a flow
• Secrets: Create, inspect, list, and delete centralized secrets from the Kitaru CLI and Python SDK
• Choose an Adapter: Pick the Kitaru integration path for your existing agent harness
• Overview: Use Kitaru with PydanticAI, OpenAI Agents, Claude Agent SDK, Gemini Interactions, and LangGraph.
• Pydantic AI: Make any PydanticAI agent replayable, resumable, and observable by wrapping it once with KitaruAgent
• OpenAI Agents: Wrap an OpenAI Agents SDK Agent with KitaruRunner so calls are durable and replayable inside Kitaru flows
• Claude Agent SDK: Wrap Claude Agent SDK invocations in Kitaru checkpoints, capture session context, and replay completed Claude calls honestly
• Gemini Interactions: Make Gemini Interactions API turns replayable and observable with Kitaru checkpoints, including Antigravity managed-agent runs
• LangGraph: Run LangGraph graphs inside Kitaru flows with either coarse graph-call checkpoints or granular LangChain call checkpoints
• Docker: Deploy the Kitaru server using Docker or Docker Compose
• Helm: Deploy the Kitaru server on Kubernetes using the Kitaru Helm chart
• Overview: Create, inspect, switch, and delete the stacks Kitaru uses for execution
• Kubernetes Stacks: Create, inspect, use, and clean up Kubernetes-backed stacks in Kitaru
• Vertex Stacks: Create, inspect, and use Vertex AI-backed stacks with GCS storage
• SageMaker Stacks: Create, inspect, and use SageMaker-backed stacks with S3 storage
• AzureML Stacks: Create, inspect, and use AzureML-backed stacks with Azure Blob storage
• Log Store: Set, inspect, and reset Kitaru's global runtime log-store backend
• MCP Server: Query and manage Kitaru executions, deployments, artifacts, stacks, and secret creation through Model Context Protocol tools
• Claude Code Skill: Install the zenml-io/kitaru-skills package for Kitaru quickstarts, workflow authoring, and adapter migrations
• Contributing: How to contribute to Kitaru.

Learn

• Overview: Guides, examples and projects
• Starter guide: Kickstart your journey into MLOps with the essentials of ZenML.
• Create an ML pipeline: Start with the basics of steps and pipelines.
• Cache previous executions: Iterating quickly with ZenML through caching.
• Manage artifacts: Understand and adjust how ZenML versions your data.
• Track ML models: Creating a full picture of a ML model using the Model Control Plane
• A starter project: Put your new knowledge into action with a simple starter project
• Production guide: Level up your skills in a production setting.
• Deploying ZenML: Deploying ZenML is the first step to production.
• Understanding stacks: Learning how to switch the infrastructure backend of your code.
• Connecting remote storage: Transitioning to remote artifact storage.
• Orchestrate on the cloud: Orchestrate using cloud resources.
• Configure your pipeline to add compute: Add more resources to your pipeline configuration.
• Configure a code repository: Connect a Git repository to ZenML to track code changes and collaborate on MLOps projects.
• Set up CI/CD: Managing the lifecycle of a ZenML pipeline with Continuous Integration and Delivery
• An end-to-end project: Put your new knowledge in action with an end-to-end project
• LLMOps guide: Leverage the power of LLMs in your MLOps workflows with ZenML.
• RAG with ZenML: RAG is a sensible way to get started with LLMs.
• RAG in 85 lines of code: Learn how to implement a RAG pipeline in just 85 lines of code.
• Understanding Retrieval-Augmented Generation (RAG): Understand the Retrieval-Augmented Generation (RAG) technique and its benefits.
• Data ingestion and preprocessing: Understand how to ingest and preprocess data for RAG pipelines with ZenML.
• Embeddings generation: Generate embeddings to improve retrieval performance.
• Storing embeddings in a vector database: Store embeddings in a vector database for efficient retrieval.
• Basic RAG inference pipeline: Use your RAG components to generate responses to prompts.
• Evaluation and metrics: Track how your RAG pipeline improves using evaluation and metrics.
• Evaluation in 65 lines of code: Learn how to implement evaluation for RAG in just 65 lines of code.
• Retrieval evaluation: See how the retrieval component responds to changes in the pipeline.
• Generation evaluation: Evaluate the generation component of your RAG pipeline.
• Evaluation in practice: Learn how to evaluate the performance of your RAG system in practice.
• Reranking for better retrieval: Add reranking to your RAG inference for better retrieval performance.
• Understanding reranking: Understand how reranking works.
• Implementing reranking in ZenML: Learn how to implement reranking in ZenML.
• Evaluating reranking performance: Evaluate the performance of your reranking model.
• Improve retrieval by finetuning embeddings: Finetune embeddings on custom synthetic data to improve retrieval performance.
• Synthetic data generation: Generate synthetic data with distilabel to finetune embeddings.
• Finetuning embeddings with Sentence Transformers: Finetune embeddings with Sentence Transformers.
• Evaluating finetuned embeddings: Evaluate finetuned embeddings and compare to original base embeddings.
• Finetuning LLMs with ZenML: Finetune LLMs for specific tasks or to improve performance and cost.
• Finetuning in 100 lines of code: Learn how to implement an LLM fine-tuning pipeline in just 100 lines of code.
• Why and when to finetune LLMs: Deciding when is the right time to finetune LLMs.
• Starter choices with finetuning: Get started with finetuning LLMs by picking a use case and data.
• Finetuning with 🤗 Accelerate: Finetuning an LLM with Accelerate and PEFT
• Evaluation for finetuning
• Deploying finetuned models
• Next steps
• Managing scheduled pipelines: A step-by-step tutorial on how to create, update, and delete scheduled pipelines in ZenML
• Trigger pipelines from external systems: A step-by-step tutorial on effectively triggering your ZenML pipelines from external systems
• Hyper-parameter tuning: Running a hyperparameter tuning trial with ZenML.
• Inspecting past pipeline runs: Inspecting a finished pipeline run and its outputs.
• Replaying runs and steps: Re-run pipelines or individual steps using artifacts from a previous execution.
• Train with GPUs: Train ZenML pipelines on GPUs and scale out with 🤗 Accelerate.
• Running notebooks remotely: Leveraging Jupyter notebooks with ZenML.
• Managing machine learning datasets: Model datasets using simple abstractions.
• Handling big data: Learn about how to manage big data with ZenML.
• 5-minute Quick Wins: 5-minute Quick Wins
• Keep Your Dashboard Clean: Learn how to keep your pipeline runs clean during development.
• Configure Python environments: Navigating multiple development environments.
• Shared Components for Teams: Sharing code and libraries within teams.
• Organizing Stacks Pipelines Models: A step-by-step tutorial on effectively organizing your ML assets in ZenML using tags and projects
• Access Management: A guide on managing user roles and responsibilities in ZenML.
• Setting up a Project Repository: Setting your team up for success with a well-architected ZenML project.
• Infrastructure as Code with Terraform: Best practices for using IaC with ZenML
• Creating Templates for ML Platform: Setting your team up for success with a well-architected ZenML project.
• Using VS Code extension: Use the ZenML VSCode extension to manage your ZenML server
• Leveraging MCP: Chat with your ZenML server
• Debugging and Solving Issues: A guide to debug common issues and get help.
• Choosing an Orchestrator: How to choose the right orchestration environment

ZenML Pro

• Introduction: Learn about the ZenML Pro features and deployment scenarios.
• System Architecture: Understanding ZenML Pro services and how they communicate.
• Scenarios: Compare ZenML Pro deployment scenarios to find the right fit for your organization.
• SaaS: Learn about ZenML Pro SaaS deployment - the fastest way to get started with production-ready MLOps.
• Hybrid: Learn about ZenML Pro Hybrid SaaS deployment - balancing control with convenience for enterprise MLOps.
• Self-hosted: Learn about ZenML Pro Self-hosted deployment - complete control and data sovereignty for the strictest security requirements.
• Deployment Details: Reference documentation for deploying ZenML Pro components.
• Prerequisites: Prepare for deploying the ZenML Pro control plane and/or workspace servers in a self-hosted environment.
• Control Plane: Configuration reference for the ZenML Control Plane.
• Kubernetes with Helm: Deploy ZenML Pro Self-hosted on Kubernetes with Helm - complete self-hosted setup with no external dependencies.
• Workspace Server: Configuration reference for the ZenML Workspace Server.
• Enroll Workspaces: Enroll a ZenML Pro workspace in the ZenML Pro control plane
• Kubernetes with Helm: Deploy ZenML Pro workspaces on Kubernetes with Helm and enroll them in the ZenML Pro control plane
• AWS ECS: Deploy ZenML Pro Hybrid on AWS ECS with a managed control plane.
• Enable Snapshot Support: Enable snapshot support for self-hosted ZenML Pro workspaces
• Enable Event Triggers and Schedules: Enable ZenML Pro event triggers and schedules (scheduler and executor microservices) for self-hosted workspace servers on Kubernetes.
• Enable Resource Pools: Enable the ZenML Pro resource pool reconciler microservice for self-hosted workspace servers on Kubernetes.
• Single Sign-On (SSO): Configure Single Sign-On (SSO) authentication for ZenML Pro self-hosted deployments.
• User Accounts: Understand and manage user accounts in ZenML Pro self-hosted deployments.
• Upgrades and Updates: How to upgrade ZenML Pro components.
• Control Plane: How to upgrade the ZenML Control Plane.
• Workspace Server: How to upgrade ZenML Workspace Servers.
• Hierarchy: Understanding ZenML's hierarchical structure
• Organizations: Manage organizations in ZenML
• Workspaces: Learn how to use workspaces in ZenML Pro.
• Projects: Managing projects in ZenML
• Teams: Learn about Teams in ZenML Pro and how they can be used to manage groups of users across your organization and workspaces.
• Snapshots: Trigger pipelines from the dashboard, SDK, CLI, or REST API.
• Triggers: Trigger pipelines by schedule or event.
• Resource Pools: Fair GPU and compute sharing for AI/ML teams: dependable production capacity, shared pools, idle reuse, and workspace-level quotas.
• Core Concepts: Precise definitions for ZenML Pro resource pools, subject policies, and resource requests.
• Reconciliation Process: How the resource pool reconciliation process works in ZenML Pro.
• Examples: Step-by-step ZenML Pro resource pool examples: pool JSON, policy JSON, ResourceSettings, and outcomes for new users.
• Roles & Permissions: Learn about the different roles and permissions you can assign to your team members in ZenML Pro.
• Trusted domains: Organization trusted domains in ZenML Pro — user visibility, invitations, SSO, and how operators configure them.
• Personal Access Tokens: Learn how to manage and use Personal Access Tokens.
• Service Accounts: Learn how to manage and use service accounts and API keys .
• Secrets Stores: Learn how to link your own secrets store backend to your ZenML Pro workspace.

Stacks

• Overview: Overview of categories of MLOps components and third-party integrations.
• Integrations
• Orchestrators: Orchestrating the execution of ML pipelines.
• Local Orchestrator: Orchestrating your pipelines to run locally.
• Local Docker Orchestrator: Orchestrating your pipelines to run in Docker.
• Kubeflow Orchestrator: Orchestrating your pipelines to run on Kubeflow.
• Kubernetes Orchestrator: Orchestrating your pipelines to run on Kubernetes clusters.
• Google Cloud VertexAI Orchestrator: Orchestrating your pipelines to run on Vertex AI.
• AWS Sagemaker Orchestrator: Orchestrating your pipelines to run on Amazon Sagemaker.
• AzureML Orchestrator: Orchestrating your pipelines to run on AzureML.
• Databricks Orchestrator: Orchestrating your pipelines to run on Databricks.
• Tekton Orchestrator: Orchestrating your pipelines to run on Tekton.
• Airflow Orchestrator: Orchestrating your pipelines to run on Airflow.
• Skypilot VM Orchestrator: Orchestrating your pipelines to run on VMs using SkyPilot.
• HyperAI Orchestrator: Orchestrating your pipelines to run on HyperAI.ai instances.
• Lightning AI Orchestrator: Orchestrating your pipelines to run on Lightning AI.
• Develop a custom orchestrator: Learning how to develop a custom orchestrator.
• Deployers: Deploy pipelines as HTTP services for real-time execution
• Local Deployer: Deploying pipelines on your local machine as background processes.
• Docker Deployer: Deploying your pipelines locally with Docker.
• Kubernetes Deployer: Deploying your pipelines to Kubernetes clusters.
• AWS App Runner Deployer: Deploying your pipelines to AWS App Runner.
• GCP Cloud Run Deployer: Deploying your pipelines to GCP Cloud Run.
• Hugging Face Deployer: Deploying your pipelines to Hugging Face Spaces.
• Artifact Stores: Setting up a persistent storage for your artifacts.
• Local Artifact Store: Storing artifacts on your local filesystem.
• Amazon Simple Cloud Storage (S3): Storing artifacts in an AWS S3 bucket.
• Google Cloud Storage (GCS): Storing artifacts using GCP Cloud Storage.
• Azure Blob Storage: Storing artifacts using Azure Blob Storage
• Alibaba Cloud OSS: Storing artifacts in Alibaba Cloud Object Storage Service (OSS).
• MinIO: Storing artifacts in MinIO object storage.
• Develop a custom artifact store: Learning how to develop a custom artifact store.
• Container Registries: Setting up a storage for Docker images.
• Default Container Registry: Storing container images locally.
• DockerHub: Storing container images in DockerHub.
• Amazon Elastic Container Registry (ECR): Storing container images in Amazon ECR.
• Google Cloud Container Registry: Storing container images in GCP.
• Azure Container Registry: Storing container images in Azure.
• GitHub Container Registry: Storing container images in GitHub.
• Develop a custom container registry: Learning how to develop a custom container registry.
• Log Stores: Storing and retrieving logs from your ML pipelines.
• Artifact Log Store: Storing logs in your artifact store.
• OpenTelemetry Log Store: Exporting logs to any OpenTelemetry-compatible backend.
• Datadog Log Store: Exporting logs to Datadog's log management platform.
• Develop a Custom Log Store: Learning how to develop a custom log store.
• Step Operators: Executing individual steps in specialized environments.
• Amazon SageMaker: Executing individual steps in SageMaker.
• AzureML: Executing individual steps in AzureML.
• Databricks: Executing individual steps on Databricks.
• Google Cloud VertexAI: Executing individual steps in Vertex AI.
• Kubernetes: Executing individual steps in Kubernetes Pods.
• Run:AI: Executing individual steps on Run:AI clusters with fractional GPU support.
• Modal: Executing individual steps in Modal.
• Spark: Executing individual steps on Spark
• Develop a Custom Step Operator: Learning how to develop a custom step operator.
• Experiment Trackers: Logging and visualizing ML experiments.
• Comet: Logging and visualizing experiments with Comet.
• MLflow: Logging and visualizing experiments with MLflow.
• Neptune: Logging and visualizing experiments with neptune.ai
• Weights & Biases: Logging and visualizing experiments with Weights & Biases.
• Google Cloud VertexAI Experiment Tracker: Logging and visualizing experiments with Vertex AI Experiment Tracker.
• Develop a custom experiment tracker: Learning how to develop a custom experiment tracker.
• Image Builders: Building container images for your ML workflow.
• Local Image Builder: Building container images locally.
• Kaniko Image Builder: Building container images with Kaniko.
• AWS Image Builder: Building container images with AWS CodeBuild
• Google Cloud Image Builder: Building container images with Google Cloud Build
• Develop a Custom Image Builder: Learning how to develop a custom image builder.
• Alerters: Sending automated alerts to chat services.
• Discord Alerter: Sending automated alerts to a Discord channel.
• Slack Alerter: Sending automated alerts to a Slack channel.
• Develop a Custom Alerter: Learning how to develop a custom alerter.
• Annotators: Annotating the data in your workflow.
• Argilla: Annotating data using Argilla.
• Label Studio: Annotating data using Label Studio.
• Pigeon: Annotating data using Pigeon.
• Prodigy: Annotating data using Prodigy.
• Develop a Custom Annotator: Learning how to develop a custom annotator.
• Data Validators: How to enhance and maintain the quality of your data and the performance of your models with data profiling and validation
• Great Expectations: How to use Great Expectations to run data quality checks in your pipelines and document the results
• Deepchecks: How to test the data and models used in your pipelines with Deepchecks test suites
• Evidently: How to keep your data quality in check and guard against data and model drift with Evidently profiling
• Whylogs: How to collect and visualize statistics to track changes in your pipelines' data with whylogs/WhyLabs profiling.
• Develop a custom data validator: How to develop a custom data validator
• Feature Stores: Managing data in feature stores.
• Feast: Managing data in Feast feature stores.
• Develop a Custom Feature Store: Learning how to develop a custom feature store.
• Model Deployers: Deploying your models and serve real-time predictions.
• MLflow: Deploying your models locally with MLflow.
• Seldon: Deploying models to Kubernetes with Seldon Core.
• BentoML: Deploying your models locally with BentoML.
• Hugging Face: Deploying models to Huggingface Inference Endpoints with Hugging Face :hugging_face:.
• Databricks: Deploying models to Databricks Inference Endpoints with Databricks
• vLLM: Deploying your LLM locally with vLLM.
• Develop a Custom Model Deployer: Learning how to develop a custom model deployer.
• Model Registries: Tracking and managing ML models.
• MLflow Model Registry: Managing MLFlow logged models and artifacts
• Develop a Custom Model Registry: Learning how to develop a custom model registry.
• Introduction: Connect your ZenML deployment to a cloud provider and other infrastructure services and resources.
• Complete guide: The complete guide to managing Service Connectors and connecting ZenML to external resources.
• Best practices: Best practices concerning the various authentication methods implemented by Service Connectors.
• Connector Types
• Docker Service Connector: Configuring Docker Service Connectors to connect ZenML to Docker container registries.
• Kubernetes Service Connector: Configuring Kubernetes Service Connectors to connect ZenML to Kubernetes clusters.
• AWS Service Connector: Configuring AWS Service Connectors to connect ZenML to AWS resources like S3 buckets, EKS Kubernetes clusters and ECR container registries.
• GCP Service Connector: Configuring GCP Service Connectors to connect ZenML to GCP resources such as GCS buckets, GKE Kubernetes clusters, and GCR container registries.
• Azure Service Connector: Configuring Azure Service Connectors to connect ZenML to Azure resources such as Blob storage buckets, AKS Kubernetes clusters, and ACR container registries.
• HyperAI Service Connector: Configuring HyperAI Connectors to connect ZenML to HyperAI instances.
• AWS: A simple guide to create an AWS stack to run your ZenML pipelines
• Azure: A simple guide to create an Azure stack to run your ZenML pipelines
• GCP: A simple guide to quickly set up a minimal stack on GCP.
• Kubernetes: Learn how to deploy ZenML pipelines on a Kubernetes cluster.
• 1-click Deployment: Deploy a cloud stack from scratch with a single click
• Terraform Modules: Deploy a cloud stack using Terraform
• Register a cloud stack: Seamlessly register a cloud stack by using existing infrastructure
• Infrastructure as code: Leverage Infrastructure as Code to manage your ZenML stacks and components.
• Custom Stack Component: How to write a custom stack component flavor
• Custom Integration: Creating an external integration and contributing to ZenML

API Reference

• Overview: The ZenML API provides programmatic access to ZenML services beyond what's available in the Python SDK.
• Getting Started
• OSS API
• Artifacts
• Artifact versions
• Batch
• Visualize
• Login
• Logout
• Device authorization
• Api token
• Code repositories
• Logs
• Models
• Model versions
• Model versions
• Artifacts
• Runs
• Pipelines
• Runs
• Runs
• Steps
• Pipeline configuration
• Status
• Refresh
• Run templates
• Runs
• Schedules
• Secrets
• Info
• Service accounts
• Api keys
• Rotate
• Service connectors
• Verify
• Client
• Full stack resources
• Services
• Stacks
• Components
• Component types
• Steps
• Step configuration
• Status
• Logs
• Tags
• Users
• Resource membership
• Current user
• Getting Started
• Pro API
• Tenants
• Deploy
• Deactivate
• Members
• Tenant status
• Users
• Authorize server
• Me
• Invitations
• Releases
• Devices
• Verify
• Roles
• Assignments
• Permissions
• Teams
• Members
• Organizations
• Trial
• Invitations
• Members
• Roles
• Teams
• Tenants
• Tenant
• Entitlement
• Validation
• Name
• Tenant name
• Health
• Usage event
• Usage batch
• Stigg webhook
• Auth
• Login
• Connections
• Authorize
• Callback
• Logout
• Device authorization
• Api token
• Tenant authorization
• Rbac
• Check permissions
• Allowed resource ids
• Resource members
• Server
• Info

SDK Reference

• Overview: See docstrings for ZenML Code
• Client
• Example usages: Interacting with your ZenML instance through the ZenML Client.

Changelog

• Overview: Stay up to date with the latest features, improvements, and fixes across ZenML OSS and ZenML Pro.
• Server & SDK: Changelog for ZenML OSS and ZenML UI.
• Pro Control Plane: Changelog for ZenML Pro.

---

Agent Instructions: Querying This Documentation

If you need additional information, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on a page URL with the ask query parameter:

GET https://docs.zenml.io/getting-started/introduction.md?ask=<question>

The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.