Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Retrieval-augmentiertes Prompting

Lektion 9 von 16 Aktualisiert am 3. November 2026 Entwickler
Auf dieser Seite
  1. Retrieval-augmentiertes Prompting
  2. Architektur eines RAP-Systems
  3. Komplett-Pipeline
  4. Chunking: Aufteilung von Dokumenten
  5. Erweiterte Retrieval-Strategien
  6. Nutzung der nativen Dateisuche von OpenAI
  7. Einen Baseline etablieren
  8. Kernaussagen

Lektion aktualisiert am 3. November 2026 basierend auf der OpenAI-Dokumentation: temperature und top_p werden nur mit einem Reasoning-Effort von none akzeptiert, während GPT-5.6-Modelle standardmäßig mit medium rechnerisch arbeiten. Aufrufe, die diese Parameter setzen, müssen daher reasoning={"effort": "none"} (Responses API) oder reasoning_effort="none" (Chat Completions) angeben. Quellen: GPT-6 verwenden · GPT-5.6 Terra.

Retrieval-augmentiertes Prompting

Retrieval-Augmentiertes Prompting (RAP) kombiniert Dokumentensuche mit Prompting, um dem Modell relevanten, aktuellen Kontext bereitzustellen. Es ist die natürliche Weiterentwicklung des Groundings: anstatt Kontext manuell einzufügen, automatisieren Sie die Suche nach relevanten Passagen vor jedem LLM-Aufruf.

Der Unterschied zeigt sich erst im großen Maßstab. Das manuelle Einfügen von drei nützlichen Abschnitten aus Ihrer Dokumentation funktioniert für eine Demo; sobald Ihre Dokumentenbasis jedoch einige hundert Seiten erreicht und Fragen kontinuierlich eintreffen, weiß niemand mehr, welche Passagen eingefügt werden sollen. RAP überträgt diese Entscheidung auf eine automatische Komponente, die vor jeder Generierung ausgeführt wird und deren einzige Aufgabe darin besteht, zu finden, was in den Prompt aufgenommen werden soll.

Architektur eines RAP-Systems

Eine RAP-Pipeline gliedert sich in drei Schritte, die unterschiedliche Geschwindigkeiten und Kosten aufweisen. Das Indexing wandelt Ihre Dokumente in Vektor-Embeddings um; dies geschieht einmalig, offline, und verwandelt jedes Dokument in einen numerischen Vektor, der seine Bedeutung kodiert, der zusammen mit dem Originaltext gespeichert wird. Das Retrieval hingegen läuft bei jeder Frage ab: Sie wandeln die Frage in einen Vektor mit demselben Embedding-Modell um und suchen dann nach den nächstgelegenen Dokumentvektoren. Schließlich ist die Augmentation nichts anderes als Standard-Prompting – Sie erstellen einen System-Prompt, der die abgerufenen Passagen enthält, und weisen das Modell an, sich nicht außerhalb dieses Rahmens zu bewegen.

Merken Sie sich diese Aufteilung: Alles, was teuer ist, geschieht während des Indexings, wo Sie es sich leisten können, anspruchsvoll zu sein, während alles, was sich bei jeder Frage wiederholt, schnell bleiben muss. Der folgende Code implementiert die ersten beiden Schritte unter Verwendung von Kosinusähnlichkeit als Maß für die Nähe.

from openai import OpenAI
import numpy as np

client = OpenAI()

# Schritt 1: Generierung von Dokumenten-Embeddings
def embed_texts(texts: list[str]) -> list[list[float]]:
    """Generiert Embeddings für eine Liste von Texten."""
    response = client.embeddings.create(
        model="text-embedding-3-large",
        input=texts
    )
    return [item.embedding for item in response.data]

# Schritt 2: Suche nach Kosinusähnlichkeit
def cosine_similarity(a: list[float], b: list[float]) -> float:
    """Berechnet die Kosinusähnlichkeit zwischen zwei Vektoren."""
    a, b = np.array(a), np.array(b)
    return float(np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b)))

def retrieve(query: str, documents: list[str],
             doc_embeddings: list[list[float]],
             top_k: int = 3) -> list[str]:
    """Gibt die top_k relevantesten Dokumente zurück."""
    query_emb = embed_texts([query])[0]

    scores = [
        (i, cosine_similarity(query_emb, doc_emb))
        for i, doc_emb in enumerate(doc_embeddings)
    ]
    scores.sort(key=lambda x: x[1], reverse=True)

    return [documents[i] for i, _ in scores[:top_k]]

Komplett-Pipeline

