Prompt-Chaining-Tutorial: Was ist Prompt Chaining und wie nutzt du es?

Hast du schon einmal versucht, ein Möbelstück ohne Anleitung zusammenzubauen? Mit etwas Glück bekommst du ein paar Teile zusammen, aber ohne Schritt-für-Schritt-Anleitung wird das Ergebnis schnell chaotisch. Ähnlich geht es großen Sprachmodellen (LLMs), wenn sie komplexe Probleme lösen sollen. Das Potenzial ist riesig, doch bei Aufgaben mit mehrstufigem Denken fehlen oft wichtige Details.

Bei einem einzelnen Prompt liefern LLMs häufig Antworten, die zu allgemein bleiben, an Tiefe mangeln oder kritische Punkte übersehen. Das liegt daran, dass sich in einem Prompt selten der gesamte Kontext und eine präzise Anleitung unterbringen lassen.

Die Lösung dafür ist Prompt Chaining.

Beim Prompt Chaining zerlegst du eine komplexe Aufgabe in mehrere, gut handhabbare Prompts. Jeder Prompt bearbeitet einen klar umrissenen Teil und die Ausgabe fließt als Eingabe in den nächsten Schritt. So entsteht eine strukturierte Abfolge von Denkschritten, die zu präziseren und umfassenderen Ergebnissen führt. Mit einer logischen Prompt-Sequenz kannst du LLMs gezielt anleiten und komplexe Probleme effizient lösen.

Dieses Tutorial ist Teil meiner Blogserie „Prompt Engineering: From Zero to Hero“:

1. Prompt Engineering für alle
2. Zero-Shot Prompting
3. Few-Shot Prompting
4. Prompt Chaining

Was ist Prompt Chaining?

Prompt Chaining bedeutet, die Ausgabe eines LLM-Prompts als Eingabe für den nächsten Prompt in einer Sequenz zu verwenden. Du erstellst dazu eine Reihe verbundener Prompts, die jeweils einen bestimmten Teil des Gesamtproblems adressieren. Entlang dieser Reihenfolge wird das LLM durch einen strukturierten Denkprozess geführt und liefert dadurch genauere und detailliertere Antworten.

Das Hauptziel von Prompt Chaining ist es, Leistung, Verlässlichkeit und Nachvollziehbarkeit von LLM-Anwendungen zu steigern. Für komplexe Aufgaben reicht ein einzelner Prompt oft nicht aus, um genug Tiefe und Kontext zu liefern. Prompt Chaining löst das, indem die Aufgabe in kleinere Schritte zerlegt wird, die jeweils sorgfältig behandelt werden. So verbessert sich die Output-Qualität und es wird klarer, wie das Endergebnis zustande kam.

Schauen wir uns die wichtigsten Vorteile von Prompt Chaining an:

So implementierst du Prompt Chaining

Prompt Chaining umzusetzen heißt, eine komplexe Aufgabe systematisch zu zerlegen und ein LLM durch klar definierte Schritte zu führen. 

So kannst du eine effektive Prompt-Kette erstellen und ausführen.

Teilaufgaben identifizieren

Zuerst zerlegst du die komplexe Aufgabe in kleinere, klar abgrenzbare Teilaufgaben. Jede Teilaufgabe sollte einen eigenen Aspekt des Gesamtproblems abbilden. So kann sich das LLM Schritt für Schritt konzentrieren.

Angenommen, das LLM soll einen umfassenden Bericht zum Klimawandel schreiben. Mögliche Teilaufgaben wären:

• Historische Klimadaten recherchieren
• Zentrale Ergebnisse aus der Fachliteratur zusammenfassen
• Die Auswirkungen des Klimawandels auf verschiedene Ökosysteme analysieren
• Mögliche Lösungen und Minderungsstrategien vorschlagen

Prompts gestalten

Formuliere für jede Teilaufgabe klare, knappe Prompts. Sie sollten spezifisch und direkt sein, damit das LLM die Aufgabe versteht und relevante Ausgaben erzeugt. Wichtig: Die Ausgabe eines Prompts muss als Eingabe für den nächsten taugen, damit ein Informationsfluss entsteht.

Für die obigen Teilaufgaben könnten die Prompts so aussehen:

• Prompt Teilaufgabe 1: "Fasse die wichtigsten Trends der globalen Temperaturentwicklung im letzten Jahrhundert zusammen."
• Prompt Teilaufgabe 2: "Nenne auf Basis dieser Trends die wichtigsten wissenschaftlichen Studien zu den Ursachen dieser Veränderungen."
• Prompt Teilaufgabe 3: "Fasse die Ergebnisse der genannten Studien zusammen, mit Fokus auf die Auswirkungen des Klimawandels auf marine Ökosysteme."
• Prompt Teilaufgabe 4: "Schlage auf Basis der zusammengefassten Ergebnisse drei Strategien vor, um die Auswirkungen auf marine Ökosysteme zu mindern."

Kette ausführen

Führe die Prompts nun der Reihe nach aus und gib jeweils die Ausgabe als Eingabe an den nächsten Prompt weiter. So baut das LLM Schritt für Schritt auf seinen vorherigen Ergebnissen auf und liefert ein stimmiges Gesamtresultat.

Für unser Beispiel könnten die Ausgaben so aussehen:

• Ausgabe Teilaufgabe 1: "Die globale Durchschnittstemperatur ist im letzten Jahrhundert um etwa 1,2 Grad Celsius gestiegen, mit deutlichen Zuwächsen in den vergangenen 20 Jahren."
• Eingabe für Teilaufgabe 2: "Angesichts eines Anstiegs der globalen Temperaturen um 1,2 Grad Celsius im letzten Jahrhundert: Liste die wichtigsten wissenschaftlichen Studien zu den Ursachen dieser Veränderungen auf."
• Ausgabe Teilaufgabe 2: "Zentrale Studien sind: 'The Role of Greenhouse Gases in Global Warming' von Dr. Smith, 'Deforestation and Climate Change' von Dr. Jones und 'Oceanic Changes and Climate Patterns' von Dr. Lee."
• Eingabe für Teilaufgabe 3: "Fasse die Ergebnisse von 'The Role of Greenhouse Gases in Global Warming' (Dr. Smith), 'Deforestation and Climate Change' (Dr. Jones) und 'Oceanic Changes and Climate Patterns' (Dr. Lee) mit Fokus auf die Auswirkungen auf marine Ökosysteme zusammen."

Fehlerbehandlung

Eine robuste Fehlerbehandlung ist zentral, um Probleme während der Ausführung zu adressieren. Dazu gehören Qualitäts- und Relevanzchecks vor dem nächsten Schritt sowie Fallback-Prompts, um das LLM bei Abweichungen wieder auf Kurs zu bringen. Zum Beispiel:

• Fehlercheck 1: Nach jeder Ausgabe prüfen, ob die Informationen relevant und vollständig sind. Ist die Zusammenfassung der Temperaturtrends lückenhaft, fordere zusätzliche Details an.
• Fallback-Prompt: Wenn keine passenden Studien genannt werden, nutze einen spezifischeren Prompt wie: "Liste fünf peer-reviewte Studien der letzten zehn Jahre zu den Ursachen des globalen Temperaturanstiegs auf."

Implementierung

Schauen wir uns die Implementierung in Python an!

Schritt 1: Umgebung einrichten

Zunächst importieren wir die benötigten Bibliotheken. Wir verwenden die Klasse OpenAI aus dem Paket openai und os für Umgebungsvariablen.

import openai
import os

Sensiblen Informationen wie API-Schlüssel solltest du sicher speichern. Eine Möglichkeit ist, den API-Schlüssel als Umgebungsvariable zu setzen. Du kannst dafür einen OpenAI-API-Key verwenden.

os.environ['OPENAI_API_KEY'] = 'your-api-key-here'

Ersetze 'your-api-key-here' durch deinen tatsächlichen OpenAI-API-Schlüssel.

Mit gesetztem API-Schlüssel kannst du nun den OpenAI-Client initialisieren. Dieser Client führt die API-Aufrufe zu den OpenAI-Services aus.

Client = OpenAI ()

Schritt 2: Funktion für die Chat-Completions-API definieren

Als Nächstes erstellen wir eine Python-Funktion, die mit der Chat-Completions-API von OpenAI interagiert. Sie sendet einen Prompt und gibt die erzeugte Antwort zurück.

def get_completion(prompt, model="gpt-3.5-turbo"):
    try:
        response = client.chat.completions.create(
            model=model,
            messages=[
                {"role": "system", "content": "You are a helpful assistant."},
                {"role": "user", "content": prompt}
            ],
            temperature=0,
        )
        return response.choices[0].message.content
    except Exception as e:
        print(f"An error occurred: {e}")
        return None

Die Funktion lässt sich so zusammenfassen:

• Nimmt einen Prompt und optional das Modell entgegen.
• Ruft die OpenAI-API über den Chat-Completions-Endpunkt auf.
• Initialisiert den Dialog mit einer System- und einer User-Nachricht (dem Prompt).
• Setzt die Temperatur auf 0 für deterministischere Ausgaben (höhere Werte für mehr Kreativität).
• Gibt den Inhalt der Antwort zurück oder None bei Fehlern.

Schritt 3: Mehrere Prompts verketten

Jetzt erstellen wir eine Funktion, die mehrere Prompts aneinanderkettet und die jeweilige Ausgabe an den nächsten Schritt weiterreicht.

def prompt_chain(initial_prompt, follow_up_prompts):
    result = get_completion(initial_prompt)
    if result is None:
        return "Initial prompt failed."
    print(f"Initial output: {result}\n")
    for i, prompt in enumerate(follow_up_prompts, 1):
        full_prompt = f"{prompt}\n\nPrevious output: {result}"
        result = get_completion(full_prompt)
        if result is None:
            return f"Prompt {i} failed."
        print(f"Step {i} output: {result}\n")
    return result

Die Funktion prompt_chain implementiert Prompt Chaining. Sie:

• Startet mit einem Initial-Prompt und holt dessen Completion.
• Iteriert über eine Liste von Folgeprompts.
• Kombiniert in jedem Schritt den neuen Prompt mit der vorherigen Ausgabe, holt eine Completion und aktualisiert das Ergebnis.
• Gibt bei Fehlern eine Meldung zurück.
• Gibt die Zwischenoutputs zur Transparenz aus.

Schritt 4: Beispielanwendung

Als Nächstes zeigen wir, wie du mit prompt_chain eine Abfolge aufeinander aufbauender Prompts erstellst. Das Beispiel fasst zentrale Temperaturtrends zusammen, prüft relevante Studien und leitet Minderungsstrategien ab – du kannst es aber beliebig anpassen.

initial_prompt = "Summarize the key trends in global temperature changes over the past century."
follow_up_prompts = [
    "Based on the trends identified, list the major scientific studies that discuss the causes of these changes.",
    "Summarize the findings of the listed studies, focusing on the impact of climate change on marine ecosystems.",
    "Propose three strategies to mitigate the impact of climate change on marine ecosystems based on the summarized findings."
]
final_result = prompt_chain(initial_prompt, follow_up_prompts)
print("Final result:", final_result)

Wir definieren einen Initial-Prompt zu globalen Temperaturtrends und eine Liste aufeinander aufbauender Folgeprompts. Dann rufen wir prompt_chain auf und geben das Endergebnis aus.

So greifen die Schritte ineinander

Lass uns den Ablauf kurz zusammenfassen:

1. Der Initial-Prompt liefert eine Zusammenfassung der Temperaturtrends.
2. Der erste Folgeprompt nutzt diese Zusammenfassung, um relevante Studien zu finden.
3. Der zweite Folgeprompt fasst die Ergebnisse zu marinen Ökosystemen zusammen.
4. Der letzte Prompt schlägt darauf aufbauend Minderungsstrategien vor.

Die Kette ermöglicht eine schrittweise Bearbeitung komplexer Anfragen, bei der jeder Schritt auf dem vorherigen aufbaut.

Techniken für Prompt Chaining

Prompt Chaining lässt sich je nach Aufgabe unterschiedlich umsetzen. Drei zentrale Ansätze sind: Sequenzielles Chaining, Konditionales Chaining und Looping-Chaining.

Sequenzielles Chaining

Beim sequenziellen Chaining verknüpfst du Prompts in einer linearen Reihenfolge. Jeder Prompt hängt von der Ausgabe des vorherigen ab – ideal für Aufgaben mit klarer, logischer Abfolge, zum Beispiel:

• Textzusammenfassung: Längere Dokumente abschnittsweise zusammenfassen und diese anschließend zu einer Gesamtsummary verdichten.
• Codegenerierung: Schrittweise Code erzeugen: zuerst Funktionssignaturen, dann Implementierung, schließlich Tests.

Der Codeschnipsel im vorherigen Abschnitt ist ein Beispiel für sequenzielles Chaining.

Konditionales Chaining

Konditionales Chaining führt basierend auf der LLM-Ausgabe Verzweigungen in die Kette ein. So entstehen flexible Workflows, die je nach Antwort unterschiedliche Pfade einschlagen.

