Startseite / Artikel

Wie RAG Ihren privaten Daten an ein LLM zur Verfügung stellt: Blöcke, Vektoren, Prompts

Verstehen Sie die retrieval-augmented Generation von der Dateneingabe bis zur Abfrage, mit einem kleinen Node.js-Beispiel, drei gängigen Fehlermodi sowie einem Vergleich zwischen RAG und Feinabstimmung.

Verlag: REACTAPP.TOP8 Min. Lesezeit1766 Wörter

Quellen: RAG Explained: How Applications Give AI Access to Their Own Data

Sprachmodelle schreiben Code, erklären komplexe Themen und entwerfen Aufsätze, stocken jedoch bei allem Privaten. Wenn man ein Standardmodell nach dem internen Produktplan, einer Kundendatenbank oder den Support-Anfragen vom Vortag fragt, gibt es entweder zu, nichts zu wissen, oder – schlimmer noch – erzeugt es eine glaubwürdige Fälschung. Dieses falsche Selbstvertrauen wird als Halluzination bezeichnet.

Eine gängige Annahme ist, dass das Unterrichten eines Modells mit privaten Daten eine Feinabstimmung bedeutet, bei der die Gewichte auf maßgeschneiderten Datensätzen neu trainiert werden. Für einen einfachen Datenzugriff in der Produktion ist eine Feinabstimmung in der Regel die falsche Wahl. Sie ist kostspielig, erfolgt nur langsam und verhindert Halluzinationen nicht zuverlässig. Stattdessen verwenden Produktionsanwendungen Retrieval-augmented Generation (RAG), die auf Anfrage externe Daten bereitstellt, ohne neu trainieren zu müssen. Während eine Feinabstimmung Wochen des Lernens für einen Schüler darstellt, ist RAG wie eine Prüfung mit offenen Büchern, bei der bereits die richtige Seite aufgeschlagen ist.

Die drei Begriffe im Namen

  • Retrieval bedeutet, in Ihrer eigenen Datenbank oder Dokumentenspeicher nach Passagen zu suchen, die mit der Frage zusammenhängen.
  • Augmented bedeutet, diese Passagen direkt in den Prompt-Kontext einzufügen.
  • Generation bedeutet, den erweiterten Prompt an das LLM zu senden, das auf der Grundlage der abgerufenen Fakten antwortet.

Ohne RAG ist der Ablauf kurz:

Without RAG:
[User Question] ──> [LLM] ──> [Answer based on generic training data]

Mit RAG befindet sich ein Suchschritt in der Mitte:

With RAG:
[User Question] ──> [Search Engine / Vector DB]
                          │
                          └──> [Relevant Documents]
                                     │
[User Question] + [Relevant Documents] ──> [LLM] ──> [Factual Answer]

Weil das Quellmaterial zusammen mit dem Prompt übermittelt wird, muss das Modell keine Fakten mehr aus seinen festgefrorenen Parametern abrufen.

Warum Teams es wählen

Beim Hinzufügen von KI-Funktionen zu bestehenden Systemen treten drei Hindernisse auf:

  • Wissensgrenze. Die Trainingsdaten enden an einem bestimmten Datum, sodass das Modell nicht wissen kann, was heute Morgen passiert ist oder was eine API vor zwei Sekunden zurückgegeben hat.
  • Privatsphäre. Öffentliche Modelle können keine interne Wiki-Seite, ein Notion-Arbeitsbereich oder eine MongoDB-Datenbank lesen.
  • Überprüfbarkeit. Eine aus dem Gedächtnis erzeugte Antwort lässt sich nicht auf eine Quelldatei zurückverfolgen. Mit RAG weiß man genau, welcher Textabschnitt in den Prompt aufgenommen wurde, wodurch Zitate einfach möglich sind.

Ein häufiger Irrtum ist, dass das Feintunen neue Fakten vermittelt. Tatsächlich passt es Ton, Stil oder Ausgabeformat an. Für die Abrufung faktischer Kenntnisse ist RAG gedacht.

Zwei Phasen

Ein Produktionssystem verfügt über eine Aufnahmephase, die die Dateien im Voraus vorbereitet, und eine Abfragesphase, die den Benutzern in Echtzeit dient. Die Aufnahme findet offline statt:

1. Ingestion Pipeline (Offline / Background):
[Raw Documents] ──> [Chunking] ──> [Embedding Model] ──> [Vector Database]

Der Abfragenpfad wird zum Zeitpunkt der Anfrage ausgeführt:

2. Query Pipeline (Runtime):
[User Question] ──> [Embedding Model] ──> [Vector Search in DB]
                                                  │
                                                  ▼
[User Question] + [Top Matching Chunks] ──> [LLM] ──> [Final Answer]

Chunking

Ein 300-seitiges PDF kann nicht in einer einzigen Abfrage verarbeitet werden. Große Dokumente werden in Abschnitte aufgeteilt, die als „Chunks“ bezeichnet werden und in der Regel 200 bis 800 Wörter umfassen. Ein Chunk sollte klein genug sein, um sich auf eine einzige Idee zu konzentrieren, und groß genug, um seinen Kontext beizubehalten.

