Selbstkorrektur und reflektierendes Prompting
Implementieren Sie einen Reflexionsschritt, in dem der Agent seine eigene Ausgabe mit dem ursprünglichen Ziel abgleicht, Lücken oder Fehler identifiziert und vor einem erneuten Versuch einen korrigierten Plan erstellt.
Selbstkorrektur und reflektierendes Prompting ist eine kostenlose AI Engineering Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des AI Engineering Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der AI Engineering Academy-Kurs umfasst insgesamt 4 Lektionen.
Was ist reflektierendes Prompting?
Reflektierendes Prompting ist eine Technik, bei der der Agent aufgefordert wird, seine eigene Ausgabe zu bewerten, bevor er sie finalisiert. Statt eine Antwort zu erzeugen und anschließend anzuhalten, überprüft der Agent seine Antwort anhand des ursprünglichen Ziels, erkennt Lücken oder Fehler und erstellt eine korrigierte Version. Dies ahmt nach, wie Menschen ihre eigene Arbeit Korrektur lesen, und verbessert die Ausgabequalität bei komplexen Aufgaben erheblich, ohne ein separates Critic-Modell zu benötigen.
Die Reflect-and-Revise-Schleife
Die grundlegende reflektierende Schleife besteht aus drei Schritten: eine erste Antwort Generate erzeugen, diese Antwort anhand klarer Kriterien Critique bewerten und sie auf Grundlage der Kritik Revise. Die Schleife kann ein- oder mehrmals durchlaufen werden. Jede Iteration verbessert die Antwort, bis die Kritik sie entweder als zufriedenstellend einstuft oder eine maximale Anzahl an Überarbeitungen erreicht ist. Der Kritikschritt ist selbst ein LLM-Aufruf mit einem spezialisierten Reflexions-Prompt.
async def reflect_and_revise(task: str, max_rounds: int = 2) -> str:
response = await generate_initial(task)
for round_num in range(max_rounds):
critique = await critique_response(task, response)
if critique.is_satisfactory:
break
response = await revise_response(task, response, critique.feedback)
return responseEinen effektiven Kritik-Prompt verfassen
Der Kritik-Prompt muss konkrete Bewertungskriterien festlegen, statt das Modell lediglich aufzufordern, die Antwort zu „verbessern“. Listen Sie die zu überprüfenden Punkte konkret auf: Ist jede Aussage korrekt? Wurden alle Teile der Frage beantwortet? Fehlt ein Schritt? Gibt es unnötige Ausschmückungen? Ein Kritik-Prompt mit expliziten Checklistenpunkten erzeugt umsetzbares Feedback, das der Überarbeitungsschritt direkt verwenden kann.
CRITIQUE_PROMPT = '''
You are reviewing an AI-generated response to this task: {task}
Response to evaluate:
{response}
Check each criterion and provide specific feedback:
1. COMPLETENESS: Does it address all parts of the task?
2. ACCURACY: Are all factual claims correct?
3. CONCISENESS: Is there unnecessary padding or repetition?
4. FORMAT: Does it match the requested output format?
5. ACTIONABILITY: Can the user act on this response?
For each issue found, state exactly what to fix.
If the response is satisfactory on all criteria, say APPROVE.
'''Die Kritikantwort parsen
Strukturieren Sie die Kritik als Pydantic-Modell, damit Sie programmgesteuert entscheiden können, ob eine Überarbeitung erforderlich ist. Das Feld is_satisfactory bestimmt, wann die Schleife beendet wird. Die Liste issues teilt dem Überarbeitungsschritt genau mit, was zu korrigieren ist. Mit dem Feld severity können Sie eine Überarbeitung bei geringfügigen stilistischen Problemen überspringen, während bei sachlichen Fehlern immer überarbeitet wird.
from pydantic import BaseModel
from typing import List, Literal
class Issue(BaseModel):
criterion: str
description: str
severity: Literal['critical', 'moderate', 'minor']
class Critique(BaseModel):
is_satisfactory: bool
issues: List[Issue]
overall_verdict: str
# is_satisfactory=True means no revision needed
# is_satisfactory=False means issues must be addressedDer Überarbeitungs-Prompt
Der Überarbeitungs-Prompt erhält die ursprüngliche Aufgabe, die erste Antwort und das Kritik-Feedback. Fordern Sie das Modell auf, eine verbesserte Version zu erstellen, die jedes von der Kritik genannte Problem gezielt behebt und zugleich die korrekten Teile der ursprünglichen Antwort beibehält. Fügen Sie immer das Wort „only“ ein, um zu verhindern, dass das Modell unnötige Änderungen an Teilen vornimmt, die von der Kritik bereits bestätigt wurden.
def build_revision_prompt(task: str, response: str, critique: Critique) -> str:
issues_text = '\n'.join(
f'- [{i.severity.upper()}] {i.criterion}: {i.description}'
for i in critique.issues
)
return f'''
Original task: {task}
Your previous response:
{response}
Issues to fix:
{issues_text}
Write an improved response that fixes ONLY the issues listed above.
Do not change parts that were not flagged as problems.
'''Selbstkorrektur bei der Codegenerierung
Selbstkorrektur ist besonders bei der Codegenerierung leistungsfähig. Führen Sie nach der Codegenerierung einen Linter oder Typechecker aus, geben Sie die Fehlerausgabe an das Modell zurück und fordern Sie es auf, die Fehler zu beheben. Diese ausführungsgestützte Reflexion ist zuverlässiger als eine rein sprachbasierte Kritik, weil das Feedback von einem objektiven Tool statt von der Einschätzung eines anderen LLM stammt.
import subprocess
import sys
async def self_correct_code(task: str, max_rounds: int = 3) -> str:
code = await generate_code(task)
for _ in range(max_rounds):
# Write code to temp file and run mypy
with open('/tmp/agent_code.py', 'w') as f:
f.write(code)
result = subprocess.run(
[sys.executable, '-m', 'mypy', '/tmp/agent_code.py', '--ignore-missing-imports'],
capture_output=True, text=True
)
if result.returncode == 0:
break # No type errors
code = await fix_code(code, result.stdout + result.stderr)
return codeÜberkorrektur vermeiden
Ein häufiges Problem reflektierender Systeme ist die Überkorrektur: Das Modell verschlimmert das ursprüngliche Problem, während es versucht, etwas anderes zu beheben. Begrenzen Sie den Umfang der Überarbeitung: Der Überarbeitungs-Prompt sollte ausdrücklich sagen: „do not change anything that was not flagged.“ Vergleichen Sie die überarbeitete Antwort außerdem mithilfe einer Diff-Prüfung mit dem Original. Wenn die überarbeitete Version sich grundlegend unterscheidet, ist etwas schiefgelaufen und Sie sollten das Original beibehalten.
from difflib import SequenceMatcher
def safe_revision(original: str, revised: str, max_change_ratio: float = 0.7) -> str:
similarity = SequenceMatcher(None, original, revised).ratio()
if similarity < (1 - max_change_ratio):
print(f'Revision changed too much (similarity: {similarity:.2f}). Keeping original.')
return original
return revisedReflexion bei mehrstufigen Agent-Aufgaben
Fügen Sie bei einem mehrstufigen Agent einen Reflexionsprüfpunkt ein, nachdem eine Reihe von Schritten abgeschlossen wurde – beispielsweise nachdem alle Recherchen gesammelt, aber bevor der Abschlussbericht verfasst wurde. Der Agent überprüft die gesammelten Informationen, erkennt Lücken und entscheidet, ob weitere Informationen gesammelt werden müssen oder fortgefahren werden kann. Diese Reflexion während der Aufgabe verhindert, dass Agents mit unvollständigen oder widersprüchlichen Belegen zum Zusammenfassungsschritt übergehen.
async def research_with_reflection(question: str) -> str:
# Phase 1: gather evidence
evidence = await gather_evidence(question)
# Reflection checkpoint
assessment = await assess_evidence_completeness(question, evidence)
if not assessment.is_complete:
for gap in assessment.gaps:
more_evidence = await targeted_search(gap.search_query)
evidence.extend(more_evidence)
# Phase 2: synthesize
return await synthesize_answer(question, evidence)Ergebnisse der Reflexion protokollieren
Protokollieren Sie jede Reflexionsrunde: die Bewertung der Kritik, welche Probleme erkannt wurden und ob die Überarbeitung diese tatsächlich behoben hat. Diese Daten zeigen, wie wirksam Ihre Reflexions-Prompts sind. Wenn die überarbeitete Antwort regelmäßig dieselben von der Kritik beanstandeten Probleme erneut einführt, ist Ihr Überarbeitungs-Prompt nicht spezifisch genug. Wenn die meisten Kritiken bereits in der ersten Runde „APPROVE“ lauten, ist die Qualität der ersten Generierung bereits hoch und der zusätzliche Aufwand der Reflexion möglicherweise nicht gerechtfertigt.
import structlog
log = structlog.get_logger()
def log_reflection_round(task_id: str, round_num: int, critique: Critique, action: str):
log.info(
'reflection_round',
task_id=task_id,
round=round_num,
is_satisfactory=critique.is_satisfactory,
issue_count=len(critique.issues),
critical_issues=sum(1 for i in critique.issues if i.severity == 'critical'),
action=action # 'approved', 'revised', 'max_rounds_reached'
)Wann Sie Reflexion einsetzen sollten
Reflexion verursacht zusätzliche Latenz und Kosten – eine Reflect-and-Revise-Schleife mit zwei Runden verdreifacht mindestens die Anzahl der LLM-Aufrufe für diese Aufgabe. Setzen Sie Reflexion gezielt ein: immer bei Ausgaben mit hohen Anforderungen (ausführbarer Code, Antworten auf folgenschwere geschäftliche Fragen), optional bei Antworten für Benutzer und niemals bei internen Zwischenschritten, die unmittelbar von einem Tool überprüft werden. Die Kosten lohnen sich, wenn Qualität wichtiger ist als Geschwindigkeit.
# Reflection decision matrix:
# Task type: Use reflection?
# SQL query generation YES (run+verify)
# Final report writing YES (review before delivery)
# Tool argument prep NO (tool result verifies it)
# Short factual answer MAYBE (if accuracy is critical)
# Internal agent thought NO (intermediate, not final)
# Code generation YES (run linter/tests)
USE_REFLECTION = {'report', 'code', 'email', 'analysis'}Die Wirksamkeit von Reflexion messen
Überprüfen Sie anhand von A/B-Tests, ob Reflexion Ihre Ausgaben tatsächlich verbessert: Verarbeiten Sie zufällig 50 % der Aufgaben mit Reflexion und 50 % ohne und bewerten Sie anschließend beide Gruppen mit Ihrem LLM-Judge. Wenn die reflektierende Gruppe deutlich besser abschneidet und die Verbesserung die zusätzliche Latenz und die zusätzlichen Kosten übersteigt, lohnt sich Reflexion. Sind die Bewertungen ähnlich, ist die Qualität Ihrer ersten Generierung bereits ausreichend hoch und Reflexion verursacht zusätzlichen Aufwand ohne Nutzen.
async def reflection_ab_test(tasks: list) -> dict:
import random
results = {'with_reflection': [], 'without_reflection': []}
for task in tasks:
if random.random() < 0.5:
response = await reflect_and_revise(task, max_rounds=2)
group = 'with_reflection'
else:
response = await generate_initial(task)
group = 'without_reflection'
score = await judge(task, response)
results[group].append(score.overall)
return {
'mean_with': sum(results['with_reflection']) / len(results['with_reflection']),
'mean_without': sum(results['without_reflection']) / len(results['without_reflection'])
}Kurzer Check
Testen Sie Ihr Verständnis von Selbstkorrektur und reflektierendem Prompting in Agents.
Zusammenfassung der Lektion
In dieser Lektion haben Sie gelernt: Reflect-and-Revise-Schleifen verbessern die Ausgabequalität, indem der Agent seine eigenen Antworten kritisiert und korrigiert. Konkrete Kritikrubriken erzeugen umsetzbares Feedback statt vager Verbesserungsvorschläge, und ausführungsgestützte Reflexion mit objektiven Tools wie Lintern ist besonders bei der Codegenerierung leistungsfähig. Als Nächstes implementieren wir Checkpointing für Agents und die Wiederaufnahme von Aufgaben.
Lerne Python mit einem KI-Tutor — kostenlos
Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.
- Kurse
- 30
- Lektionen
- 120
Häufig gestellte Fragen
Ist die Lektion „Selbstkorrektur und reflektierendes Prompting“ kostenlos?
Ja — der vollständige Text von „Selbstkorrektur und reflektierendes Prompting“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des AI Engineering Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der AI Engineering Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Selbstkorrektur und reflektierendes Prompting“?
Implementieren Sie einen Reflexionsschritt, in dem der Agent seine eigene Ausgabe mit dem ursprünglichen Ziel abgleicht, Lücken oder Fehler identifiziert und vor einem erneuten Versuch einen korrigie… Du übst AI Engineering Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um AI Engineering Academy zu starten?
Keine Vorkenntnisse erforderlich. AI Engineering Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.
Wie lange dauert die Lektion „Selbstkorrektur und reflektierendes Prompting“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser AI Engineering Academy-Lektion Code schreiben und ausführen?
Ja. Jede AI Engineering Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Fehlermodi von Agenten klassifizieren
- Selbstkorrektur und reflektierendes Prompting
- Checkpoints und Fortsetzen von Aufgaben
- Eskalation mit Human-in-the-Loop