So kannst du beispielsweise eine Sentimentanalyse mit konditionalen Schritten umsetzen:

def analyze_sentiment(text):
    prompt = f"Analyze the sentiment of the following text and respond with only one word - 'positive', 'negative', or 'neutral': {text}"
    sentiment = get_completion(prompt)
    return sentiment.strip().lower()

def conditional_prompt_chain(initial_prompt):
    result = get_completion(initial_prompt)
    if result is None:
        return "Initial prompt failed."
    print(f"Initial output: {result}\n")
    sentiment = analyze_sentiment(result)
    print(f"Sentiment: {sentiment}\n")
    if sentiment == 'positive':
        follow_up = "Given this positive outlook, what are three potential opportunities we can explore?"
    elif sentiment == 'negative':
        follow_up = "Considering these challenges, what are three possible solutions we can implement?"
    else:  # neutral
        follow_up = "Based on this balanced view, what are three key areas we should focus on for a comprehensive approach?"
    final_result = get_completion(f"{follow_up}\n\nContext: {result}")
    return final_result

# Example usage
initial_prompt = "Analyze the current state of renewable energy adoption globally."
final_result = conditional_prompt_chain(initial_prompt)
print("Final result:", final_result)

Wir definieren zunächst analyze_sentiment(), um die Stimmung eines Textes vom Modell bestimmen zu lassen. In conditional_prompt_chain() starten wir mit einem Initial-Prompt zur globalen Einführung erneuerbarer Energien. Nach der ersten Antwort analysieren wir deren Sentiment und wählen abhängig davon unterschiedliche Folgeprompts:

• Bei positiver Stimmung fragen wir nach Chancen.
• Bei negativer Stimmung fragen wir nach Lösungen.
• Bei neutraler Stimmung fragen wir nach Prioritäten.

Der gewählte Folgeprompt geht zusammen mit dem Kontext der ersten Antwort an das Modell. Das finale Ergebnis ist die Antwort auf diesen konditionalen Prompt.

Beachte: Die Wahl des zweiten Prompts ist nicht vorab festgelegt, sondern hängt vom Inhalt der ersten Antwort ab. Der Gesprächsverlauf passt sich dynamisch an und zeigt, wie die Kette in unterschiedliche Pfade verzweigt. So entstehen kontextadaptive Interaktionen.

Beim Ausführen hängt die spezifische Nachfrage davon ab, ob die erste Analyse als positiv, negativ oder neutral wahrgenommen wird. Das erzeugt eine anpassungsfähige Prompt-Kette.

Looping-Chaining

Looping-Chaining erstellt Schleifen innerhalb der Prompt-Kette, um über Daten zu iterieren oder wiederkehrende Aufgaben auszuführen. Das ist nützlich bei Listen oder Sammlungen, die ähnlich verarbeitet werden müssen. Vorteile und Herausforderungen:

• Effizienz: Automatisiert Wiederholungen und spart Zeit.
• Datenverarbeitung: Geeignet für das Verarbeiten mehrerer Einträge, Batch-Zusammenfassungen oder iterative Verbesserungen.
• Herausforderungen: Sorgfältig mit Abbruchkriterien umgehen, Endlosschleifen vermeiden und pro Iteration echten Fortschritt sicherstellen.

So ließe sich Looping-Chaining für eine Vollständigkeitsprüfung umsetzen:

def check_completeness(text):
    prompt = f"Analyze the following text and respond with only 'complete' if it covers all necessary aspects, or 'incomplete' if more information is needed:\n\n{text}"
    response = get_completion(prompt)
    return response.strip().lower() == 'complete'

def looping_prompt_chain(initial_prompt, max_iterations=5):
    current_response = get_completion(initial_prompt)
    if current_response is None:
        return "Initial prompt failed."
    print(f"Initial output: {current_response}\n")
    iteration = 0
    while iteration < max_iterations:
        if check_completeness(current_response):
            print(f"Complete response achieved after {iteration + 1} iterations.")
            return current_response
        print(f"Iteration {iteration + 1}: Response incomplete. Expanding...")
        expand_prompt = f"The following response is incomplete. Please expand on it to make it more comprehensive:\n\n{current_response}"
        new_response = get_completion(expand_prompt)
        if new_response is None:
            return f"Expansion failed at iteration {iteration + 1}."
        current_response = new_response
        print(f"Expanded response: {current_response}\n")
        iteration += 1
    print(f"Maximum iterations ({max_iterations}) reached without achieving completeness.")
    return current_response

