RAG-Tutorials: Schritt-für-Schritt Anleitungen

Was dieser Artikel über RAG-Tutorials behandelt

Vier komplette Tutorials von minimal bis interaktiv, alle mit lauffähigem Python-Code
Setup-Anleitung für Python, Ollama und die benötigten Packages
Praxis-Tipps, um Tutorials an eigene Dokumente anzupassen
Typische Stolpersteine und wie Du sie vermeidest
FAQ mit den häufigsten Fragen zu RAG-Tutorials

Einleitung: RAG-Tutorials verständlich erklärt

Die Theorie hinter RAG ist schnell erklärt: Dokumente durchsuchen, passende Stellen finden, an ein Sprachmodell übergeben. Doch zwischen Theorie und lauffähigem Code klafft oft eine Lücke. Genau hier setzen diese RAG-Tutorials an. Du erhältst vier vollständige Anleitungen, die Du Schritt für Schritt nachvollziehen kannst. Jedes Tutorial baut auf dem vorherigen auf und führt Dich näher an eine echte RAG-Anwendung heran.

Wenn Du die Grundlagen noch nicht kennst, lies zuerst den Artikel RAG Grundlagen. Dort erkläre ich die Konzepte hinter Retrieval Augmented Generation. Wer sich generell fragt, was lokale KI überhaupt bedeutet, findet Antworten unter Was ist lokale KI?.

Warum brauche ich Tutorials?

Stell Dir vor, Du hast die RAG-Grundlagen gelesen. Du weißt, was Embeddings sind, wie eine Vektordatenbank funktioniert und warum Chunking wichtig ist. Dann öffnest Du Deinen Editor und fragst Dich: Wo fange ich an? Welche Library brauche ich? Wie verbinde ich Ollama mit Chroma? Wie bekomme ich meinen Text in die Datenbank?

Genau dieses Problem haben viele Entwickler. Die Theorie ist verständlich, aber der erste funktionierende Code will geschrieben sein. Ein gutes Tutorial schließt diese Lücke. Es zeigt Dir nicht nur, was zu tun ist, sondern auch in welcher Reihenfolge und mit welchem Code. Du kopierst den Code, führst ihn aus, siehst ein Ergebnis und verstehst sofort, wie die Teile zusammenwirken.

RAG-Tutorials kurz erklärt

Dieser Artikel liefert Dir vier komplette Walkthroughs. Jedes Tutorial ist in sich abgeschlossen und bringt ein lauffähiges Ergebnis. Du beginnst mit einem minimalen RAG in 30 Zeilen, machst PDFs durchsuchbar, baust einen interaktiven Chat und nutzt am Ende LangChain für eine strukturierte Pipeline.

Alle Tutorials laufen lokal. Du brauchst keine Cloud, keinen API-Key und keine Internetverbindung nach dem Setup. Das Sprachmodell läuft über Ollama, die Vektordatenbank ist Chroma. Mehr zur lokalen RAG findest Du im Überblicksartikel.

Für wen sind diese Tutorials gedacht?

Diese Tutorials richten sich an Entwickler, die RAG zum ersten Mal selbst umsetzen wollen. Du brauchst grundlegende Python-Kenntnisse, also Variablen, Funktionen und Schleifen. Vorwissen in Machine Learning ist nicht erforderlich. Wenn Du schon einmal ein Python-Skript geschrieben und über die Kommandozeile ausgeführt hast, reicht das.

Auch wenn Du bereits RAG ausprobiert hast, aber unsicher bist, wie die Teile zusammenhängen, hilft Dir dieser Artikel. Die Tutorials sind so aufgebaut, dass Du jedes einzeln durchführen oder als Vorlage für eigene Projekte nutzen kannst.

Wichtige Begriffe rund um RAG-Tutorials

Begriff	Bedeutung
Tutorial	Schritt-für-Schritt Anleitung mit erklärtem Code
Walkthrough	Kompletter Durchlauf eines Beispiels von Anfang bis Ende
Pipeline	Abfolge von Verarbeitungsschritten, die Daten durchlaufen
Stack	Kombination von Tools und Libraries, die zusammen eingesetzt werden
Ollama	Lokaler Server zum Ausführen von Sprachmodellen
Chroma	Lokale Vektordatenbank für Embeddings
LangChain	Framework, das RAG-Komponenten verbindet
Python	Programmiersprache, in der alle Tutorials geschrieben sind
Virtual Environment	Isolierte Python-Umgebung für Packages
Requirements	Liste der benötigten Packages und Versionen

