DSPy: Programmatisches Prompt Engineering

Was dieser Artikel behandelt

• Was DSPy ist und wie es Prompt Engineering verändert.
• Signatures, Modules und Teleprompters als zentrale Konzepte.
• Wie Du einfache Predictions und Chain-of-Thought-Abläufe baust.
• Aufbau eines RAG-Programms mit DSPy.
• Wie Du Prompts automatisch mit Beispielen optimierst.
• Typische Fehler und Stolpersteine beim Arbeiten mit DSPy.

Einleitung

DSPy ist ein Python-Framework für sogenanntes programmatisches Prompt Engineering. Statt Prompts per Hand zu schreiben und mühsam zu iterieren, definierst Du, was ein Modell tun soll, und lässt DSPy die besten Prompts und Few-Shot-Beispiele finden. Der große Unterschied zu herkömmlichem Vorgehen: Du optimierst Programme, nicht einzelne Prompt-Strings.

Das Framework wurde von der Stanford NLP Group entwickelt und richtet sich an fortgeschrittene Anwender. Es verbindet Sprachmodelle, Retrieval und Optimierung in einer gemeinsamen Struktur. Wer mit LangChain, LlamaIndex oder Haystack vertraut ist, findet viele bekannte Muster wieder, allerdings mit einem stärkeren Fokus auf automatische Optimierung.

Warum brauche ich DSPy?

Prompt Engineering ist zeitaufwendig. Eine kleine Änderung im Prompt kann große Auswirkungen auf die Ausgabe haben. Bei mehreren Modellen und Aufgaben verlierst Du schnell den Überblick. DSPy trennt die gewünschte Aufgabe, also die Signatur, vom konkreten Prompt. Du beschreibst Eingaben und Ausgaben, und DSPy sucht die beste Formulierung.

Dadurch wird Dein Code wartbarer. Wenn Du das Modell wechselst, musst Du den Prompt nicht komplett umschreiben. DSPy passt Prompt und Beispiele an das neue Modell an. Das ist besonders wertvoll für komplexe RAG-Systeme, Agenten oder Frage-Antwort-Pipelines.

DSPy kurz erklärt

DSPy basiert auf vier Säulen:

• Signature: Eine Art Vertrag, der Eingaben, Ausgaben und die Aufgabe beschreibt.
• Module: Wiederverwendbare Bausteine wie Predict, ChainOfThought oder ReAct.
• Programm: Eine Kette aus Modulen, die zusammen eine Aufgabe lösen.
• Teleprompter: Ein Optimierer, der Prompts und Few-Shot-Beispiele automatisch anpasst.
• LM: Das Sprachmodell, das DSPy für Aufrufe verwendet.
• RM: Ein Retrieval-Modell, das Kontextdokumente liefert.

Die Signatur ist der zentrale Gedanke. Sie beschreibt, was das Modell bekommt und was es zurückgeben soll. Aus der Signatur erzeugt DSPy den passenden Prompt. Du kannst den Prompt manuell überschreiben, musst es aber nicht.

Für wen ist dieser Artikel gedacht?

Dieser Artikel ist für fortgeschrittene Python-Entwickler gedacht. Du solltest mit objektorientierter Programmierung vertraut sein und verstehen, wie Sprachmodelle funktionieren. Grundkenntnisse in Prompt Engineering und RAG sind hilfreich, aber nicht zwingend.

Wenn Du noch ganz am Anfang stehst, empfehlen wir LangChain oder LlamaIndex. DSPy lohnt sich, sobald Du wiederkehrende Prompts automatisieren und systematisch verbessern möchtest.

Wichtige Begriffe

Begriff	Bedeutung
Signature	Beschreibt Aufgabe, Eingaben und Ausgaben für ein Modul.
InputField	Ein Eingabefeld in einer Signatur.
OutputField	Ein Ausgabefeld in einer Signatur.
Module	Ein wiederverwendbarer DSPy-Baustein wie Predict oder ChainOfThought.
Predict	Ein Modul, das direkt eine Vorhersage trifft.
ChainOfThought	Modul, das das Modell auffordert, Schritt für Schritt zu denken.
Teleprompter	Optimierer für Prompts und Few-Shot-Beispiele.
LM	Das Sprachmodell, das DSPy konfiguriert hat.
RM	Das Retrieval-Modell oder der Retriever für Kontext.
Compile	Vorgang, bei dem ein Programm mit Teleprompter optimiert wird.

Installation

Installiere DSPy am besten in einer virtuellen Umgebung:

pip install dspy

Für den lokalen Betrieb mit Ollama benötigst Du keinen API-Key. Stelle sicher, dass Ollama läuft und ein Modell wie llama3.2 bereitliegt:

ollama pull llama3.2

Optional installierst Du zusätzliche Pakete, wenn Du mit ColBERT, ChromaDB oder Weaviate als Retriever arbeiten möchtest.

Erste Schritte: Signaturen und Predictions

Jedes DSPy-Programm beginnt mit einer Signatur. Sie definiert die Aufgabe in natürlicher Sprache und legt die Felder fest.