# Example usage
initial_prompt = "Explain the process of photosynthesis."
final_result = looping_prompt_chain(initial_prompt)
print("Final result:", final_result)

Zuerst definiert check_completeness(), ob eine Antwort vollständig ist oder mehr Informationen braucht.

Dann startet looping_prompt_chain() mit einem Initial-Prompt zur Fotosynthese. Nach der ersten Antwort beginnt die Schleife:

• Wir prüfen die Vollständigkeit mit check_completeness().
• Ist die Antwort vollständig, beenden wir die Schleife und geben das Ergebnis zurück.
• Ist sie unvollständig, fordern wir eine Erweiterung der bisherigen Antwort an.
• Anschließend holen wir die erweiterte Antwort ab und wiederholen den Prozess.

Das läuft so lange, bis die Antwort als vollständig gilt oder die maximale Anzahl an Iterationen (Standard: 5) erreicht ist.

So verfeinerst du die Antwort iterativ, bis sie als komplett eingestuft wird – oder bis das Limit erreicht ist.

Beim Ausführen entsteht so eine umfassende Erklärung der Fotosynthese, die bei Bedarf über mehrere Iterationen ausgebaut wird.

Praktische Anwendungsfälle für Prompt Chaining

Prompt Chaining erweitert die Fähigkeiten von LLMs in vielen Szenarien. Im Folgenden siehst du praxisnahe Anwendungen und wie sie in realen Aufgaben helfen.

Fragenbeantwortung über Dokumente

Zuerst lassen sich lange Dokumente zusammenfassen, um anschließend gezielte Fragen zu beantworten. Dazu wird das Dokument in Abschnitte zerlegt, jeder Abschnitt wird kurz zusammengefasst, und diese Summaries dienen als Kontext für detaillierte Antworten.

So setzt du es um:

def split_document(document, max_length=1000):
    """Split the document into sections of approximately max_length characters."""
    words = document.split()
    sections = []
    current_section = []
    current_length = 0
    for word in words:
        if current_length + len(word) + 1 > max_length and current_section:
            sections.append(' '.join(current_section))
            current_section = []
            current_length = 0
        current_section.append(word)
        current_length += len(word) + 1
    if current_section:
        sections.append(' '.join(current_section))
    return sections

def summarize_section(section):
    prompt = f"Summarize the following text in a concise manner:\n\n{section}"
    return get_completion(prompt)

def answer_question(summaries, question):
    context = "\n\n".join(summaries)
    prompt = f"Given the following context, answer the question:\n\nContext:\n{context}\n\nQuestion: {question}"
    return get_completion(prompt)

def document_qa(document, questions):
    # Step 1: Split the document
    sections = split_document(document)
    print(f"Document split into {len(sections)} sections.")
    # Step 2: Summarize each section
    summaries = []
    for i, section in enumerate(sections):
        summary = summarize_section(section)
        summaries.append(summary)
        print(f"Section {i+1} summarized.")
    # Step 3: Answer questions
    answers = []
    for question in questions:
        answer = answer_question(summaries, question)
        answers.append((question, answer))
    return answers

# Example usage
long_document = """
[Insert a long document here. For brevity, we are using a placeholder. 
In a real scenario, this would be a much longer text, maybe several 
paragraphs or pages about a specific topic.]
This is a long document about climate change. It discusses various aspects 
including causes, effects, and potential solutions. The document covers 
topics such as greenhouse gas emissions, rising global temperatures, 
melting ice caps, sea level rise, extreme weather events, impact on 
biodiversity, and strategies for mitigation and adaptation.
The document also explores the economic implications of climate change, 
international agreements like the Paris Agreement, renewable energy 
technologies, and the role of individual actions in combating climate change.
[Continue with more detailed information about climate change...]
"""
questions = [
    "What are the main causes of climate change mentioned in the document?",
    "What are some of the effects of climate change discussed?",
    "What solutions or strategies are proposed to address climate change?"
]
results = document_qa(long_document, questions)
for question, answer in results:
    print(f"\nQ: {question}")
    print(f"A: {answer}")

Das Beispiel zeigt, wie sich eine große Aufgabe (ein langes Dokument verstehen) in kleine Schritte zerlegen lässt (Abschnitte zusammenfassen). Die Ausgaben eines Schritts (Summaries) werden als Eingabe für den nächsten genutzt (Fragen beantworten). So kannst du auch sehr lange Texte verarbeiten, die nicht in einen einzelnen Prompt passen.

