RAG und seine praktische Implementierung mit LangChain, Bun, Ollama und Qdrant

Moderne Large Language Models (LLMs) sind beeindruckend, haben jedoch eine wesentliche Einschränkung: Ihr Wissen ist in ihren Gewichtungen fixiert, was es schwierig macht, ihr Wissen zu aktualisieren und zu erweitern. Retrieval-Augmented Generation (RAG) ist ein Ansatz, der entwickelt wurde, um dieses Problem zu lösen. Von Meta im Jahr 2020 eingeführt, verbindet es ein Sprachmodell mit einer externen Wissensdatenbank (zum Beispiel einer Sammlung von Dokumenten), damit es aktuelle und spezifische Informationen in seine Antworten einbeziehen kann. In der Praxis extrahiert das RAG-System für jede gestellte Frage zunächst relevante Inhalte aus seiner Dokumentenbasis und generiert dann eine Antwort, indem es diesen abgerufenen Kontext mit den sprachlichen Fähigkeiten des LLM kombiniert.

Hinweis: Der vollständige Quellcode für das in diesem Artikel erwähnte Beispielprojekt ist auf GitHub verfügbar.

Artikelübersicht

1. Was ist RAG und warum sollte man es verwenden?

   • Funktionsprinzip
   • Vorteile gegenüber klassischen Ansätzen
   • Konkrete Anwendungsfälle

2. Architektur eines RAG-Systems

   • Wesentliche Komponenten
   • Datenfluss
   • Technologieauswahl

3. Praktische Implementierung mit TypeScript

   • Projekteinrichtung mit Bun
   • LangChain-Integration
   • Ollama- und Qdrant-Konfiguration

4. Codeanalyse und Best Practices

   • Dokumentenindexierung
   • Semantische Suche
   • Antwortgenerierung

5. Vorteile des technischen Stacks

   • Bun-Leistung vs. Node.js
   • Einfachheit von LangChain
   • Flexibilität von Ollama
   • Skalierbarkeit von Qdrant

6. Weiterführende Themen

   • Fortgeschrittene Optimierungen
   • Bewertung und Metriken
   • Technologische Alternativen

Was ist RAG und warum sollte man es verwenden?

Retrieval-Augmented Generation (RAG) bedeutet wörtlich "durch Abruf erweiterte Generierung". Die Idee besteht darin, das Wissen vom Modell zu trennen. Anstatt zu versuchen, alle Informationen in die Parameter eines LLM einzubauen (durch kostspieliges Fine-Tuning) oder ein klassisches Modell zu entwerfen, das Antworten aus Daten vorhersagen würde, lassen wir das Hauptmodell Text generieren und erweitern es mit einem Zwischenschritt der Informationsabfrage. Ein typischer RAG-Pipeline funktioniert wie folgt:

1. Benutzeranfrage – Der Benutzer stellt eine Frage oder gibt eine Anfrage in natürlicher Sprache ein (z.B. "Wofür wird Klasse X in diesem Projekt verwendet?").
2. Suche nach relevanten Dokumenten – Das System transformiert diese Frage in eine Vektordarstellung (Embedding) und fragt dann eine Vektordatenbank ab, um Dokumente oder Passagen abzurufen, die semantisch am ähnlichsten zur Anfrage sind. Dies identifiziert den relevanten Kontext (z.B. einen Auszug aus der Dokumentation, Code oder einem Artikel, der der Frage entspricht).
3. Kontext + Fragenkombination – Die abgerufenen Dokumente oder Auszüge werden dann dem Sprachmodell als Kontext zur Verfügung gestellt. In der Praxis werden sie in den Prompt des LLM eingefügt, typischerweise über eine Systemnachricht oder indem die Frage des Benutzers mit dem Text der gefundenen Dokumente versehen wird.
4. Antwortgenerierung – Das Sprachmodell (LLM) generiert dann eine Antwort basierend sowohl auf der Frage als auch auf dem bereitgestellten Kontext. Die Antwort sollte Informationen aus den Dokumenten enthalten, die dank der Fähigkeiten des LLM kohärent formuliert sind.

Dieser Prozess ermöglicht es dem Modell, sich zum Zeitpunkt der Generierung auf spezifisches externes Wissen zu stützen, ohne es dauerhaft speichern zu müssen. Dies kann mit einem Menschen verglichen werden, der angesichts einer Frage Bücher oder Referenzdokumente konsultieren würde, bevor er antwortet: Das LLM "durchsucht seine Bibliothek", bevor es spricht.