Embedding

Computer verstehen keine Wörter, und Schlüsselwortabgleiche wie SQL LIKE '%refund%' funktionieren nicht, wenn Menschen Synonyme verwenden. Deshalb wird jeder Chunk durch ein Embedding-Modell geleitet, das eine Liste von Fließkommazahlen zurückgibt – einen Vektor mit etwa 1.536 Einträgen. Diese Vektoren platzieren Bedeutungen im geometrischen Raum. Phrasen mit ähnlicher Bedeutung, wie „Wie kann ich stornieren?“ und „Schritte zur Kündigung des Kontos“, liegen nah beieinander, während unverwandte Phrasen wie „Wie backt man Sauerteigbrot“ weit voneinander entfernt sind.

Die Vektoren werden neben dem ursprünglichen Text in einer Vektordatenbank wie Pinecone, Qdrant, Milvus oder PostgreSQL mit der pgvector-Erweiterung gespeichert.

Auswertung und Anfrageformulierung

Wenn eine Frage eingeht, fügt der Server sie mit demselben Modell hinzu. Die Datenbank misst den Winkel zwischen dem Fragevektor und jedem gespeicherten Vektor (Kosinusähnlichkeit) und gibt die drei bis fünf nächsten Ergebnisse zurück. Die Anwendung fügt diese dann in den Systemprompt ein und weist das LLM an, ausschließlich mit diesem Material zu antworten.

Ein kleines funktionierendes Beispiel

Stellen Sie sich ein Softwareunternehmen vor, das einen Assistenten haben möchte, der Fragen zu seiner internen Rückerstattungspolitik beantwortet. Die Eingabedatei beginnt mit der Importierung des OpenAI-Clients:

// ingest.js
import { OpenAI } from "openai";

und erstellt den Client:

const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

Eine echte Anwendung würde Dokumente aus Markdown oder einem CMS laden, während dieses Beispiel einige Dokumente fest kodiert hat:

// In a real application, you would load these from Markdown files or a CMS
const documents = [
  {
    id: "doc_1",
    text: "Enterprise customers can request a full refund within 30 days of contract signing. Contact enterprise-support@example.com."
  },
  {
    id: "doc_2",
    text: "Monthly self-serve subscriptions are non-refundable once the billing cycle begins. Users can cancel anytime to avoid future charges."
  },
  {
    id: "doc_3",
    text: "Custom engineering work and onboarding packages are strictly non-refundable once the kickoff meeting has taken place."
  }
];

Ein Hilfsprogramm wandelt Text in ein Embedding um:

async function createEmbedding(text) {
  const response = await openai.embeddings.create({
    model: "text-embedding-3-small",
    input: text,
  });
  return response.data[0].embedding;
}

Ein anderer baut die Wissensdatenbank auf, indem er jedes Dokument einbettet:

export async function buildKnowledgeBase() {
  const embeddedDocs = [];
  for (const doc of documents) {
    const vector = await createEmbedding(doc.text);
    embeddedDocs.push({ ...doc, vector });
  }
  return embeddedDocs;
}

In der Produktion führt die Vektordatenbank die Entfernungsberechnung für Millionen von Zeilen in Millisekunden durch. Für eine Demo kann die Kosinusähnlichkeit manuell berechnet werden:

// search.js
function cosineSimilarity(vecA, vecB) {
  let dotProduct = 0;
  let normA = 0;
  let normB = 0;
  for (let i = 0; i < vecA.length; i++) {
    dotProduct += vecA[i] * vecB[i];
    normA += vecA[i] * vecA[i];
    normB += vecB[i] * vecB[i];
  }
  return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
}

und die besten Übereinstimmungen ausgewählt:

export function findTopMatches(queryVector, knowledgeBase, topK = 2) {
  return knowledgeBase
    .map(doc => ({
      ...doc,
      score: cosineSimilarity(queryVector, doc.vector)
    }))
    .sort((a, b) => b.score - a.score)
    .slice(0, topK);
}

Danach verbindet eine Datei die Abfrage, die Suchergebnisse und das LLM miteinander, wobei mit den Importen begonnen wird:

// answer.js
import { OpenAI } from "openai";
import { createEmbedding, buildKnowledgeBase } from "./ingest.js";
import { findTopMatches } from "./search.js";

Dann der Kunde wieder:

const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

Die Hauptfunktion fügt zunächst die Frage des Benutzers ein:

async function askKnowledgeBase(userQuestion, knowledgeBase) {
  // 1. Convert user question into an embedding
  const questionVector = await createEmbedding(userQuestion);

Dann werden die wichtigsten Abschnitte abgerufen:

  // 2. Retrieve top matching chunks
  const matches = findTopMatches(questionVector, knowledgeBase, 1);
  const contextText = matches.map(m => m.text).join("\n---\n");

dann erstellt ein erweitertes Prompt:

  // 3. Augment prompt with retrieved context
  const systemPrompt = `
You are a helpful customer service assistant.
Answer the user's question using ONLY the context provided below.
If the context does not contain the answer, say "I do not have enough information to answer that."

was mit dem eingefügten Kontext endet:

Context:
${contextText}
`;

und erzeugt schließlich die Antwort:

  // 4. Generate answer
  const completion = await openai.chat.completions.create({
    model: "gpt-4o-mini",
    messages: [
      { role: "system", content: systemPrompt },
      { role: "user", content: userQuestion }
    ],
    temperature: 0.2, // Low temperature minimizes creative liberties
  });

Der Text des Modells wird zurückgegeben:

  return completion.choices[0].message.content;
}

Die Verwendung sieht so aus, mit einer Frage zur Rückerstattung von Geldern nach einem Unternehmensgeschäft:

// Example usage:
const knowledgeBase = await buildKnowledgeBase();
const answer = await askKnowledgeBase("I signed an enterprise deal 2 weeks ago, can I get my money back?", knowledgeBase);
console.log(answer);
// Output: Yes, enterprise customers can request a full refund within 30 days of contract signing. You can email enterprise-support@example.com to initiate the process.

Die Antwort stammt nicht aus den allgemeinen Trainingsgewichten des Modells. Sie wurde aus dem kleinen Ausschnitt abgerufen, der zur Laufzeit eingefügt wurde.

Drei häufige Fehler

Ein kurzer Script lässt RAG einfach erscheinen, doch echte Systeme versagen auf drei wiederkehrende Weisen.

Zerschneiden des Textes in feste Längen. Das Abschneiden alle 500 Zeichen aufteilt Wörter, Sätze und Tabellen. Wenn ein Satz, der eine wichtige Bedingung beschreibt, auf zwei Teile aufgeteilt wird, verlieren beide ihren Sinn. Die Lösung besteht darin, die Daten entlang natürlicher Grenzen wie Abschnitten, Überschriften oder Markdown-Sektionen zu gliedern und Überschneidungen hinzuzufügen – beispielsweise 500-Token-Blöcke, die 50 Token teilen.

Allein auf Vektoren verlassen. Die Vektorsuche versteht Konzepte, kommt aber mit exakten Zeichenketten nur schlecht zurecht. Eine Suche nach einer Rechnungsnummer wie INV-2026-09 kann Rechnungen zurückgeben, die nur ähnlich aussehen. Die Lösung ist die hybride Suche: Kombinieren Sie Schlüsselwortsuche wie BM25 oder Volltextsuche mit der Vektorsuche und fügen Sie die Ergebnisbewertungen mithilfe einer Methode wie Reciprocal Rank Fusion (RRF) zusammen.

Übermäßige Angaben im Prompt. Die Kontextfenster werden immer größer, doch das Senden von 50 Teilstücken verringert die Qualität. Modelle können Material am besten am Anfang oder am Ende eines Prompts abrufen, während der mittlere Teil oft übersehen wird. Nehmen Sie nur die drei bis fünf zuverlässigsten Teilstücke. Falls mehr Dokumente geprüft werden müssen, führen Sie vor dem Haupt-LLM einen leichten Neubewertungsalgorithmus wie Cohere Rerank aus.

RAG oder Feinabstimmung

Speicherung und gewöhnliche API-Aufrufe
Dimension RAG Feinabstimmung
Hauptziel Lieferung faktischer, sich ändernder Daten Vermittlung eines Stils, Dialekts oder strenger Syntax
Aktualisierungen Sofortig, durch Bearbeitung von Datenbankenotizen Schwerfällig, erfordert neue Daten und Neutraining
Risiko von Halluzinationen Niedrig, begrenzt durch den bereitgestellten Kontext Mittel bis hoch
Zitierungen Integriert, da die Chunk-ID bekannt ist Unmöglich, Fakten verschmelzen mit den Gewichten
WartungskostenHohe Kosten für GPU-Training und -Hosting

Wenn sich die Daten täglich, wöchentlich oder stündlich ändern, ist Feintuning unpraktisch – RAG ist die für dynamisches Wissen konzipierte Architektur.

Erste Schritte

Der schwierige Teil beim Arbeiten mit LLMs ist die faktenbasierte Grundlage, nicht die Intelligenz des Modells. RAG verbindet ein statisches Grundmodell mit privaten, sich ändernden Daten, und die Kombination einer guten Abrufschicht mit einem erweiterten Prompt verwandelt einen unvorhersehbaren Textgenerator in ein System, das überprüfbare Antworten liefert. Ein sinnvoller Ausgangspunkt: Wählen Sie einen Vektorlagers, teilen Sie Dokumente in sinnvolle Abschnitte auf und überprüfen Sie, ob der Abruf tatsächlich den richtigen Kontext findet, bevor Sie dem LLM eine schlechte Antwort vorwerfen.