Mit einem echten langen Dokument wird es in Abschnitte geteilt, jeder Abschnitt zusammengefasst und die Summaries dienen zur Beantwortung der Fragen zu Ursachen, Auswirkungen und Lösungen des Klimawandels.

Textgenerierung mit Faktenprüfung

Bei der Textgenerierung mit Faktenprüfung erzeugst du zunächst Text und baust danach Fact-Checking-Schritte in die Prompt-Kette ein. So wird der Output nicht nur stimmig, sondern auch sachlich belastbarer.

def generate_text(topic):
    prompt = f"Write a short paragraph about {topic}."
    return get_completion(prompt)

def extract_facts(text):
    prompt = f"Extract the key factual claims from the following text, listing each claim on a new line:\n\n{text}"
    return get_completion(prompt)

def verify_facts(facts):
    verified_facts = []
    for fact in facts.split('\n'):
        if fact.strip():
            prompt = f"Verify the following statement and respond with 'True' if it's factually correct, 'False' if it's incorrect, or 'Uncertain' if it can't be verified without additional research: '{fact}'"
            verification = get_completion(prompt)
            verified_facts.append((fact, verification.strip()))
    return verified_facts

def revise_text(original_text, verified_facts):
    context = "Original text:\n" + original_text + "\n\nVerified facts:\n"
    for fact, verification in verified_facts:
        context += f"- {fact}: {verification}\n"
    
    prompt = f"{context}\n\nRewrite the original text, keeping the verified facts, removing or correcting any false information, and indicating any uncertain claims as 'It is claimed that...' or similar phrasing."
    return get_completion(prompt)

def text_generation_with_verification(topic):
    print(f"Generating text about: {topic}")
    # Step 1: Generate initial text
    initial_text = generate_text(topic)
    print("\nInitial Text:")
    print(initial_text)
    # Step 2: Extract facts
    extracted_facts = extract_facts(initial_text)
    print("\nExtracted Facts:")
    print(extracted_facts)
    # Step 3: Verify facts
    verified_facts = verify_facts(extracted_facts)
    print("\nVerified Facts:")
    for fact, verification in verified_facts:
        print(f"- {fact}: {verification}")
    # Step 4: Revise text
    revised_text = revise_text(initial_text, verified_facts)
    print("\nRevised Text:")
    print(revised_text)
    return revised_text

# Example usage
topic = "the effects of climate change on polar bears"
final_text = text_generation_with_verification(topic)

Die Funktion text_generation_with_verification() steuert den gesamten Ablauf: generate_text() erstellt einen ersten Absatz, extract_facts() extrahiert Kernaussagen, verify_facts() prüft diese als True, False oder Uncertain und revise_text() überarbeitet den Ursprungstext auf Basis der Verifikation. So wird der finale Text informativer und korrekter.

Das Prompt Chaining passiert hier in mehreren Stufen: initiale Textgenerierung, Extraktion von Fakten, deren Prüfung und die Ableitung der finalen, überarbeiteten Fassung.

Mit einem Thema wie "the effects of climate change on polar bears" wird erst Text erzeugt, dann Fakten extrahiert, überprüft und der Text entsprechend korrigiert oder relativiert. Natürlich kannst du jedes beliebige Thema einsetzen.

Codegenerierung mit Debugging

Prompt Chaining zum Coden und anschließenden Testen beschleunigt die Entwicklung. So stellst du sicher, dass der Code nicht nur läuft, sondern auch fachlich korrekt arbeitet – ganz ähnlich wie echte Entwicklungs-Workflows.

def generate_code(task):
    prompt = f"Write a Python function to {task}. Include comments explaining the code."
    return get_completion(prompt)

def generate_test_cases(code):
    prompt = f"Given the following Python code, generate 3 test cases to verify its functionality. Include both input and expected output for each test case:\n\n{code}"
    return get_completion(prompt)

def run_tests(code, test_cases):
    prompt = f"""
    Given the following Python code and test cases, run the tests and report the results. 
    If any tests fail, explain why and suggest fixes.
    Code:
    {code}
    Test Cases:
    {test_cases}
    For each test case, respond with:
    1. "PASS" if the test passes
    2. "FAIL" if the test fails, along with an explanation of why it failed and a suggested fix
    """
    return get_completion(prompt)

