Uploading dataset files from the local data folder.

optanything_claudecode.py

@@ -0,0 +1,276 @@
+"""optimize_anything "omni" + Claude Code.
+
+Implements the two-phase **omni-GEPA** pattern from GEPA's release blog
+(https://gepa-ai.github.io/gepa/blog/2026/07/22/optimize-anything-omni/) on the
+"pelican riding a bicycle" SVG task, driven entirely by the local `claude` CLI
+(Claude Code) — no hosted VLM, no API keys:
+
+  * PHASE 1 (explore) — ``optimize_best_of`` runs *three* engines in parallel
+    and keeps the single best candidate:
+        - ``gepa``         : reflective evolution; its reflection LM is the
+                             `claude` CLI (it *sees* each rendered SVG).
+        - ``autoresearch`` : a black-box research optimizer that spawns
+                             ``claude --print`` to iterate on the artifact.
+        - ``meta_harness`` : an iterative meta-optimizer, also Claude-driven.
+  * PHASE 2 (continue) — a fresh ``gepa`` run is *seeded from the winner*.
+    This continuation-from-the-best is what the blog calls omni-GEPA.
+
+SCORING for every engine goes through one evaluator: render the SVG to PNG,
+show it to Claude Code, and parse ``SCORE: X/10``. The score + textual feedback
+(Actionable Side Information) is returned to whichever engine asked for it.
+
+Prereqs:
+  * `claude` CLI on PATH and authenticated (`claude -p "hi"` works). The
+    agentic engines shell out to `claude --print` themselves.
+  * `bwrap` on PATH if GEPA_SANDBOX=1 (the default) — the agentic engines jail
+    their `claude` subprocess, allowing only localhost (the eval server) and
+    api.anthropic.com. Set GEPA_SANDBOX=0 to run unsandboxed.
+  * `cairosvg` for SVG -> PNG rendering.
+  * gepa installed from git main (the "omni" API is unreleased as of 0.1.4);
+    see pyproject.toml.
+
+Run:  uv run python optanything_claudecode.py
+"""
+
+import base64
+import os
+import re
+import subprocess
+import tempfile
+
+import cairosvg
+
+from gepa.optimize_anything import (
+    optimize_anything,
+    optimize_best_of,
+    OptimizeAnythingConfig,
+)
+from gepa.gepa_launcher import GEPAConfig, EngineConfig, ReflectionConfig
+from gepa import Image
+
+GOAL = "a pelican riding a bicycle"
+
+# Per-engine eval-server budget. Phase 1 spends this on EACH of the three
+# engines (they run concurrently), phase 2 spends it once more on gepa.
+MAX_EVALS = int(os.environ.get("GEPA_MAX_EVALS", "20"))
+# Model the agentic engines pass to `claude --model`. An alias ("sonnet",
+# "opus", "haiku") or a full id both work.
+CLAUDE_MODEL = os.environ.get("GEPA_CLAUDE_MODEL", "sonnet")
+CLAUDE_TIMEOUT = int(os.environ.get("GEPA_CLAUDE_TIMEOUT", "600"))
+# The agentic engines jail their `claude` subprocess with bwrap by default.
+SANDBOX = os.environ.get("GEPA_SANDBOX", "1") not in ("0", "false", "no", "")
+
+
+# ---------------------------------------------------------------------------
+# SVG rendering + Claude-Code scoring.
+# ---------------------------------------------------------------------------
+_SVG_RE = re.compile(r"<svg\b.*?</svg>", re.IGNORECASE | re.DOTALL)
+
+
+def coerce_svg(candidate: str) -> str:
+    """Extract SVG source from a candidate string.
+
+    The `gepa` engine hands us clean SVG, but the agentic engines return
+    whatever `claude` wrote — often wrapped in ```svg fences or prefaced with
+    prose. Pull out the first ``<svg>...</svg>`` block; fall back to the raw
+    text so a render error (and its feedback) still flows back to the engine.
+    """
+    m = _SVG_RE.search(candidate)
+    return m.group(0) if m else candidate.strip()
+
+
+def render_image(svg_code: str) -> str:
+    """Render SVG source to a base64-encoded PNG string."""
+    png_bytes = cairosvg.svg2png(bytestring=svg_code.encode("utf-8"))
+    return base64.b64encode(png_bytes).decode("utf-8")
+
+
+def score_with_claude(image_b64: str, criteria: str) -> tuple[float, str]:
+    """Show the rendered image to Claude Code and parse `SCORE: X/10` -> (0..1, text)."""
+    tmpdir = tempfile.mkdtemp(prefix="gepa_score_")
+    path = os.path.join(tmpdir, "candidate.png")
+    with open(path, "wb") as f:
+        f.write(base64.b64decode(image_b64))
+    prompt = (
+        f"{criteria}\n\n"
+        f"Open and look at the image, then give one or two sentences of concrete, "
+        f"actionable feedback on what to improve. End your reply with a line "
+        f"exactly of the form 'SCORE: X/10'.\n\nImage: @{path}"
+    )
+    text = _claude_cli(prompt)
+    m = re.search(r"SCORE:\s*([0-9]+(?:\.[0-9]+)?)\s*/\s*10", text, re.IGNORECASE)
+    score = (float(m.group(1)) / 10.0) if m else 0.0
+    return max(0.0, min(1.0, score)), text
+
+
+# ---------------------------------------------------------------------------
+# Claude Code CLI as the reflection LM for the `gepa` engine.
+# ---------------------------------------------------------------------------
+def _claude_cli(prompt: str) -> str:
+    result = subprocess.run(
+        ["claude", "-p", prompt],
+        capture_output=True, text=True, timeout=CLAUDE_TIMEOUT,
+    )
+    if result.returncode != 0:
+        raise RuntimeError(f"claude -p failed (code {result.returncode}): {result.stderr}")
+    return result.stdout
+
+
+def _data_uri_to_file(url: str, tmpdir: str, idx: int) -> str | None:
+    """Decode a `data:image/...;base64,...` URI to a temp file; return its path."""
+    if not url.startswith("data:"):
+        return None
+    header, _, b64 = url.partition(",")
+    ext = ".jpg" if "image/jpeg" in header else ".webp" if "image/webp" in header else ".png"
+    path = os.path.join(tmpdir, f"reflect_img_{idx}{ext}")
+    with open(path, "wb") as f:
+        f.write(base64.b64decode(b64))
+    return path
+
+
+def claude_reflection_lm(prompt):
+    """Reflection LM backed by the `claude` CLI.
+
+    GEPA passes either a plain string (text-only reflective data) or an
+    OpenAI-style chat-messages list when images are present (our RenderedSVG).
+    We flatten to text and, for any inline image, write it to a temp PNG and
+    @-reference it so Claude Code can view it.
+    """
+    if isinstance(prompt, str):
+        return _claude_cli(prompt)
+
+    text_parts: list[str] = []
+    img_paths: list[str] = []
+    tmpdir = tempfile.mkdtemp(prefix="gepa_claude_")
+    for msg in prompt:
+        content = msg.get("content", "")
+        if isinstance(content, str):
+            text_parts.append(content)
+            continue
+        for part in content:
+            if part.get("type") == "text":
+                text_parts.append(part.get("text", ""))
+            elif part.get("type") == "image_url":
+                path = _data_uri_to_file(
+                    part["image_url"]["url"], tmpdir, len(img_paths) + 1
+                )
+                if path:
+                    img_paths.append(path)
+
+    prompt_text = "\n\n".join(p for p in text_parts if p)
+    if img_paths:
+        refs = " ".join(f"@{p}" for p in img_paths)
+        prompt_text += (
+            "\n\nThe referenced image(s) are the rendered SVG(s) above — "
+            f"open and inspect them: {refs}"
+        )
+    return _claude_cli(prompt_text)
+
+
+# ---------------------------------------------------------------------------
+# Task definition — ONE evaluator, shared by every engine.
+#
+# In the omni layer the candidate is a plain SVG *string* (only the `gepa`
+# engine accepts a multi-component dict seed; autoresearch/meta_harness require
+# a single text). So `evaluate` takes the SVG string directly.
+# ---------------------------------------------------------------------------
+def evaluate(candidate, example):
+    """Render SVG -> image, score with Claude Code, return (score, side_info)."""
+    svg = coerce_svg(candidate)
+    try:
+        image = render_image(svg)
+    except Exception as e:
+        # Give the engine actionable feedback instead of crashing the run.
+        return 0.0, {"Feedback": f"SVG failed to render ({type(e).__name__}): {e}"}
+    score, feedback = score_with_claude(image, example["criteria"])
+    return score, {
+        "RenderedSVG": Image(base64_data=image, media_type="image/png"),
+        "Feedback": feedback,
+    }
+
+
+VISUAL_ASPECTS = [
+    # 6 visual aspects -> Pareto-efficient selection (gepa engine).
+    {"id": "overall",     "criteria": f"Rate overall quality of this SVG ({GOAL}). SCORE: X/10"},
+    {"id": "anatomy",     "criteria": "Rate pelican accuracy: beak, pouch, plumage. SCORE: X/10"},
+    {"id": "bicycle",     "criteria": "Rate bicycle: wheels, frame, handlebars, pedals. SCORE: X/10"},
+    {"id": "composition", "criteria": "Rate how convincingly the pelican rides the bicycle. SCORE: X/10"},
+    {"id": "visual",      "criteria": "Rate visual appeal, scenery, and color usage. SCORE: X/10"},
+    {"id": "craft",       "criteria": "Rate SVG technical quality: shapes, layering. SCORE: X/10"},
+]
+
+OBJECTIVE = f"Optimize SVG code to illustrate '{GOAL}'. Output ONLY valid SVG."
+BACKGROUND = (
+    "The candidate is raw SVG source. It is rendered to a PNG and graded 0-10 "
+    "by a vision model against several visual criteria (pelican anatomy, the "
+    "bicycle, the riding composition, appeal, and SVG craft). Higher is better. "
+    "Output ONLY a single valid <svg>...</svg> document."
+)
+
+
+def _gepa_config() -> OptimizeAnythingConfig:
+    """The reflective-evolution engine, with Claude Code as its reflection LM.
+
+    ``engine_config`` is forwarded verbatim as ``GEPAConfig(**engine_config)``
+    by the omni gepa engine, so we build real GEPAConfig sub-objects here.
+    """
+    return OptimizeAnythingConfig(
+        engine="gepa",
+        max_evals=MAX_EVALS,
+        sandbox=SANDBOX,
+        engine_config=dict(
+            engine=EngineConfig(display_progress_bar=True),
+            reflection=ReflectionConfig(reflection_lm=claude_reflection_lm),
+        ),
+    )
+
+
+def _agentic_config(engine: str) -> OptimizeAnythingConfig:
+    """autoresearch / meta_harness — both spawn `claude --print` themselves."""
+    return OptimizeAnythingConfig(
+        engine=engine,
+        max_evals=MAX_EVALS,
+        sandbox=SANDBOX,
+        engine_config=dict(model=CLAUDE_MODEL),
+    )
+
+
+if __name__ == "__main__":
+    seed_svg = open("seed.svg").read()  # a plain white canvas
+    task = dict(
+        evaluator=evaluate,
+        dataset=VISUAL_ASPECTS,
+        objective=OBJECTIVE,
+        background=BACKGROUND,
+    )
+
+    # -- Phase 1 (explore): run all three engines in parallel, keep the best. --
+    # NOTE: temporarily running ONLY the autoresearch engine — the gepa and
+    # meta_harness engines are commented out below.
+    print(f"\n=== Phase 1: explore (autoresearch only, "
+          f"max_evals={MAX_EVALS}, sandbox={SANDBOX}) ===")
+    explore = optimize_best_of(
+        seed_svg,
+        configs=[
+            # _gepa_config(),
+            _agentic_config("autoresearch"),
+            # _agentic_config("meta_harness"),
+        ],
+        max_workers=3,
+        **task,
+    )
+    print(f"\nPhase 1 best score: {explore.best_score:.3f} "
+          f"({explore.total_evals} evals)")
+
+    # -- Phase 2 (continue): seed a fresh autoresearch run from the winner. --
+    print(f"\n=== Phase 2: continue with autoresearch, seeded from the phase-1 "
+          f"winner (max_evals={MAX_EVALS}) ===")
+    omni = optimize_anything(
+        explore.best_candidate,
+        config=_agentic_config("autoresearch"),
+        **task,
+    )
+
+    best = omni if omni.best_score >= explore.best_score else explore
+    print(f"\n=== Done. best score: {best.best_score:.3f} ===")
+    print(coerce_svg(best.best_candidate))