Konkrete Anwendungsfälle für RAG

Der RAG-Ansatz ist besonders nützlich, wenn ein Konversationsassistent eine sich entwickelnde oder umfangreiche Wissensbasis verwalten muss. Hier sind einige Beispiele für konkrete Anwendungsfälle, in denen RAG im Vergleich zu klassischen Methoden hervorragend abschneidet:

Dokumentarische Chatbots: Ein Assistent, der von der technischen Dokumentation eines Unternehmens angetrieben wird und in der Lage ist, Fragen von Entwicklern oder Kunden zu beantworten, indem er direkt aus Handbüchern, internen Wissensdatenbanken oder sogar Quellcode schöpft. Zum Beispiel kann das Modell mit API-Spezifikationen oder dem Code eines Open-Source-Projekts verbunden werden, um zu erklären, wie eine Funktion funktioniert oder warum ein bestimmtes Design gewählt wurde.

Dynamische FAQs: In einem Kundenservice-Kontext kann ein RAG-Chatbot häufig gestellte Fragen (FAQs) auf der Grundlage der neuesten Richtlinien oder Produktdaten beantworten. Wenn sich eine Richtlinie (z.B. Rückgabebedingungen) ändert, müssen Sie nur das Referenzdokument aktualisieren, und der Bot wird es sofort berücksichtigen, ohne dass ein erneutes Training erforderlich ist. Dies führt zu stets aktuellen FAQs mit der Möglichkeit, die Informationsquelle zur Unterstützung der Antwort anzugeben.

Juristische Assistenten: Ein Assistent kann Anwälten oder Juristen helfen, indem er relevante Passagen in einer Datenbank von Gesetzen, Rechtsprechung oder Verträgen für eine bestimmte Frage findet und dann die Antwort in natürlicher Sprache formuliert. Das Modell muss nicht das gesamte Bürgerliche Gesetzbuch auswendig kennen; es muss nur die entsprechenden Artikel nachschlagen. Dasselbe gilt für einen medizinischen Assistenten, der Datenbanken wissenschaftlicher Publikationen oder medizinischer Protokolle abfragen könnte, um Antworten auf der Grundlage des neuesten klinischen Wissens zu geben.

Programmierassistent: Dies ist der Fall unseres Beispielprojekts – ein Assistent, der den Inhalt eines Code-Repositorys kennt und Fragen zu diesem Code beantworten kann (Architektur, Rolle eines Moduls, potenzielle Fehler usw.). Anstatt ein spezialisiertes Programmiermodell zu trainieren, verwenden wir ein generalistisches LLM, das durch die Suche nach relevanten Codedateien im Repository erweitert wird.

Architektur eines RAG-Systems

Wesentliche Komponenten

Ein vollständiges RAG-System umfasst typischerweise die folgenden Komponenten:

1. Indexierung und Speicherung

   • Dokumentenprozessor (Extraktion, Bereinigung, Chunking)
   • Embedding-Generator (Transformation in Vektoren)
   • Vektordatenbank (Speicherung und Suche)

2. Abfrage-Pipeline

   • Abfrage-Vorverarbeiter
   • Semantische Suchmaschine
   • Prompt-Generator

3. Generierung und Nachbearbeitung

   • LLM-Schnittstelle
   • Antwortbewerter
   • Ausgabeformatierer

Datenfluss

typescript
1// Vereinfachtes Beispiel des Datenflusses in einem RAG-System
2async function processQuery(query: string): Promise<string> {
3  // 1. Transformiere die Anfrage in ein Embedding
4  const queryEmbedding = await embedder.embedQuery(query);
5  
6  // 2. Suche nach relevanten Dokumenten
7  const relevantDocs = await vectorStore.similaritySearch(queryEmbedding);
8  
9  // 3. Baue den Prompt mit Kontext auf
10  const prompt = buildPromptWithContext(query, relevantDocs);
11  
12  // 4. Generiere die Antwort mit dem LLM
13  const response = await llm.generate(prompt);
14  
15  return response;
16}

Technologieauswahl

Für unsere Implementierung haben wir einen modernen und leistungsstarken Stack gewählt:

• Bun: Ultraschnelle JavaScript-Laufzeitumgebung, ideal für Serveranwendungen
• TypeScript: Statische Typisierung für bessere Wartbarkeit
• LangChain: Framework zum Erstellen LLM-basierter Anwendungen
• Ollama: Tool zum lokalen Ausführen von Sprachmodellen
• Qdrant: Leistungsstarke und einfach zu implementierende Vektordatenbank

