ZenML

https://github.com/zenml-io/zenml
Admin
ZenML is an open-source MLOps platform that enables ML engineers to build, track, and deploy machine...
Tokens:1,173,023
Snippets:8,016
Trust Score:8.3
License:Apache-2.0
Update:1 month ago
Show doc for...
Tokens:
Raw
### Quick Start: Setup and Run Agent Framework Example

Source: https://github.com/zenml-io/zenml/blob/main/examples/agent_framework_integrations/README.md

Sets up and runs any agent framework example. Requires an OpenAI API key and Python 3.11. Creates a virtual environment, installs dependencies from requirements.txt, and executes the main script.

```bash
export OPENAI_API_KEY="your-api-key-here"
cd framework-name/
uv venv --python 3.11
source .venv/bin/activate
uv pip install -r requirements.txt
python run.py

```

--------------------------------

### Install ZenML and clone the repository

Source: https://github.com/zenml-io/zenml/blob/main/examples/mlops_starter/README.md

Installs ZenML with the server extra and clones the ZenML repository, then changes into the mlops_starter example directory. This is the prerequisite setup for running the quickstart locally.

```shell
# Install ZenML
pip install "zenml[server]"

# clone the ZenML repository
git clone https://github.com/zenml-io/zenml.git
cd zenml/examples/mlops_starter
```

--------------------------------

### Quick start: clone and install deploying_agent example

Source: https://github.com/zenml-io/zenml/blob/main/docs/book/getting-started/your-first-ai-pipeline.md

Clone the ZenML repository, navigate to the deploying_agent example, and install its dependencies with uv. This is the quick start for the agent deployment path.

```bash
git clone --depth 1 https://github.com/zenml-io/zenml.git
cd zenml/examples/deploying_agent
uv pip install -r requirements.txt
```

--------------------------------

### Set up the deploying_agent example

Source: https://github.com/zenml-io/zenml/blob/main/examples/deploying_agent/README.md

Clone the ZenML repository, install example dependencies, initialize ZenML, and log in.

```bash
git clone --depth 1 https://github.com/zenml-io/zenml.git
cd zenml/examples/deploying_agent
pip install -r requirements.txt
zenml init
zenml login
```

--------------------------------

### Setup and run the LangGraph + ZenML example

Source: https://github.com/zenml-io/zenml/blob/main/examples/agent_framework_integrations/langgraph/README.md

Setup commands for the LangGraph + ZenML example: export the OpenAI API key, create a Python 3.11 virtual environment with uv, install dependencies, initialize ZenML, log in, and run the pipeline.

```bash
export OPENAI_API_KEY="your-api-key-here"
uv venv --python 3.11
source .venv/bin/activate
uv pip install -r requirements.txt
```

```bash
zenml init
zenml login
```

```bash
python run.py
```

--------------------------------

### Quickstart: Run the LakeFS + ZenML pipeline

Source: https://github.com/zenml-io/zenml/blob/main/examples/lakefs_data_versioning/README.md

Start a local LakeFS instance with Docker, install dependencies, initialize ZenML, and run the pipeline.

```bash
docker compose up -d          # start local LakeFS
pip install -r requirements.txt
zenml init
python run.py                 # run the pipeline
```

--------------------------------

### Quick start commands

Source: https://github.com/zenml-io/zenml/blob/main/docs/book/getting-started/your-first-ai-pipeline.md

Commands to clone the ZenML repository and install dependencies for the deploying_ml_model example.

```bash
git clone --depth 1 https://github.com/zenml-io/zenml.git
cd zenml/examples/deploying_ml_model
uv pip install -r requirements.txt
```

--------------------------------

### Install and log in to ZenML

Source: https://github.com/zenml-io/zenml/blob/main/docs/book/user-guide/starter-guide/create-an-ml-pipeline.md

Install ZenML with the server extra and log in locally to launch the dashboard. Run these commands before starting the guide.

```shell
pip install "zenml[server]"
```

```shell
zenml login --local  # Will launch the dashboard locally
```

--------------------------------

### Quick Start Commands for RLM Document Analysis

Source: https://github.com/zenml-io/zenml/blob/main/examples/rlm_document_analysis/README.md

Commands to set up and run the example. Includes installing dependencies, setting the API key, initializing ZenML, and running with default or custom queries. Also shows how to control chunking and use keyword fallback mode without an API key.

