Mittelstufe 22 minRAG

Lokales RAG mit ChromaDB und Ollama: Tutorial Python

RAG lokal mit ChromaDB und Ollama: Python-Tutorial

Lokales RAG mit ChromaDB, Ollama und Python besteht aus drei ineinandergreifenden Bausteinen: einem Vektorspeicher, der Daten dauerhaft auf dem Datenträger speichert (ChromaDB), einem Embedding-Modell, das Ihre Chunks in Vektoren umwandelt (nomic-embed-text über Ollama), und einem Chat-LLM, das seine Antworten auf die gefundenen Textpassagen stützt. Kein API-Schlüssel, keine Datenlecks. Dieser Leitfaden führt Sie in 22 Minuten von einer unbearbeiteten PDF-Datei zu einem Chatbot, der seine Quellen zitiert.

Von Mohamed Meguedmi·Aktualisierung 2026-10-14·Unter Windows, macOS und Linux getestet

#Warum dieser Stack für lokales RAG

Viele RAG-Tutorials beginnen mit LangChain oder LlamaIndex. Diese Frameworks sind leistungsfähig, verbergen aber, was unter der Haube passiert. Hier schreiben wir die Pipeline von Hand mit nur drei Abhängigkeiten. Sie werden jeden Schritt verstehen und wissen, was Sie später optimieren können.

ChromaDB
Open-Source-Vektorspeicher in reinem Python mit integriertem persistentem Modus (SQLite + HNSW-Index). Es muss kein Server gestartet werden.
Ollama
Stellt sowohl das Embedding-Modell (nomic-embed-text) als auch das Chat-LLM (Qwen 3.5, Granite 4.2, Gemma 4) bereit. Ein einziger HTTP-Endpunkt unter localhost:11434.
Natives Python
Ein paar Funktionen, kein Framework. Sie können LangChain später bei Bedarf anbinden, aber für den Einstieg ist das nicht nötig.
i
Was Sie erhalten
Ein Python-Skript mit etwa 150 Zeilen, das die PDFs aus einem Ordner einliest, sie in Chunks aufteilt, in ChromaDB indexiert und Fragen auf Französisch mit Zitaten beantwortet. Alles lokal, keine ausgehenden Anfragen.

#Voraussetzungen

Das komplette Kit, um deinen eigenen KI-Copilot zu erstellen.

Profitiere von unserer Erfahrung und einem geführten Lernpfad, um deinen lokalen Copilot zu erstellen und deinen Code-Assistenten kennenzulernen.

  • Lebenslanger Online-Zugang
  • PDF + Dateien
  • Erstattung binnen 30 Tagen
Python 3.10+
ChromaDB erfordert mindestens 3.10. Prüfen Sie die Version mit python --version.
Ollama installiert und gestartet
Der Daemon lauscht standardmäßig auf http://localhost:11434. Wenn Sie bei null anfangen, folgen Sie zunächst dem Leitfaden zur Installation von Ollama.
8 GB RAM
Mit 16 GB läuft es komfortabel. Das 9B-Chat-Modell in Q4 benötigt etwa 6 GB, das Embedding-Modell etwa 300 MB.
Eine GPU ist nicht erforderlich
Inferenz auf der CPU funktioniert, nur langsamer. Beim Einlesen eines großen Korpus beschleunigt eine GPU mit mindestens 6 GB die Berechnung der Embeddings erheblich.

#1. ChromaDB installieren und Ollama vorbereiten

Wir erstellen eine saubere virtuelle Umgebung, installieren die drei benötigten Bibliotheken und laden die Modelle in Ollama herunter.

Python-Umgebung
python -m venv .venv
source .venv/bin/activate  # sous Windows : .venv\Scripts\activate
pip install chromadb ollama pypdf

Drei Pakete: chromadb für den Vektorspeicher, ollama für den offiziellen Python-Client, pypdf zum Lesen von PDFs. Das ist alles.

Ollama-Modelle
ollama pull nomic-embed-text:v1.5
ollama pull qwen3.5:9b

Der Ablauf verwendet nomic-embed-text:v1.5, um das Modell und seine Aufgabenpräfixe explizit zu machen. Es dient als Ausgangsbeispiel; messen Sie bei einem französischen Korpus die Suchergebnisse und vergleichen Sie insbesondere BGE-M3. Die Qualität hängt auch von der Aufteilung und den Dokumenten ab.

→
Prüfen, ob Ollama antwortet
Ein einfaches curl http://localhost:11434/api/tags sollte Ihre Modelle auflisten. Wenn nichts ausgegeben wird, läuft der Daemon nicht: ollama serve in einem anderen Terminal starten.

