AI Prompt Engineering · Lektion

Über naives RAG hinaus

Einschränkungen des einfachen Retrievals

Über naives RAG hinaus ist eine kostenlose AI Prompt Engineering-Lektion auf CoddyKit. Dies ist Lektion 1 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 Prompt Engineering-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der AI Prompt Engineering-Kurs umfasst insgesamt 4 Lektionen.

Was Naive RAG leistet

Naive RAG ist die Baseline: Dokumente in Chunks aufteilen, Embeddings erstellen, Vektoren speichern, die Query einbetten, die Top-k-Chunks anhand der Kosinusähnlichkeit abrufen, die Chunks in den Prompt übernehmen und generieren. Das ist ein guter Ausgangspunkt, versagt aber bei größerem Maßstab auf vorhersehbare Weise.

Das Verständnis dieser Fehlerquellen ist die Voraussetzung für die fortgeschrittenen Techniken (Re-Ranking, Kompression, Query-Rewriting), die in diesem Kurs behandelt werden.

def naive_rag(query, k=5):
    q = embed(query)
    chunks = vector_store.search(q, k)        # top-k by cosine
    context = '\n\n'.join(c.text for c in chunks)
    return llm('Context:\n' + context + '\n\nQ: ' + query)

Recall und Precision beim Retrieval

Naives Top-k-Retrieval optimiert die reine Vektor-Ähnlichkeit, die Relevanz mit oberflächlicher semantischer Nähe gleichsetzt. Sie stehen vor einem Zielkonflikt: Bei einem kleinen k besteht das Risiko, die Antwort zu verfehlen (geringer Recall); bei einem großen k wird der Kontext mit Ablenkungen überflutet (geringe Precision).

Die Embedding-Ähnlichkeit, die das Retrieval steuert, ist nur ein grober Näherungswert für die tatsächliche Relevanz und die Ursache mehrerer nachgelagerter Probleme.

# The core dilemma
# small k -> may miss the gold chunk (recall problem)
# large k -> distractors crowd context (precision + cost problem)
# Advanced RAG decouples 'retrieve many' from 'use few'

Das Embedding-Mismatch-Problem

Queries und Dokumente liegen häufig in unterschiedlichen sprachlichen Registern vor: eine kurze Frage steht einem langen aussagenden Text gegenüber. Bi-Encoder-Embeddings können eine relevante Antwort weit von der Frage entfernt platzieren, weil beide unterschiedlich formuliert sind (das Vokabular-Mismatch-Problem).

Das führt zu Techniken wie Query-Rewriting und HyDE, die die Query vor dem Retrieval so umformen, dass sie besser zum Dokumentenraum passt.

# Query:  'how do I revoke a token?'
# Doc:    'Token invalidation is performed via the /sessions endpoint.'
# Lexically and semantically distant -> bi-encoder may miss it
sim = cos(embed('how do I revoke a token?'),
          embed('Token invalidation via /sessions'))  # may be low

Lost in the Middle

Selbst wenn der richtige Chunk abgerufen wird, löst das Einfügen vieler Chunks den Lost-in-the-Middle-Effekt aus: Das Modell schenkt Inhalten in der Mitte eines langen Kontexts weniger Aufmerksamkeit. Ein korrekter Chunk auf Rang 3 von 10 kann dadurch praktisch ignoriert werden.

Das motiviert Re-Ranking (den besten Chunk dort zu platzieren, wo das Modell aufmerksam ist) und Kompression (den Kontext zu verkleinern, damit nichts darin untergeht).

# Retrieval rank != attention rank
# Place the highest-relevance chunk at the START or END,
# never stranded in the middle of a large concatenation.

Empfindlichkeit gegenüber Ablenkungen

LLMs reagieren empfindlich auf irrelevanten Kontext. Das Hinzufügen plausibler, aber falscher Chunks kann die Antwort vom richtigen Weg abbringen, selbst wenn der korrekte Chunk ebenfalls vorhanden ist. Mehr abgerufener Kontext ist nicht automatisch besser.

