Lokale RAG-Pipeline mit Ollama und TypeScript/Python einrichten

In Zeiten steigender Cloud-Kosten und strenger Datenschutzvorgaben gewinnt die lokale Verarbeitung von KI-Modellen zunehmend an Bedeutung. Ein RAG-Pipeline (Retrieval-Augmented Generation) ermöglicht es Unternehmen, interne Dokumente effizient durchsuchbar zu machen – ohne sensible Daten an externe Anbieter zu übermitteln. Dieser Leitfaden zeigt, wie Sie mit Ollama, Python und TypeScript eine performante RAG-Lösung in nur 15 Minuten aufsetzen.

Warum lokale RAG-Pipelines die Cloud-Alternativen übertreffen

Der Verzicht auf externe KI-Dienste wie OpenAI oder Anthropic bietet zwei zentrale Vorteile:

• Kosteneffizienz: Keine variablen API-Gebühren pro Abfrage oder Token.
• Datensouveränität: Alle Verarbeitungsprozesse bleiben innerhalb der eigenen Infrastruktur – ideal für Unternehmen mit Compliance-Anforderungen wie der DSGVO.

Laut einer aktuellen Studie von DEV Community verzeichnen 68 % der Tech-Teams, die lokale LLMs einsetzen, eine Reduzierung der Antwortzeiten um bis zu 70 % im Vergleich zu cloudbasierten Lösungen. Gleichzeitig entfallen die typischen Latenzprobleme durch Netzwerkübertragungen.

Die Architektur: Von der Dokumentenaufnahme bis zur Antwortgenerierung

Eine funktionierende RAG-Pipeline folgt einem klaren Datenfluss, der sich in fünf Phasen unterteilen lässt:

1. Dokumentenaufnahme: Unterstützung für gängige Formate wie Markdown, PDF oder Textdateien.
2. Chunking: Aufteilung des Textes in sinnvolle Segmente (z. B. 500 Zeichen pro Chunk mit 50 Zeichen Überlappung).
3. Embedding-Generierung: Lokale Erstellung von Vektordarstellungen der Textfragmente.
4. Semantische Suche: Abgleich der Nutzeranfrage mit den generierten Embeddings.
5. Antwortgenerierung: Kontextbasierte Antwort durch das lokale Sprachmodell.

Diese Struktur stellt sicher, dass selbst komplexe Abfragen präzise und schnell beantwortet werden – ohne Abhängigkeit von externen Diensten.

Schritt-für-Schritt-Anleitung: Lokale RAG-Pipeline einrichten

1. Ollama und benötigte Modelle lokal installieren

Bevor Sie mit der Implementierung beginnen, installieren Sie Ollama und laden die erforderlichen Modelle herunter. Öffnen Sie ein Terminal und führen Sie folgende Befehle aus:

ollama pull llama3  # Grundlegendes Sprachmodell
ollama pull nomic-embed-text  # Spezialmodell für Embeddings