import dspy

lm = dspy.LM(
    model='ollama_chat/llama3.2',
    api_base='http://localhost:11434',
    api_key='',
    max_tokens=512,
)
dspy.configure(lm=lm)

class GenerateAnswer(dspy.Signature):
    """Answer questions with short factoid answers."""

    context = dspy.InputField(desc="may contain relevant facts")
    question = dspy.InputField()
    answer = dspy.OutputField(desc="often between 1 and 5 words")

qa = dspy.Predict(GenerateAnswer)

antwort = qa(
    context="Das Paris befindet sich in Frankreich.",
    question="In welchem Land liegt Paris?"
)
print(antwort.answer)

dspy.Predict ist der einfachste Modul-Typ. Er nimmt die Signatur und erzeugt einen Aufruf an das konfigurierte LM. Die Ausgabe ist ein Objekt, das auf die Felder der Signatur zugreift.

Mit Chain of Thought denken

Für komplexere Aufgaben lohnt sich ChainOfThought. Es zwingt das Modell, Zwischenschritte auszugeben, bevor es die finale Antwort liefert.

cot = dspy.ChainOfThought(GenerateAnswer)

antwort = cot(
    context="Die Hauptstadt von Frankreich ist Paris. Paris liegt am Fluss Seine.",
    question="An welchem Fluss liegt die Hauptstadt von Frankreich?"
)
print(antwort.answer)
print(antwort.rationale)

Das Feld rationale enthält den Gedankengang, den das Modell intern erzeugt hat. Das erhöht die Qualität bei rechenintensiven oder logischen Fragen.

Ein RAG-Programm bauen

DSPy eignet sich besonders gut für RAG. Du kombinierst ein Modul für das Retrieval mit einem Modul für die Antwortgenerierung. In diesem Beispiel verwenden wir ein vorgefertigtes Retrieval-Modell. Für den lokalen Einsatz kannst Du es gegen einen eigenen Retriever wie ChromaDB oder Weaviate austauschen.

import dspy

class GenerateAnswer(dspy.Signature):
    """Answer questions based on the provided context."""

    context = dspy.InputField(desc="relevant passages for the question")
    question = dspy.InputField()
    answer = dspy.OutputField()

class RAG(dspy.Module):
    def __init__(self, num_passages=3):
        super().__init__()
        self.num_passages = num_passages
        self.generate_answer = dspy.ChainOfThought(GenerateAnswer)

    def forward(self, question):
        # Hier würdest Du normalerweise einen echten Retriever nutzen.
        context = "Dies ist ein Beispielkontext, der in einer echten Anwendung aus einem Retriever kommt."
        return self.generate_answer(context=context, question=question)

rag = RAG()
antwort = rag("Was ist DSPy?")
print(antwort.answer)

Das Modul RAG verpackt den Ablauf. Der Retriever-Teil ist hier vereinfacht. In der Praxis konfigurierst Du dspy.settings.configure(rm=retriever) und nutzt dspy.Retrieve(k=3).

Mehr Hintergrund zu RAG findest Du in RAG Grundlagen und Lokales RAG. Für Embeddings und Vektorspeicher siehe Embedding-Modelle und Vektordatenbanken.

Prompts automatisch optimieren

Das Besondere an DSPy ist der Teleprompter. Du erstellst ein Trainings-Set und lässt DSPy die besten Few-Shot-Beispiele und die beste Instruktion finden.

from dspy.teleprompt import BootstrapFewShot

trainset = [
    dspy.Example(
        question="Wer entwickelte die Relativitätstheorie?",
        answer="Albert Einstein",
    ).with_inputs("question"),
    dspy.Example(
        question="Welches ist das größte Tier?",
        answer="Blauwal",
    ).with_inputs("question"),
]

def metrik(gold, pred, trace=None):
    return gold.answer.lower() == pred.answer.lower()

teleprompter = BootstrapFewShot(metric=metrik, max_bootstrapped_demos=4)
compiled_rag = teleprompter.compile(student=RAG(), train=trainset)

antwort = compiled_rag("Was ist DSPy?")
print(antwort.answer)

BootstrapFewShot wählt aus dem Trainings-Set Beispiele aus, die nach Deiner Metrik am besten funktionieren. Das Ergebnis ist ein optimiertes Programm, das bessere Prompts und Beispiele verwendet.

Weitere Optimierer

Neben BootstrapFewShot gibt es weitere Teleprompter. MIPROv2 kombiniert Prompt-Optimierung mit Beispielauswahl und eignet sich für anspruchsvolle Aufgaben. BootstrapFewShotWithRandomSearch probiert zufällige Teilmengen aus. Für den Einstieg reicht BootstrapFewShot aus.

Du brauchst keinen riesigen Trainingsdatensatz. DSPy arbeitet oft mit wenigen Dutzend Beispielen. Wichtiger ist eine gute Metrik, die das gewünschte Verhalten misst.

Typische Stolpersteine