Diese Kombination bietet ein ausgezeichnetes Gleichgewicht zwischen Leistung, Entwicklungskomfort und Flexibilität.

Praktische Implementierung mit TypeScript

Projekteinrichtung mit Bun

Beginnen wir mit der Initialisierung unseres Projekts:

bash
1# Projekterstellung
2mkdir rag-code-assistant
3cd rag-code-assistant
4bun init
5
6# Installation der Abhängigkeiten
7bun add langchain @langchain/community @langchain/openai
8bun add qdrant-js ollama
9bun add -d typescript @types/node

Grundlegende Konfiguration

typescript
1// src/config.ts
2export const CONFIG = {
3  // Ollama-Konfiguration
4  OLLAMA_BASE_URL: 'http://localhost:11434',
5  OLLAMA_MODEL_NAME: 'llama3',
6  
7  // Qdrant-Konfiguration
8  QDRANT_URL: 'http://localhost:6333',
9  QDRANT_COLLECTION_NAME: 'code_repository',
10  
11  // Indexierungskonfiguration
12  CHUNK_SIZE: 1000,
13  CHUNK_OVERLAP: 200,
14  
15  // Pfad zum zu indexierenden Code-Repository
16  REPOSITORY_PATH: './repository',
17};

Dokumentenindexierung

Die Indexierung ist ein entscheidender Schritt in einem RAG-System. Sie umfasst die Umwandlung von Rohdokumenten in angemessen große Chunks und anschließend die Generierung von Embeddings für jeden Chunk.

typescript
1// src/indexer.ts
2import { DirectoryLoader } from 'langchain/document_loaders/fs/directory';
3import { RecursiveCharacterTextSplitter } from 'langchain/text_splitter';
4import { OllamaEmbeddings } from '@langchain/community/embeddings/ollama';
5import { QdrantClient } from 'qdrant-js';
6import { CONFIG } from './config';
7
8export async function indexRepository() {
9  // 1. Laden der Repository-Dateien
10  const loader = new DirectoryLoader(
11    CONFIG.REPOSITORY_PATH,
12    {
13      '.ts': (path) => new TextLoader(path),
14      '.js': (path) => new TextLoader(path),
15      '.tsx': (path) => new TextLoader(path),
16      '.jsx': (path) => new TextLoader(path),
17      '.md': (path) => new TextLoader(path),
18    }
19  );
20  
21  const docs = await loader.load();
22  console.log(`Laden von ${docs.length} Dateien abgeschlossen`);
23  
24  // 2. Aufteilen in Chunks
25  const textSplitter = new RecursiveCharacterTextSplitter({
26    chunkSize: CONFIG.CHUNK_SIZE,
27    chunkOverlap: CONFIG.CHUNK_OVERLAP,
28  });
29  
30  const chunks = await textSplitter.splitDocuments(docs);
31  console.log(`Erstellung von ${chunks.length} Chunks abgeschlossen`);
32  
33  // 3. Generieren von Embeddings
34  const embeddings = new OllamaEmbeddings({
35    baseUrl: CONFIG.OLLAMA_BASE_URL,
36    model: CONFIG.OLLAMA_MODEL_NAME,
37  });
38  
39  // 4. Speichern in Qdrant
40  const qdrant = new QdrantClient({ url: CONFIG.QDRANT_URL });
41  
42  // Erstellen der Collection, falls sie nicht existiert
43  try {
44    await qdrant.createCollection(CONFIG.QDRANT_COLLECTION_NAME, {
45      vectors: {
46        size: 1536, // Größe der Embedding-Vektoren
47        distance: 'Cosine',
48      },
49    });
50  } catch (e) {
51    console.log('Collection existiert bereits oder Fehler:', e.message);
52  }
53  
54  // Einfügen von Dokumenten mit ihren Embeddings
55  for (let i = 0; i < chunks.length; i += 100) {
56    const batch = chunks.slice(i, i + 100);
57    const batchEmbeddings = await embeddings.embedDocuments(
58      batch.map(chunk => chunk.pageContent)
59    );
60    
61    await qdrant.upsert(CONFIG.QDRANT_COLLECTION_NAME, {
62      points: batchEmbeddings.map((vector, idx) => ({
63        id: `${i + idx}`,
64        vector,
65        payload: {
66          text: batch[idx].pageContent,
67          metadata: batch[idx].metadata,
68        },
69      })),
70    });
71    
72    console.log(`Verarbeitung des Batches ${i}-${i + batch.length} abgeschlossen`);
73  }
74  
75  console.log('Indexierung erfolgreich abgeschlossen!');
76}

