synth-ai 0.2.16__py3-none-any.whl → 0.2.19__py3-none-any.whl

examples/blog_posts/gepa/gepa_baseline.py

@@ -0,0 +1,204 @@
+"""Banking77 baseline file for intent classification evaluation."""
+
+from __future__ import annotations
+
+from typing import Any, Dict
+
+from datasets import load_dataset
+
+from synth_ai.baseline import BaselineConfig, BaselineTaskRunner, DataSplit, TaskResult
+from synth_ai.inference import InferenceClient
+import os
+import httpx
+
+
+# Load dataset once at module level
+_dataset = None
+_label_names = None
+
+
+def _load_dataset():
+    """Load Banking77 dataset."""
+    global _dataset, _label_names
+    if _dataset is None:
+        try:
+            _dataset = load_dataset("PolyAI/banking77")
+        except Exception:
+            # Fallback: try without org prefix
+            _dataset = load_dataset("banking77")
+        _label_names = _dataset["train"].features["label"].names
+    return _dataset, _label_names
+
+
+class Banking77TaskRunner(BaselineTaskRunner):
+    """Task runner for Banking77 intent classification."""
+    
+    def __init__(self, policy_config: Dict[str, Any], env_config: Dict[str, Any]):
+        super().__init__(policy_config, env_config)
+        
+        # Load dataset
+        self.dataset, self.label_names = _load_dataset()
+        
+        # Store config for inference
+        self.model = policy_config["model"]
+        self.temperature = policy_config.get("temperature", 0.0)
+        self.max_tokens = policy_config.get("max_tokens", 128)
+        self.inference_url = policy_config.get("inference_url")
+        
+        # Tool definition
+        self.tool = {
+            "type": "function",
+            "function": {
+                "name": "banking77_classify",
+                "description": "Classify a banking query into an intent",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "label": {
+                            "type": "string",
+                            "enum": self.label_names,
+                            "description": "The intent label",
+                        }
+                    },
+                    "required": ["label"],
+                },
+            },
+        }
+    
+    async def run_task(self, seed: int) -> TaskResult:
+        """Run a single Banking77 classification task."""
+        
+        # Get split
+        split = self.env_config.get("split", "train")
+        
+        # Get example from dataset
+        example = self.dataset[split][seed]
+        
+        # Build prompt
+        system_prompt = f"""You are an expert banking assistant that classifies customer queries.
+Given a customer message, respond with exactly one intent label using the tool call.
+
+Valid intents: {', '.join(self.label_names)}"""
+        
+        user_prompt = f"Customer Query: {example['text']}\n\nClassify this query."
+        
+        # Run inference
+        messages = [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": user_prompt},
+        ]
+        
+        # Use InferenceClient if URL provided, otherwise use OpenAI-compatible API
+        if self.inference_url and self.inference_url.startswith("http"):
+            api_key = os.getenv("SYNTH_API_KEY") or os.getenv("OPENAI_API_KEY") or ""
+            base_url = self.inference_url.rstrip("/")
+            if not base_url.endswith("/api"):
+                base_url = f"{base_url}/api" if "/api" not in base_url else base_url
+            client = InferenceClient(base_url=base_url, api_key=api_key)
+            response = await client.create_chat_completion(
+                model=self.model,
+                messages=messages,
+                tools=[self.tool],
+                tool_choice={"type": "function", "function": {"name": "banking77_classify"}},
+                temperature=self.temperature,
+                max_tokens=self.max_tokens,
+            )
+        else:
+            # Use OpenAI/Groq directly
+            # Check if model starts with groq: prefix
+            model_name = self.model
+            use_groq = model_name.startswith("groq:")
+            if use_groq:
+                model_name = model_name[5:]  # Remove "groq:" prefix
+            
+            api_key = os.getenv("GROQ_API_KEY") if use_groq else os.getenv("OPENAI_API_KEY") or ""
+            base_url = "https://api.groq.com/openai/v1" if use_groq else "https://api.openai.com/v1"
+            async with httpx.AsyncClient() as http_client:
+                resp = await http_client.post(
+                    f"{base_url}/chat/completions",
+                    json={
+                        "model": model_name,
+                        "messages": messages,
+                        "tools": [self.tool],
+                        "tool_choice": {"type": "function", "function": {"name": "banking77_classify"}},
+                        "temperature": self.temperature,
+                        "max_tokens": self.max_tokens,
+                    },
+                    headers={"Authorization": f"Bearer {api_key}"} if api_key else {},
+                )
+                response = resp.json()
+        
+        # Extract prediction
+        predicted_label = ""
+        tool_calls = []
+        if "choices" in response and len(response["choices"]) > 0:
+            message = response["choices"][0].get("message", {})
+            tool_calls = message.get("tool_calls", [])
+        elif "tool_calls" in response:
+            tool_calls = response["tool_calls"]
+        
+        if tool_calls:
+            # Handle both string and dict arguments
+            args = tool_calls[0]["function"].get("arguments", "")
+            if isinstance(args, str):
+                import json
+                args = json.loads(args)
+            predicted_label = args.get("label", "") if isinstance(args, dict) else ""
+        
+        # Evaluate
+        expected_label = self.label_names[example["label"]]
+        correct = predicted_label == expected_label
+        
+        return TaskResult(
+            seed=seed,
+            success=True,
+            outcome_reward=1.0 if correct else 0.0,
+            total_steps=1,
+            metadata={
+                "query": example["text"],
+                "expected": expected_label,
+                "predicted": predicted_label,
+                "correct": correct,
+                "split": split,
+            },
+        )
+
+
+# Define baseline config
+# Note: We need to load the dataset first to get the label names
+_load_dataset()
+gepa_baseline = BaselineConfig(
+    baseline_id="gepa",
+    name="GEPA - Banking77 Intent Classification",
+    description="Banking77 intent classification baseline for prompt optimization experiments",
+    task_runner=Banking77TaskRunner,
+    splits={
+        "train": DataSplit(
+            name="train",
+            seeds=list(range(min(10000, len(_dataset["train"]))) if _dataset else range(10000)),
+        ),
+        "val": DataSplit(
+            name="val",
+            seeds=list(range(min(1000, len(_dataset["test"]))) if _dataset else range(1000)),
+        ),
+        "test": DataSplit(
+            name="test",
+            seeds=list(range(min(3000, len(_dataset["test"]))) if _dataset else range(3000)),
+        ),
+    },
+    default_policy_config={
+        "model": "groq:llama-3.1-70b-versatile",
+        "temperature": 0.0,
+        "max_tokens": 128,
+    },
+    default_env_config={
+        "split": "train",
+    },
+    metadata={
+        "dataset": "PolyAI/banking77",
+        "num_classes": 77,
+        "task_type": "classification",
+    },
+    tags=["classification", "nlp", "intent", "blog-post"],
+)
+