Tutorial 1: Minimal RAG in 30 Zeilen

Dieses Tutorial zeigt das kleinstmögliche RAG. Du legst drei Textabschnitte in Chroma ab, stellst eine Frage und erhältst eine Antwort vom Sprachmodell. Kein Framework, keine Abstraktion, nur die Kernlogik.

Voraussetzung: Ollama läuft und das Modell llama3.2 ist heruntergeladen. Außerdem brauchst Du das Embedding-Modell nomic-embed-text. Mehr zu Embedding-Modellen findest Du unter Embedding-Modelle.

import chromadb
import requests

# Chroma starten und Collection anlegen
client = chromadb.PersistentClient(path="./minrag_db")
collection = client.get_or_create_collection("docs")

# Dokumente hinzufuegen
texts = [
    "Python ist eine Programmiersprache mit dynamischer Typisierung.",
    "Ollama fuehrt Sprachmodelle lokal auf dem eigenen Rechner aus.",
    "Chroma ist eine Vektordatenbank fuer Embeddings."
]
collection.add(
    documents=texts,
    ids=["1", "2", "3"]
)

# Frage stellen und relevante Abschnitte finden
frage = "Was ist Ollama?"
results = collection.query(query_texts=[frage], n_results=2)
kontext = "\n".join(results["documents"][0])

# Prompt bauen und an Ollama senden
prompt = f"Antworte kurz auf Deutsch. Nutze nur diesen Kontext:\n{kontext}\n\nFrage: {frage}"
response = requests.post(
    "http://localhost:11434/api/generate",
    json={"model": "llama3.2", "prompt": prompt, "stream": False}
)
print(response.json()["response"])

Speichere den Code als minrag.py und führe ihn mit python minrag.py aus. Die Ausgabe ist eine kurze Antwort, die auf dem gefundenen Kontext basiert. Chroma verwendet intern ein Standard-Embedding-Modell, daher brauchst Du hier kein zusaetzliches Setup.

Das Skript legt eine Datenbank im Ordner minrag_db an. Beim erneuten Aufruf lädt Chroma die bestehenden Daten. Wenn Du neue Dokumente hinzufügst, rufe collection.add() mit neuen IDs auf.

Tutorial 2: PDF-Dokumente durchsuchbar machen

Im ersten Tutorial hast Du Texte von Hand eingetippt. In der Praxis willst Du echte Dateien durchsuchen, vor allem PDFs. Dieses Tutorial lädt eine PDF-Datei, teilt sie in Abschnitte und macht sie durchsuchbar.

Du brauchst die zusätzliche Library pypdf zum Lesen von PDFs. Mehr zum Vorbereiten von Dokumenten findest Du unter Dokumente vorbereiten.

import chromadb
import requests
from pypdf import PdfReader

# PDF laden und Text extrahieren
reader = PdfReader("beispiel.pdf")
volltext = ""
for page in reader.pages:
    text = page.extract_text()
    if text:
        volltext += text + "\n"

# Text in Chunks teilen (einfache Aufteilung nach Zeichen)
chunk_size = 500
chunk_overlap = 50
chunks = []
start = 0
while start < len(volltext):
    end = start + chunk_size
    chunks.append(volltext[start:end])
    start += chunk_size - chunk_overlap

print(f"{len(chunks)} Chunks erstellt")

# Chunks in Chroma speichern
client = chromadb.PersistentClient(path="./pdf_rag_db")
collection = client.get_or_create_collection("pdf_docs")
collection.add(
    documents=chunks,
    ids=[str(i) for i in range(len(chunks))]
)

# Frage stellen
frage = "Worum geht es in diesem Dokument?"
results = collection.query(query_texts=[frage], n_results=3)
kontext = "\n\n".join(results["documents"][0])

prompt = f"Antworte auf Deutsch basierend auf diesem Kontext:\n{kontext}\n\nFrage: {frage}"
response = requests.post(
    "http://localhost:11434/api/generate",
    json={"model": "llama3.2", "prompt": prompt, "stream": False}
)
print(response.json()["response"])