• Veraltete Syntax: DSPy entwickelt sich schnell. Alte Tutorials verwenden OpenAI oder ColBERTv2 Klassen, die in neueren Versionen anders heißen. Prüfe die Version.
• Falsche Modellangabe: Für Ollama nutze ollama_chat/model und setze api_base, nicht api_base_url oder base_url.
• Fehlende Eingaben: with_inputs ist notwendig, damit DSPy weiß, welche Felder die Frage darstellen.
• Schlechte Metrik: Eine schwache Metrik führt zu nutzlosen optimierten Prompts. Investiere Zeit in das Bewertungskriterium.
• Zu wenige Trainingsbeispiele: BootstrapFewShot braucht einige positive Beispiele. Mit nur einem Beispiel funktioniert die Optimierung nicht gut.
• Retrieval vergessen: Ein RAG-Programm ohne echten Retriever liefert nur Halluzinationen. Konfiguriere dspy.settings.configure(rm=...).
• Falsche Signaturen: Beschreibungen in InputField und OutputField beeinflussen den Prompt. Halte sie präzise.
• Nicht compiliert testen: Viele Vergleiche zwischen manuellen und DSPy-Prompts funktionieren nur nach dem compile-Schritt.

Hardware, Kosten und Sicherheit

DSPy selbst ist kostenlos. Kosten entstehen über die verwendeten Sprachmodelle. Bei Ollama bleiben Aufrufe lokal. Der Optimierungsschritt compile kann jedoch viele Modellaufrufe erzeugen, weil DSPy unterschiedliche Prompts und Beispiele testet. Plane dafür genügend Rechenzeit ein.

Für größere Trainingsläufe empfiehlt sich ein Modell, das zuverlässig und schnell antwortet. Starke Modelle liefern bessere optimierte Prompts, benötigen aber mehr Speicher. Ein 7B-Modell in Quantisierung läuft auf 8 GB VRAM.

Sicherheit ist wichtig, sobald Du sensible Trainingsbeispiele oder Retrieval-Quellen verwendest. Halte Daten lokal und vermeide öffentliche Endpunkte für vertrauliche Inhalte. DSPy speichert Aufrufe intern zwischen, also prüfe Caching-Einstellungen, wenn Du sensible Informationen verarbeitest.

Weiterführende Links

• Entwicklungs-Tools Übersicht für verwandte Frameworks.
• LangChain für Chains und Agenten.
• LlamaIndex für RAG und Indexing.
• Haystack für Pipelines und NLP.
• Lokales RAG für den Gesamtkontext.
• RAG Grundlagen für die Theorie.
• Vektordatenbanken zur Auswahl eines passenden Retrievers.
• Embedding-Modelle für Hintergründe zu Embeddings.
• Ollama für den lokalen Modellbetrieb.
• Was ist ein KI-Agent für Agentenkonzepte.

FAQ

Ist DSPy kostenlos?

Ja, das Framework ist Open Source. Kosten entstehen nur für Modell-APIs oder eigene Hardware.

Was ist programmatisches Prompt Engineering?

Es bedeutet, Prompts und Beispiele über Code und Optimierung zu steuern, anstatt sie händisch zu verändern.

Brauche ich DSPy, wenn ich bereits LangChain nutze?

Nicht zwingend. DSPy ergänzt andere Frameworks, sobald Du Prompts automatisch optimieren willst.

Was ist eine DSPy-Signatur?

Eine Signatur beschreibt, welche Eingaben ein Modul erhält und welche Ausgaben es produziert.

Wie unterscheidet sich Predict von ChainOfThought?

Predict ist direkt. ChainOfThought fordert das Modell auf, einen Gedankengang zu erzeugen, bevor es die Antwort gibt.

Was ist ein Teleprompter?

Ein Teleprompter optimiert Prompts und Few-Shot-Beispiele anhand von Trainingsdaten und einer Metrik.

Kann ich DSPy mit Ollama nutzen?

Ja. Du konfigurierst dspy.LM mit einem Ollama-Endpunkt.

Was brauche ich für BootstrapFewShot?

Einige Beispiele mit Eingaben und erwarteten Ausgaben sowie eine Funktion, die Vorhersagen bewertet.

Ist DSPy nur für RAG geeignet?

Nein. DSPy eignet sich auch für Klassifikation, Zusammenfassung, Frage-Antwort und Agenten.

Wie groß sollte das Trainings-Set sein?

Meist reichen 20 bis 100 Beispiele. Wichtiger als die Menge ist die Qualität der Metrik.

Was passiert bei compile?

DSPy testet verschiedene Prompts und Beispiele auf dem Trainings-Set und erzeugt ein optimiertes Programm.

Kann ich DSPy mit lokalen Retriever-Datenbanken verbinden?

Ja. DSPy ist Retriever-unabhängig. Du kannst ChromaDB, Weaviate, FAISS oder eigene Implementierungen verwenden.

Quellen

• DSPy Documentation: https://dspy.ai/
• DSPy GitHub: https://github.com/stanfordnlp/dspy
• DSPy API: https://dspy.ai/api/
• DSPy RAG Tutorial: https://dspy.ai/tutorials/rag/
• Stanford NLP Group: https://nlp.stanford.edu/