```bash
cd examples/rlm_document_analysis
pip install -r requirements.txt
export OPENAI_API_KEY="your-api-key"
zenml init && zenml login

# Default query with sample data
python run.py

# Custom query
python run.py --query "What concerns did Vince Kaminski raise about risk?"

# Control chunking
python run.py --query "Trace the Raptor vehicle timeline" --max-chunks 5

# Without API key (keyword fallback mode)
unset OPENAI_API_KEY
python run.py --query "California trading strategies"
```

--------------------------------

### Clone and install agent_outer_loop example

Source: https://github.com/zenml-io/zenml/blob/main/docs/book/getting-started/your-first-ai-pipeline.md

Quick start commands to clone the ZenML repository, navigate to the agent_outer_loop example, and install dependencies with uv.

```bash
git clone --depth 1 https://github.com/zenml-io/zenml.git
cd zenml/examples/agent_outer_loop
uv pip install -r requirements.txt
```

--------------------------------

### Install ZenML and Setup Environment

Source: https://github.com/zenml-io/zenml/blob/main/examples/quickstart/quickstart.ipynb

Installs ZenML with server support and configures the environment for Google Colab, including cloning the quickstart repository.

```python
!pip install -q "zenml[server]"

from zenml.environment import Environment

if Environment.in_google_colab():
    # Install Cloudflare Tunnel binary for public endpoint
    !wget -q https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-amd64.deb && dpkg -i cloudflared-linux-amd64.deb

    # Clone the quickstart example
    !git clone -q -b main https://github.com/zenml-io/zenml
    !cp -r zenml/examples/quickstart/* . && rm -rf zenml

print("✅ ZenML installed successfully!")
```

--------------------------------

### Clone e2e example alternative

Source: https://github.com/zenml-io/zenml/blob/main/docs/book/user-guide/production-guide/end-to-end.md

Alternative setup: clones the ZenML repository, navigates to the e2e example, installs requirements, and initializes ZenML.

```bash
git clone --depth 1 git@github.com:zenml-io/zenml.git
cd zenml/examples/e2e
pip install -r requirements.txt
zenml init
```

--------------------------------

### Set up e2e_batch template for Production Guide

Source: https://github.com/zenml-io/zenml/blob/main/docs/book/user-guide/best-practices/project-templates.md

Recommended setup for following the Production Guide: create a directory, enter it, and initialize the e2e_batch template with defaults.

```bash
mkdir e2e_batch
cd e2e_batch
zenml init --template e2e_batch --template-with-defaults
```

--------------------------------

### Run the software factory example

Source: https://github.com/zenml-io/zenml/blob/main/examples/software_factory/README.md

Installs dependencies and runs the example with required flags. Only --repo, --issue, and --sandbox-image are required; other flags have defaults.

```bash
cd examples/software_factory
pip install -r requirements.txt

python run.py \
  --repo owner/name \
  --issue "Add a health check endpoint." \
  --test-command "uv run pytest tests/unit -q" \
  --sandbox-image <registry>/software-factory-sandbox:latest
```

--------------------------------

### Run quickstart interactively with Jupyter Notebook

Source: https://github.com/zenml-io/zenml/blob/main/examples/mlops_starter/README.md

Installs Jupyter Notebook and launches it so you can interactively explore the quickstart.ipynb notebook. This is Option 1 for running the quickstart locally.

```bash
pip install notebook
jupyter notebook
# open quickstart.ipynb
```

--------------------------------

### Install and initialize ZenML with server

Source: https://github.com/zenml-io/zenml/blob/main/README.md

Install ZenML with server capabilities, initialize a ZenML repository, and start a local server or connect to a remote one. The first command installs the server-enabled package; a plain `pip install zenml` installs a slimmer client. Run these commands in order to set up a local ZenML environment.

```bash
pip install "zenml[server]"  # pip install zenml will install a slimmer client
```

```bash
zenml init
```

```bash
zenml login
```

--------------------------------

### Quick Start Commands for Hierarchical Document Search Agent

Source: https://github.com/zenml-io/zenml/blob/main/examples/hierarchical_doc_search_agent/README.md

Run these commands from the example directory to set up and execute the agent. It installs dependencies, sets the OpenAI API key, optionally overrides the default model (gpt-5-nano), initializes ZenML, and runs queries with optional --max-agents and --max-depth flags (clamped to 1-10 and 1-5 respectively).