def debug_code(code, test_results):
    prompt = f"""
    Given the following Python code and test results, debug the code to fix any issues.
    Provide the corrected code along with explanations of the changes made.
    Original Code:
    {code}
    Test Results:
    {test_results}
    """
    return get_completion(prompt)

def code_generation_with_debugging(task):
    print(f"Generating code for task: {task}")
    # Step 1: Generate initial code
    initial_code = generate_code(task)
    print("\nInitial Code:")
    print(initial_code)
    # Step 2: Generate test cases
    test_cases = generate_test_cases(initial_code)
    print("\nGenerated Test Cases:")
    print(test_cases)
    # Step 3: Run tests
    test_results = run_tests(initial_code, test_cases)
    print("\nTest Results:")
    print(test_results)
    # Step 4: Debug code if necessary
    if "FAIL" in test_results:
        print("\nDebugging code...")
        debugged_code = debug_code(initial_code, test_results)
        print("\nDebugged Code:")
        print(debugged_code)    
        # Optionally, you can run tests again on the debugged code
        print("\nRe-running tests on debugged code...")
        final_test_results = run_tests(debugged_code, test_cases)
        print("\nFinal Test Results:")
        print(final_test_results)    
        return debugged_code
    else:
        print("\nAll tests passed. No debugging necessary.")
        return initial_code

# Example usage
task = "calculate the factorial of a number"
final_code = code_generation_with_debugging(task)

Die Funktion code_generation_with_debugging() orchestriert alles: generate_code() erzeugt Python-Code für die Aufgabe, generate_test_cases() erstellt Tests, run_tests() prüft sie. Schlagen Tests fehl, versucht debug_code() die Fehler zu beheben.

Jeder Schritt baut auf dem vorherigen auf: Code schreiben, Tests erstellen, ausführen und ggf. fixen. So zerlegst du die Entwicklung in überschaubare Schritte – ein Paradebeispiel für Prompt Chaining bei komplexen Aufgaben wie Programmierung.

Mit einer Aufgabe wie "calculate the factorial of a number" generiert das Skript den Code, erstellt Testfälle, simuliert ihre Ausführung und berichtet die Ergebnisse. Bei Fehlschlägen wird der Code debuggt und erneut getestet.

Aufgaben mit mehrstufigem Denken

Prompt Chaining eignet sich hervorragend für Probleme, die mehrere logische Schritte erfordern – etwa Textaufgaben in Mathe oder Logikrätsel. Jeder Schritt baut auf dem vorherigen auf und sorgt für einen strukturierten Lösungsweg.

def solve_step_by_step(problem):
    steps = []
    current_problem = problem
    while True:
        prompt = f"Solve the following problem step by step. Provide the next step only and explain it clearly:\n\n{current_problem}"
        step = get_completion(prompt)
        if step is None or "solution" in step.lower():
            break
        steps.append(step)
        current_problem = f"{current_problem}\n\n{step}"
        print(f"Step {len(steps)}: {step}\n")
    return steps

def combine_steps(steps):
    combined_steps = "\n".join(steps)
    prompt = f"Combine the following steps into a coherent solution for the problem:\n\n{combined_steps}"
    return get_completion(prompt)

def multi_step_reasoning(problem):
    print(f"Solving problem: {problem}")    
    # Step 1: Solve step by step
    steps = solve_step_by_step(problem)    
    # Step 2: Combine steps into a final solution
    final_solution = combine_steps(steps)
    print("\nFinal Solution:")
    print(final_solution)
    return final_solution

# Example usage
problem = "A car travels 60 miles per hour for 2 hours, then 40 miles per hour for 3 hours. What is the total distance traveled by the car?"
final_solution = multi_step_reasoning(problem)

Zuerst zerlegt solve_step_by_step() das Problem in einzelne Schritte und fragt das Modell jeweils nur nach dem nächsten. Anschließend verbindet combine_steps() diese in eine stimmige Gesamtlösung. get_completion() übernimmt die Kommunikation mit der OpenAI-API.

Im Beispiel lautet die Aufgabe: "A car travels 60 miles per hour for 2 hours, then 40 miles per hour for 3 hours. What is the total distance traveled by the car?"

Beim Ausführen werden die Schritte nacheinander erarbeitet, protokolliert und anschließend zu einer finalen Lösung zusammengeführt.

Best Practices für Prompt Chaining

Damit Prompt Chaining maximal wirksam ist, solltest du einige Grundregeln beachten. So werden deine Ketten robuster, genauer und effizienter – für verlässlichere LLM-Anwendungen.