examples/blog_posts/gepa/query_prompts_example.py

@@ -0,0 +1,97 @@
+"""
+Example script showing how to query prompt learning job results.
+
+Usage:
+    python query_prompts_example.py pl_9c58b711c2644083
+"""
+
+import os
+import sys
+from pprint import pprint
+
+from synth_ai.learning import get_prompts, get_prompt_text, get_scoring_summary
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("Usage: python query_prompts_example.py <job_id>")
+        print("Example: python query_prompts_example.py pl_9c58b711c2644083")
+        sys.exit(1)
+    
+    job_id = sys.argv[1]
+    
+    # Get credentials from environment
+    base_url = os.getenv("BACKEND_BASE_URL", "http://localhost:8000")
+    api_key = os.getenv("SYNTH_API_KEY")
+    
+    if not api_key:
+        print("Error: SYNTH_API_KEY environment variable not set")
+        sys.exit(1)
+    
+    print(f"Querying job: {job_id}")
+    print(f"Backend: {base_url}")
+    print("=" * 80)
+    
+    # Get all prompts and metadata
+    print("\n📊 Fetching prompt results...")
+    results = get_prompts(job_id, base_url, api_key)
+    
+    # Print best score
+    if results.best_score is not None:
+        print(f"\n🏆 Best Score: {results.best_score:.3f} ({results.best_score * 100:.1f}%)")
+    
+    # Print top-K prompts with scores
+    top_prompts = results.top_prompts
+    if top_prompts:
+        print(f"\n📝 Top {len(top_prompts)} Prompts:")
+        print("=" * 80)
+        for prompt_info in sorted(top_prompts, key=lambda p: p.get("rank", 999)):
+            rank = prompt_info["rank"]
+            train_accuracy = prompt_info.get("train_accuracy")
+            val_accuracy = prompt_info.get("val_accuracy")
+            
+            print(f"\nRank #{rank}:")
+            if train_accuracy is not None:
+                print(f"  Train Accuracy: {train_accuracy:.3f} ({train_accuracy * 100:.1f}%)")
+            if val_accuracy is not None:
+                print(f"  Val Accuracy:   {val_accuracy:.3f} ({val_accuracy * 100:.1f}%)")
+            print(f"  Prompt Text:")
+            print("  " + "-" * 76)
+            full_text = prompt_info.get("full_text", "")
+            for line in full_text.split("\n"):
+                print(f"  {line}")
+            print("  " + "-" * 76)
+    
+    # Get scoring summary
+    print("\n📈 Scoring Summary:")
+    print("=" * 80)
+    summary = get_scoring_summary(job_id, base_url, api_key)
+    
+    print(f"Best Train Accuracy:     {summary['best_train_accuracy']:.3f} ({summary['best_train_accuracy'] * 100:.1f}%)")
+    if summary['best_val_accuracy']:
+        print(f"Best Val Accuracy:       {summary['best_val_accuracy']:.3f} ({summary['best_val_accuracy'] * 100:.1f}%)")
+    print(f"Mean Train Accuracy:     {summary['mean_train_accuracy']:.3f} ({summary['mean_train_accuracy'] * 100:.1f}%)")
+    print(f"Candidates Tried:        {summary['num_candidates_tried']}")
+    print(f"Frontier Candidates:     {summary['num_frontier_candidates']}")
+    
+    print(f"\nScore Distribution:")
+    for bin_range, count in summary['score_distribution'].items():
+        bar = "█" * count
+        print(f"  {bin_range}: {count:3d} {bar}")
+    
+    # Quick access to best prompt text only
+    print("\n💡 Quick access to best prompt:")
+    print("=" * 80)
+    best_text = get_prompt_text(job_id, base_url, api_key, rank=1)
+    if best_text:
+        print(best_text)
+    else:
+        print("Best prompt text not available yet (job may still be running)")
+    
+    print("\n" + "=" * 80)
+    print("✅ Query complete!")
+
+
+if __name__ == "__main__":
+    main()
+