Stellen Sie sicher, dass Ollama im Hintergrund läuft. Die Standard-Adresse für lokale API-Anfragen lautet `

2. Projektumgebung für TypeScript oder Python vorbereiten

Wählen Sie je nach Präferenz die Sprache für die Orchestrierung Ihrer RAG-Pipeline:

#### Option A: TypeScript

Installieren Sie die Ollama-Bibliothek für TypeScript:

npm install ollama

Hier ein Beispiel, wie Sie Embeddings lokal generieren:

// index.ts
import { Ollama } from 'ollama';

const ollama = new Ollama({
  host: '
});

async function generateLocalEmbedding(text: string): Promise<number[]> {
  const response = await ollama.embeddings({
    model: 'nomic-embed-text',
    prompt: text,
  });
  return response.embedding;
}

#### Option B: Python

Installieren Sie den offiziellen Ollama-Client:

pip install ollama

Implementieren Sie die Embedding-Generierung asynchron:

# orchestrator.py
import asyncio
from ollama import AsyncClient

client = AsyncClient(host=')

async def generate_local_embedding(text: str) -> list[float]:
    response = await client.embed(
        model='nomic-embed-text',
        input=text
    )
    return response['embeddings'][0]

3. Semantische Suche mit Kosinus-Ähnlichkeit umsetzen

Um die relevantesten Dokumentenfragmente für eine Nutzeranfrage zu finden, berechnen Sie die Kosinus-Ähnlichkeit zwischen den Embeddings der Abfrage und der lokalen Dokumenten-Chunks.

#### Implementierung in TypeScript

function cosineSimilarity(vecA: number[], vecB: number[]): number {
  const dotProduct = vecA.reduce((sum, a, i) => sum + a * vecB[i], 0);
  const normA = Math.sqrt(vecA.reduce((sum, a) => sum + a * a, 0));
  const normB = Math.sqrt(vecB.reduce((sum, b) => sum + b * b, 0));
  return dotProduct / (normA * normB);
}

#### Implementierung in Python

import math

def cosine_similarity(vec_a: list[float], vec_b: list[float]) -> float:
    dot_product = sum(a * b for a, b in zip(vec_a, vec_b))
    norm_a = math.sqrt(sum(a * a for a in vec_a))
    norm_b = math.sqrt(sum(b * b for b in vec_b))
    
    if not norm_a or not norm_b:
        return 0.0  # Verhindert Division durch Null
    
    return dot_product / (norm_a * norm_b)

Tipp: Normalisieren Sie die Vektoren vor der Berechnung, um numerische Stabilität zu gewährleisten.

Häufige Fallstricke und Optimierungsstrategien

Auch bei lokalen RAG-Pipelines gibt es typische Herausforderungen, die die Performance beeinträchtigen können:

• Speichernutzung: Lokale Sprachmodelle benötigen erhebliche RAM-Ressourcen. Begrenzen Sie die Anzahl gleichzeitiger Embedding-Generierungen, um Systemabstürze zu vermeiden.
• Chunk-Größe: Zu kleine Fragmente verlieren Kontext, zu große Segmente überlasten das Modell. Ein Kompromiss liegt bei 500 Zeichen pro Chunk mit 50 Zeichen Überlappung.
• Modellauswahl: Nicht alle Embedding-Modelle sind gleich leistungsfähig. Testen Sie verschiedene Modelle wie nomic-embed-text oder all-minilm für Ihre spezifischen Anforderungen.

Eine Studie von DEV Community zeigt, dass Teams, die diese Optimierungen umsetzen, bis zu 40 % schnellere Abfragezeiten erreichen.

Ausblick: Von der In-Memory-Lösung zur skalierbaren RAG-Pipeline

Die in diesem Leitfaden vorgestellte Lösung nutzt zunächst eine In-Memory-Vektordatenbank. Für produktive Anwendungen mit großen Dokumentenmengen empfiehlt sich jedoch der Wechsel zu einer persistenten Lösung:

• Chroma: Leichtgewichtige, Open-Source-Vektordatenbank mit einfacher API.
• Milvus: Hochskalierbare Lösung für unternehmenskritische Anwendungen.
• Weaviate: Kombiniert Vektorsuche mit semantischer Graphfunktionalität.

Die Integration dieser Systeme erfordert minimalen Aufwand, bietet jedoch erhebliche Vorteile in puncto Skalierbarkeit und Persistenz. Zukunftsweisend sind zudem hybride Ansätze, die lokale Modelle mit cloudbasierten Backup-Lösungen kombinieren – für maximale Flexibilität und Ausfallsicherheit.

Die Wahl des richtigen Ansatzes hängt letztlich von Ihren spezifischen Anforderungen ab: Während lokale RAG-Pipelines ideale Datensouveränität bieten, ermöglichen hybride Modelle eine Balance zwischen Performance und Kosten.