Suche und Antwortgenerierung

typescript
1// src/rag.ts
2import { OllamaEmbeddings } from '@langchain/community/embeddings/ollama';
3import { QdrantClient } from 'qdrant-js';
4import { Ollama } from '@langchain/community/llms/ollama';
5import { CONFIG } from './config';
6
7export async function generateResponse(query: string): Promise<string> {
8  // 1. Initialisierung der Komponenten
9  const embeddings = new OllamaEmbeddings({
10    baseUrl: CONFIG.OLLAMA_BASE_URL,
11    model: CONFIG.OLLAMA_MODEL_NAME,
12  });
13  
14  const qdrant = new QdrantClient({ url: CONFIG.QDRANT_URL });
15  
16  const llm = new Ollama({
17    baseUrl: CONFIG.OLLAMA_BASE_URL,
18    model: CONFIG.OLLAMA_MODEL_NAME,
19  });
20  
21  // 2. Generieren des Anfrage-Embeddings
22  const queryEmbedding = await embeddings.embedQuery(query);
23  
24  // 3. Suche nach relevanten Dokumenten
25  const searchResults = await qdrant.search(CONFIG.QDRANT_COLLECTION_NAME, {
26    vector: queryEmbedding,
27    limit: 5,
28  });
29  
30  const relevantDocs = searchResults.map(result => result.payload.text).join('\n\n');
31  
32  // 4. Erstellen des Prompts mit Kontext
33  const prompt = `
34  Sie sind ein erfahrener Programmierassistent, der dabei hilft, den Quellcode eines Projekts zu verstehen.
35  Verwenden Sie den folgenden Kontext, um die Frage des Benutzers zu beantworten.
36  Wenn Sie die Informationen nicht im Kontext finden können, sagen Sie dies deutlich.
37  
38  KONTEXT:
39  ${relevantDocs}
40  
41  FRAGE: ${query}
42  
43  ANTWORT:
44  `;
45  
46  // 5. Generieren der Antwort
47  const response = await llm.call(prompt);
48  
49  return response;
50}

Einfache Benutzeroberfläche

typescript
1// src/index.ts
2import { indexRepository } from './indexer';
3import { generateResponse } from './rag';
4
5async function main() {
6  // Argument für Indexierung oder Abfrage
7  const args = process.argv.slice(2);
8  
9  if (args[0] === 'index') {
10    console.log('Starte Indexierung...');
11    await indexRepository();
12  } else if (args[0] === 'query') {
13    const query = args.slice(1).join(' ');
14    if (!query) {
15      console.log('Verwendung: bun run src/index.ts query "Ihre Frage zum Code"');
16      process.exit(1);
17    }
18    
19    console.log(`Frage: ${query}`);
20    console.log('Generiere Antwort...');
21    const response = await generateResponse(query);
22    console.log('\nAntwort:');
23    console.log(response);
24  } else {
25    console.log('Verwendung: bun run src/index.ts [index|query "Ihre Frage"]');
26  }
27}
28
29main().catch(console.error);

Codeanalyse und Best Practices

Effizientes Chunking

Das Aufteilen von Dokumenten in Chunks ist ein kritischer Schritt, der die Qualität der Ergebnisse direkt beeinflusst. Einige Best Practices:

• Angemessene Größe: Chunks sollten groß genug sein, um Kontext zu enthalten, aber nicht zu groß, um relevant zu bleiben (typischerweise zwischen 500 und 1500 Zeichen).
• Überlappung: Überlappung zwischen Chunks verhindert den Verlust von Kontext an den Grenzen.
• Semantische Aufteilung: Idealerweise sollte die Aufteilung die semantische Struktur der Dokumente (Absätze, Funktionen usw.) respektieren.

Suchoptimierung

Die Qualität der semantischen Suche ist essenziell:

• Metadatenfilter: Verwenden Sie Metadaten (Dateityp, Datum, Autor), um Suchen zu verfeinern.
• Re-Ranking: Wenden Sie eine zweite Filterebene an, um die Relevanz zu verbessern.
• Diversität: Stellen Sie die Vielfalt der Ergebnisse sicher, um verschiedene Aspekte der Frage abzudecken.

Fortgeschrittenes Prompting

Die Konstruktion von Prompts ist eine Kunst, die die Qualität der Antworten stark beeinflusst:

typescript
1// Beispiel eines fortgeschritteneren Prompts
2const prompt = `
3# ROLLE
4Sie sind ein erfahrener Programmierassistent, der auf die Analyse von Quellcode spezialisiert ist.
5
6# KONTEXT
7${relevantDocs}
8
9# ANWEISUNGEN
10- Beantworten Sie die Frage des Benutzers nur auf Grundlage des bereitgestellten Kontexts
11- Wenn der Kontext nicht die notwendigen Informationen enthält, weisen Sie deutlich darauf hin
12- Zitieren Sie relevante Codeausschnitte in Ihrer Antwort
13- Erklären Sie den Code auf pädagogische Weise
14- Schlagen Sie Verbesserungen vor, wenn Sie welche identifizieren
15
16# FRAGE
17${query}
18`;

Vorteile des technischen Stacks

Bun-Leistung vs. Node.js

Bun bietet signifikante Vorteile für diese Art von Anwendung:

• Schneller Start: Startzeit bis zu 4x schneller als Node.js
• Optimierte Ausführung: Überlegene Ausführungsleistung, insbesondere für I/O-Operationen
• Integrierter Bundler: Vereinfachung des Entwicklungs-Workflows

Einfachheit von LangChain

LangChain erleichtert die Entwicklung von LLM-basierten Anwendungen erheblich:

• Abstraktion: Einheitliche Schnittstelle für verschiedene Modelle und Anbieter
• Wiederverwendbare Komponenten: Einsatzbereite Chains, Agents und Tools
• Etablierte Muster: Referenzimplementierungen für gängige Anwendungsfälle

Flexibilität von Ollama

Ollama ermöglicht das lokale Ausführen von Sprachmodellen mit großer Flexibilität:

• Lokale Modelle: Keine Abhängigkeit von externen APIs
• Datenschutz: Daten bleiben in Ihrer Infrastruktur
• Anpassung: Möglichkeit, Modelle nach Ihren Bedürfnissen anzupassen

Skalierbarkeit von Qdrant

Qdrant ist eine moderne Vektordatenbank, die für semantische Suche konzipiert wurde:

• Leistung: Optimiert für schnelle Ähnlichkeitssuchen
• Filterung: Erweiterte Filtermöglichkeiten für Metadaten
• Flexible Bereitstellung: Nutzbar im eingebetteten Modus oder als Dienst

Weiterführende Themen

Fortgeschrittene Optimierungen

• Hybride Suche: Kombination von Vektorsuche und Schlüsselwortsuche
• Hierarchisches Chunking: Verwendung verschiedener Granularitätsebenen für Chunks
• Caching: Zwischenspeichern von Suchergebnissen und häufigen Antworten

Bewertung und Metriken

Um die Qualität eines RAG-Systems zu messen:

• Relevanz: Sind die abgerufenen Dokumente relevant für die Frage?
• Treue: Ist die Antwort den Quelldokumenten treu?
• Nützlichkeit: Beantwortet die Antwort effektiv die Frage des Benutzers?

Technologische Alternativen

• Frameworks: Haystack, LlamaIndex als Alternativen zu LangChain
• Vektordatenbanken: Pinecone, Weaviate, Milvus als Alternativen zu Qdrant
• Modelle: Verschiedene lokale Modelle (Llama, Mistral) oder APIs (OpenAI, Anthropic)

Fazit

Retrieval-Augmented Generation stellt einen bedeutenden Fortschritt dar in der Art und Weise, wie wir Sprachmodelle für spezifische Anwendungsfälle nutzen können. Durch die Trennung von Wissen und Generierungsmodell ermöglicht RAG die Erstellung von KI-Assistenten, die genauer, aktueller und transparenter sind.

Unsere Implementierung mit TypeScript, Bun, LangChain, Ollama und Qdrant zeigt, dass es jetzt möglich ist, leistungsstarke RAG-Systeme mit modernen und zugänglichen Technologien zu erstellen. Dieser Ansatz ebnet den Weg für eine neue Generation von KI-Assistenten, die in der Lage sind, auf spezifischen Wissensdatenbanken zu argumentieren und gleichzeitig die Flüssigkeit und Kohärenz großer Sprachmodelle beizubehalten.

Zögern Sie nicht, den vollständigen Quellcode auf GitHub zu erkunden und ihn an Ihre eigenen Anwendungsfälle anzupassen. RAG ist eine sich entwickelnde Technologie, und es gibt zahlreiche Möglichkeiten für Innovation in diesem spannenden Bereich.