examples/blog_posts/gepa/run_gepa_banking77.sh

@@ -0,0 +1,87 @@
+#!/bin/bash
+# Run GEPA optimization for Banking77 against the backend
+
+set -e
+
+echo "🧬 Running GEPA on Banking77"
+echo "============================="
+
+# Check for required environment variables
+if [ -z "$SYNTH_API_KEY" ]; then
+    echo "❌ Error: SYNTH_API_KEY not set"
+    echo "Please get your API key from the backend and set it:"
+    echo "  export SYNTH_API_KEY=your_key"
+    exit 1
+fi
+
+if [ -z "$ENVIRONMENT_API_KEY" ]; then
+    echo "❌ Error: ENVIRONMENT_API_KEY not set"
+    echo "Please set the same key used when deploying the task app:"
+    echo "  export ENVIRONMENT_API_KEY=your_key"
+    exit 1
+fi
+
+if [ -z "$GROQ_API_KEY" ]; then
+    echo "❌ Error: GROQ_API_KEY not set"
+    echo "Please set your Groq API key:"
+    echo "  export GROQ_API_KEY=your_key"
+    exit 1
+fi
+
+# Default to localhost backend if not specified
+BACKEND_URL="${BACKEND_BASE_URL:-http://localhost:8000}"
+
+echo "✅ SYNTH_API_KEY: ${SYNTH_API_KEY:0:20}..."
+echo "✅ ENVIRONMENT_API_KEY: ${ENVIRONMENT_API_KEY:0:20}..."
+echo "✅ GROQ_API_KEY: ${GROQ_API_KEY:0:20}..."
+echo "✅ Backend URL: $BACKEND_URL"
+echo ""
+
+# Navigate to repo root
+cd "$(dirname "$0")/../../.."
+
+# Check if task app is running
+echo "🔍 Checking if Banking77 task app is running on http://127.0.0.1:8102..."
+if ! curl -s -f -H "X-API-Key: $ENVIRONMENT_API_KEY" http://127.0.0.1:8102/health > /dev/null 2>&1; then
+    echo "❌ Error: Banking77 task app is not running on http://127.0.0.1:8102"
+    echo ""
+    echo "Please start it first:"
+    echo "  ./examples/blog_posts/gepa/deploy_banking77_task_app.sh"
+    echo ""
+    echo "Or in another terminal:"
+    echo "  cd $(pwd)"
+    echo "  uvx synth-ai deploy banking77 --runtime uvicorn --port 8102"
+    exit 1
+fi
+echo "✅ Task app is healthy"
+echo ""
+
+# Check backend connection
+echo "🔍 Checking backend connection to $BACKEND_URL..."
+if ! curl -s -f "$BACKEND_URL/api/health" > /dev/null 2>&1; then
+    echo "⚠️  Warning: Cannot connect to backend at $BACKEND_URL"
+    echo "Make sure the backend is running."
+    read -p "Continue anyway? (y/N) " -n 1 -r
+    echo
+    if [[ ! $REPLY =~ ^[Yy]$ ]]; then
+        exit 1
+    fi
+else
+    echo "✅ Backend is healthy"
+fi
+echo ""
+
+echo "🚀 Starting GEPA training..."
+echo "Config: examples/blog_posts/gepa/configs/banking77_gepa_local.toml"
+echo ""
+
+# Run the training
+uvx synth-ai train \
+    --type prompt_learning \
+    --config examples/blog_posts/gepa/configs/banking77_gepa_local.toml \
+    --backend "$BACKEND_URL" \
+    --poll
+
+echo ""
+echo "✅ GEPA training complete!"
+