optanything_rag_claudecode (1).py

@@ -0,0 +1,379 @@
+"""optimize_anything "omni" + Claude Code — RAG *answer-prompt* optimization.
+
+A sibling of ``optanything_claudecode.py``. Same two-phase **omni-GEPA** pattern
+(https://gepa-ai.github.io/gepa/blog/2026/07/22/optimize-anything-omni/), but the
+task is prompt engineering for a **retrieval-augmented QA** system instead of
+SVG drawing.
+
+The key framing the user asked for: **the query and the retrieved content are
+FIXED — retrieval is frozen. The ONLY thing being optimized is the prompt used
+to answer the question.**
+
+  * The optimized artifact (the "candidate") is a single ANSWER-GENERATION
+    PROMPT — the instruction block that tells the model how to use the retrieved
+    context to answer. GEPA rewrites this string; nothing else moves.
+  * Each dataset row is a frozen (question, context, gold_answer) triple. The
+    context is a pre-retrieved bundle of passages that deliberately includes
+    distractors, and one row whose answer is *absent* from the context (so a
+    good prompt must abstain rather than hallucinate).
+
+  * PHASE 1 (explore) — ``optimize_best_of`` runs three engines in parallel and
+    keeps the single best answer-prompt:
+        - ``gepa``         : reflective evolution; its reflection LM is the
+                             `claude` CLI (it reads each generated answer + the
+                             judge's critique).
+        - ``autoresearch`` : a black-box research optimizer that spawns
+                             ``claude --print`` to iterate on the prompt.
+        - ``meta_harness`` : an iterative meta-optimizer, also Claude-driven.
+  * PHASE 2 (continue) — a fresh run is *seeded from the winner*. This
+    continuation-from-the-best is what the blog calls omni-GEPA.
+
+SCORING for every engine goes through one evaluator: take the candidate prompt,
+splice in the FIXED context + question, ask Claude Code to answer *grounded in
+that context only*, then ask Claude Code to grade the answer against the gold
+answer and parse ``SCORE: X/10``. The score + textual feedback (Actionable Side
+Information) flows back to whichever engine asked for it.
+
+Prereqs (identical to optanything_claudecode.py):
+  * `claude` CLI on PATH and authenticated (`claude -p "hi"` works).
+  * `bwrap` on PATH if GEPA_SANDBOX=1 (the default).
+  * gepa installed from git main (the "omni" API is unreleased as of 0.1.4);
+    see pyproject.toml.
+
+Run:  uv run python optanything_rag_claudecode.py
+"""
+
+import os
+import re
+import subprocess
+
+from gepa.optimize_anything import (
+    optimize_anything,
+    optimize_best_of,
+    OptimizeAnythingConfig,
+)
+from gepa.gepa_launcher import GEPAConfig, EngineConfig, ReflectionConfig
+
+# Per-engine eval-server budget. Phase 1 spends this on EACH of the three
+# engines (they run concurrently), phase 2 spends it once more.
+MAX_EVALS = int(os.environ.get("GEPA_MAX_EVALS", "20"))
+# Model the agentic engines pass to `claude --model`. An alias ("sonnet",
+# "opus", "haiku") or a full id both work.
+CLAUDE_MODEL = os.environ.get("GEPA_CLAUDE_MODEL", "sonnet")
+CLAUDE_TIMEOUT = int(os.environ.get("GEPA_CLAUDE_TIMEOUT", "600"))
+# The agentic engines jail their `claude` subprocess with bwrap by default.
+SANDBOX = os.environ.get("GEPA_SANDBOX", "1") not in ("0", "false", "no", "")
+
+
+# ---------------------------------------------------------------------------
+# The FROZEN RAG corpus + queries.
+#
+# In a real system these `context` strings come out of a retriever. Here they
+# are pre-retrieved and hard-coded: retrieval is FIXED, so the optimizer can
+# only improve how the model *reads* the context to answer — never what gets
+# retrieved. The passages include distractors, and `nyquist` has NO supporting
+# passage on purpose (its gold answer is an explicit "not in context" abstain).
+#
+# The corpus is split TRAIN / VAL. GEPA optimizes the prompt against the
+# trainset and scores candidates on the held-out valset to pick the one that
+# GENERALIZES — the winning prompt must work on questions/contexts it never
+# trained on, not just overfit the training rows. The valset mirrors the same
+# stresses (a distractor row + an abstain-required row) over UNSEEN content.
+# ---------------------------------------------------------------------------
+RAG_TRAINSET = [
+    {
+        "id": "capital",
+        "question": "What is the capital city mentioned for the Kingdom of Aldoria?",
+        "context": (
+            "[Doc 12] Aldoria is a mountainous kingdom. Its largest port is Vellmar.\n"
+            "[Doc 47] The seat of Aldorian government and its capital is the walled "
+            "city of Threnhold, founded 800 years ago.\n"
+            "[Doc 51] Neighbouring Corvane has its capital at Ashgate."
+        ),
+        "gold_answer": "Threnhold.",
+    },
+    {
+        "id": "multi_hop",
+        "question": "Who succeeded the ruler who commissioned the Great Aqueduct?",
+        "context": (
+            "[Doc 03] The Great Aqueduct was commissioned by Queen Maeve during her reign.\n"
+            "[Doc 09] Queen Maeve reigned for 31 years and was succeeded by her nephew, King Doran.\n"
+            "[Doc 22] King Doran later abdicated in favour of a council."
+        ),
+        "gold_answer": "King Doran (Queen Maeve's nephew) succeeded her.",
+    },
+    {
+        "id": "number",
+        "question": "How long did the siege of Threnhold last?",
+        "context": (
+            "[Doc 31] The siege of Threnhold began in spring and, after repeated assaults, "
+            "the walls held for exactly 214 days before the attackers withdrew.\n"
+            "[Doc 32] Threnhold's walls are 12 metres high."
+        ),
+        "gold_answer": "214 days.",
+    },
+    {
+        "id": "distractor",
+        "question": "What is Aldoria's chief export?",
+        "context": (
+            "[Doc 15] Aldoria is famous for its silver mines; refined silver is its chief export.\n"
+            "[Doc 16] Corvane, by contrast, exports mostly timber.\n"
+            "[Doc 17] Aldorian cuisine features salted fish from Vellmar."
+        ),
+        "gold_answer": "Silver (refined silver).",
+    },
+    {
+        "id": "nyquist",
+        # No passage supports this — a good answer prompt must ABSTAIN, not guess.
+        "question": "What is the population of Threnhold?",
+        "context": (
+            "[Doc 47] The seat of Aldorian government and its capital is the walled "
+            "city of Threnhold, founded 800 years ago.\n"
+            "[Doc 32] Threnhold's walls are 12 metres high."
+        ),
+        "gold_answer": (
+            "The population is not stated in the provided context; a correct answer "
+            "must say the information is not available rather than guess a number."
+        ),
+    },
+]
+
+# Held-out validation set — UNSEEN questions over UNSEEN content. GEPA never
+# optimizes against these; they are used only to score candidates for
+# generalization, so the winning prompt is the one that transfers, not the one
+# that memorised the trainset. Same stress mix: a distractor row (`val_export`)
+# and an abstain-required row (`val_abstain`).
+RAG_VALSET = [
+    {
+        "id": "val_capital",
+        "question": "Which city is the capital of Corvane?",
+        "context": (
+            "[Doc 51] Neighbouring Corvane has its capital at Ashgate.\n"
+            "[Doc 63] Corvane's largest festival is held each autumn in the town of Brill.\n"
+            "[Doc 64] Ashgate sits at the mouth of the River Corve."
+        ),
+        "gold_answer": "Ashgate.",
+    },
+    {
+        "id": "val_number",
+        "question": "How many towers does Ashgate castle have?",
+        "context": (
+            "[Doc 70] Ashgate castle is ringed by a moat and defended by nine towers.\n"
+            "[Doc 71] The castle's great hall seats three hundred."
+        ),
+        "gold_answer": "Nine towers.",
+    },
+    {
+        "id": "val_export",
+        "question": "What does Corvane mainly export?",
+        "context": (
+            "[Doc 16] Corvane exports mostly timber from its northern forests.\n"
+            "[Doc 15] Aldoria, by contrast, is famous for silver.\n"
+            "[Doc 17] Corvane also brews a well-known cider."
+        ),
+        "gold_answer": "Timber.",
+    },
+    {
+        "id": "val_abstain",
+        # No passage gives the founding year — the prompt must ABSTAIN.
+        "question": "In what year was Ashgate castle built?",
+        "context": (
+            "[Doc 70] Ashgate castle is ringed by a moat and defended by nine towers.\n"
+            "[Doc 64] Ashgate sits at the mouth of the River Corve."
+        ),
+        "gold_answer": (
+            "The founding year is not stated in the provided context; a correct "
+            "answer must say the information is not available rather than guess."
+        ),
+    },
+]
+
+
+# ---------------------------------------------------------------------------
+# Claude Code CLI helper (shared by the answerer, the judge, and — for the
+# `gepa` engine — the reflection LM).
+# ---------------------------------------------------------------------------
+def _claude_cli(prompt: str) -> str:
+    result = subprocess.run(
+        ["claude", "-p", prompt],
+        capture_output=True, text=True, timeout=CLAUDE_TIMEOUT,
+    )
+    if result.returncode != 0:
+        raise RuntimeError(f"claude -p failed (code {result.returncode}): {result.stderr}")
+    return result.stdout
+
+
+def claude_reflection_lm(prompt):
+    """Reflection LM backed by the `claude` CLI (text-only for this task)."""
+    if isinstance(prompt, str):
+        return _claude_cli(prompt)
+    # Flatten any chat-messages form to plain text (no images here).
+    parts: list[str] = []
+    for msg in prompt:
+        content = msg.get("content", "")
+        if isinstance(content, str):
+            parts.append(content)
+        else:
+            for part in content:
+                if part.get("type") == "text":
+                    parts.append(part.get("text", ""))
+    return _claude_cli("\n\n".join(p for p in parts if p))
+
+
+# ---------------------------------------------------------------------------
+# The candidate is a plain-text answer prompt. The agentic engines return
+# whatever `claude` wrote — sometimes wrapped in ``` fences or prefaced with
+# prose ("Here is the improved prompt:"). Strip fences; otherwise use as-is.
+# ---------------------------------------------------------------------------
+_FENCE_RE = re.compile(r"^```[a-zA-Z]*\n(.*?)\n```", re.DOTALL | re.MULTILINE)
+
+
+def coerce_prompt(candidate: str) -> str:
+    """Pull the answer prompt out of a candidate string."""
+    m = _FENCE_RE.search(candidate)
+    return (m.group(1) if m else candidate).strip()
+
+
+# ---------------------------------------------------------------------------
+# Answer generation + grading, both via Claude Code.
+# ---------------------------------------------------------------------------
+def generate_answer(answer_prompt: str, question: str, context: str) -> str:
+    """Run the candidate answer-prompt against the FIXED context + question."""
+    full = (
+        f"{answer_prompt}\n\n"
+        f"=== RETRIEVED CONTEXT (do not use outside knowledge) ===\n{context}\n\n"
+        f"=== QUESTION ===\n{question}\n\n"
+        f"=== ANSWER ==="
+    )
+    return _claude_cli(full).strip()
+
+
+def grade_answer(question: str, gold: str, answer: str) -> tuple[float, str]:
+    """LLM-judge the generated answer against the gold answer -> (0..1, text)."""
+    prompt = (
+        "You are grading a retrieval-augmented QA system's answer.\n\n"
+        f"QUESTION:\n{question}\n\n"
+        f"REFERENCE (gold) ANSWER:\n{gold}\n\n"
+        f"SYSTEM ANSWER:\n{answer}\n\n"
+        "Grade the system answer for factual correctness and grounding relative "
+        "to the reference. Full marks require the right fact (or a correct "
+        "abstention when the reference says the info is unavailable), concisely "
+        "stated and grounded in the context. Penalise hallucinations, hedging, "
+        "and answering when the reference says to abstain.\n"
+        "Give one or two sentences of concrete, actionable feedback on how the "
+        "ANSWER PROMPT could be rewritten to fix what went wrong, then end with a "
+        "line exactly of the form 'SCORE: X/10'."
+    )
+    text = _claude_cli(prompt)
+    m = re.search(r"SCORE:\s*([0-9]+(?:\.[0-9]+)?)\s*/\s*10", text, re.IGNORECASE)
+    score = (float(m.group(1)) / 10.0) if m else 0.0
+    return max(0.0, min(1.0, score)), text
+
+
+# ---------------------------------------------------------------------------
+# Task definition — ONE evaluator, shared by every engine.
+#
+# `candidate` is the answer-generation prompt string. `example` is one frozen
+# (question, context, gold_answer) row.
+# ---------------------------------------------------------------------------
+def evaluate(candidate, example):
+    """Answer the FIXED query with the candidate prompt, then grade it."""
+    answer_prompt = coerce_prompt(candidate)
+    try:
+        answer = generate_answer(answer_prompt, example["question"], example["context"])
+    except Exception as e:
+        return 0.0, {"Feedback": f"Answer generation failed ({type(e).__name__}): {e}"}
+    score, feedback = grade_answer(example["question"], example["gold_answer"], answer)
+    return score, {
+        # The generated answer is the actionable side-info the reflection LM
+        # reads to understand *why* this prompt scored what it did.
+        "GeneratedAnswer": answer,
+        "Feedback": feedback,
+    }
+
+
+OBJECTIVE = (
+    "Optimize the ANSWER PROMPT for a retrieval-augmented QA system. Retrieval "
+    "is fixed; only the prompt that instructs the model how to answer from the "
+    "retrieved context may change. Output ONLY the prompt text."
+)
+BACKGROUND = (
+    "The candidate is a reusable ANSWER PROMPT. At eval time it is concatenated "
+    "with a FROZEN retrieved-context bundle and a question, and a model produces "
+    "an answer strictly from that context. A judge grades the answer 0-10 "
+    "against a gold reference for factual correctness and grounding. The corpus "
+    "contains distractor passages and at least one question whose answer is NOT "
+    "in the context — for that one a correct answer must ABSTAIN ('not stated in "
+    "the context') rather than hallucinate. A good prompt therefore enforces: "
+    "answer only from the context, cite/quote support, be concise, and abstain "
+    "when the context lacks the answer. Output ONLY the prompt text."
+)
+
+# A deliberately weak seed prompt — it neither grounds nor abstains, so there is
+# room for the optimizer to improve it.
+SEED_PROMPT = "Answer the question."
+
+
+def _gepa_config() -> OptimizeAnythingConfig:
+    """Reflective-evolution engine, with Claude Code as its reflection LM."""
+    return OptimizeAnythingConfig(
+        engine="gepa",
+        max_evals=MAX_EVALS,
+        sandbox=SANDBOX,
+        engine_config=dict(
+            engine=EngineConfig(display_progress_bar=True),
+            reflection=ReflectionConfig(reflection_lm=claude_reflection_lm),
+        ),
+    )
+
+
+def _agentic_config(engine: str) -> OptimizeAnythingConfig:
+    """autoresearch / meta_harness — both spawn `claude --print` themselves."""
+    return OptimizeAnythingConfig(
+        engine=engine,
+        max_evals=MAX_EVALS,
+        sandbox=SANDBOX,
+        engine_config=dict(model=CLAUDE_MODEL),
+    )
+
+
+if __name__ == "__main__":
+    task = dict(
+        evaluator=evaluate,
+        dataset=RAG_TRAINSET,
+        valset=RAG_VALSET,
+        objective=OBJECTIVE,
+        background=BACKGROUND,
+    )
+
+    # -- Phase 1 (explore): run engines in parallel, keep the best prompt. --
+    # Mirroring optanything_claudecode.py, only the autoresearch engine is
+    # enabled by default; uncomment the others to run the full best-of-three.
+    print(f"\n=== Phase 1: explore (autoresearch only, "
+          f"max_evals={MAX_EVALS}, sandbox={SANDBOX}) ===")
+    explore = optimize_best_of(
+        SEED_PROMPT,
+        configs=[
+            # _gepa_config(),
+            _agentic_config("autoresearch"),
+            # _agentic_config("meta_harness"),
+        ],
+        max_workers=3,
+        **task,
+    )
+    print(f"\nPhase 1 best score: {explore.best_score:.3f} "
+          f"({explore.total_evals} evals)")
+
+    # -- Phase 2 (continue): seed a fresh run from the winner. --
+    print(f"\n=== Phase 2: continue with autoresearch, seeded from the phase-1 "
+          f"winner (max_evals={MAX_EVALS}) ===")
+    omni = optimize_anything(
+        explore.best_candidate,
+        config=_agentic_config("autoresearch"),
+        **task,
+    )
+
+    best = omni if omni.best_score >= explore.best_score else explore
+    print(f"\n=== Done. best score: {best.best_score:.3f} ===")
+    print("\n--- Optimized answer prompt ---")
+    print(coerce_prompt(best.best_candidate))