Das Zusammenfügen dieser Bausteine ergibt eine Klasse, die in etwa dreißig Zeilen Platz beansprucht. Die meisten Entscheidungen treffen Sie im generierten System-Prompt, und es lohnt sich, ihn Zeile für Zeile zu lesen. Das Modell erhält zunächst den Befehl, die Antwort NUR auf Basis der bereitgestellten Passagen zu geben, was halluzinierte Antworten einschränkt, wenn die Dokumentation stumm bleibt. Anschließend erhält es die Anweisung, die Passagennummer für jede Behauptung anzuführen, und dies ist es, was die Verifizierung ermöglicht: ein Prüfer kann die Quelle auf einen Blick zurückverfolgen. Eine temperature von 0,1 rundet die Einrichtung ab – bei einer auf Dokumenten verankerten Antwort ist Kreativität ein Fehler.

class RAGPipeline:
    """Minimalistische RAP-Pipeline."""

    def __init__(self, documents: list[str]):
        self.documents = documents
        self.embeddings = embed_texts(documents)

    def query(self, question: str, top_k: int = 3) -> str:
        """Beantwortet eine Frage basierend auf den Dokumenten."""
        # Retrieval
        relevant_docs = retrieve(
            question, self.documents,
            self.embeddings, top_k
        )

        # Prompt-Augmentation
        context = "\n\n---\n\n".join(
            f"[Passage {i+1}]\n{doc}"
            for i, doc in enumerate(relevant_docs)
        )

        system = f"""Sie sind ein technischer Assistent.
Beantworten Sie NUR auf Basis der bereitgestellten Passagen.
Wenn die Passagen die Antwort nicht enthalten, sagen Sie dies.
Führen Sie für jede Behauptung die Passagennummer an.

RELEVANTE PASSAGEN:
{context}"""

        # Generierung
        response = client.responses.create(
            model="gpt-5.6-terra",
            reasoning={"effort": "none"},  # temperature erfordert effort none
            instructions=system,
            input=question,
            temperature=0.1
        )
        return response.output_text

Chunking: Aufteilung von Dokumenten

Die Aufteilung von Dokumenten in Chunks ist entscheidend für die Qualität des Retrievals. Wenn Chunks zu groß sind, ertrinken relevante Informationen; wenn sie zu klein sind, gehen sie den Kontext verloren. Eine API-gestützte Aufteilung in Blöcke von zehn Seiten wird unabhängig von der gestellten Frage immer denselben generischen Block zurückgeben. Eine Aufteilung in isolierte Sätze würde einen Satz zurückgeben, der mit „diese Methode” beginnt, ohne dass das Modell weiß, welche Methode gemeint ist. Eine Überlappung mildert dieses Risiko spezifisch ab: jedes Chunk wiederholt das Ende des vorherigen, sodass Informationen, die eine Grenze überschreiten, von mindestens einer Seite aus lesbar bleiben.

Wenn Ihre Dokumente eine Überschriftenstruktur aufweisen, ist eine nach Sektionen basierende Aufteilung fast immer überlegen zu einer Aufteilung nach fester Größe: Eine Sektion „Authentifizierung” bleibt intakt, inklusive ihrer Einleitung und Beispiele.

def chunk_document(text: str, chunk_size: int = 500,
                   overlap: int = 50) -> list[str]:
    """Teilt Text in Chunks mit Überlappung auf."""
    words = text.split()
    chunks = []

    for i in range(0, len(words), chunk_size - overlap):
        chunk = " ".join(words[i:i + chunk_size])
        if chunk.strip():
            chunks.append(chunk)

    return chunks

def chunk_by_sections(text: str) -> list[str]:
    """Teilt nach Sektionen (Markdown-Überschriften) auf."""
    sections = []
    current = []

    for line in text.split("\n"):
        if line.startswith("## ") and current:
            sections.append("\n".join(current))
            current = [line]
        else:
            current.append(line)

    if current:
        sections.append("\n".join(current))

    return sections

Erweiterte Retrieval-Strategien

Reranking

Nach dem initialen Retrieval verwenden Sie das LLM, um die Ergebnisse neu zu ordnen. Die Logik ist die eines Trichters: Die Vektorsuche ist schnell, aber approximativ und bringt ein Dutzend plausible Kandidaten zurück; das Modell ist langsamer, aber nuancierter, liest diese Kandidaten erneut, kennt die Frage und rangiert sie. Sie behalten dann nur die Spitze der Liste für die Generierung bei. Der Gewinn ist bei Fragen am sichtbarsten, bei denen mehrere Passagen dasselbe Thema behandeln, aber nur eine tatsächlich die Antwort liefert – drei Sektionen erwähnen das Wort „Quota”, aber nur eine erklärt, wie man es erhöht.

