RAG Complete Guide

RAG (Retrieval Augmented Generation) kombiniert Information Retrieval mit Text Generation. Das LLM kann so auf dein eigenes Wissen zugreifen — statt nur auf seine Trainingsdaten.

Warum RAG?

• LLMs wissen nicht alles — besonders nicht dein Wissen
• Trainings-Daten sind veraltet — RAG nutzt aktuelle Dokumente
• Kein Prompt-Engineering für jeden Use Case nötig
• Zitate und Quellen sind nachvollziehbar
• Datenschutz: Deine Dokumente verlassen nie deine Infrastruktur

RAG Workflow

Phase 1: Offline (einmalig)

1. Document Chunking: Dokumente in kleinere Teile splitten (256-512 Tokens)
2. Embedding: Chunks in numerische Vektoren umwandeln
3. Indexing: Vektoren in durchsuchbare Datenbank speichern

Phase 2: Online (bei jeder Query)

1. Query Embedding: User-Frage in Vektor umwandeln
2. Retrieval: Ähnlichste Dokument-Chunks finden
3. Augmented Generation: LLM generiert Antwort basierend auf Query + Chunks

Vector Databases

Embedding Models

Best Practices

1. Chunk Size: 256-512 Tokens — Balance zwischen Kontext und Präzision
2. Overlap: 50-100 Tokens — Kontext geht nicht verloren an Chunk-Grenzen
3. Hybrid Search: BM25 (Keyword) + Semantische Suche kombinieren
4. Reranking: Cross-Encoder nach initial Retrieval für bessere Ergebnisse
5. Metadata Filtering: Filter nach Datum, Autor, Kategorie ermöglichen

Einfaches RAG Setup mit Ollama

# 1. Ollama mit LangChain/LlamaIndex
pip install langchain langchain-community llama-index

# 2. Einfaches RAG mit LangChain
from langchain_community.document_loaders import TextLoader
from langchain.text_splitter import CharacterTextSplitter
from langchain_community.embeddings import OllamaEmbeddings
from langchain_community.vectorstores import Chroma
from langchain_ollama import ChatOllama
from langchain.chains import RetrievalQA

# Dokumente laden
loader = TextLoader("meine_dokumente.txt")
docs = loader.load()

# Chunking
text_splitter = CharacterTextSplitter(chunk_size=500, chunk_overlap=50)
chunks = text_splitter.split_documents(docs)

# Embedding + Vector Store
embeddings = OllamaEmbeddings(model="nomic-embed-text")
vectorstore = Chroma.from_documents(chunks, embeddings)

# QA Chain
llm = ChatOllama(model="llama3.2")
qa = RetrievalQA.from_chain_type(llm=llm, chain_type="stuff", 
                                   retriever=vectorstore.as_retriever())

# Query
result = qa.run("Was steht in meinen Dokumenten?")
print(result)

Erwartete Ausgabe:

# Beispielausgabe:
# "In Ihren Dokumenten geht es um die Projektplanung für Q1 2026.
# Die Hauptpunkte sind: Budgetfreigabe, Team-Ressourcen und 
# Meilenstein-Definitionen."

Hybrid RAG: BM25 + Vektor

Für beste Ergebnisse kombinieren wir keyword-basierte Suche (BM25) mit semantischer Suche:

# Hybrid Search mit LangChain
from langchain.retrievers import ContextualCompressionRetriever
from langchain.retrievers.document_compressors import LLMChainExtractor
from langchain_community.retrievers import BM25Retriever

# BM25 Retriever (Keyword)
bm25_retriever = BM25Retriever.from_documents(chunks)

# Vector Retriever (Semantic)
vector_retriever = vectorstore.as_retriever(search_kwargs={"k": 5})

# Beide kombinieren
from langchain.retrievers import EnsembleRetriever
ensemble = EnsembleRetriever(
    retrievers=[bm25_retriever, vector_retriever],
    weights=[0.5, 0.5]
)

# Fusion Retrieval (neuere Alternative)
# Alle Ergebnisse mischen und nach Score neu sortieren

Fortgeschritten: Query Transformations

Du kannst die Query vor dem Retrieval verbessern:

# Multi-Query Retrieval
from langchain.retrievers.multi_query import MultiQueryRetriever

# Generiert mehrere Varianten der User-Query
# und führt alle Retrievals zusammen
retriever = MultiQueryRetriever.from_llm(
    retriever=vector_retriever,
    llm=llm
)

# Step-back Prompting
from langchain.prompts import PromptTemplate
step_back_prompt = PromptTemplate.from_template("""
Du bist ein hilfreicher Assistent. 
Frage allgemeiner formuliert: {question}
""")

# HyDE (Hypothetical Document Embeddings)
# LLM generiert hypothetische Antwort → embedden → Retrieval

Unser Hybrid RAG Stack