synth-ai 0.2.9.dev0__py3-none-any.whl → 0.2.23.dev3__py3-none-any.whl

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!"
+

examples/blog_posts/mipro/README.md

@@ -0,0 +1,415 @@
+# MIPROv2: Multi-Objective Prompt Optimization
+
+This directory contains examples and configurations for using MIPROv2 (Multi-Objective Prompt Optimization) to optimize prompts for various classification and reasoning tasks.
+
+## Overview
+
+**MIPROv2** is a meta-learning algorithm that optimizes prompts using:
+- **Bootstrap Phase**: Collects few-shot examples from high-scoring seeds
+- **Meta-Model**: LLM that proposes prompt improvements based on demonstrations
+- **TPE Optimization**: Tree-structured Parzen Estimator for efficient hyperparameter search
+- **Mini-Batch Evaluation**: Efficient online evaluation on small seed pools
+
+MIPROv2 is particularly effective when:
+- You want faster convergence with fewer evaluations (~100 vs ~1000 for GEPA)
+- You have clear task structure (can bootstrap with examples)
+- You need efficient optimization (mini-batch evaluation)
+- You want meta-learning benefits (few-shot adaptation)
+
+## Supported Tasks
+
+Configuration files live under `configs/`:
+
+| Task | Description | Config Files |
+|------|-------------|--------------|
+| **Banking77** | Intent classification (single-step) | `banking77_mipro_local.toml`, `banking77_mipro_test.toml` |
+| **Banking77 Pipeline** | Classifier ➞ calibrator multi-step pipeline | `banking77_pipeline_mipro_local.toml`, `banking77_pipeline_mipro_test.toml` |
+
+*More task configs coming soon: HotpotQA, IFBench, HoVer, PUPA*
+
+---
+
+## Quick Start (Banking77 Single-Step)
+
+### Prerequisites
+
+```bash
+# 1. Install dependencies
+uv pip install -e .
+
+# 2. Set environment variables
+export SYNTH_API_KEY="your-backend-api-key"
+export GROQ_API_KEY="gsk_your_groq_key"
+export OPENAI_API_KEY="sk-your-openai-key"  # Required for meta-model
+export ENVIRONMENT_API_KEY="$(python -c 'import secrets; print(secrets.token_urlsafe(32))')"
+```
+
+**Where to get API keys:**
+- **GROQ_API_KEY**: Get from https://console.groq.com/keys
+- **OPENAI_API_KEY**: Get from https://platform.openai.com/api-keys (required for meta-model)
+- **SYNTH_API_KEY**: Get from your backend admin or `.env.dev` file
+- **ENVIRONMENT_API_KEY**: Generate a random secure token (command above)
+
+### Step 1: Start the Backend
+
+```bash
+# Make sure your backend is running
+curl http://localhost:8000/api/health
+# Should return: {"status":"ok"}
+```
+
+### Step 2: Deploy Task App
+
+**Option A: Using helper script (recommended)**
+```bash
+# Terminal 1
+./examples/blog_posts/mipro/deploy_banking77_task_app.sh
+```
+
+**Option B: Using CLI**
+```bash
+uvx synth-ai deploy banking77 --runtime uvicorn --port 8102
+```
+
+**Option C: Deploy to Modal**
+```bash
+uvx synth-ai deploy banking77 --runtime modal --name banking77-mipro --env-file .env
+```
+
+### Step 3: Run MIPROv2 Optimization
+
+**Option A: Using helper script (recommended)**
+```bash
+# Terminal 2
+./examples/blog_posts/mipro/run_mipro_banking77.sh
+```
+
+**Option B: Using CLI directly**
+```bash
+uvx synth-ai train \
+  --config examples/blog_posts/mipro/configs/banking77_mipro_local.toml \
+  --backend http://localhost:8000 \
+  --poll
+```
+
+### Step 4: Monitor Progress
+
+You'll see real-time output like:
+```
+🔬 Running MIPROv2 on Banking77
+=================================
+✅ Backend URL: http://localhost:8000
+✅ Task app is healthy
+
+🚀 Starting MIPROv2 training...
+
+Bootstrap Phase:
+  Evaluating baseline on seeds [0-4]...
+  Found 3 high-scoring examples (score >= 0.85)
+  Initializing meta-model with few-shot examples...
+
+Iteration 1/16:
+  Meta-model proposing 6 prompt variants...
+  Evaluating on online pool [5-9]...
+  Best score: 0.78
+
+Iteration 2/16:
+  ...
+  
+✅ MIPROv2 training complete!
+Best prompt accuracy: 0.87 (87%)
+```
+
+Results are automatically saved and can be queried via the Python API or REST endpoints.
+
+---
+
+## Quick Start (Banking77 Multi-Step Pipeline)
+
+The pipeline task app chains a classifier stage with a calibrator stage. Each evaluation now executes both modules, so configs are toned down for latency.
+
+### Step 1: Deploy Pipeline Task App
+
+```bash
+# Terminal 1
+./examples/blog_posts/mipro/deploy_banking77_pipeline_task_app.sh
+```
+
+This launches the `banking77-pipeline` task app on `http://127.0.0.1:8112`.
+
+### Step 2: Run Pipeline Optimisation
+
+```bash
+# Terminal 2
+./examples/blog_posts/mipro/run_mipro_banking77_pipeline.sh
+```
+
+The helper script checks backend health, ensures the pipeline task app is online, and runs `banking77_pipeline_mipro_local.toml`.
+
+### Step 3: Monitor Output
+
+```
+🔬 Running MIPROv2 on Banking77 Pipeline
+========================================
+✅ Pipeline task app is healthy
+✅ Backend is healthy
+
+🚀 Starting MIPROv2 training...
+Multi-Step Flow:
+  1. Bootstrap: two-module pipeline on seeds [0-7]
+  2. Optimisation: 8 iterations × 4 variants
+  3. Held-out evaluation on seeds [16-23]
+```
+
+Expect slightly higher per-iteration latency because each candidate runs both pipeline modules. The script summarises results when optimisation finishes.
+
+## Configuration
+
+### Example: Banking77 MIPROv2 Configuration (Single-Step)
+
+```toml
+[prompt_learning]
+algorithm = "mipro"
+task_app_url = "http://127.0.0.1:8102"
+task_app_id = "banking77"
+
+[prompt_learning.initial_prompt]
+messages = [
+  { role = "system", content = "You are an expert banking assistant..." },
+  { role = "user", pattern = "Customer Query: {query}\n\nClassify..." }
+]
+
+[prompt_learning.mipro]
+num_iterations = 16                    # Optimization iterations
+num_evaluations_per_iteration = 6      # Variants per iteration
+batch_size = 6                         # Concurrent evaluations
+max_concurrent = 16                    # Max parallel rollouts
+meta_model = "gpt-4o-mini"            # Meta-model for proposals
+meta_model_provider = "openai"
+few_shot_score_threshold = 0.85        # Bootstrap threshold
+
+# Seed pools
+bootstrap_train_seeds = [0, 1, 2, 3, 4]    # Bootstrap phase seeds
+online_pool = [5, 6, 7, 8, 9]              # Online evaluation seeds
+test_pool = [10, 11, 12, 13, 14, 15, 16, 17, 18, 19]  # Final test seeds
+```
+
+### Example: Banking77 Pipeline Configuration (Multi-Step)
+
+```toml
+[prompt_learning]
+algorithm = "mipro"
+task_app_url = "http://127.0.0.1:8112"
+task_app_id = "banking77-pipeline"
+
+[prompt_learning.initial_prompt.metadata]
+pipeline_modules = [
+  { name = "classifier", instruction_text = "...", few_shots = [] },
+  { name = "calibrator", instruction_text = "...", few_shots = [] }
+]
+
+[prompt_learning.mipro]
+num_iterations = 8
+num_evaluations_per_iteration = 4
+batch_size = 4
+max_concurrent = 12
+few_shot_score_threshold = 0.82
+```
+
+The `pipeline_modules` metadata tells the task app which instruction text and demonstrations belong to each stage.
+
+### Key Parameters
+
+| Parameter | Description | Typical Range |
+|-----------|-------------|---------------|
+| `num_iterations` | Optimization iterations | 10-20 |
+| `num_evaluations_per_iteration` | Variants per iteration | 4-8 |
+| `batch_size` | Concurrent evaluations | 4-10 |
+| `few_shot_score_threshold` | Bootstrap threshold | 0.75-0.90 |
+| `bootstrap_train_seeds` | Bootstrap phase seeds | 3-10 seeds |
+| `online_pool` | Online evaluation seeds | 5-20 seeds |
+| `test_pool` | Final test seeds | 5-50 seeds |
+
+---
+
+## How MIPROv2 Works
+
+### Bootstrap Phase
+
+1. **Evaluate Baseline**: Run initial prompt on `bootstrap_train_seeds`
+2. **Collect Examples**: Filter seeds with score >= `few_shot_score_threshold`
+3. **Generate Demonstrations**: Format high-scoring examples as few-shot demonstrations
+4. **Initialize Meta-Model**: Provide demonstrations to meta-model for context
+5. **Warm Up TPE**: Initialize Tree-structured Parzen Estimator with initial evaluations
+
+### Optimization Loop
+
+For each iteration (1 to `num_iterations`):
+
+1. **Meta-Model Proposals**: Meta-model proposes `num_evaluations_per_iteration` prompt variants
+2. **TPE Selection**: TPE selects hyperparameters (mutation locations, instruction additions)
+3. **Mini-Batch Evaluation**: Evaluate variants on `online_pool` seeds (batch_size concurrent)
+4. **Update Meta-Model**: Learn from evaluation results
+5. **Update TPE**: Refine hyperparameter distribution
+
+### Final Evaluation
+
+- Evaluate best prompts on `test_pool` (held-out seeds)
+- Return optimized prompt with test score
+
+---
+
+## Querying Results
+
+### Python API
+
+```python
+from synth_ai.learning import get_prompts, get_prompt_text, get_scoring_summary
+
+# Get all results
+results = get_prompts(
+    job_id="pl_abc123",
+    base_url="http://localhost:8000",
+    api_key="sk_..."
+)
+
+# Access best prompt
+best_prompt = results["best_prompt"]
+best_score = results["best_score"]
+print(f"Best Score: {best_score:.3f}")
+
+# Get prompt text
+best_text = get_prompt_text(
+    job_id="pl_abc123",
+    base_url="http://localhost:8000",
+    api_key="sk_...",
+    rank=1
+)
+```
+
+### REST API
+
+```bash
+# Get job status
+curl -H "Authorization: Bearer $SYNTH_API_KEY" \
+  http://localhost:8000/api/prompt-learning/online/jobs/JOB_ID
+
+# Stream events
+curl -H "Authorization: Bearer $SYNTH_API_KEY" \
+  http://localhost:8000/api/prompt-learning/online/jobs/JOB_ID/events/stream
+
+# Get metrics
+curl -H "Authorization: Bearer $SYNTH_API_KEY" \
+  http://localhost:8000/api/prompt-learning/online/jobs/JOB_ID/metrics
+```
+
+---
+
+## Expected Results
+
+MIPROv2 typically achieves similar accuracy to GEPA with fewer evaluations:
+
+| Phase | Typical Accuracy | Notes |
+|-------|------------------|-------|
+| Baseline | 60-75% | Initial prompt |
+| After Bootstrap | 70-80% | Meta-model initialized with examples |
+| After 10 iterations | 80-85% | Mid-optimization |
+| After 16 iterations | 85-90%+ | Final optimized prompt |
+
+**Total Evaluations**: ~96 rollouts (16 iterations × 6 variants) vs ~1000 for GEPA
+
+---
+
+## GEPA vs MIPROv2
+
+| Aspect | GEPA | MIPROv2 |
+|--------|------|---------|
+| **Initialization** | Random population | Bootstrap phase (few-shot examples) |
+| **Exploration** | Mutation + Crossover | Meta-model + TPE |
+| **Evaluation** | Full (30 seeds) | Mini-batch (5 seeds per iteration) |
+| **Learning** | Population evolution | Meta-learning |
+| **Cost** | ~1000 rollouts | ~96 rollouts |
+| **Convergence** | 3-10 generations | 10-20 iterations |
+| **Best For** | Diverse solutions | Fast, efficient optimization |
+
+**When to Use GEPA:**
+- Need diverse prompt variants (Pareto front)
+- Want to explore many approaches
+- Have large evaluation budget
+
+**When to Use MIPROv2:**
+- Want faster convergence
+- Have clear task structure
+- Need efficient optimization
+- Want meta-learning benefits
+
+---
+
+## Troubleshooting
+
+### ❌ "MIPRO algorithm is not yet implemented"
+
+**Solution:** MIPROv2 support is currently under development. Use GEPA for now:
+```bash
+uvx synth-ai train --config examples/blog_posts/gepa/configs/banking77_gepa_local.toml
+```
+
+### ❌ "OPENAI_API_KEY environment variable is required"
+
+**Solution:** Export your OpenAI API key for the meta-model:
+```bash
+export OPENAI_API_KEY="sk-your-key-here"
+```
+
+### ❌ "Bootstrap phase found no high-scoring examples"
+
+**Solution:** Lower the `few_shot_score_threshold` in your config:
+```toml
+[prompt_learning.mipro]
+few_shot_score_threshold = 0.75  # Lower from 0.85
+```
+
+### ❌ "Banking77 task app is not running"
+
+**Solution:** Start the task app first:
+```bash
+./examples/blog_posts/mipro/deploy_banking77_task_app.sh
+```
+
+---
+
+## Files in This Directory
+
+```
+examples/blog_posts/mipro/
+├── README.md                         # This file - comprehensive guide
+├── configs/                          # Configuration files
+│   ├── banking77_mipro_local.toml   # Banking77 MIPRO config (local)
+│   └── banking77_mipro_test.toml    # Banking77 MIPRO config (test)
+├── deploy_banking77_task_app.sh     # Helper: Start task app
+└── run_mipro_banking77.sh            # Helper: Run MIPROv2 optimization
+```
+
+---
+
+## Next Steps
+
+1. **Test the bootstrap phase**: Verify few-shot example collection works
+2. **Run full optimization**: Complete 16 iterations and check results
+3. **Compare with GEPA**: Run GEPA on same task and compare accuracy/cost
+4. **Experiment with parameters**: Adjust bootstrap threshold, iteration count
+5. **Try other tasks**: Adapt configs for HotpotQA, IFBench, etc.
+
+---
+
+## Support
+
+For issues or questions:
+
+1. Verify all API keys are set correctly (SYNTH_API_KEY, GROQ_API_KEY, OPENAI_API_KEY)
+2. Check task app: `curl -H "X-API-Key: $ENVIRONMENT_API_KEY" http://127.0.0.1:8102/health`
+3. Check backend: `curl http://localhost:8000/api/health`
+4. Review logs in both terminals for error messages
+
+Happy optimizing! 🔬🚀
+