Wann man dazu greift
- Ergebnisqualität Vorrang vor minimaler Latenz hat.
- Fehler vom Modell durch gezielte Selbstkritik erkannt werden können.
Reflexion.
Handeln. Bewerten. Reflektieren. Erneut versuchen.
Der Agent bewertet seine eigenen Zwischenergebnisse kritisch und nutzt dieses Feedback, um in iterativen Schleifen die nächsten Schritte oder die Ausgabe zu verbessern.
Wann es nach hinten losgeht
- Die Selbsteinschätzung des Modells unzuverlässig ist.
- Harte externe Validierungen existieren.
- Latenz und Kosten streng begrenzt sind.
Die Abwägung
Führt zu höherer Ergebnisqualität, verursacht aber zusätzliche Token-Kosten und kann zu falschem Vertrauen führen.
Eine Form, die du auf eine Serviette zeichnen kannst.
Handeln, bewerten, reflektieren, erneut versuchen. Eine Selbstkritik-Schleife, begrenzt durch ein Retry-Budget.
Ein realer Ablauf, Schritt für Schritt.
Aufgabe"Schreibe eine SQL-Abfrage, die den Umsatz des letzten Quartals nach Region zurückgibt."
Handelnactor(prompt) → SELECT region, SUM(amount) FROM sales WHERE quarter = 'Q1' GROUP BY region
Bewertenevaluator(query) → FEHLER: Spalte 'quarter' existiert nicht; verwende 'date' mit EXTRACT(QUARTER FROM date)
Reflektierenreflector(error) → 'Ich habe angenommen, dass eine Spalte quarter existiert. Ich brauche EXTRACT(QUARTER FROM date) und muss für das vorherige Quartal filtern.'
Erneut versuchenactor(reflection) → SELECT region, SUM(amount) FROM sales WHERE EXTRACT(QUARTER FROM date) = EXTRACT(QUARTER FROM CURRENT_DATE - INTERVAL '3 months') GROUP BY region
Bewerten 2evaluator(query) → BESTANDEN: Abfrage wird ausgeführt und gibt 4 Zeilen zurück
AntwortSQL-Abfrage geliefert. Schleife nach 2 Iterationen beendet (Budget: 3).
Die Schleife ist schon eingebaut.
LangGraphpython
from typing import TypedDict
from langgraph.graph import StateGraph, END
class State(TypedDict):
prompt: str
attempt: str | None
evaluation: str | None
reflection: str | None
retries: int
max_retries: int
def attempt(state):
return {"attempt": actor_llm(state["prompt"])}
def evaluate(state):
return {"evaluation": evaluator_llm(state["attempt"])}
def reflect(state):
return {"reflection": reflector_llm(state["evaluation"]), "retries": state["retries"] + 1}
def should_continue(state):
if "PASS" in state["evaluation"]:
return "end"
if state["retries"] >= state["max_retries"]:
return "end"
return "retry"
g = StateGraph(State)
g.add_node("attempt", attempt)
g.add_node("evaluate", evaluate)
g.add_node("reflect", reflect)
g.add_edge("attempt", "evaluate")
g.add_conditional_edges("evaluate", should_continue, {
"retry": "reflect",
"end": END,
})
g.add_edge("reflect", "attempt")
g.set_entry_point("attempt")
# Initial state includes budget
reflexion = g.compile()Zwei Wege, wie dieses Pattern Probleme verursachen kann.
Kein Retry-Budget — Reflexion kann bei einer unlösbaren Aufgabe in eine Endlosschleife geraten
Die Schleife versucht es endlos bei einer Aufgabe, die grundsätzlich unmöglich ist (z. B. Abfrage einer nicht existierenden Tabelle).
Lösung · Hartes Limit auf Wiederholungen (max_retries). Budget-Erschöpfung als erwartetes Ergebnis behandeln, nicht als Ausnahme.
Reflektor liefert generische 'erneut versuchen'-Hinweise
Die Reflexion ist zu vage, um den nächsten Versuch des Actors zu verändern. Die Schleife konvergiert zur gleichen falschen Antwort.
Lösung · Den Reflektor dazu zwingen, konkrete Fehler zu benennen und eine spezifische Änderung vorzuschlagen. Falls nicht möglich, zur menschlichen Eskalation weiterleiten.