optanything_rag_claudecode.py

"""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))