Ollama RAG: Lokale Wissensdatenbank für private Fragen und Antworten

In diesem Kapitel kombinieren wir die zuvor gelernten Embedding-, Retrieval- und Generierungsfähigkeiten zu einer wirklich nutzbaren Anwendung: Füttern Sie Ihre Dokumente einem lokalen Modell und lassen Sie es Fragen ausschließlich auf Grundlage Ihrer Materialien beantworten, mit Quellenangaben.

Der vollständige Code umfasst weniger als 100 Zeilen, hat keinerlei externe Abhängigkeiten zu Vektordatenbanken und lässt sich durch einfaches Kopieren ausführen.


Anforderungsanalyse und Technologieauswahl

Klären wir zunächst das Problem: Das LLM kennt die Materialien auf Ihrer Festplatte nicht, und wenn man es direkt fragt, erhält man nur erfundene Antworten. Die Idee von RAG (Retrieval-Augmented Generation) ist eine "Open-Book-Prüfung" — zuerst relevante Abschnitte aus Ihren Materialien abrufen, sie in den Prompt einfügen und das Modell auf ihrer Grundlage antworten lassen.

RAG 双阶段流程:离线索引与在线问答

Die Technologieauswahl folgt dem Prinzip der "minimalen Abhängigkeiten":

PhaseSelectionGrund
Embedding-ModellembeddinggemmaKlein, lokal schnell; Alternative: qwen3-embedding
Generierungsmodellqwen3.5:4bGut für Chinesisch, kann auf 16GB RAM ausgeführt werden
VektorspeicherPython-Liste + KosinusähnlichkeitKeine Abhängigkeiten, gut für die Lehre nachvollziehbar; bei großen Datenmengen auf professionelle Bibliotheken wie Chroma umsteigen
Dokumentformattxt / mdReiner Text reicht aus, um die Prinzipien zu erklären; siehe Ende des Artikels für die PDF-Erweiterung

Du musst zwei Modelle pullen:

ollama pull embeddinggemma
ollama pull qwen3.5:4b

EmbeddingGemma ist ein leichtgewichtiges mehrsprachiges Text-Embedding-Modell, das von Google als Open Source veröffentlicht wurde und speziell dafür entwickelt wurde, Text in Vektoren umzuwandeln. Es eignet sich sehr gut für den Offline-Einsatz auf lokalen Geräten. Ollama hat dieses Modell bereits angepasst und paketiert, sodass du es direkt pullen und verwenden kannst.


Schritt 1: Dokument-Parsing und Chunking

Der Kontext des Modells ist begrenzt, und ein ganzes Dokument passt nicht hinein, daher muss es in kleine Chunks aufgeteilt werden. Die Chunking-Strategie verwendet den einfachsten Ansatz „feste Länge + Überlappung“: Jeder Chunk umfasst 300 Zeichen, wobei benachbarte Chunks um 50 Zeichen überlappen, um das Abschneiden wichtiger Sätze zu vermeiden.

Beispiel

# Dateipfad: rag.py
import os

def load_chunks(folder, size=300, overlap=50):
    """Liest alle txt/md-Dateien im Ordner, teilt sie in Chunks mit Quellmarkierungen auf"""
    chunks = []
    for name in sorted(os.listdir(folder)):
        if not name.endswith(('.txt', '.md')):
            continue
        path = os.path.join(folder, name)
        text = open(path, encoding='utf-8').read().strip()
        # Sliding-Window-Chunking: Schrittgröße = size - overlap
        step = size - overlap
        for i in range(0, len(text), step):
            piece = text[i:i + size].strip()
            if len(piece) > 20:  # Zu kurze Fragmente herausfiltern
                chunks.append({'file': name, 'text': piece})
    return chunks

Schritt 2: Vektorisierung und Retrieval

Konvertiere alle Chunks und die Frage des Benutzers in Vektoren und verwende die Kosinus-Ähnlichkeit, um die Top-k-Chunks zu finden, die für die Frage am relevantesten sind.

Beispiel

import ollama

EMBED_MODEL = 'embeddinggemma'

def embed(text):
    """Vektoren generieren: Eingabe einer Liste, Ausgabe einer Liste von Vektoren"""
    result = ollama.⟦embed⟦⟧EMBED_MODELembed(model=EMBED_MODEL, input=texts)
    return result['embeddings']

def cosine(a, b):
    """Kosinusähnlichkeit: je näher an 1, desto ähnlicher"""
    dot = sum(x * y for x, y in zip(a, b))
    na = sum(x * x for x in a) ** 0.5
    nb⟦⟧sum⟦⟧for⟦⟧in = sum(x * x for x in b) ** 0.5
    return dot / (na * nb)

⟦⟧search search(question, chunks, vectors, top_k=3):
    """Abruf: Gib die k relevantesten Chunks und ihre Ähnlichkeiten zurück"""
    q_vec = embed([question])[0]
    scored = [
        (cosine(q_vec, v), c)
        for v, c in zip(vectors, chunks)
    ]
    scored.sort(key=lambda x: -x[0])
    return scored[:top_k]

embeddinggemma gibt L2-normalisierte Vektoren aus; die vollständige Kosinus-Formel wird hier dennoch beibehalten, damit das Prinzip auf einen Blick klar wird; ersetzt man sie durch das Skalarprodukt, ergibt sich dasselbe Ergebnis.


Schritt 3: Zusammenstellen des Prompts und Generieren von Antworten mit Quellenangaben