def rerank(question: str, passages: list[str]) -> list[str]:
    """Ordnet Passagen nach Relevanz unter Verwendung des LLM neu an."""
    prompt = f"""Frage: {question}

Hier sind Kandidaten-Passagen. Rangieren Sie sie von der
relevantesten bis zur weniger relevanten zur Beantwortung der Frage.
Geben Sie nur die Nummern in der Reihenfolge zurück (z. B. 3, 1, 2).

{chr(10).join(f"[{i+1}] {p[:200]}" for i, p in enumerate(passages))}"""

    response = client.responses.create(
        model="gpt-5.6-terra",
        reasoning={"effort": "none"},  # temperature erfordert effort none
        input=prompt,
        temperature=0.0
    )
    # Geparste Reihenfolge zurückgegeben und neu organisiert
    return response.output_text

Hypothetical Document Embedding (HyDE)

Generieren Sie ein ideales hypothetisches Dokument und suchen Sie dann nach ähnlichen Dokumenten. Das Problem, das diese Technik löst, ist die Vokabular-Mismatch: Eine Frage, die in Alltagssprache gestellt wird, sieht vektoriell nicht aus wie ein Absatz technischer Dokumentation. Indem Sie das Modell zunächst auffordern, die Antwort zu schreiben, die es sich vorstellt, erhalten Sie einen Text, der im Register Ihrer Dokumente verfasst ist, und genau diesen Text verwenden Sie als Abfrage. Es spielt keine Rolle, ob der hypothetische Absatz Näherungen enthält: Er dient niemals als Antwort, sondern nur als Sonde.

def hyde_retrieve(question: str, documents: list[str],
                  doc_embeddings: list[list[float]]) -> list[str]:
    """Retrieval über HyDE."""
    # Generierung eines hypothetischen Absatzes
    hypo_response = client.responses.create(
        model="gpt-5.6-terra",
        reasoning={"effort": "none"},  # temperature erfordert effort none
        input=f"Schreiben Sie einen kurzen technischen Absatz, der diese Frage perfekt "
              f"beantwortet: {question}",
        temperature=0.5
    )
    hypothetical_doc = hypo_response.output_text

    # Suche nach Dokumenten, die dem hypothetischen Absatz ähnlich sind
    return retrieve(hypothetical_doc, documents,
                    doc_embeddings, top_k=3)

Nutzung der nativen Dateisuche von OpenAI

Für eine schnelle Bereitstellung bietet die API integriertes Retrieval an. Sie laden die Datei hoch, erstellen einen Vektorspeicher, hängen die Datei daran und deklarieren das file_search-Tool im Aufruf: Chunking, Embedding und Suche werden serverseitig behandelt. Dies ist die richtige Wahl, wenn Ihre Dokumente standardisiert sind und Ihnen nicht wichtig ist, wo die Daten gespeichert werden. Die hausgemachte Pipeline behält den Vorteil, sobald Sie das Chunking beherrschen müssen, den Index selbst hosten oder spezifisches Reranking integrieren möchten.

# Datei hochladen
file = client.files.create(
    file=open("documentation.pdf", "rb"),
    purpose="assistants"
)

# Vektorspeicher erstellen
vector_store = client.vector_stores.create(
    name="Technische Dokumentation"
)

client.vector_stores.files.create(
    vector_store_id=vector_store.id,
    file_id=file.id
)

# Abfrage mit Dateisuche
response = client.responses.create(
    model="gpt-5.6-terra",
    instructions="Beantworten Sie basierend auf der bereitgestellten Dokumentation.",
    input="Wie konfiguriere ich die Authentifizierung?",
    tools=[{
        "type": "file_search",
        "vector_store_ids": [vector_store.id]
    }]
)

Einen Baseline etablieren

Nehmen Sie fünf bis zehn Seiten technischer Dokumentation und implementieren Sie die komplette Pipeline, von der Chunking bis zur Generierung. Schreiben Sie zehn Fragen, deren Antworten in den Dokumenten stehen, führen Sie die Pipeline für jede davon aus und wiederholen Sie dies mit aktiviertem Reranking: Erst durch das Beobachten, bei welchen Fragen sich die Rangierung ändert, verstehen Sie, was die Vektorsuche allein verpasst. Beenden Sie dies mit der Messung des prozentualen Anteils korrekt verankerter Antworten, bei denen jede Behauptung effektiv auf eine bereitgestellte Passage verweist. Diese Zahl ist Ihr Ausgangspunkt; alle nachfolgenden Optimierungen werden daran gemessen, nicht am Eindruck, den zwei oder drei zufällig gelesene Antworten hinterlassen.

Kernaussagen

  • RAP automatisiert die Einbindung relevanten Kontexts in den Prompt
  • Chunking ist entscheidend: Experimentieren Sie mit verschiedenen Größen
  • Reranking mit dem LLM verbessert die Relevanz signifikant
  • HyDE ist nützlich, wenn die Frage stark vom Vokabular der Dokumente abweicht
  • OpenAI File Search vereinfacht die Bereitstellung für Standardfälle