zenml-nightly 0.84.0.dev20250714__tar.gz → 0.84.0.dev20250716__tar.gz

{zenml_nightly-0.84.0.dev20250714 → zenml_nightly-0.84.0.dev20250716}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: zenml-nightly
-Version: 0.84.0.dev20250714
+Version: 0.84.0.dev20250716
 Summary: ZenML: Write production-ready ML code.
 License: Apache-2.0
 Keywords: machine learning,production,pipeline,mlops,devops
@@ -144,20 +144,17 @@ Project-URL: Homepage, https://zenml.io
 Project-URL: Repository, https://github.com/zenml-io/zenml
 Description-Content-Type: text/markdown
 
-<div align="center">
-  <img referrerpolicy="no-referrer-when-downgrade" src="https://static.scarf.sh/a.png?x-pxid=0fcbab94-8fbe-4a38-93e8-c2348450a42e" />
-  <h1 align="center">MLOps for Reliable AI - From Classical ML to Agents</h1>
-  <h3 align="center">Your unified toolkit for shipping everything from decision trees to complex AI agents, built on the MLOps principles you already trust.</h3>
-</div>
-
 <div align="center">
 
   <!-- PROJECT LOGO -->
   <br />
     <a href="https://zenml.io">
-      <img alt="ZenML Logo" src="docs/book/.gitbook/assets/header.png" alt="ZenML Logo">
+      <img src="docs/book/.gitbook/assets/header.png" alt="ZenML Header">
     </a>
   <br />
+  <div align="center">
+    <h3 align="center">Your unified toolkit for shipping everything from decision trees to complex AI agents, built on the MLOps principles you already trust.</h3>
+  </div>
 
   [![PyPi][pypi-shield]][pypi-url]
   [![PyPi][pypiversion-shield]][pypi-url]
@@ -224,172 +221,193 @@ With ZenML, you're not replacing your knowledge; you're extending it. Use the pi
 
 ## 💻 See It In Action: Multi-Agent Architecture Comparison
 
-**The Challenge:** Your team built three different customer service agents. Which one should go to production? With ZenML, you can build a reproducible pipeline to test them on real data and make a data-driven decision.
+**The Challenge:** Your team built three different customer service agents. Which one should go to production? With ZenML, you can build a reproducible pipeline to test them on real data and make a data-driven decision, with full observability via Langgraph, LiteLLM & Langfuse.
+
+https://github.com/user-attachments/assets/edeb314c-fe07-41ba-b083-cd9ab11db4a7
 
 ```python
 from zenml import pipeline, step
+from zenml.types import HTMLString
 import pandas as pd
 
 @step
 def load_real_conversations() -> pd.DataFrame:
-    """Load actual customer queries from a feature store."""
-    return load_from_feature_store("customer_queries_sample_1k")
+    """Load customer service queries for testing."""
+    return load_customer_queries()
+
+@step
+def train_intent_classifier(queries: pd.DataFrame):
+    """Train a scikit-learn classifier alongside your agents."""
+    return train_sklearn_pipeline(queries)
+
+@step
+def load_prompts() -> dict:
+    """Load prompts as versioned ZenML artifacts."""
+    return load_agent_prompts_from_files()
 
 @step
-def run_architecture_comparison(queries: pd.DataFrame) -> dict:
+def run_architecture_comparison(queries: pd.DataFrame, classifier, prompts: dict) -> tuple:
     """Test three different agent architectures on the same data."""
     architectures = {
-        "single_agent": SingleAgentRAG(),
-        "multi_specialist": MultiSpecialistAgents(),
-        "hierarchical": HierarchicalAgentTeam()
+        "single_agent": SingleAgentRAG(prompts),
+        "multi_specialist": MultiSpecialistAgents(prompts), 
+        "langgraph_workflow": LangGraphAgent(prompts)  # Real LangGraph implementation!
     }
     
-    results = {}
-    for name, agent in architectures.items():
-        # ZenML automatically versions the agent's code, prompts, and tools
-        results[name] = agent.batch_process(queries)
-    return results
+    # ZenML automatically versions agent code, prompts, and configurations
+    # LiteLLM provides unified access to 100+ LLM providers
+    # Langgraph orchestrates a multi-agent graph
+    # Langfuse tracks costs, performance, and traces for full observability
+    results = test_all_architectures(queries, architectures)
+    mermaid_diagram = generate_langgraph_visualization()
+    
+    return results, mermaid_diagram
 
 @step
-def evaluate_and_decide(results: dict) -> str:
-    """Evaluate results and generate a recommendation report."""
-    # Compare architectures on quality, cost, latency, etc.
-    evaluation_df = evaluate_results(results)
-    
-    # Generate a rich report comparing the architectures
-    report = create_comparison_report(evaluation_df)
-    
-    # Automatically tag the winning architecture for a staging deployment
-    winner = evaluation_df.sort_values("overall_score").iloc[0]
-    tag_for_staging(winner["architecture_name"])
-    
-    return report
+def evaluate_and_decide(queries: pd.DataFrame, results: dict) -> HTMLString:
+    """Generate beautiful HTML report with winner selection."""
+    return create_styled_comparison_report(results)
 
 @pipeline
 def compare_agent_architectures():
-    """Your new Friday afternoon ritual: data-driven agent decisions."""
+    """Data-driven agent architecture decisions with full MLOps tracking."""
     queries = load_real_conversations()
-    results = run_architecture_comparison(queries)
-    report = evaluate_and_decide(results)
+    prompts = load_prompts()  # Prompts as versioned artifacts
+    classifier = train_intent_classifier(queries)
+    results, viz = run_architecture_comparison(queries, classifier, prompts)
+    report = evaluate_and_decide(queries, results)
 
 if __name__ == "__main__":
-    # Run locally, compare results in the ZenML dashboard
     compare_agent_architectures()
+    # 🎯 Rich visualizations automatically appear in ZenML dashboard
 ```
 