```bash
cd examples/hierarchical_doc_search_agent
pip install -r requirements.txt
export OPENAI_API_KEY="your-api-key"
# Optionally override the default model (gpt-5-nano):
# export LLM_MODEL="openai:gpt-4o"
zenml init && zenml login

# Simple query (fast keyword search)
python run.py --query "What is Python?"

# Deep query (agents traverse the document graph)
python run.py --query "How does quantum computing relate to machine learning?"

# Control breadth and depth (clamped: max_agents 1-10, max_depth 1-5)
python run.py --query "Compare ML approaches" --max-agents 5 --max-depth 3
```

--------------------------------

### Run the Comparison Pipeline

Source: https://github.com/zenml-io/zenml/blob/main/examples/agent_comparison/README.md

Navigate to the example directory, install dependencies, and execute the pipeline script.

```bash
# Clone and navigate to the example
cd examples/agent_comparison

# Install dependencies
pip install -r requirements.txt

# Run the comparison pipeline
python agent_comparison_pipeline.py
```

--------------------------------

### Setup and Run ZenML E2E Project

Source: https://github.com/zenml-io/zenml/blob/main/examples/e2e/README.md

Commands to set up a Python virtual environment, install requirements and integrations, optionally provision a local stack, start the ZenML UI locally, and run the pipeline.

```bash
# Set up a Python virtual environment, if you haven't already
python3 -m venv .venv
source .venv/bin/activate
# Install requirements & integrations
make setup
# Optionally, provision default local stack
make install-stack-local
# Start the ZenML UI locally (recommended, but optional)
zenml login --local
# Run the pipeline included in the project
python run.py
```

--------------------------------

### Prerequisites: Setup environment and ZenML

Source: https://github.com/zenml-io/zenml/blob/main/examples/hydra_config_management/README.md

Commands to create a virtual environment, install dependencies, and initialize and log in to ZenML.

```bash
uv venv --seed
source .venv/bin/activate
pip install -r requirements.txt
zenml init
zenml login
```

--------------------------------

### Install ZenML server

Source: https://github.com/zenml-io/zenml/blob/main/examples/mlops_starter/quickstart.ipynb

Installs the latest version of ZenML with the server extra using pip. This is the first step to get started with the example.

```python
!pip install "zenml[server]"
```

--------------------------------

### Quickstart: Install, init, and run the agentic HITL pipeline

Source: https://github.com/zenml-io/zenml/blob/main/examples/agentic_hitl_pipeline/README.md

Install dependencies, initialize ZenML, and run the pipeline. When the run pauses, open the dashboard URL printed in the logs and resolve the `human_approval` wait condition (Continue / Abort).

```bash
pip install -r requirements.txt
zenml init
python run.py
```

--------------------------------

### Set up ZenML starter project

Source: https://github.com/zenml-io/zenml/blob/main/docs/book/user-guide/production-guide/understand-stacks.md

Commands to set up the ZenML starter project. This installs ZenML with templates and server, installs the sklearn integration, creates a new directory, initializes a starter template, and installs requirements.

```bash
pip install "zenml[templates,server]" notebook
zenml integration install sklearn -y
mkdir zenml_starter
cd zenml_starter
zenml init --template starter --template-with-defaults

# Just in case, we install the requirements again
pip install -r requirements.txt
```

--------------------------------

### Environment setup with uv

Source: https://github.com/zenml-io/zenml/blob/main/examples/agent_framework_integrations/README.md

Sets up a Python 3.11 virtual environment and installs dependencies from a requirements file using uv. These commands are the standard environment setup for all framework examples.

```bash
uv venv --python 3.11
```

```bash
uv pip install -r requirements.txt
```

--------------------------------

### Install dependencies and set up environment

Source: https://github.com/zenml-io/zenml/blob/main/examples/agent_framework_integrations/qwen-agent/README.md

Sets up the environment for the Qwen-Agent example. Requires Python 3.11 and the OPENAI_API_KEY environment variable.

```bash
export OPENAI_API_KEY="your-api-key-here"
cd qwen-agent/
uv venv --python 3.11
source .venv/bin/activate
uv pip install -r requirements.txt
```

--------------------------------

### Set up ZenML in Google Colab

Source: https://github.com/zenml-io/zenml/blob/main/examples/mlops_starter/quickstart.ipynb