optanything_rag_claudecode.py

@@ -0,0 +1,378 @@
+"""optimize_anything "omni" + Claude Code — RAG *answer-prompt* optimization.
+
+A sibling of ``optanything_claudecode.py``. Same two-phase **omni-GEPA** pattern
+(https://gepa-ai.github.io/gepa/blog/2026/07/22/optimize-anything-omni/), but the
+task is prompt engineering for a **retrieval-augmented QA** system instead of
+SVG drawing.
+
+The key framing the user asked for: **the query and the retrieved content are
+FIXED — retrieval is frozen. The ONLY thing being optimized is the prompt used
+to answer the question.**
+
+  * The optimized artifact (the "candidate") is a single ANSWER-GENERATION
+    PROMPT — the instruction block that tells the model how to use the retrieved
+    context to answer. GEPA rewrites this string; nothing else moves.
+  * Each dataset row is a frozen (question, context, gold_answer) triple. The
+    context is a pre-retrieved bundle of passages that deliberately includes
+    distractors, and one row whose answer is *absent* from the context (so a
+    good prompt must abstain rather than hallucinate).
+
+  * PHASE 1 (explore) — ``optimize_best_of`` runs three engines in parallel and
+    keeps the single best answer-prompt:
+        - ``gepa``         : reflective evolution; its reflection LM is the
+                             `claude` CLI (it reads each generated answer + the
+                             judge's critique).
+        - ``autoresearch`` : a black-box research optimizer that spawns
+                             ``claude --print`` to iterate on the prompt.
+        - ``meta_harness`` : an iterative meta-optimizer, also Claude-driven.
+  * PHASE 2 (continue) — a fresh run is *seeded from the winner*. This
+    continuation-from-the-best is what the blog calls omni-GEPA.
+
+SCORING for every engine goes through one evaluator: take the candidate prompt,
+splice in the FIXED context + question, ask Claude Code to answer *grounded in
+that context only*, then ask Claude Code to grade the answer against the gold
+answer and parse ``SCORE: X/10``. The score + textual feedback (Actionable Side
+Information) flows back to whichever engine asked for it.
+
+Prereqs (identical to optanything_claudecode.py):
+  * `claude` CLI on PATH and authenticated (`claude -p "hi"` works).
+  * `bwrap` on PATH if GEPA_SANDBOX=1 (the default).
+  * gepa installed from git main (the "omni" API is unreleased as of 0.1.4);
+    see pyproject.toml.
+
+Run:  uv run python optanything_rag_claudecode.py
+"""
+
+import os
+import re
+import subprocess
+
+from gepa.optimize_anything import (
+    optimize_anything,
+    optimize_best_of,
+    OptimizeAnythingConfig,
+)
+from gepa.gepa_launcher import GEPAConfig, EngineConfig, ReflectionConfig
+
+# Per-engine eval-server budget. Phase 1 spends this on EACH of the three
+# engines (they run concurrently), phase 2 spends it once more.
+MAX_EVALS = int(os.environ.get("GEPA_MAX_EVALS", "20"))
+# Model the agentic engines pass to `claude --model`. An alias ("sonnet",
+# "opus", "haiku") or a full id both work.
+CLAUDE_MODEL = os.environ.get("GEPA_CLAUDE_MODEL", "sonnet")
+CLAUDE_TIMEOUT = int(os.environ.get("GEPA_CLAUDE_TIMEOUT", "600"))
+# The agentic engines jail their `claude` subprocess with bwrap by default.
+SANDBOX = os.environ.get("GEPA_SANDBOX", "1") not in ("0", "false", "no", "")
+
+
+# ---------------------------------------------------------------------------
+# The FROZEN RAG corpus + queries.
+#
+# In a real system these `context` strings come out of a retriever. Here they
+# are pre-retrieved and hard-coded: retrieval is FIXED, so the optimizer can
+# only improve how the model *reads* the context to answer — never what gets
+# retrieved. The passages include distractors, and `nyquist` has NO supporting
+# passage on purpose (its gold answer is an explicit "not in context" abstain).
+#
+# The corpus is split TRAIN / VAL. GEPA optimizes the prompt against the
+# trainset and scores candidates on the held-out valset to pick the one that
+# GENERALIZES — the winning prompt must work on questions/contexts it never
+# trained on, not just overfit the training rows. The valset mirrors the same
+# stresses (a distractor row + an abstain-required row) over UNSEEN content.
+# ---------------------------------------------------------------------------
+RAG_TRAINSET = [
+    {
+        "id": "capital",
+        "question": "What is the capital city mentioned for the Kingdom of Aldoria?",
+        "context": (
+            "[Doc 12] Aldoria is a mountainous kingdom. Its largest port is Vellmar.\n"
+            "[Doc 47] The seat of Aldorian government and its capital is the walled "
+            "city of Threnhold, founded 800 years ago.\n"
+            "[Doc 51] Neighbouring Corvane has its capital at Ashgate."
+        ),
+        "gold_answer": "Threnhold.",
+    },
+    {
+        "id": "multi_hop",
+        "question": "Who succeeded the ruler who commissioned the Great Aqueduct?",
+        "context": (
+            "[Doc 03] The Great Aqueduct was commissioned by Queen Maeve during her reign.\n"
+            "[Doc 09] Queen Maeve reigned for 31 years and was succeeded by her nephew, King Doran.\n"
+            "[Doc 22] King Doran later abdicated in favour of a council."
+        ),
+        "gold_answer": "King Doran (Queen Maeve's nephew) succeeded her.",
+    },
+    {
+        "id": "number",
+        "question": "How long did the siege of Threnhold last?",
+        "context": (
+            "[Doc 31] The siege of Threnhold began in spring and, after repeated assaults, "
+            "the walls held for exactly 214 days before the attackers withdrew.\n"
+            "[Doc 32] Threnhold's walls are 12 metres high."
+        ),
+        "gold_answer": "214 days.",
+    },
+    {
+        "id": "distractor",
+        "question": "What is Aldoria's chief export?",
+        "context": (
+            "[Doc 15] Aldoria is famous for its silver mines; refined silver is its chief export.\n"
+            "[Doc 16] Corvane, by contrast, exports mostly timber.\n"
+            "[Doc 17] Aldorian cuisine features salted fish from Vellmar."
+        ),
+        "gold_answer": "Silver (refined silver).",
+    },
+    {
+        "id": "nyquist",
+        # No passage supports this — a good answer prompt must ABSTAIN, not guess.
+        "question": "What is the population of Threnhold?",
+        "context": (
+            "[Doc 47] The seat of Aldorian government and its capital is the walled "
+            "city of Threnhold, founded 800 years ago.\n"
+            "[Doc 32] Threnhold's walls are 12 metres high."
+        ),
+        "gold_answer": (
+            "The population is not stated in the provided context; a correct answer "
+            "must say the information is not available rather than guess a number."
+        ),
+    },
+]
+
+# Held-out validation set — UNSEEN questions over UNSEEN content. GEPA never
+# optimizes against these; they are used only to score candidates for
+# generalization, so the winning prompt is the one that transfers, not the one
+# that memorised the trainset. Same stress mix: a distractor row (`val_export`)
+# and an abstain-required row (`val_abstain`).
+RAG_VALSET = [
+    {
+        "id": "val_capital",
+        "question": "Which city is the capital of Corvane?",
+        "context": (
+            "[Doc 51] Neighbouring Corvane has its capital at Ashgate.\n"
+            "[Doc 63] Corvane's largest festival is held each autumn in the town of Brill.\n"
+            "[Doc 64] Ashgate sits at the mouth of the River Corve."
+        ),
+        "gold_answer": "Ashgate.",
+    },
+    {
+        "id": "val_number",
+        "question": "How many towers does Ashgate castle have?",
+        "context": (
+            "[Doc 70] Ashgate castle is ringed by a moat and defended by nine towers.\n"
+            "[Doc 71] The castle's great hall seats three hundred."
+        ),
+        "gold_answer": "Nine towers.",
+    },
+    {
+        "id": "val_export",
+        "question": "What does Corvane mainly export?",
+        "context": (
+            "[Doc 16] Corvane exports mostly timber from its northern forests.\n"
+            "[Doc 15] Aldoria, by contrast, is famous for silver.\n"
+            "[Doc 17] Corvane also brews a well-known cider."
+        ),
+        "gold_answer": "Timber.",
+    },
+    {
+        "id": "val_abstain",
+        # No passage gives the founding year — the prompt must ABSTAIN.
+        "question": "In what year was Ashgate castle built?",
+        "context": (
+            "[Doc 70] Ashgate castle is ringed by a moat and defended by nine towers.\n"
+            "[Doc 64] Ashgate sits at the mouth of the River Corve."
+        ),
+        "gold_answer": (
+            "The founding year is not stated in the provided context; a correct "
+            "answer must say the information is not available rather than guess."
+        ),
+    },
+]
+
+
+# ---------------------------------------------------------------------------
+# Claude Code CLI helper (shared by the answerer, the judge, and — for the
+# `gepa` engine — the reflection LM).
+# ---------------------------------------------------------------------------
+def _claude_cli(prompt: str) -> str:
+    result = subprocess.run(
+        ["claude", "-p", prompt],
+        capture_output=True, text=True, timeout=CLAUDE_TIMEOUT,
+    )
+    if result.returncode != 0:
+        raise RuntimeError(f"claude -p failed (code {result.returncode}): {result.stderr}")
+    return result.stdout
+
+
+def claude_reflection_lm(prompt):
+    """Reflection LM backed by the `claude` CLI (text-only for this task)."""
+    if isinstance(prompt, str):
+        return _claude_cli(prompt)
+    # Flatten any chat-messages form to plain text (no images here).
+    parts: list[str] = []
+    for msg in prompt:
+        content = msg.get("content", "")
+        if isinstance(content, str):
+            parts.append(content)
+        else:
+            for part in content:
+                if part.get("type") == "text":
+                    parts.append(part.get("text", ""))
+    return _claude_cli("\n\n".join(p for p in parts if p))
+
+
+# ---------------------------------------------------------------------------
+# The candidate is a plain-text answer prompt. The agentic engines return
+# whatever `claude` wrote — sometimes wrapped in ``` fences or prefaced with
+# prose ("Here is the improved prompt:"). Strip fences; otherwise use as-is.
+# ---------------------------------------------------------------------------
+_FENCE_RE = re.compile(r"^```[a-zA-Z]*\n(.*?)\n```", re.DOTALL | re.MULTILINE)
+
+
+def coerce_prompt(candidate: str) -> str:
+    """Pull the answer prompt out of a candidate string."""
+    m = _FENCE_RE.search(candidate)
+    return (m.group(1) if m else candidate).strip()
+
+
+# ---------------------------------------------------------------------------
+# Answer generation + grading, both via Claude Code.
+# ---------------------------------------------------------------------------
+def generate_answer(answer_prompt: str, question: str, context: str) -> str:
+    """Run the candidate answer-prompt against the FIXED context + question."""
+    full = (
+        f"{answer_prompt}\n\n"
+        f"=== RETRIEVED CONTEXT (do not use outside knowledge) ===\n{context}\n\n"
+        f"=== QUESTION ===\n{question}\n\n"
+        f"=== ANSWER ==="
+    )
+    return _claude_cli(full).strip()
+
+
+def grade_answer(question: str, gold: str, answer: str) -> tuple[float, str]:
+    """LLM-judge the generated answer against the gold answer -> (0..1, text)."""
+    prompt = (
+        "You are grading a retrieval-augmented QA system's answer.\n\n"
+        f"QUESTION:\n{question}\n\n"
+        f"REFERENCE (gold) ANSWER:\n{gold}\n\n"
+        f"SYSTEM ANSWER:\n{answer}\n\n"
+        "Grade the system answer for factual correctness and grounding relative "
+        "to the reference. Full marks require the right fact (or a correct "
+        "abstention when the reference says the info is unavailable), concisely "
+        "stated and grounded in the context. Penalise hallucinations, hedging, "
+        "and answering when the reference says to abstain.\n"
+        "Give one or two sentences of concrete, actionable feedback on how the "
+        "ANSWER PROMPT could be rewritten to fix what went wrong, then end with a "
+        "line exactly of the form 'SCORE: X/10'."
+    )
+    text = _claude_cli(prompt)
+    m = re.search(r"SCORE:\s*([0-9]+(?:\.[0-9]+)?)\s*/\s*10", text, re.IGNORECASE)
+    score = (float(m.group(1)) / 10.0) if m else 0.0
+    return max(0.0, min(1.0, score)), text
+
+
+# ---------------------------------------------------------------------------
+# Task definition — ONE evaluator, shared by every engine.
+#
+# `candidate` is the answer-generation prompt string. `example` is one frozen
+# (question, context, gold_answer) row.
+# ---------------------------------------------------------------------------
+def evaluate(candidate, example):
+    """Answer the FIXED query with the candidate prompt, then grade it."""
+    answer_prompt = coerce_prompt(candidate)
+    try:
+        answer = generate_answer(answer_prompt, example["question"], example["context"])
+    except Exception as e:
+        return 0.0, {"Feedback": f"Answer generation failed ({type(e).__name__}): {e}"}
+    score, feedback = grade_answer(example["question"], example["gold_answer"], answer)
+    return score, {
+        # The generated answer is the actionable side-info the reflection LM
+        # reads to understand *why* this prompt scored what it did.
+        "GeneratedAnswer": answer,
+        "Feedback": feedback,
+    }
+
+
+OBJECTIVE = (
+    "Optimize the ANSWER PROMPT for a retrieval-augmented QA system. Retrieval "
+    "is fixed; only the prompt that instructs the model how to answer from the "
+    "retrieved context may change. Output ONLY the prompt text."
+)
+BACKGROUND = (
+    "The candidate is a reusable ANSWER PROMPT. At eval time it is concatenated "
+    "with a FROZEN retrieved-context bundle and a question, and a model produces "
+    "an answer strictly from that context. A judge grades the answer 0-10 "
+    "against a gold reference for factual correctness and grounding. The corpus "
+    "contains distractor passages and at least one question whose answer is NOT "
+    "in the context — for that one a correct answer must ABSTAIN ('not stated in "
+    "the context') rather than hallucinate. A good prompt therefore enforces: "
+    "answer only from the context, cite/quote support, be concise, and abstain "
+    "when the context lacks the answer. Output ONLY the prompt text."
+)
+
+# A deliberately weak seed prompt — it neither grounds nor abstains, so there is
+# room for the optimizer to improve it.
+SEED_PROMPT = "Answer the question."
+
+
+def _gepa_config() -> OptimizeAnythingConfig:
+    """Reflective-evolution engine, with Claude Code as its reflection LM."""
+    return OptimizeAnythingConfig(
+        engine="gepa",
+        max_evals=MAX_EVALS,
+        sandbox=SANDBOX,
+        engine_config=dict(
+            engine=EngineConfig(display_progress_bar=True),
+            reflection=ReflectionConfig(reflection_lm=claude_reflection_lm),
+        ),
+    )
+
+
+def _agentic_config(engine: str) -> OptimizeAnythingConfig:
+    """autoresearch / meta_harness — both spawn `claude --print` themselves."""
+    return OptimizeAnythingConfig(
+        engine=engine,
+        max_evals=MAX_EVALS,
+        sandbox=SANDBOX,
+        engine_config=dict(model=CLAUDE_MODEL),
+    )
+
+
+if __name__ == "__main__":
+    task = dict(
+        evaluator=evaluate,
+        dataset=RAG_DATASET,
+        objective=OBJECTIVE,
+        background=BACKGROUND,
+    )
+
+    # -- Phase 1 (explore): run engines in parallel, keep the best prompt. --
+    # Mirroring optanything_claudecode.py, only the autoresearch engine is
+    # enabled by default; uncomment the others to run the full best-of-three.
+    print(f"\n=== Phase 1: explore (autoresearch only, "
+          f"max_evals={MAX_EVALS}, sandbox={SANDBOX}) ===")
+    explore = optimize_best_of(
+        SEED_PROMPT,
+        configs=[
+            # _gepa_config(),
+            _agentic_config("autoresearch"),
+            # _agentic_config("meta_harness"),
+        ],
+        max_workers=3,
+        **task,
+    )
+    print(f"\nPhase 1 best score: {explore.best_score:.3f} "
+          f"({explore.total_evals} evals)")
+
+    # -- Phase 2 (continue): seed a fresh run from the winner. --
+    print(f"\n=== Phase 2: continue with autoresearch, seeded from the phase-1 "
+          f"winner (max_evals={MAX_EVALS}) ===")
+    omni = optimize_anything(
+        explore.best_candidate,
+        config=_agentic_config("autoresearch"),
+        **task,
+    )
+
+    best = omni if omni.best_score >= explore.best_score else explore
+    print(f"\n=== Done. best score: {best.best_score:.3f} ===")
+    print("\n--- Optimized answer prompt ---")
+    print(coerce_prompt(best.best_candidate))

semantic-log-file-mcp.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:934970000fff2250b6b601ee15d9b3cc6b135d65a9b805de9d20d2c6f1280858
+size 61143040