Ersetze beispiel.pdf durch den Pfad zu einer echten PDF-Datei. Das Skript liest alle Seiten, verbindet den Text und teilt ihn in 500-Zeichen-Abschnitte mit 50 Zeichen Überlappung. Mehr zu sinnvollen Chunk-Strategien findest Du unter Chunking.

Achte darauf, dass die PDF Text enthält, nicht nur Bilder. Für gescannte Dokumente brauchst Du OCR. Details dazu findest Du ebenfalls im Artikel über Dokumente vorbereiten.

Tutorial 3: Chat mit Deinen Dokumenten

Bis jetzt hast Du einzelne Fragen gestellt. In der Praxis willst Du ein Gespräch führen, mit Verlauf und Folgefragen. Dieses Tutorial erweitert das RAG um einen Chat-Loop mit Konversationshistorie.

import chromadb
import requests
import json

client = chromadb.PersistentClient(path="./chat_rag_db")
collection = client.get_or_create_collection("chat_docs")

# Beispieldokumente laden
dokumente = [
    "Der Urlaubanspruch betraegt 30 Tage im Jahr.",
    "Ueberstunden werden am Ende des Monats abgebaut oder ausgezahlt.",
    "Die Probezeit dauert sechs Monate.",
    "Homeoffice ist an zwei Tagen pro Woche moeglich."
]
collection.add(documents=dokumente, ids=["1", "2", "3", "4"])

# Konversationshistorie
history = []

def rag_chat(frage):
    # Relevante Dokumente finden
    results = collection.query(query_texts=[frage], n_results=2)
    kontext = "\n".join(results["documents"][0])

    # Prompt mit Historie und Kontext bauen
    messages = []
    messages.append({
        "role": "system",
        "content": f"Du bist ein Assistent. Nutze diesen Kontext: {kontext}"
    })
    for eintrag in history:
        messages.append(eintrag)
    messages.append({"role": "user", "content": frage})

    # An Ollama senden (Chat-API)
    response = requests.post(
        "http://localhost:11434/api/chat",
        json={"model": "llama3.2", "messages": messages, "stream": False}
    )
    antwort = response.json()["message"]["content"]

    # Historie aktualisieren
    history.append({"role": "user", "content": frage})
    history.append({"role": "assistant", "content": antwort})
    return antwort

# Interaktiver Chat-Loop
print("Chat gestartet. Tippe 'exit' zum Beenden.")
while True:
    frage = input("Du: ")
    if frage.lower() == "exit":
        break
    antwort = rag_chat(frage)
    print(f"KI: {antwort}\n")

Speichere den Code als chat_rag.py und starte ihn. Du kannst Fragen stellen wie “Wie viel Urlaub habe ich?” oder “Kann ich im Homeoffice arbeiten?”. Die KI sucht bei jeder Frage neu in der Datenbank, berücksichtigt aber auch den bisherigen Gesprächsverlauf.

Die Chat-API von Ollama akzeptiert eine Liste von Messages mit Rollen. Das system-Message enthält den Kontext, die user- und assistant-Messages bilden den Verlauf. So versteht die KI auch Folgefragen wie “Und wie lange ist die Probezeit?” ohne dass Du das Thema wiederholst.

Tutorial 4: RAG mit LangChain

Bis jetzt hast Du alle Schritte manuell implementiert. LangChain nimmt Dir viel davon ab, bietet aber auch mehr Struktur und Erweiterbarkeit. Dieses Tutorial zeigt dieselbe Pipeline mit LangChain.

from langchain_community.document_loaders import TextLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.embeddings import OllamaEmbeddings
from langchain_community.vectorstores import Chroma
from langchain_community.llms import Ollama
from langchain.chains import RetrievalQA

# Dokument laden
loader = TextLoader("notizen.txt")
docs = loader.load()

# In Chunks teilen
splitter = RecursiveCharacterTextSplitter(
    chunk_size=500,
    chunk_overlap=50
)
chunks = splitter.split_documents(docs)

# Embeddings und Vektordatenbank
embeddings = OllamaEmbeddings(model="nomic-embed-text")
vectordb = Chroma.from_documents(
    chunks,
    embeddings,
    persist_directory="./langchain_db"
)