#2. Das Embedding-Modell konfigurieren

Ein Embedding ist ein Vektor, der die Bedeutung eines Textes darstellt. Zwei semantisch ähnliche Texte haben ähnliche Vektoren. Das ist die Grundlage von RAG: Man sucht nach den Chunks, deren Embedding dem der Frage am ähnlichsten ist.

embed.py — schneller Test
import ollama

resp = ollama.embed(
    model="nomic-embed-text:v1.5",
    input="search_document: Le contrat est résilié en cas de manquement grave.",
)
vec = resp["embeddings"][0]
print(f"Dimension du vecteur : {len(vec)}")
print(f"5 premières valeurs : {vec[:5]}")

Sie sollten die Ausgabe „Dimension du vecteur: 768“ sehen. Wenn es mit model not found fehlschlägt, wurde ollama pull nomic-embed-text nicht ausgeführt.

i
Präfixe und Konsistenz des Index
Nomic v1.5 verlangt search_document: vor jedem Chunk und search_query: vor der Frage. Mischen Sie in einer Sammlung keine Vektoren, die mit anderen Modellen, Dimensionen oder Konventionen erzeugt wurden. Das Modellprofil rechtfertigt für Ihr Korpus keine Einstufung als „Top 5 auf Französisch“.

#3. PDF-Verarbeitung auf Französisch

Die Ingestion erledigt drei Aufgaben: Sie liest die Seiten eines PDF-Dokuments, teilt den Text in Chunks angemessener Größe auf und speichert jeden Chunk mit seinem Embedding in ChromaDB im persistenten Modus.

ingest.py
import os
import chromadb
import ollama
from pypdf import PdfReader

client = chromadb.PersistentClient(path="./chroma_db")
# Nouveau nom : un ancien index "docs" peut encore utiliser la distance L2.
collection = client.get_or_create_collection(
    name="docs_nomic_v15_cosine",
    configuration={"hnsw": {"space": "cosine"}},
)

def chunk_text(text, size=800, overlap=100):
    chunks = []
    start = 0
    while start < len(text):
        end = min(start + size, len(text))
        chunk = text[start:end].strip()
        if chunk:
            chunks.append(chunk)
        start += size - overlap
    return chunks

def ingest_pdf(path):
    reader = PdfReader(path)
    name = os.path.basename(path)
    # Ce dossier d'exemple suppose des noms de fichiers uniques.
    # Retire aussi les chunks devenus obsolètes si le PDF a été raccourci.
    collection.delete(where={"source": name})
    count = 0
    for page_num, page in enumerate(reader.pages):
        text = page.extract_text() or ""
        for i, chunk in enumerate(chunk_text(text)):
            emb = ollama.embed(
                model="nomic-embed-text:v1.5",
                input="search_document: " + chunk,
            )["embeddings"][0]
            collection.upsert(
                ids=[f"{name}-p{page_num}-c{i}"],
                embeddings=[emb],
                documents=[chunk],
                metadatas=[{"source": name, "page": page_num + 1}],
            )
            count += 1
    print(f"OK : {name} ({len(reader.pages)} pages, {count} chunks indexés)")

if __name__ == "__main__":
    for f in os.listdir("./pdfs"):
        if f.lower().endswith(".pdf"):
            ingest_pdf(f"./pdfs/{f}")

Der Chunker teilt den Text in Blöcke von 800 Zeichen mit einer Überlappung von 100 Zeichen auf. Das ist ein Ausgangspunkt: weder zu klein (zu wenig Kontext) noch zu groß (das Signal wird verwässert). Bei sehr dichten juristischen Inhalten reduzieren Sie die Blockgröße auf 500 Zeichen. Bei technischen Handbüchern mit großzügigem Layout erhöhen Sie sie auf 1200 Zeichen.

→
Der persistente Modus von ChromaDB
PersistentClient speichert die Datenbank auf der Festplatte. Der neue Name docs_nomic_v15_cosine verhindert, dass versehentlich der alte L2-Index übernommen wird. Wenn Sie das Modell, seine Präfixe, die Dimension oder die Distanz ändern, erstellen Sie eine neue Sammlung und indexieren Sie die Dokumente erneut. Sichern Sie die PDFs vor einer erneuten Indexierung: Das Skript entfernt zuerst die alten Chunks der Datei.

Starten Sie die Ingestion für einen Ordner ./pdfs/, der Ihre Dokumente enthält:

Ingestion starten
mkdir -p pdfs
# placez vos PDF dans ./pdfs/
python ingest.py
!
Gescannte PDFs = kein Text
pypdf extrahiert nur nativen Text. Wenn Ihre PDFs aus Bildscans bestehen, gibt extract_text() nichts zurück. Dann müssen Sie vor der Verarbeitung ein OCR-Verfahren (Tesseract oder ein multimodales Vision-Modell wie Qwen 3.5 9B über Ollama) einsetzen.

#4. Top-k-Suche in ChromaDB

Die obige Sammlung wählt ausdrücklich die Kosinusdistanz statt der standardmäßigen L2-Einstellung. Die Frage erhält das Präfix search_query:, anschließend findet ChromaDB die ähnlichsten Passagen in diesem Index. get_or_create_collection wandelt einen alten Index nicht dadurch um, dass nur sein Variablenname geändert wird.

search.py
import chromadb
import ollama

client = chromadb.PersistentClient(path="./chroma_db")
collection = client.get_collection(name="docs_nomic_v15_cosine")

def search(question, k=4):
    count = collection.count()
    if count == 0:
        return []
    q_emb = ollama.embed(
        model="nomic-embed-text:v1.5",
        input="search_query: " + question,
    )["embeddings"][0]
    results = collection.query(
        query_embeddings=[q_emb],
        n_results=min(k, count),
    )
    chunks = results["documents"][0]
    metas = results["metadatas"][0]
    return list(zip(chunks, metas))

if __name__ == "__main__":
    hits = search("Quelles sont les conditions de résiliation ?")
    for chunk, meta in hits:
        print(f"[{meta['source']} p.{meta['page']}]")
        print(chunk[:200], "...\n")

k=4 ist ein guter Standardwert. Ist der Wert zu klein, entgeht Ihnen relevanter Kontext; ist er zu groß, überfrachten Sie das LLM mit irrelevanten Informationen und überschreiten das Kontextfenster. Für sehr präzise Fragen reicht k=2 aus. Für übergreifende Fragen erhöhen Sie den Wert auf 6.

#5. Chat-Schleife mit Quellenangaben

Jetzt setzen wir alles zusammen: Wir suchen die relevanten Chunks, erstellen einen Prompt mit dem Kontext, senden ihn über Ollama an Qwen 3.5 und bitten das Modell, seine Quellen zu zitieren.

chat.py
import ollama
from search import search

SYSTEM = """Tu es un assistant qui répond uniquement à partir du CONTEXTE fourni.
Si la réponse n'est pas dans le contexte, dis-le clairement.
Cite tes sources entre crochets sous la forme [source.pdf p.X]."""

def ask(question):
    hits = search(question, k=4)
    if not hits:
        return "Aucun passage indexé disponible pour répondre."
    context = "\n\n".join(
        f"[{m['source']} p.{m['page']}]\n{c}" for c, m in hits
    )
    prompt = f"CONTEXTE :\n{context}\n\nQUESTION : {question}"
    resp = ollama.chat(
        model="qwen3.5:9b",
        messages=[
            {"role": "system", "content": SYSTEM},
            {"role": "user", "content": prompt},
        ],
        options={"temperature": 0.2, "num_ctx": 8192},
    )
    return resp["message"]["content"]

if __name__ == "__main__":
    while True:
        q = input("\nQuestion (vide pour quitter) > ").strip()
        if not q:
            break
        print("\n" + ask(q))

Der Kontext num_ctx=8192 muss die Chunks, die Frage, die Anweisungen und die Antwort enthalten; reduzieren Sie die Anzahl der Passagen, wenn der Speicher nicht ausreicht. Der Prompt fordert Zitate und eine auf den Dokumenten basierende Antwort, garantiert jedoch nicht das Ausbleiben von Halluzinationen: Öffnen Sie die zitierten Seiten und überprüfen Sie die Aussagen.

→
Streaming für eine bessere Benutzererfahrung
Ersetzen Sie ollama.chat durch ollama.chat(..., stream=True) und iterieren Sie über die Antwort, um die Tokens nach und nach anzuzeigen. Das ist entscheidend, sobald Sie diesen Code in eine echte Benutzeroberfläche integrieren (FastAPI + WebSocket oder Streamlit).

#6. Konkretes Beispiel: juristischer Chatbot für Verträge

Stellen wir uns ein Büro vor, das 200 Dienstleistungsverträge im PDF-Format abfragen möchte. Mit dem oben genannten Stack steht in weniger als einer Stunde ein Assistent bereit, der Fragen wie diese beantwortet:

Typische Frage
„Welche Verträge enthalten eine Klausel für ein nachvertragliches Wettbewerbsverbot von mehr als 12 Monaten?“
Was passiert
Das Embedding der Frage findet die Chunks, die semantisch ähnliche Schlüsselwörter enthalten (Wettbewerbsverbot, nach Beendigung, Dauer). Qwen 3.5 liest diese 4 Passagen und antwortet mit den Namen der betreffenden Dateien.
Garantie der Vertraulichkeit
Keine Daten verlassen den Rechner. Kein API-Schlüssel. Keine Telemetrie. Das unterscheidet ein lokales RAG von einem OpenAI-Wrapper.
!
Einschränkungen, die Sie kennen sollten
Ein einfaches RAG beantwortet gezielte Fragen („Was ist Klausel X?“) gut, aggregierende Fragen („Wie viele Verträge enthalten X?“) dagegen schlecht. Für Letztere braucht man entweder einen Agenten, der die Datenbank in mehreren Schritten abfragt, oder ein GraphRAG. Das ist ein anderes Thema.

#Fehlerbehebung

ChromaDB langsam bei der Ingestion
Messen Sie die Zeit für PDF-Extraktion, Aufteilung, Embedding und Schreiben getrennt. Prüfen Sie die Platzierung des Modells mit ollama ps. Dieser Leitfaden belegt keinen allgemeingültigen Durchsatz von 50 oder 500 Chunks pro Sekunde.
„Modell nicht gefunden“
Ollama findet nomic-embed-text nicht. Führen Sie ollama pull nomic-embed-text erneut aus und prüfen Sie das Ergebnis mit ollama list.
Antworten, die Quellen erfinden
Ein 9B-Modell halluziniert noch gelegentlich. Wechseln Sie zu mistral-small (24B, ~14 GB, sehr gut auf Französisch) oder qwen3.8:27b, wenn Sie genügend VRAM haben. Oder schalten Sie nach ChromaDB einen Reranker (Cross-Encoder), um falsch positive Treffer herauszufiltern.
Schlechte Embeddings für Französisch
Bewerten Sie die abgerufenen Passagen anhand französischer Fragen, deren Antworten Sie kennen. BGE-M3 ist direkt mit ollama pull bge-m3 verfügbar. Wenn Sie das Modell wechseln, indizieren Sie in einer separaten Collection neu; nomic-Präfixe dürfen nicht automatisch für alle Modelle übernommen werden.
ChromaDB wächst unbegrenzt
Das aktualisierte Skript entfernt die Chunks der Datei vor ihrer erneuten Aufnahme und verwendet stabile IDs mit upsert. Dadurch werden auch die alten Seiten eines gekürzten PDFs entfernt. Es bleibt ein einfaches lokales Beispiel: Bewahren Sie die Originaldokumente und eine Sicherung der Datenbank auf.

#Quellen und Überprüfung vom 14. Oktober 2026

Überarbeitung vom 14. Oktober 2026: Der Code wurde mit einem echten ChromaDB-Index für die Kosinus-Einstufung und einer Test-PDF für die erneute Indexierung überprüft. Die Embedding-Aufrufe dieses Tests verwenden einen lokalen Simulationsserver; die semantische Qualität und Geschwindigkeit eines Ollama-Modells müssen noch an Ihrem Korpus gemessen werden.

#Weiterführende Informationen

Sie verfügen über ein funktionierendes RAG-System. Hier sind die naheliegenden nächsten Aufgaben, um es weiterzuentwickeln:

Embedding-Modelle für Französisch vergleichen
Unser Leitfaden „Die besten Embedding-Modelle FR“ vergleicht BGE, E5, Solon und nomic anhand französischsprachiger Inhalte.
Chunking verbessern
„Chunking-Strategien“ erläutert semantisches Chunking sowie die Aufteilung nach Markdown-Überschriften oder Absätzen – damit lässt sich oft der größte Zugewinn an Genauigkeit erzielen.
Einen Reranker hinzufügen
„Einen Reranker zur eigenen Pipeline hinzufügen“: +15 % Relevanz, indem ein Cross-Encoder nach Chroma eingesetzt wird. Der nächste logische Schritt.
Hybride Suche
„Hybride Suche mit BM25 und Vektoren“ kombiniert lexikalische und semantische Suche und ist unverzichtbar, sobald viel Fachjargon oder viele Eigennamen vorkommen.
Hat Ihnen dieser Guide geholfen?

Haben Sie Feedback, einen Fehler entdeckt oder möchten Sie etwas präzisieren? Geben Sie uns Bescheid – so wird der Guide für alle besser.