Prompt-Design

Klare und prägnante Prompts sind entscheidend für gute Ergebnisse. Je eindeutiger die Anweisung, desto geringer das Risiko von Missverständnissen – und desto besser die Antworten.

Tipps:

• Einfache Sprache: Vermeide unnötigen Jargon.
• Sei direkt: Formuliere klar, was du brauchst – ohne Abschweifungen.
• Ein Ziel pro Prompt: Jeder Prompt sollte genau eine Aufgabe adressieren. 

Beispiel:

• Statt: "Can you please summarize the key points of the historical trends in global temperatures over the past century, focusing on any significant changes and their potential causes, as well as notable events that might have influenced these trends?"
• Nutze: "Summarize the key points of historical global temperature trends over the past century."

Gut strukturierte Prompts helfen dem LLM, einem logischen Fluss zu folgen. Je besser organisiert, desto treffsicherer die Antwort.

Tipps:

• Komplexes aufteilen: Teile große Aufgaben in kleine Schritte.
• Logik sicherstellen: Jeder Prompt baut auf dem vorherigen auf und leitet sinnvoll zum nächsten über.

So führst du das LLM Schritt für Schritt und erhältst bessere, präzisere Antworten. Beispiel:

• Schritt 1: "List the major changes in global temperatures over the past century."
• Schritt 2: "Identify potential causes for each major change in global temperatures."

Experimentieren

Unterschiedliche Aufgaben brauchen unterschiedliche Ketten. Teste verschiedene Ansätze und vergleiche die Ergebnisse, um den besten Weg für deinen Anwendungsfall zu finden.

Überprüfe regelmäßig, wie gut deine Prompt-Ketten funktionieren. Achte auf Genauigkeit, Vollständigkeit und Relevanz der Outputs. So erkennst du Optimierungspotenziale und kannst gezielt nachjustieren.

Iterativ verfeinern

Iteratives Verfeinern auf Basis von Feedback und Ergebnissen führt zu präziseren und wirksameren Prompts. Sammle Erkenntnisse aus den Outputs, identifiziere Schwachstellen und passe die Prompts an. So werden sie im Zeitverlauf immer treffsicherer. Beispiel:

• Initialer Prompt: "Describe the impact of climate change."
• Verfeinerter Prompt: "Describe the impact of climate change on coastal ecosystems over the past decade."

Kettenstruktur optimieren

Die Struktur deiner Kette beeinflusst das Ergebnis stark. Passe Reihenfolge und Logik an, wenn du siehst, dass alternative Abfolgen bessere Resultate liefern. So stellst du sicher, dass jeder Schritt sinnvoll auf den vorherigen folgt.

Fehlerbehandlung

Robuste Fehlerbehandlung hält die Kette am Laufen, selbst wenn einzelne Prompts scheitern. Mit Validitätschecks und Fallback-Prompts bringst du das LLM wieder auf Kurs und sicherst einen stabilen Flow.

Monitoring und Logging

Behalte die Leistung deiner Prompt-Ketten im Blick. Protokolliere Inputs, Outputs, Latenzen und Fehler je Schritt. So kannst du den Prozess analysieren, Schwachstellen finden und gezielt verbessern.

Sauber strukturierte Aufzeichnungen erleichtern Fehlersuche und Optimierung. Bewahre sie ordentlich auf, um Muster zu erkennen und deine Ketten kontinuierlich zu verfeinern – für bessere, verlässlichere Ergebnisse.

Wenn du diese Best Practices befolgst, erstellst du effektive, belastbare Prompt-Ketten, die die Fähigkeiten von LLMs deutlich steigern – für bessere Performance und relevantere Ergebnisse in vielen Anwendungen.

Fazit

In diesem Beitrag haben wir Prompt Chaining vorgestellt – eine Technik, mit der du komplexe Aufgaben in kleinere, verknüpfte Prompts zerlegst und so die Leistung von LLMs steigerst. Wir haben verschiedene Kettenarten, Anwendungsfälle und Best Practices besprochen, damit du LLMs in vielen Szenarien gezielt einsetzen kannst.

Wenn du tiefer ins Prompt Engineering einsteigen willst, empfehle ich dir diese Artikel:

• Prompt Compression: Ein Leitfaden mit Python-Beispielen
• Buffer of Thoughts (BoT)
• Was ist DSPy? Funktionsweise, Anwendungsfälle und Ressourcen
• Understanding Prompt Tuning