# QA-Chain aufbauen
llm = Ollama(model="llama3.2")
qa = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=vectordb.as_retriever(search_kwargs={"k": 3})
)

# Frage stellen
frage = "Was steht in den Notizen?"
antwort = qa.run(frage)
print(antwort)

LangChain kapselt das Laden, Teilen, Embedden und Abfragen in einzelnen Komponenten. Die RetrievalQA-Chain verbindet Retriever und LLM automatisch. Du tauschst Komponenten aus, ohne den Rest zu ändern. Wenn Du statt Chroma eine andere Vektordatenbank nutzen willst, änderst Du nur eine Zeile.

Für komplexere Abläufe mit Bedingungen und Schleifen lohnt sich ein Blick auf LangGraph. Damit baust Du State-Machines für RAG-Pipelines mit mehreren Schritten, etwa mit automatischem Reranking oder Query-Transformation.

Voraussetzungen für alle Tutorials

Bevor Du die Tutorials durchführst, brauchst Du drei Dinge: Python, Ollama und ein paar Python-Packages.

Python installieren

Python 3.10 oder neuer genügt. Prüfe die Version mit python --version. Erstelle für die Tutorials ein Virtual Environment, damit die Packages Dein System nicht beeinflussen:

python -m venv rag-env
source rag-env/bin/activate

Unter Windows nutzt Du rag-env\Scripts\activate statt source.

Ollama einrichten

Lade Ollama von der offiziellen Website herunter und installiere es. Starte dann den Ollama-Server und lade die Modelle:

ollama pull llama3.2
ollama pull nomic-embed-text

llama3.2 ist das Sprachmodell, nomic-embed-text erzeugt Embeddings. Ollama läuft standardmäßig auf Port 11434. Mehr Details findest Du unter Ollama.

Packages installieren

Erstelle eine Datei requirements.txt mit folgenden Einträgen:

chromadb
requests
pypdf
langchain
langchain-community

Installiere alle Packages mit einem Befehl:

pip install -r requirements.txt

Danach kannst Du jedes Tutorial direkt ausführen.

Tipps für eigene Projekte

Die Tutorials verwenden Beispieldokumente. Für echte Projekte passen Du einige Stellen an:

Dokumente: Ersetze die hartcodierten Texte durch echte Dateien. Nutze TextLoader, PdfReader oder DirectoryLoader für ganze Ordner.
Chunk-Größe: Teste verschiedene Größen zwischen 300 und 800 Zeichen. Bei technischen Dokumenten sind kleinere Chunks oft präziser. Mehr dazu unter Chunking.
Modell: llama3.2 ist ein guter Startpunkt. Für bessere Antworten probiere mistral oder qwen2.5. Größere Modelle liefern bessere Ergebnisse, brauchen aber mehr RAM.
Anzahl Treffer: Der Parameter n_results beziehungsweise k steuert, wie viele Abschnitte das Modell erhält. Drei bis fünf sind ein guter Startwert.
Persistenz: Chroma speichert mit PersistentClient auf der Festplatte. So bleiben Deine Daten zwischen Aufrufen erhalten. Für Tests nutze EphemeralClient, der alles im RAM hält.
Metadaten: Fuege jedem Chunk Metadaten wie Dateiname, Seite oder Datum hinzu. So kannst Du spaeter filtern, etwa nur in bestimmten Dokumenten suchen.

Typische Stolpersteine bei RAG-Tutorials

