Add an agent in production example (#3890)

* Add ZenML introduction to README.md

* added agent example

* Update evaluation pipeline max items to 100, 125, and 125

* Add document analysis pipeline and evaluation pipeline

* Code review

* Simplify analysis result extraction from artifacts

* Refactor artifact loading and handling logic

* Add "Your First AI Pipeline" section to table of contents

* Add your first AI pipeline example for ZenML

* Add login command for ZenML dashboard

* Update Docker command for container startup

* Update Docker compose command to start containers

* Add architecture overview and screenshots

* Add figures for pipeline visualization in ZenML dashboard

* Add reasons for using pipelines in AI/ML workflows

* Revise AI pipeline benefits in quickstart guide

* Update AI pipeline architecture diagram layout

* Update flowchart orientation to top to bottom

* Add architecture overview in getting started guide

* Add example installation instructions and architecture overview

* Add whitespace and update comments for clarity

* Update AI pipeline and examples with new links and services

* Update ZenML hello-world.md with login step & new links.-

* Refactor quickstart README for clarity and consistency

* Add FloraCast and Retail Forecast to projects list

* Update mypy configuration to ignore missing imports

* Update ignore_missing_imports setting in pyproject.toml

* Update links in README and fix relative path in docs

* Add initial pipeline analysis and evaluation diagrams

* Images

* Delete test.html and add architecture.png image.<commit message>

* Optimised images with calibre/image-actions

* Update Argilla documentation links to correct URLs

* Update docs/book/getting-started/your-first-ai-pipeline.md

* Update docs/book/getting-started/your-first-ai-pipeline.md

* Add new ML pipeline examples to README.md

* Update README with new example images and links

* Add example-06 and example-07 images to user guide

* Add ZenML Pro cover image

---------

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
Co-authored-by: Alex Strick van Linschoten <[email protected]>
(cherry picked from commit bdd3319)

Author: 3 people

README.md

@@ -45,6 +45,9 @@
 
 ---
 
+ZenML is a unified MLOps framework that extends the battle-tested principles you rely on for classical ML to the new world of AI agents. It's one platform to develop, evaluate, and deploy your entire AI portfolio - from decision trees to complex multi-agent systems. By providing a single framework for your entire AI stack, ZenML enables developers across your organization to collaborate more effectively without maintaining separate toolchains for models and agents.
+
+
 ## 🚨 The Problem: MLOps Works for Models, But What About AI?
 
 ![No MLOps for modern AI](docs/book/.gitbook/assets/readme_problem.png)
@@ -137,6 +140,7 @@ if __name__ == "__main__":
 ```
 
 **🚀 [See the complete working example →](examples/agent_comparison/)**
+Prefer a smaller end-to-end template? Check out the [Minimal Agent Production](examples/minimal_agent_production/) example — a lightweight document analysis service with pipelines, evaluation, and a simple web UI.
 
 **The Result:** A clear winner is selected based on data, not opinions. You have full lineage from the test data and agent versions to the final report and deployment decision.
 
@@ -269,6 +273,7 @@ The MCP (Model Context Protocol) integration transforms your ZenML metadata into
 
 The best way to learn about ZenML is through our comprehensive documentation and tutorials:
 
+- **[Your First AI Pipeline](https://docs.zenml.io/your-first-ai-pipeline)** - Build and evaluate an AI service in minutes
 - **[Starter Guide](https://docs.zenml.io/user-guides/starter-guide)** - From zero to production in 30 minutes
 - **[LLMOps Guide](https://docs.zenml.io/user-guides/llmops-guide)** - Specific patterns for LLM applications
 - **[SDK Reference](https://sdkdocs.zenml.io/)** - Complete SDK reference
@@ -280,10 +285,11 @@ For visual learners, start with this 11-minute introduction:
 ### 📖 Production Examples
 
 1. **[Agent Architecture Comparison](examples/agent_comparison/)** - Compare AI agents with LangGraph workflows, LiteLLM integration, and automatic visualizations via custom materializers
-2. **[E2E Batch Inference](examples/e2e/)** - Complete MLOps pipeline with feature engineering
-3. **[LLM RAG Pipeline](https://github.com/zenml-io/zenml-projects/tree/main/llm-complete-guide)** - Production RAG with evaluation loops
-4. **[Agentic Workflow (Deep Research)](https://github.com/zenml-io/zenml-projects/tree/main/deep_research)** - Orchestrate your agents with ZenML
-5. **[Fine-tuning Pipeline](https://github.com/zenml-io/zenml-projects/tree/main/gamesense)** - Fine-tune and deploy LLMs
+2. **[Minimal Agent Production](examples/minimal_agent_production/)** - Document analysis service with pipelines, evaluation, and web UI
+3. **[E2E Batch Inference](examples/e2e/)** - Complete MLOps pipeline with feature engineering
+4. **[LLM RAG Pipeline](https://github.com/zenml-io/zenml-projects/tree/main/llm-complete-guide)** - Production RAG with evaluation loops
+5. **[Agentic Workflow (Deep Research)](https://github.com/zenml-io/zenml-projects/tree/main/deep_research)** - Orchestrate your agents with ZenML
+6. **[Fine-tuning Pipeline](https://github.com/zenml-io/zenml-projects/tree/main/gamesense)** - Fine-tune and deploy LLMs
 
 ### 🏢 Deployment Options
 

docs/book/.gitbook/assets/your_first_pipeline_analysis.png

@@ -14,7 +14,7 @@ Argilla distinguishes itself for its focus on specific use cases and human-in-th
 
 If you need to label textual data as part of your ML workflow, that is the point at which you could consider adding the Argilla annotator stack component as part of your ZenML stack.
 
-We currently support the use of annotation at the various stages described in[the main annotators docs page](./). The Argilla integration currently is built to support annotation using a local (Docker-backed) instance of Argilla as well as a deployed instance of Argilla. There is an easy way to deploy Argilla as a [Hugging Face Space](https://huggingface.co/docs/hub/spaces-sdks-docker-argilla), for instance, which is documented in the [Argilla documentation](https://docs.argilla.io/latest/getting_started/quickstart/).
+We currently support the use of annotation at the various stages described in[the main annotators docs page](./). The Argilla integration currently is built to support annotation using a local (Docker-backed) instance of Argilla as well as a deployed instance of Argilla. There is an easy way to deploy Argilla as a [Hugging Face Space](https://huggingface.co/docs/hub/spaces-sdks-docker-argilla), for instance, which is documented in the [Argilla documentation](https://argilla.io/).
 
 ### How to deploy it?
 
@@ -89,6 +89,6 @@ dataset = annotator.get_dataset("dataset_name")
 annotations = annotator.get_labeled_data(dataset_name="dataset_name")
 ```
 
-For more detailed information on how to use the Argilla annotator and the functionality it provides, visit the [Argilla documentation](https://docs.argilla.io/latest/).
+For more detailed information on how to use the Argilla annotator and the functionality it provides, visit the [Argilla documentation](https://argilla.io/).
 
 <figure><img src="https://static.scarf.sh/a.png?x-pxid=f0b4f458-0a54-4fcd-aa95-d5ee424815bc" alt="ZenML Scarf"><figcaption></figcaption></figure>

docs/book/.gitbook/assets/your_first_pipeline_pipeline_evaluation.png

@@ -17,9 +17,11 @@ Start by installing ZenML in a fresh Python environment:
 
 ```bash
 pip install zenml
+zenml login
 ```
 
-This gives you access to both the ZenML Python SDK and CLI tools.
+This gives you access to both the ZenML Python SDK and CLI tools. It also surfaces the
+ZenML dashboard + connects it to your local client.
 {% endstep %}
 
 {% step %}
@@ -128,8 +130,8 @@ To continue your ZenML journey, explore these key topics:
 * **Organization**: Use [tags](../how-to/tags/tags.md) and [metadata](../how-to/metadata/metadata.md) to keep your AI projects structured
 
 **For LLMs and AI Agents:**
-* **LLMOps Guide**: Follow our comprehensive [LLMOps Guide](https://docs.zenml.io/user-guides/llmops-guide) for agent development patterns
-* **Agent Evaluation**: Learn to [systematically evaluate](https://github.com/zenml-io/zenml-projects/tree/main/llm-complete-guide) and compare different agent architectures
+* **LLMOps Guide**: Write your [first AI pipeline](your-first-ai-pipeline.md) for agent development patterns
+* **Agent Evaluation**: Learn to [systematically evaluate](https://github.com/zenml-io/zenml/tree/main/examples/agent_comparison) and compare different agent architectures
 * **Prompt Management**: Version and track prompts, tools, and agent configurations as [artifacts](../how-to/artifacts/artifacts.md)
 
 **Infrastructure & Deployment:**

docs/book/.gitbook/assets/your_first_pipeline_ui.png

@@ -0,0 +1,162 @@
+---
+description: Build your first AI pipeline and service with ZenML in minutes.
+icon: rocket
+---
+
+## Your First AI Pipeline
+
+Build and evaluate a real AI service powered by a ZenML pipeline. This quickstart works out of the box with a deterministic fallback and upgrades seamlessly to LLMs when you add a provider API key.
+
+{% hint style="info" %}
+Why pipelines?
+- **Reproducible & portable**: Run the same code locally or on the cloud by switching stacks.
+- **One approach for models and agents**: Steps, pipelines, and artifacts work for sklearn and LLMs alike.
+- **Evaluate & observe by default**: Quality reports, lineage, and step metadata (tokens, latency) out of the box.
+{% endhint %}
+
+Modeling agents as pipelines makes non-deterministic workflows debuggable and shippable: prompts, tools, and routing become explicit steps; runs produce versioned artifacts (including traces and metrics) you can compare and evaluate. This is the same pattern you use for classical ML, so agents and models share the lifecycle and tooling.
+
+### What you'll build
+- **Document analysis service**: A FastAPI app that triggers a ZenML pipeline
+- **LLM-first with fallback**: Uses [LiteLLM](https://github.com/BerriAI/litellm) if an API key is set, otherwise runs a deterministic analysis that doesn't require making an API request to an LLM service
+- **Tracked artifacts**: Summary, keywords, sentiment, readability, and rich metadata
+- **Quality evaluation**: A separate pipeline that annotates runs and generates an HTML report
+
+### Architecture (at a glance)
+
+```mermaid
+---
+config:
+  layout: elk
+  theme: mc
+---
+flowchart TB
+ subgraph Evaluation["Evaluation Pipeline"]
+        R1["load recent analyses"]
+        R2["annotate and score"]
+        R3["render evaluation HTML"]
+  end
+ subgraph s1["Document Analysis Pipeline"]
+        S1["ingest_document_step"]
+        S2["analyze_document_step LLM or fallback"]
+        S3["render_report_step"]
+  end
+ subgraph s2["Stack"]
+        O[("Orchestrator - local or remote")]
+        AR["Artifact Store"]
+  end
+    U["User / Client"] --> A["FastAPI app"]
+    A -- Triggers on document upload --> s1
+    S1 --> S2
+    S2 --> S3
+    S3 -- DocumentAnalysisResult --> AR
+    R1 --> R2
+    R2 --> R3
+    U -- Triggers to evaluate app --> Evaluation
+    Evaluation -- Executes on --> O
+    s1 -- Executes on --> O
+    style s1 fill:#E1BEE7,stroke:#AA00FF
+    style Evaluation fill:#E1BEE7,stroke:#AA00FF
+```
+
+### Prerequisites
+
+```bash
+pip install "zenml[server]"
+zenml init
+```
+
+Optional (for LLM mode via LiteLLM, OpenAI shown):
+```bash
+export OPENAI_API_KEY="your-key"
+```
+
+### Get the example
+
+```bash
+git clone --depth 1 https://github.com/zenml-io/zenml.git
+cd zenml/examples/minimal_agent_production
+pip install -r requirements.txt
+```
+{% hint style="info" %}
+Already have the repo? Just `cd examples/minimal_agent_production` and continue.
+{% endhint %}
+
+### Run the service
+
+```bash
+uvicorn app.main:app --reload --port 8010
+```
+
+Open `http://localhost:8010` to use the UI, or call it programmatically:
+```bash
+curl -X POST http://localhost:8010/analyze \
+  -H 'Content-Type: application/json' \
+  -d '{
+        "filename": "sample-report.txt",
+        "content": "This is a sample document for analysis...",
+        "document_type": "report",
+        "analysis_type": "full"
+      }'
+```
+
+The endpoint triggers a ZenML pipeline run that stores detailed results and metadata you can inspect in the dashboard.
+
+<figure>
+  <img src="../.gitbook/assets/your_first_pipeline_ui.png" alt="FastAPI document analysis UI">
+  <figcaption>The web UI served by uvicorn at <code>http://localhost:8010</code>.</figcaption>
+</figure>
+
+### Inspect your pipeline runs
+
+```bash
+zenml login --local
+```
+
+In the dashboard, open the latest run to explore:
+- **Steps** like `ingest_document_step`, `analyze_document_step`, `render_report_step`
+- **Artifacts** like `DocumentAnalysis` with summary, keywords, sentiment, readability score
+- **Metadata** such as latency, token usage, and model name (when in LLM mode)
+
+<figure>
+  <img src="../.gitbook/assets/your_first_pipeline_analysis.png" alt="Document analysis pipeline DAG in ZenML dashboard">
+  <figcaption>Document analysis pipeline DAG with step-level artifacts and metadata.</figcaption>
+</figure>
+
+### Evaluate quality
+
+Generate a quality report across recent analyses:
+```bash
+python run_evaluation.py
+```
+
+Open the run in the dashboard and locate the HTML report artifact with per-item annotations (summary quality, keyword relevance, sentiment accuracy, completeness) and aggregated scores.
+
+<figure>
+  <img src="../.gitbook/assets/your_first_pipeline_pipeline_evaluation.png" alt="Evaluation pipeline DAG in ZenML dashboard">
+  <figcaption>Evaluation pipeline producing an HTML report artifact with aggregated metrics.</figcaption>
+</figure>
+
+### How it works (at a glance)
+
+- The FastAPI app forwards requests to the `document_analysis_pipeline` in `pipelines/production.py`
+- The `analyze` step uses LiteLLM if an API key is configured, otherwise a deterministic analyzer
+- Artifacts are versioned and traceable; evaluation runs read past analyses and render a report
+
+Key files to explore:
+- `examples/minimal_agent_production/pipelines/production.py`
+- `examples/minimal_agent_production/steps/analyze.py`
+- `examples/minimal_agent_production/run_evaluation.py`
+
+### Production next steps
+- **Run remotely**: Configure a remote stack/orchestrator and run the same pipeline on managed compute. See [Deploy](deploying-zenml/README.md)
+- **Automate triggering**: [Create a run template](https://docs.zenml.io/user-guides/tutorial/trigger-pipelines-from-external-systems) (ZenML Pro) and trigger via API/webhooks from your app
+- **Operationalize**: Add caching, retries, schedules, and CI/CD using concepts in the docs
+
+### Extend it
+
+- Swap LLMs/providers through LiteLLM without code changes
+- Add guardrails/structured outputs via Pydantic models
+- Add retrieval or additional steps for more advanced analysis
+
+Looking for the code? Browse the complete example at `examples/minimal_agent_production`.

docs/book/component-guide/annotators/argilla.md

@@ -5,6 +5,7 @@
 * [Welcome to ZenML](introduction.md)
 * [Installation](getting-started/installation.md)
 * [Hello World](getting-started/hello-world.md)
+* [Your First AI Pipeline](getting-started/your-first-ai-pipeline.md)
 * [Core Concepts](getting-started/core-concepts.md)
 * [System Architecture](getting-started/system-architectures.md)