Deshalb ist Precision wichtig: Ein kompakter, neu gerankter und komprimierter Kontext ist häufig besser als eine große Menge lose verwandter Chunks.

# Empirically: appending a single highly-similar but WRONG chunk
# can flip a previously-correct answer. RAG quality depends on
# keeping distractors OUT, not just getting the gold chunk IN.

Chunking-Probleme

Chunking mit fester Größe trennt Ideen mitten im Satz, löst eine Aussage von ihren Belegen und entfernt strukturellen Kontext (welcher Abschnitt, welches Dokument). Ein Chunk, der für sich allein schlüssig wirkt, kann ohne seinen Umgebungskontext nutzlos oder irreführend sein.

Fortgeschrittene Pipelines verwenden strukturbewusstes Chunking, Overlap, die Erweiterung auf das übergeordnete Dokument und Metadaten, um die Bedeutung zu bewahren.

def structure_aware_chunks(doc, max_tokens=400, overlap=50):
    sections = split_by_headings(doc)        # respect document structure
    chunks = []
    for sec in sections:
        for c in sliding_window(sec.text, max_tokens, overlap):
            chunks.append(Chunk(c, meta={'section': sec.title}))
    return chunks

Lücken beim rein semantischen Retrieval

Reines Dense-Retrieval verfehlt Anforderungen an exakte Treffer: Identifier, Fehlercodes, seltene Eigennamen und API-Namen. Gerade hier erwarten Nutzerinnen und Nutzer wörtliche Präzision. Hybrides Retrieval kombiniert Dense- (semantische) und Sparse- (BM25-/Keyword-)Signale, um beides abzudecken.

Reciprocal Rank Fusion ist eine einfache, robuste Möglichkeit, die beiden Ranglisten zusammenzuführen, ohne einen Gewichtungsfaktor abstimmen zu müssen.

def rrf(dense_ranks, sparse_ranks, k0=60):
    scores = {}
    for ranks in (dense_ranks, sparse_ranks):
        for rank, doc_id in enumerate(ranks):
            scores[doc_id] = scores.get(doc_id, 0) + 1.0 / (k0 + rank)
    return sorted(scores, key=scores.get, reverse=True)

Veralteter und nicht überprüfbarer Kontext

Naive RAG kennt weder Aktualität noch Provenienz. Es kann veraltete Dokumente abrufen und bietet keine integrierte Möglichkeit, Aussagen Quellen zuzuordnen. Das untergräbt das Vertrauen und erschwert es, Halluzinationen zu erkennen.

Fortgeschrittene Systeme fügen Metadaten hinzu (Zeitstempel, Quelle, Version), filtern danach und verpflichten den Generator, Chunk-IDs zu zitieren, damit Antworten überprüfbar sind.

def filtered_retrieve(q, after_date):
    cands = vector_store.search(embed(q), k=50)
    fresh = [c for c in cands if c.meta['date'] >= after_date]
    return fresh  # then re-rank; generator must cite c.id

Kein Feedback, keine Anpassung

Naive RAG ruft Inhalte blind ab: Es kann nicht erkennen, wann das Retrieval fehlgeschlagen ist, nicht entscheiden, dass kein Retrieval erforderlich ist, und nicht iterieren. Fortgeschrittene Muster ergänzen eine Relevanzprüfung, bedingtes Retrieval und mehrstufiges (agentisches) Retrieval, das die Query neu formuliert, wenn die Ergebnisse schwach wirken.

Die Pipeline wird zu einem Loop mit Selbstbewertung statt zu einem einzigen Vorwärtsdurchlauf.

def adaptive_rag(q):
    chunks = retrieve(q)
    if relevance_score(q, chunks) < 0.4:
        q2 = rewrite_query(q)            # reformulate and retry
        chunks = retrieve(q2)
    if relevance_score(q, chunks) < 0.4:
        return 'I could not find this in the sources.'
    return generate(q, chunks)

