RAG lets a language model answer from documents it was never trained on. Instead of relying only on what's baked into its weights, the model first retrieves relevant text, then generates an answer grounded in it — parametric memory plus a searchable, swappable knowledge base.

Where you meet it

• Chat-with-your-docs tools, internal knowledge bots, customer support over a help center.
• Anything that needs fresh or private facts — yesterday's release notes, your company wiki — that no public model was trained on.
• Answers that must cite a source, so a human can check the claim.

What it does

It splits the problem into two memories: a non-parametric store (your documents, in a vector index you can update anytime) and the parametric LLM (its trained weights). Retrieval pulls the right passages from the store; the model conditions its generation on them. Change the index and the model "knows" new things — no retraining.

RAG is only as good as its retrieval — if the right chunk isn't fetched, no amount of generation can invent it.

How it works

The tool above walks the online path (query → retrieve → augment → generate). The part it doesn't show is the offline step that has to happen first.

1. Index (offline). Split the knowledge base into chunks, run each through an embedding model to get a vector, and store the vectors in a vector database. Done once, refreshed when the docs change.
2. Embed the query. The user's question goes through the same embedding model, landing it in the same vector space as the chunks.
3. Retrieve. A nearest-neighbour search returns the top-k chunks closest to the query vector — the passages most likely to hold the answer.
4. Augment. Those chunks are pasted into the prompt as context, alongside the question and a short instruction ("answer only from the context").
5. Generate. The LLM writes the answer from that context, so claims trace back to retrieved text.

# offline, once
for doc in knowledge_base:
    for chunk in split(doc):
        index.add(embed(chunk), chunk)

# online, per question
q       = embed(question)
chunks  = index.search(q, k=3)        # nearest neighbours
prompt  = build(context=chunks, question=question)
answer  = llm(prompt)                  # grounded generation

Why bother: current and private knowledge without retraining, fewer hallucinations because answers are grounded, and citations you can verify.

Watch out

Go deeper

• Lewis et al. — Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks (the original paper)
• LangChain — Build a RAG agent (indexing → retrieval → generation)
• LlamaIndex — Introduction to RAG (the five stages)
• Hugging Face — the RAG model in Transformers

RAG lässt ein Sprachmodell aus Dokumenten antworten, mit denen es nie trainiert wurde. Statt sich nur auf das in den Gewichten gespeicherte Wissen zu verlassen, holt das Modell zuerst passenden Text (Retrieval) und generiert dann eine darauf gestützte Antwort — parametrisches Gedächtnis plus eine durchsuchbare, austauschbare Wissensbasis.

Wo es vorkommt

• Chat-mit-deinen-Docs-Tools, interne Wissens-Bots, Kundensupport über ein Help-Center.
• Alles, was aktuelles oder privates Wissen braucht — die Release-Notes von gestern, das Firmen-Wiki — mit dem kein öffentliches Modell trainiert wurde.
• Antworten, die eine Quelle angeben müssen, damit ein Mensch die Aussage prüfen kann.

Was es tut

Es teilt das Problem in zwei Gedächtnisse: einen nicht-parametrischen Speicher (deine Dokumente, in einem jederzeit aktualisierbaren Vektor-Index) und das parametrische LLM (seine trainierten Gewichte). Das Retrieval zieht die richtigen Passagen aus dem Speicher; das Modell stützt seine Generierung darauf. Ändere den Index, und das Modell „weiß" Neues — ohne Retraining.

RAG ist nur so gut wie sein Retrieval — wird der richtige Chunk nicht geholt, kann keine Generierung ihn erfinden.

Wie es funktioniert

Das Tool oben zeigt den Online-Pfad (Query → Retrieve → Augment → Generate). Was es nicht zeigt, ist der Offline-Schritt, der vorher passieren muss.

1. Indexieren (offline). Die Wissensbasis in Chunks zerlegen, jeden durch ein Embedding-Modell zu einem Vektor machen und die Vektoren in einer Vektor-DB speichern. Einmal erledigt, neu gebaut, wenn sich die Docs ändern.
2. Query embedden. Die Frage des Nutzers läuft durch dasselbe Embedding-Modell und landet damit im selben Vektorraum wie die Chunks.
3. Retrieven. Eine Nächste-Nachbarn-Suche liefert die top-k Chunks, die dem Query-Vektor am nächsten sind — die Passagen, die die Antwort am ehesten enthalten.
4. Augmentieren. Diese Chunks werden als Kontext in den Prompt eingesetzt, neben Frage und kurzer Anweisung („antworte nur aus dem Kontext").
5. Generieren. Das LLM schreibt die Antwort aus diesem Kontext, sodass sich Aussagen auf abgerufenen Text zurückführen lassen.

# offline, einmal
for doc in wissensbasis:
    for chunk in split(doc):
        index.add(embed(chunk), chunk)

# online, pro Frage
q       = embed(frage)
chunks  = index.search(q, k=3)        # nächste Nachbarn
prompt  = build(kontext=chunks, frage=frage)
answer  = llm(prompt)                  # geerdete Generierung

Warum der Aufwand: aktuelles und privates Wissen ohne Retraining, weniger Halluzinationen, weil Antworten geerdet sind, und überprüfbare Quellenangaben.

Worauf achten

Mehr dazu

• Lewis et al. — Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks (das Originalpaper)
• LangChain — Build a RAG agent (Indexieren → Retrieval → Generierung)
• LlamaIndex — Introduction to RAG (die fünf Stufen)
• Hugging Face — das RAG-Modell in Transformers