examples/blog_posts/gepa/task_apps.py

@@ -0,0 +1,105 @@
+"""Metadata for GEPA blog task app coverage.
+
+This module centralises the set of task apps that the GEPA blog post
+references so that configuration files and documentation can import the
+same canonical definitions. Each entry mirrors a task app that is
+available via Synth's prompt-learning backend, making it easier to keep
+configs, docs, and evaluation notebooks in sync.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Iterable, Sequence
+
+
+@dataclass(frozen=True, slots=True)
+class TaskAppSupport:
+    """Describes a task app that the GEPA blog supports."""
+
+    app_id: str
+    display_name: str
+    dataset_id: str
+    description: str
+    default_port: int
+    tags: Sequence[str]
+    metrics: Sequence[str]
+    sources: Sequence[str]
+
+
+SUPPORTED_TASK_APPS: tuple[TaskAppSupport, ...] = (
+    TaskAppSupport(
+        app_id="banking77",
+        display_name="Banking77 Intent Classification",
+        dataset_id="PolyAI/banking77",
+        description="Classify banking customer support queries into 77 intents.",
+        default_port=8102,
+        tags=("classification", "intent", "nlp"),
+        metrics=("accuracy",),
+        sources=(
+            "GEPA blog quickstart",
+            "PolyAI Banking77 dataset card",
+        ),
+    ),
+    TaskAppSupport(
+        app_id="hotpotqa",
+        display_name="HotpotQA Multi-Hop QA",
+        dataset_id="hotpot_qa",
+        description="Answer multi-hop questions with supporting facts sourced from Wikipedia passages.",
+        default_port=8110,
+        tags=("qa", "multi-hop", "reasoning"),
+        metrics=("answer_em", "supporting_fact_f1"),
+        sources=(
+            "GEPA Table 1",
+            "HotpotQA (Yang et al., 2018)",
+        ),
+    ),
+    TaskAppSupport(
+        app_id="ifbench",
+        display_name="IFBench Instruction Following",
+        dataset_id="Muennighoff/IFBench",
+        description="Follow natural language instructions focusing on faithful adherence.",
+        default_port=8111,
+        tags=("instruction-following", "nlp"),
+        metrics=("compliance", "accuracy"),
+        sources=(
+            "GEPA Table 1",
+            "IFBench benchmark release",
+        ),
+    ),
+    TaskAppSupport(
+        app_id="hover",
+        display_name="HoVer Claim Verification",
+        dataset_id="hover",
+        description="Determine whether Wikipedia claims are supported, refuted, or not enough info given retrieved evidence.",
+        default_port=8112,
+        tags=("fact-checking", "classification"),
+        metrics=("label_accuracy", "evidence_f1"),
+        sources=(
+            "GEPA Table 1",
+            "HoVer benchmark (Jiang et al., 2020)",
+        ),
+    ),
+    TaskAppSupport(
+        app_id="pupa",
+        display_name="PUPA Privacy-Aware Delegation",
+        dataset_id="microsoft/PUPA",
+        description="Delegate actions while respecting privacy policies and extracting structured responses.",
+        default_port=8113,
+        tags=("delegation", "privacy", "structured-output"),
+        metrics=("privacy_compliance", "task_success"),
+        sources=(
+            "GEPA Table 1",
+            "PUPA benchmark release",
+        ),
+    ),
+)
+
+
+def list_supported_task_apps() -> Iterable[TaskAppSupport]:
+    """Return iterable over supported task apps for convenience."""
+
+    return SUPPORTED_TASK_APPS
+
+
+__all__ = ["TaskAppSupport", "SUPPORTED_TASK_APPS", "list_supported_task_apps"]

examples/blog_posts/gepa/test_gepa_local.sh

@@ -0,0 +1,67 @@
+#!/bin/bash
+# Quick test script for GEPA Banking77 prompt learning
+# Tests against local backend on port 8000
+
+set -e
+
+echo "🚀 Testing GEPA Prompt Learning for Banking77"
+echo "=============================================="
+
+# Check required environment variables
+if [ -z "$SYNTH_API_KEY" ]; then
+    echo "❌ ERROR: SYNTH_API_KEY not set"
+    exit 1
+fi
+
+if [ -z "$ENVIRONMENT_API_KEY" ]; then
+    echo "❌ ERROR: ENVIRONMENT_API_KEY not set"
+    exit 1
+fi
+
+# Set backend URL (default to localhost:8000)
+BACKEND_URL="${BACKEND_BASE_URL:-http://localhost:8000}"
+echo "📍 Backend URL: $BACKEND_URL"
+
+# Check backend is accessible
+echo "🔍 Checking backend health..."
+if curl -s -f "$BACKEND_URL/api/health" > /dev/null 2>&1; then
+    echo "✅ Backend is accessible"
+else
+    echo "❌ ERROR: Backend not accessible at $BACKEND_URL"
+    echo "   Make sure backend is running on port 8000"
+    exit 1
+fi
+
+# Check task app is accessible
+TASK_APP_URL="${TASK_APP_URL:-http://127.0.0.1:8102}"
+echo "🔍 Checking task app health..."
+if curl -s -f -H "X-API-Key: $ENVIRONMENT_API_KEY" "$TASK_APP_URL/health" > /dev/null 2>&1; then
+    echo "✅ Task app is accessible"
+else
+    echo "⚠️  WARNING: Task app not accessible at $TASK_APP_URL"
+    echo "   You may need to deploy it first:"
+    echo "   uvx synth-ai deploy banking77 --runtime uvicorn --port 8102"
+fi
+
+# Run GEPA training
+echo ""
+echo "🎯 Starting GEPA prompt optimization..."
+echo ""
+
+CONFIG_FILE="examples/blog_posts/gepa/configs/banking77_gepa_local.toml"
+
+if [ ! -f "$CONFIG_FILE" ]; then
+    echo "❌ ERROR: Config file not found: $CONFIG_FILE"
+    exit 1
+fi
+
+uvx synth-ai train \
+  --type prompt_learning \
+  --config "$CONFIG_FILE" \
+  --backend "$BACKEND_URL" \
+  --poll \
+  --poll-timeout 3600
+
+echo ""
+echo "✅ GEPA training completed!"
+

examples/blog_posts/gepa/verify_banking77_setup.sh

@@ -0,0 +1,123 @@
+#!/bin/bash
+# Verify Banking77 setup is working
+
+set -e
+
+echo "🔍 Verifying Banking77 Setup"
+echo "============================="
+echo ""
+
+cd "$(dirname "$0")/../../.."
+
+echo "1️⃣ Checking Python import..."
+python3 -c "
+try:
+    from examples.task_apps.banking77.banking77_task_app import build_config
+    print('   ✅ Task app imports successfully')
+    config = build_config()
+    print(f'   ✅ Config built: app_id={config.app_id}')
+    print(f'   ✅ Task name: {config.name}')
+except ImportError as e:
+    print(f'   ❌ Import error: {e}')
+    print('   💡 Run: uv pip install -e .')
+    exit(1)
+except Exception as e:
+    print(f'   ❌ Error: {e}')
+    exit(1)
+"
+
+echo ""
+echo "2️⃣ Checking CLI registration..."
+if uvx synth-ai task-app list 2>/dev/null | grep -q "banking77"; then
+    echo "   ✅ Banking77 registered with CLI"
+else
+    echo "   ⚠️  Banking77 not found in task-app list"
+    echo "   💡 This is OK if you haven't run 'uv pip install -e .' yet"
+fi
+
+echo ""
+echo "3️⃣ Checking helper scripts..."
+if [ -x "./examples/blog_posts/gepa/deploy_banking77_task_app.sh" ]; then
+    echo "   ✅ deploy_banking77_task_app.sh is executable"
+else
+    echo "   ❌ deploy_banking77_task_app.sh is not executable"
+    echo "   💡 Run: chmod +x ./examples/blog_posts/gepa/deploy_banking77_task_app.sh"
+fi
+
+if [ -x "./examples/blog_posts/gepa/run_gepa_banking77.sh" ]; then
+    echo "   ✅ run_gepa_banking77.sh is executable"
+else
+    echo "   ❌ run_gepa_banking77.sh is not executable"
+    echo "   💡 Run: chmod +x ./examples/blog_posts/gepa/run_gepa_banking77.sh"
+fi
+
+echo ""
+echo "4️⃣ Checking configuration files..."
+if [ -f "./examples/blog_posts/gepa/configs/banking77_gepa_local.toml" ]; then
+    echo "   ✅ banking77_gepa_local.toml exists"
+else
+    echo "   ❌ banking77_gepa_local.toml not found"
+fi
+
+echo ""
+echo "5️⃣ Checking environment variables..."
+if [ -n "$GROQ_API_KEY" ]; then
+    echo "   ✅ GROQ_API_KEY is set (${GROQ_API_KEY:0:10}...)"
+else
+    echo "   ⚠️  GROQ_API_KEY not set"
+    echo "   💡 Run: export GROQ_API_KEY='gsk_...'"
+fi
+
+if [ -n "$ENVIRONMENT_API_KEY" ]; then
+    echo "   ✅ ENVIRONMENT_API_KEY is set (${ENVIRONMENT_API_KEY:0:10}...)"
+else
+    echo "   ⚠️  ENVIRONMENT_API_KEY not set"
+    echo "   💡 Run: export ENVIRONMENT_API_KEY=\$(python3 -c 'import secrets; print(secrets.token_urlsafe(32))')"
+fi
+
+if [ -n "$SYNTH_API_KEY" ]; then
+    echo "   ✅ SYNTH_API_KEY is set (${SYNTH_API_KEY:0:10}...)"
+else
+    echo "   ⚠️  SYNTH_API_KEY not set"
+    echo "   💡 Get from backend admin or .env.dev file"
+fi
+
+echo ""
+echo "6️⃣ Checking services..."
+if curl -s -f http://localhost:8000/api/health > /dev/null 2>&1; then
+    echo "   ✅ Backend is running on http://localhost:8000"
+else
+    echo "   ⚠️  Backend not reachable at http://localhost:8000"
+    echo "   💡 Start the backend before running GEPA"
+fi
+
+if curl -s -f http://127.0.0.1:8102/health > /dev/null 2>&1; then
+    echo "   ✅ Task app is running on http://127.0.0.1:8102"
+else
+    echo "   ⚠️  Task app not running on http://127.0.0.1:8102"
+    echo "   💡 Run: ./examples/blog_posts/gepa/deploy_banking77_task_app.sh"
+fi
+
+echo ""
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo "Summary"
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo ""
+echo "To run Banking77 GEPA:"
+echo ""
+echo "  1. Install dependencies:"
+echo "     uv pip install -e ."
+echo ""
+echo "  2. Set environment variables:"
+echo "     export GROQ_API_KEY='gsk_...'"
+echo "     export SYNTH_API_KEY='your-backend-key'"
+echo "     export ENVIRONMENT_API_KEY=\$(python3 -c 'import secrets; print(secrets.token_urlsafe(32))')"
+echo ""
+echo "  3. Start task app (Terminal 1):"
+echo "     ./examples/blog_posts/gepa/deploy_banking77_task_app.sh"
+echo ""
+echo "  4. Run GEPA (Terminal 2):"
+echo "     ./examples/blog_posts/gepa/run_gepa_banking77.sh"
+echo ""
+echo "✅ Setup verification complete!"
+