-**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.
-
-## 🔄 The AI Development Lifecycle with ZenML
+**🚀 [See the complete working example →](examples/agent_comparison/)**
 
-### From Chaos to Process
+**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.
 
 ![Development lifecycle](docs/book/.gitbook/assets/readme_development_lifecycle.png)
 
-<details>
-  <summary><b>Click to see your new, structured workflow</b></summary>
-
-### Your New Workflow
-
-**Monday: Quick Prototype**
-```python
-# Start with a local script, just like always
-agent = LangGraphAgent(prompt="You are a helpful assistant...")
-response = agent.chat("Help me with my order")
-```
+## 🚀 Get Started (5 minutes)
 
-**Tuesday: Make it a Pipeline**
-```python
-# Wrap your code in a ZenML step to make it reproducible
-@step
-def customer_service_agent(query: str) -> str:
-    return agent.chat(query)
-```
+### 🏗️ Architecture Overview
 
-**Wednesday: Add Evaluation**
-```python
-# Test on real data, not toy examples
-@pipeline
-def eval_pipeline():
-    test_data = load_production_samples()
-    responses = customer_service_agent.map(test_data)
-    scores = evaluate_responses(responses)
-    track_experiment(scores)
-```
+ZenML uses a **client-server architecture** with an integrated web dashboard ([zenml-io/zenml-dashboard](https://github.com/zenml-io/zenml-dashboard)) for pipeline visualization and management:
 
-**Thursday: Compare Architectures**
-```python
-# Make data-driven architecture decisions
-results = compare_architectures(
-    baseline="current_prod",
-    challenger="new_multiagent_v2"
-)
-```
-
-**Friday: Ship with Confidence**
-```python
-# Deploy the new agent with the same command you use for ML models
-python agent_deployment.py --env=prod --model="customer_service:challenger"
-```
-</details>
-
-## 🚀 Get Started (5 minutes)
-
-### For ML Engineers Ready to Tame AI
+- **Local Development**: `pip install "zenml[server]"` - runs both client and server locally
+- **Production**: Deploy server separately, connect with `pip install zenml` + `zenml login <server-url>`
 
 ```bash
-# You know this drill
-pip install zenml  # Includes LangChain, LlamaIndex integrations
-zenml integration install langchain llamaindex
+# Install ZenML with server capabilities
+pip install "zenml[server]"
 
-# Initialize (your ML pipelines still work!)
+# Install required dependencies
+pip install scikit-learn openai numpy
+
+# Initialize your ZenML repository
 zenml init
 
-# Pull our agent evaluation template
-zenml init --template agent-evaluation-starter
+# Start local server or connect to a remote one
+zenml login
+
+# Set OpenAI API key (optional)
+export OPENAI_API_KEY=sk-svv....
 ```
 
-### Your First AI Pipeline
+### Your First Pipeline (2 minutes)
 
 ```python
-# look_familiar.py
+# simple_pipeline.py
 from zenml import pipeline, step
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.datasets import make_classification
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import accuracy_score
+from typing import Tuple
+from typing_extensions import Annotated
+import numpy as np
 
 @step
-def run_my_agent(test_queries: list[str]) -> list[str]:
-    """Your existing agent code, now with MLOps superpowers."""
-    # Use ANY framework - LangGraph, CrewAI, raw OpenAI
-    agent = YourExistingAgent()
-    
-    # Automatic versioning of prompts, tools, code, and configs
-    return [agent.run(q) for q in test_queries]
+def create_dataset() -> Tuple[
+    Annotated[np.ndarray, "X_train"],
+    Annotated[np.ndarray, "X_test"], 
+    Annotated[np.ndarray, "y_train"],
+    Annotated[np.ndarray, "y_test"]
+]:
+    """Generate a simple classification dataset."""
+    X, y = make_classification(n_samples=100, n_features=4, n_classes=2, random_state=42)
+    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+    return X_train, X_test, y_train, y_test
 
 @step
-def evaluate_responses(queries: list[str], responses: list[str]) -> dict:
-    """LLM judges + your custom business metrics."""
-    quality = llm_judge(queries, responses)
-    latency = measure_response_times()
-    costs = calculate_token_usage()
-    
-    return {
-        "quality": quality.mean(),
-        "p95_latency": latency.quantile(0.95),
-        "cost_per_query": costs.mean()
-    }
+def train_model(X_train: np.ndarray, y_train: np.ndarray) -> RandomForestClassifier:
+    """Train a simple sklearn model."""
+    model = RandomForestClassifier(n_estimators=10, random_state=42)
+    model.fit(X_train, y_train)
+    return model
+
+@step
+def evaluate_model(model: RandomForestClassifier, X_test: np.ndarray, y_test: np.ndarray) -> float:
+    """Evaluate the model accuracy."""
+    predictions = model.predict(X_test)
+    return accuracy_score(y_test, predictions)
+
+@step
+def generate_summary(accuracy: float) -> str:
+    """Use OpenAI to generate a model summary."""
+    import openai
+
+    client = openai.OpenAI()  # Set OPENAI_API_KEY environment variable
+    response = client.chat.completions.create(
+        model="gpt-3.5-turbo",
+        messages=[{
+            "role": "user", 
+            "content": f"Write a brief summary of a ML model with {accuracy:.2%} accuracy."
+        }],
+        max_tokens=50
+    )
+    return response.choices[0].message.content
 
 @pipeline
-def my_first_agent_pipeline():
-    # Look ma, no YAML!
-    queries = ["How do I return an item?", "What's your refund policy?"]
-    responses = run_my_agent(queries)
-    metrics = evaluate_responses(queries, responses)
-    
-    # Metrics are auto-logged, versioned, and comparable in the dashboard
-    return metrics
+def simple_ml_pipeline():
+    """A simple pipeline combining sklearn and OpenAI."""
+    X_train, X_test, y_train, y_test = create_dataset()
+    model = train_model(X_train, y_train)
+    accuracy = evaluate_model(model, X_test, y_test)
+    try:
+        import openai  # noqa: F401
+        generate_summary(accuracy)
+    except ImportError:
+        print("OpenAI is not installed. Skipping summary generation.")
+
 
 if __name__ == "__main__":
-    my_first_agent_pipeline()
-    print("Check your dashboard: http://localhost:8080")
+    result = simple_ml_pipeline()
+```
+
+Run it:
+```bash
+export OPENAI_API_KEY="your-api-key-here"
+python simple_pipeline.py
+```
+
+## 🗣️ Chat With Your Pipelines: ZenML MCP Server
+
+Stop clicking through dashboards to understand your ML workflows. The **[ZenML MCP Server](https://github.com/zenml-io/mcp-zenml)** lets you query your pipelines, analyze runs, and trigger deployments using natural language through Claude Desktop, Cursor, or any MCP-compatible client.
+
 ```
+💬 "Which pipeline runs failed this week and why?"
+📊 "Show me accuracy metrics for all my customer churn models"  
+🚀 "Trigger the latest fraud detection pipeline with production data"
+```
+
+**Quick Setup:**
+1. Download the `.dxt` file from [zenml-io/mcp-zenml](https://github.com/zenml-io/mcp-zenml)
+2. Drag it into Claude Desktop settings
+3. Add your ZenML server URL and API key
+4. Start chatting with your ML infrastructure
+
+The MCP (Model Context Protocol) integration transforms your ZenML metadata into conversational insights, making pipeline debugging and analysis as easy as asking a question. Perfect for teams who want to democratize access to ML operations without requiring dashboard expertise.
 
 ## 📚 Learn More
 
@@ -399,7 +417,7 @@ The best way to learn about ZenML is through our comprehensive documentation and
 
 - **[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 API documentation
+- **[SDK Reference](https://sdkdocs.zenml.io/)** - Complete SDK reference
 
 For visual learners, start with this 11-minute introduction:
 
@@ -407,10 +425,11 @@ For visual learners, start with this 11-minute introduction:
 
 ### 📖 Production Examples
 
-1. **[E2E Batch Inference](examples/e2e/)** - Complete MLOps pipeline with feature engineering
-2. **[LLM RAG Pipeline](https://github.com/zenml-io/zenml-projects/tree/main/llm-complete-guide)** - Production RAG with evaluation loops
-3. **[Agentic Workflow (Deep Research)](https://github.com/zenml-io/zenml-projects/tree/main/deep_research)** - Orchestrate your agents with ZenML
-4. **[Fine-tuning Pipeline](https://github.com/zenml-io/zenml-projects/tree/main/gamesense)** - Fine-tune and deploy LLMs
+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
 
 ### 🏢 Deployment Options
 
@@ -419,9 +438,9 @@ For visual learners, start with this 11-minute introduction:
 - **[ZenML Pro](https://cloud.zenml.io/?utm_source=readme)** - Managed service with enterprise support (free trial)
 
 **Infrastructure Requirements:**
-- Kubernetes cluster (or local Docker)
+- Docker (or Kubernetes for production)
 - Object storage (S3/GCS/Azure)
-- PostgreSQL database
+- MySQL-compatible database (MySQL 8.0+ or MariaDB)
 - _[Complete requirements](https://docs.zenml.io/getting-started/deploying-zenml/deploy-with-helm)_
 
 ### 🎓 Books & Resources
@@ -447,23 +466,32 @@ ZenML is featured in these comprehensive guides to production AI systems.
 **Stay Updated:**
 - 🗺 [Public Roadmap](https://zenml.io/roadmap) - See what's coming next
 - 📰 [Blog](https://zenml.io/blog) - Best practices and case studies
-- 🎙 [Podcast](https://zenml.io/podcast) - Interviews with ML practitioners
+- 🎙 [Slack](https://zenml.io/slack) - Talk with AI practitioners
 
 ## ❓ FAQs from ML Engineers Like You
 
 **Q: "Do I need to rewrite my agents or models to use ZenML?"**
+
 A: No. Wrap your existing code in a `@step`. Keep using `scikit-learn`, PyTorch, LangGraph, LlamaIndex, or raw API calls. ZenML orchestrates your tools, it doesn't replace them.
 
 **Q: "How is this different from LangSmith/Langfuse?"**
+
 A: They provide excellent observability for LLM applications. We orchestrate the **full MLOps lifecycle for your entire AI stack**. With ZenML, you manage both your classical ML models and your AI agents in one unified framework, from development and evaluation all the way to production deployment.
 
 **Q: "Can I use my existing MLflow/W&B setup?"**
-A: Yes! We integrate with both. Your experiments, our pipelines.
+
+A: Yes! ZenML integrates with both [MLflow](https://docs.zenml.io/stacks/experiment-trackers/mlflow) and [Weights & Biases](https://docs.zenml.io/stacks/experiment-trackers/wandb). Your experiments, our pipelines.
 
 **Q: "Is this just MLflow with extra steps?"**
+
 A: No. MLflow tracks experiments. We orchestrate the entire development process – from training and evaluation to deployment and monitoring – for both models and agents.
 
+**Q: "How do I configure ZenML with Kubernetes?"**
+
+A: ZenML integrates with Kubernetes through the native Kubernetes orchestrator, Kubeflow, and other K8s-based orchestrators. See our [Kubernetes orchestrator guide](https://docs.zenml.io/stacks/orchestrators/kubernetes) and [Kubeflow guide](https://docs.zenml.io/stacks/orchestrators/kubeflow), plus [deployment documentation](https://docs.zenml.io/getting-started/deploying-zenml/deploy-with-helm).
+
 **Q: "What about cost? I can't afford another platform."**
+
 A: ZenML's open-source version is free forever. You likely already have the required infrastructure (like a Kubernetes cluster and object storage). We just help you make better use of it for MLOps.
 
 ### 🛠 VS Code Extension