Der fortgeschrittene RAG-Stack

Aus diesen Fehlerquellen ergibt sich eine fortgeschrittene Pipeline mit mehreren Schichten: strukturbewusstes Chunking mit Metadaten, hybrides Retrieval mit hohem Recall, ein Cross-Encoder-Re-Ranker für Precision, Kontextkompression zur Anpassung und Fokussierung des Kontexts, Query-Rewriting / HyDE zur Behebung des Mismatchs sowie ein Relevanz-Gate mit Zitaten.

In den nächsten Lektionen wird jede Schicht aufgebaut. Der rote Faden lautet: breit abrufen und anschließend aggressiv filtern und verfeinern.

def advanced_rag(q):
    cands = hybrid_retrieve(rewrite_query(q), k=50)  # high recall
    top = rerank(q, cands)[:8]                       # precision
    ctx = compress(q, top)                            # focus + fit
    return generate_with_citations(q, ctx)            # verifiable

Vor der Optimierung messen

Diagnostizieren Sie zuerst, welches Problem tatsächlich vorliegt, bevor Sie zusätzliche Komponenten einführen. Messen Sie den Retrieval Recall@k (wird der Gold-Chunk überhaupt abgerufen?) getrennt von der Antwortgenauigkeit (verwendet der Generator ihn?). Ein Recall-Problem und ein Precision-Problem erfordern unterschiedliche Lösungen.

Instrumentieren Sie beide Hälften; setzen Sie nicht einfach einen Re-Ranker auf, wenn die eigentliche Ursache in der Chunk-Aufteilung oder im Query-Mismatch liegt.

def diagnose(eval_set):
    return {
        'recall@5':  recall_at_k(eval_set, k=5),     # retrieval health
        'recall@50': recall_at_k(eval_set, k=50),    # ceiling with rerank
        'answer_acc': answer_accuracy(eval_set),      # generation health
    }

Schnelltest

Diagnostizieren Sie eine Fehlerquelle in RAG.

Zusammenfassung

Wichtigste Erkenntnisse:

Naive RAG (Chunking, Embedding, Top-k, Einfügen, Generieren) ist eine starke Baseline mit vorhersehbaren Fehlerquellen.
Die Ähnlichkeit von Bi-Encodern ist ein grober Näherungswert für Relevanz; ein Mismatch zwischen sprachlichem Register von Query und Dokument beeinträchtigt den Recall.
Mehr Kontext ist nicht besser: Empfindlichkeit gegenüber Ablenkungen und der Lost-in-the-Middle-Effekt verschlechtern Antworten, wenn k wächst.
Probleme beim Chunking, Lücken des rein semantischen Retrievals, veraltete Inhalte und fehlendes Feedback begrenzen Naive RAG.
Fortgeschrittene RAG-Systeme rufen zunächst breit ab und filtern dann: hybrides Retrieval, Re-Ranking, Kompression, Query-Rewriting und Relevanz-Gating. Messen Sie Recall und Antwortgenauigkeit getrennt, bevor Sie optimieren.

Häufig gestellte Fragen

Ist die Lektion „Über naives RAG hinaus“ kostenlos?

Ja — der vollständige Text von „Über naives RAG hinaus“ 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 Prompt Engineering-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der AI Prompt Engineering-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Über naives RAG hinaus“?

Einschränkungen des einfachen Retrievals Du übst AI Prompt Engineering 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 Prompt Engineering zu starten?

Keine Vorkenntnisse erforderlich. AI Prompt Engineering 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 1 von 4.

Wie lange dauert die Lektion „Über naives RAG hinaus“?

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 Prompt Engineering-Lektion Code schreiben und ausführen?

Ja. Jede AI Prompt Engineering-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

← Zurück zu AI Prompt Engineering