Schreibe die abgerufenen Chunks zusammen mit Quellennummern in den Prompt und verlange vom Modell ausdrücklich, "nur auf Grundlage der Materialien zu antworten", und markiere Quellenangaben.

Beispiel

from ollama import chat

GEN_MODEL = 'qwen3.5:4b'

def answer(question, chunks, vectors):
    hits = search(question, chunks, vectors, top_k=3)

    # Chunks und Quellennummern in den Kontext verketten
    context = '\n\n'.join(
        f'[Quelle {idx}] (aus {c["file"]})\n{c["text"]}'
        for idx, (score, c) in enumerate(hits, 1)
    )
    prompt = f'''Beantworten Sie die Frage ausschließlich auf Grundlage der folgenden Materialien und geben Sie an, welche Quellennummern verwendet wurden.
Wenn die Materialien nicht ausreichen, um zu antworten, geben Sie direkt an, dass Sie es nicht wissen.

Materialien:
{context}

Frage: {question}'''


    response = chat(
        model=GEN_MODEL,
        messages=[{'role': 'user', 'content': prompt}],
        options={'temperature': 0.2},  # Niedrige Temperatur, reduziert kreative Freiheit
    )
    print(response.message.content)
    print('\nQuellen: ')
    for idx, (score, c) in enumerate(hits, 1):
        print(f' [Quelle {idx}] {c["file"]} (Ähnlichkeit {score:.3f})')

Vollständiger Lauf: Einstieg ins Hauptprogramm

Beispiel

# Ans Ende von rag.py anhängen
if __name__ == '__main__':
    folder = 'docs'  # Lege deine txt/md-Dokumente im docs-Ordner ab
    chunks = load_chunks(folder)

    # Offline-Indizierung: alle Chunks auf einmal vektorisieren
    print(f'Indexiere {len(chunks)} Chunks...')
    vectors = embed([c['text'] for c in chunks])
    print('Indizierung abgeschlossen.'\n')

    # Online-Frage-und-Antwort-Schleife
    while True:
        q = input('Frage (zum Beenden exit eingeben): ').strip()
        if q.lower() == 'exit':
            break
        if q:
            Antwort(q, Chunks, Vektoren)
            print()

Materialien vorbereiten und ausführen:

mkdir docs
cp EXAMPLE-python-notes.md docs/
python rag.py

Ausgabe:

$ python rag.py
正在索引 42 个片段...
索引完成。

问题(exit 退出):Python 的切片是什么?
Python 切片是用 [start:stop:step] 从序列截取子序列的语法 [资料1]。
例如 s[1:4] 取索引 1 到 3 的字符 [资料2]。

参考来源:
  [资料1] EXAMPLE-python-notes.md(相似度 0.712)
  [资料2] EXAMPLE-python-notes.md(相似度 0.668)

Beachte die Quellenangaben am Ende der Antwort: Jeder Satz lässt sich auf eine bestimmte Datei in deinem docs-Verzeichnis zurückverfolgen. Das ist genau der Kernwert von RAG im Vergleich zum "direkten Fragen des Modells."


Performance-Tuning und häufige Probleme

Wenn die RAG-Leistung schlecht ist, liegt das Problem normalerweise in der Retrieval-Phase und nicht in der Generierungsphase. Die Tuning-Hebel, nach Auswirkung geordnet:

HebelStandardwertAnpassungsrichtung
Chunk-Größe300 ZeichenErhöhen, wenn Antworten zu fragmentiert sind; zu groß macht das Retrieval ungenau; empirischer Bereich 200~500
Überlappung50 ZeichenErhöhen, wenn Sätze häufig abgeschnitten werden
Anzahl der abgerufenen Elemente top_k3Erhöhen, wenn Materialien dicht sind, aber es wird mehr Kontext verbraucht
ÄhnlichkeitsschwelleNicht aktiviertChunks mit zu geringer Ähnlichkeit herausfiltern, um irrelevante Störungen zu reduzieren
Generierungstemperatur0.2Niedrig halten; eine Wissensdatenbank braucht keine Kreativität

Kurzübersicht für häufige Probleme:

SymptomUrsacheLösung
Antwort hat keinen Bezug zu den MaterialienRetrieval hat Relevantes verpasstPrüfen, ob Chunks zu klein/groß sind, und sicherstellen, dass die Sprache der Frage mit den Materialien übereinstimmt
Modell erfindet weiterhin AntwortenUnzureichende Prompt-EinschränkungenVerschärfe die Formulierung "nur auf Grundlage der Materialien"; wenn nichts abgerufen wird, antworte direkt "Ich weiß es nicht"
Die Indizierung ist sehr langsamZu viele Chunks werden einzeln eingebettetBatch-Embedding verwenden; bei großem Dokumentvolumen auf professionelle Vektordatenbanken und inkrementelle Indizierung umsteigen
Antworten werden bei langen Dokumenten schlechterSchlüsselinformationen sind fragmentiertChunking nach semantischen Grenzen wie Überschriften/Absätzen statt rein fester Länge

Produktions-Roadmap: Wenn Sie Zehntausende von Dokumenten haben oder PDF-Parsing benötigen, ersetzen Sie den "List-Vektorspeicher" durch eine professionelle Vektordatenbank wie Chroma (die Persistenz und effiziente Nächste-Nachbarn-Suche bietet), verwenden Sie pypdf, um PDF-Text zu extrahieren, und lassen Sie den Rest des Code-Gerüsts unverändert — genau das ist der Sinn der Entkopplung jeder Stufe in diesem Artikel.

Andere Erweiterungen