Checks if running in Google Colab and, if so, installs Cloudflare Tunnel, clones the ZenML repository, copies the quickstart example files, and removes the cloned repo. This prepares the Colab environment for the example.

```python
from zenml.environment import Environment

if Environment.in_google_colab():
    # Install Cloudflare Tunnel binary
    !wget -q https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-amd64.deb && dpkg -i cloudflared-linux-amd64.deb

    # Pull required modules from this example
    !git clone -b main https://github.com/zenml-io/zenml
    !cp -r zenml/examples/quickstart/* .
    !rm -rf zenml
```

--------------------------------

### Run the pipeline API locally with environment setup

Source: https://github.com/zenml-io/zenml/blob/main/docs/book/user-guide/tutorial/trigger-pipelines-from-external-systems.md

Commands to install dependencies, set required environment variables (PIPELINE_API_KEY, ZENML_STORE_URL, ZENML_STORE_API_KEY, ZENML_ACTIVE_STACK_ID), and start the API server locally.

```bash
# Install the required dependencies
pip install -r requirements.txt

# Set the API key
export PIPELINE_API_KEY="your-secure-api-key"

# If using a remote ZenML server, set these as well
export ZENML_STORE_URL="https://your-zenml-server-url"
export ZENML_STORE_API_KEY="your-zenml-api-key"

# If you want to use a specific stack
export ZENML_ACTIVE_STACK_ID="your-stack-id"

# Start the API server
python pipeline_api.py
```

--------------------------------

### Pull and Inspect ZenML Examples

Source: https://github.com/zenml-io/zenml/blob/main/RELEASE_NOTES.md

Use the new `zenml example` CLI sub-group to pull and inspect examples. Pull all examples or a specific one, and get quick info about an example.

```bash
zenml example pull # pulls all examples in `zenml_examples` directory
zenml example pull EXAMPLE_NAME  # pulls specific example
zenml example info EXAMPLE_NAME  # gives quick info regarding example

```

--------------------------------

### Initialize starter template

Source: https://github.com/zenml-io/zenml/blob/main/docs/book/user-guide/starter-guide/starter-project.md

Creates a directory, initializes a ZenML project with the starter template and defaults, then installs requirements.

```bash
mkdir zenml_starter
cd zenml_starter
zenml init --template starter --template-with-defaults

# Just in case, we install the requirements again
pip install -r requirements.txt
```

--------------------------------

### Install Azure and Kubernetes integrations

Source: https://github.com/zenml-io/zenml/blob/main/docs/book/user-guide/production-guide/cloud-orchestration.md

Install the required ZenML integrations for Azure and Kubernetes. This is necessary before proceeding with the setup.

```shell
zenml integration install azure kubernetes -y
```

--------------------------------

### Install dependencies for LLM fine-tuning

Source: https://github.com/zenml-io/zenml/blob/main/docs/book/user-guide/llmops-guide/finetuning-llms/finetuning-100-loc.md

Install the required Python packages for the fine-tuning example. The accelerate version must be at least 0.26.0.

```bash
pip install datasets transformers torch accelerate>=0.26.0
```

--------------------------------

### Start local ZenML server

Source: https://github.com/zenml-io/zenml/blob/main/docs/book/getting-started/installation.md

Starts the local ZenML server and opens the dashboard locally. Requires the 'server' extra to be installed.

```shell
# Make sure to have the `server` extra installed
pip install "zenml[server]"
zenml login --local  # opens the dashboard locally
```

--------------------------------

### Existing GCP infrastructure example

Source: https://github.com/zenml-io/zenml/blob/main/docs/book/how-to/infrastructure-deployment/infrastructure-as-code/README.md

Shows an example of existing GCP infrastructure with a storage bucket and artifact registry repository, which are referenced later in the guide.

```hcl
# Example of existing GCP infrastructure
resource "google_storage_bucket" "ml_artifacts" {
  name     = "company-ml-artifacts"
  location = "US"
}

resource "google_artifact_registry_repository" "ml_containers" {
  repository_id = "ml-containers"
  format        = "DOCKER"
}
```

--------------------------------

### Install and Initialize ZenML

Source: https://github.com/zenml-io/zenml/blob/main/examples/agent_comparison/README.md

Install the ZenML server integration and initialize the local ZenML environment.

```bash
# Install ZenML with required integrations
pip install "zenml[server]"

# Initialize ZenML
zenml init
```
Tokens:
Raw