Ollama läuft nicht: Prüfe mit curl http://localhost:11434/api/tags, ob Ollama erreichbar ist. Wenn nicht, starte den Server mit ollama serve.
Falsches Modell: Wenn Du nomic-embed-text in LangChain nutzt, muss das Modell auch in Ollama heruntergeladen sein. ollama list zeigt alle installierten Modelle.
Doppelte IDs in Chroma: Jede ID darf nur einmal vorkommen. Wenn Du das Skript mehrfach ausführst, nutze collection.upsert() statt collection.add(), oder lösche die Datenbank vorher.
PDF ohne Text: Gescannte PDFs enthalten nur Bilder. pypdf extrahiert dann leeren String. Nutze OCR-Bibliotheken wie pytesseract für solche Dateien.
Encoding-Probleme: Deutsche Umlaute können bei falschem Encoding verloren gehen. Öffne Dateien immer mit encoding="utf-8".
Zu viel Kontext: Wenn Du n_results zu hoch setzt, bekommt das Modell irrelevante Abschnitte. Die Antwort wird ungenauer. Starte mit drei Treffern und erhöhe nur bei Bedarf.
Veraltete LangChain-API: LangChain ändert häufig seine API. Wenn ein Import fehlschlägt, prüfe die installierte Version mit pip show langchain und schaue in die aktuelle Dokumentation.
Kein persistenter Speicher: Wenn Du chromadb.Client() ohne PersistentClient nutzt, sind die Daten nach Skriptende weg. Nutze immer einen Pfad für echte Projekte.

Hardware, Kosten und Sicherheit bei RAG-Tutorials

Alle Tutorials laufen auf einem durchschnittlichen Laptop. Das Sprachmodell llama3.2 braucht etwa 4 GB RAM, nomic-embed-text weniger als 1 GB. Chroma benötigt Speicherplatz auf der Festplatte, für ein paar hundert Dokumente reichen wenige Megabyte.

Die Kosten halten sich auf null, da alle Tools Open Source sind. Du brauchst keinen Cloud-Dienst und keinen bezahlten API-Key.

Sicherheit ist ein zentraler Vorteil. Deine Dokumente, Embeddings und die generierten Antworten bleiben auf Deinem Rechner. Nichts wird an einen externen Server gesendet. Das ist besonders wichtig bei sensiblen Daten wie Verträgen, internen Notizen oder Kundendaten. Mehr zum Thema Sicherheit bei lokaler KI findest Du im entsprechenden Artikel.

Programmieren lernen: RAG-Tutorials in Python

Wichtiger Hinweis

Viele RAG-Tutorials setzen Python voraus. Wer die Grundlagen versteht, kann Beispiele leichter anpassen und eigene Projekte bauen. Auf IRC-Coding.de findest Du KI-Coding-Tutorials zu RAG, ChatBots, Python, C# und mehr.

FAQ: RAG-Tutorials - Typische Fragen

Brauche ich eine GPU für diese Tutorials?

Nein. Alle Tutorials laufen auf der CPU. Eine GPU beschleunigt die Antwortgenerierung, ist aber nicht erforderlich. Für llama3.2 reicht ein normaler Laptop-Prozessor.

Kann ich die Tutorials auch ohne Ollama ausführen?

Die Tutorials sind für Ollama geschrieben. Du kannst die Ollama-Aufrufe durch andere lokale Server wie LM Studio ersetzen, musst dann aber die API-Aufrufe anpassen.

Welches Sprachmodell ist am besten für RAG?

Für den Einstieg ist llama3.2 eine gute Wahl. Für komplexere Antworten probiere mistral oder qwen2.5. Für Deutsch spezifisch optimierte Modelle liefert qwen2.5 oft bessere Ergebnisse.

Wie viele Dokumente verträgt Chroma?

Chroma schafft problemlos mehrere zehntausend Chunks auf einem normalen Rechner. Für noch größere Mengen oder verteilte Setups sind Qdrant oder Weaviate eine Alternative.

Muss ich LangChain verwenden?

Nein. Tutorial 1 bis 3 kommen ohne LangChain aus. LangChain ist nützlich, wenn Du schnell Komponenten tauschen oder komplexe Chains bauen willst. Für einfache Anwendungen reicht direkter Code.

Wie verbessere ich die Qualität der Antworten?

Drei Hebel helfen: besseres Chunking, mehr relevante Treffer und ein größeres Modell. Außerdem kannst Du Reranking einsetzen, um die gefundenen Abschnitte nach Relevanz zu sortieren. Mehr dazu unter Reranking.

Kann ich die Tutorials in einer anderen Sprache als Python umsetzen?

Ja. Chroma bietet Clients für JavaScript, Go und Ruby. Ollama spricht eine HTTP-API, die jede Sprache aufrufen kann. Die Konzepte sind identisch, nur der Code unterscheidet sich.

Wie halte ich die Datenbank aktuell?

