Reflection Prompting

Reflection Prompting im Überblick

Reflection Prompting lässt das LLM seine eigene Antwort kritisch prüfen und verbessern. Statt einer Antwort bekommst du eine überarbeitete, bessere Version.

Der Prozess:

Schritt 1: Generierung
User: "Schreibe eine Funktion, die Primzahlen findet."
LLM: [Erste Version der Funktion]

Schritt 2: Reflection
"Prüfe deine Antwort auf Fehler, Effizienz und Edge Cases."
LLM: "Ich sehe folgende Probleme:
      1. Keine Behandlung von n < 2
      2. Ineffizient für große Zahlen
      3. Keine Typprüfung"

Schritt 3: Verbesserung
"Korrigiere die identifizierten Probleme."
LLM: [Verbesserte Version]

Warum funktioniert das?

Technisch betrachtet

Einfaches Reflection-Pattern

def reflect_and_improve(prompt, model, max_iterations=2):
    # Erste Antwort
    response = model.generate(prompt)
    
    for i in range(max_iterations):
        # Reflection
        reflection_prompt = (
            "Hier ist deine Antwort:\n" + response + "\n\n" +
            "Prüfe kritisch:\n" +
            "1. Gibt es Fehler oder Ungenauigkeiten?\n" +
            "2. Fehlt etwas Wichtiges?\n" +
            "3. Kann etwas klarer formuliert werden?\n\n" +
            "Liste die Probleme auf."
        )
        
        critique = model.generate(reflection_prompt)
        
        # Keine Probleme gefunden?
        if "keine Probleme" in critique.lower():
            break
        
        # Verbesserung
        improve_prompt = (
            "Ursprüngliche Antwort:\n" + response + "\n\n" +
            "Identifizierte Probleme:\n" + critique + "\n\n" +
            "Erstelle eine verbesserte Version, die alle Probleme behebt."
        )
        
        response = model.generate(improve_prompt)
    
    return response

Strukturierte Reflection

REFLECTION_TEMPLATE = """
Analysiere deine Antwort nach folgenden Kriterien:

## Korrektheit
- Sind alle Fakten richtig?
- Gibt es logische Fehler?

## Vollständigkeit
- Wurden alle Aspekte der Frage behandelt?
- Fehlen wichtige Informationen?

## Klarheit
- Ist die Antwort verständlich?
- Gibt es Mehrdeutigkeiten?

## Für Code zusätzlich:
- Funktioniert der Code?
- Gibt es Edge Cases?
- Ist er effizient?

Bewerte jeden Bereich mit ✓ (gut) oder ✗ (Verbesserung nötig).
Beschreibe konkret, was verbessert werden muss.
"""

Reflexion für Code

def code_with_reflection(task, model):
    # Code generieren
    code = model.generate(f"Schreibe Python-Code: {task}")
    
    # Selbst-Review
    review_prompt = f"""
    Prüfe diesen Code als erfahrener Entwickler:
    
    ```python
    {code}
    ```
    
    Checklist:
    - [ ] Syntax korrekt?
    - [ ] Logik korrekt?
    - [ ] Edge Cases behandelt?
    - [ ] Effizient?
    - [ ] Lesbar?
    - [ ] Fehlerbehandlung?
    
    Für jedes Problem: Beschreibe es und zeige die Korrektur.
    """
    
    review_result = model.generate(review_prompt)
    
    # Verbesserten Code generieren
    if "Problem" in review_result or "Fehler" in review_result:
        improved = model.generate(
            "Ursprünglicher Code:\n" + code + "\n\n" +
            "Review:\n" + review_result + "\n\n" +
            "Schreibe den korrigierten Code:"
        )
        return improved
    
    return code

Reflexion mit externem Feedback

def reflect_with_execution(code, model):
    # Code ausführen
    try:
        result = exec(code)
        feedback = "Code läuft erfolgreich. Output: " + str(result)
    except Exception as e:
        feedback = "Fehler: " + type(e).__name__ + ": " + str(e)
    
    # Reflection mit echtem Feedback
    reflection = model.generate(
        "Code:\n" + code + "\n\n" +
        "Ausführungsergebnis:\n" + feedback + "\n\n" +
        "Analysiere das Ergebnis und verbessere den Code falls nötig."
    )
    
    return reflection

Wann Reflection nutzen?

Kosten-Nutzen

Ohne Reflection:
1 API-Call × Tokens = Kosten

Mit Reflection:
Zusätzliche Modellaufrufe oder längere Prompts = höhere Kosten und Latenz

Lohnt sich wenn:
- Qualität kritisch ist
- Fehler teuer sind
- Aufgabe komplex ist