Lösche alte Einträge mit collection.delete() und füge neue mit collection.add() hinzu. Für häufige Änderungen lohnt sich ein Skript, das geänderte Dateien erkennt und nur diese neu indiziert.

Sind die Tutorials auch für den produktiven Einsatz geeignet?

Die Tutorials sind Lernmaterial. Für den produktiven Einsatz brauchst Du Fehlerbehandlung, Logging, ein Frontend und eventuell eine Datenbank wie PostgreSQL statt Chroma. Die Konzepte bleiben aber dieselben.

Was ist der Unterschied zwischen RAG und Fine-Tuning?

RAG fügt Dokumente zur Laufzeit hinzu, ohne das Modell zu verändern. Fine-Tuning trainiert das Modell auf neuen Daten. RAG ist schneller aufgebaut und flexibler bei wechselnden Dokumenten. Fine-Tuning ist besser, wenn das Modell einen bestimmten Stil oder Fachjargon erlernen soll.

Kann ich mehrere Dateitypen gleichzeitig durchsuchen?

Ja. Lade PDFs mit pypdf, Textdateien mit open(), Markdown mit TextLoader und Webseiten mit WebBaseLoader. Füge alle Chunks in dieselbe Chroma-Collection ein. Metadaten helfen, die Quelle später zu unterscheiden.

Quellen und weiterführende Literatur

Chroma Documentation, chromadb.com
Ollama Documentation, ollama.com
LangChain Documentation, python.langchain.com
LangGraph Documentation, langchain-ai.github.io/langgraph
Hugging Face Embedding-Modelle, huggingface.co

Täglicher Artikel

RAG-Tutorials: Schritt-für-Schritt Anleitungen

RAG-Tutorials: Schritt-für-Schritt Anleitungen

Was dieser Artikel über RAG-Tutorials behandelt

Einleitung: RAG-Tutorials verständlich erklärt

Warum brauche ich Tutorials?

RAG-Tutorials kurz erklärt

Für wen sind diese Tutorials gedacht?

Wichtige Begriffe rund um RAG-Tutorials

Tutorial 1: Minimal RAG in 30 Zeilen

Tutorial 2: PDF-Dokumente durchsuchbar machen

Tutorial 3: Chat mit Deinen Dokumenten

Tutorial 4: RAG mit LangChain

Voraussetzungen für alle Tutorials

Python installieren

Ollama einrichten

Packages installieren

Tipps für eigene Projekte

Typische Stolpersteine bei RAG-Tutorials

Hardware, Kosten und Sicherheit bei RAG-Tutorials

Programmieren lernen: RAG-Tutorials in Python

Weiterführende Links und Infos zu RAG-Tutorials

FAQ: RAG-Tutorials - Typische Fragen

Quellen und weiterführende Literatur

Nächster Artikel in Lokale KI

Ähnliche Beiträge

Lokale KI

AnythingLLM mit Ollama per Docker Compose

Embeddings mit Ollama

Täglicher Artikel

RAG-Tutorials: Schritt-für-Schritt Anleitungen

IRC-Mania Die Seite rund um Sicherheit und Programmierung

Was dieser Artikel über RAG-Tutorials behandelt

Einleitung: RAG-Tutorials verständlich erklärt

Warum brauche ich Tutorials?

RAG-Tutorials kurz erklärt

Für wen sind diese Tutorials gedacht?

Wichtige Begriffe rund um RAG-Tutorials

Tutorial 1: Minimal RAG in 30 Zeilen

Tutorial 2: PDF-Dokumente durchsuchbar machen

Tutorial 3: Chat mit Deinen Dokumenten

Tutorial 4: RAG mit LangChain

Voraussetzungen für alle Tutorials

Python installieren

Ollama einrichten

Packages installieren

Tipps für eigene Projekte

Typische Stolpersteine bei RAG-Tutorials

Hardware, Kosten und Sicherheit bei RAG-Tutorials

Programmieren lernen: RAG-Tutorials in Python

Weiterführende Links und Infos zu RAG-Tutorials

FAQ: RAG-Tutorials - Typische Fragen

Quellen und weiterführende Literatur

Premium VPS Hosting

Nächster Artikel in Lokale KI

Ähnliche Beiträge

Lokale KI

AnythingLLM mit Ollama per Docker Compose

Embeddings mit Ollama