RAG-Chatbot bauen: Vom Dokument zum intelligenten Bot

Du hast eine Produktdokumentation, ein internes Wiki oder einen Haufen PDFs – und willst, dass ein Chatbot Fragen dazu akkurat beantwortet. Genau das ist der Kernanwendungsfall von RAG. In diesem Artikel baust du Schritt für Schritt eine vollständige RAG-Pipeline: vom rohen Dokument bis zum antwortenden Bot.

Die fünf Phasen einer RAG-Pipeline

Eine RAG-Pipeline besteht aus zwei zeitlich getrennten Phasen:

Ingestion (einmalig oder periodisch): Dokumente laden → Chunking → Embeddings generieren → in Vektordatenbank speichern.

Retrieval + Generation (bei jeder Anfrage): Nutzeranfrage als Embedding → ähnliche Chunks suchen → Kontext + Frage an LLM → Antwort.

Lass uns beide Phasen konkret durchgehen.

Phase 1: Dokumente laden und chunken

Rohe Dokumente (PDF, DOCX, Markdown, Web-Seiten) müssen zunächst in Text umgewandelt und dann in kleinere Chunks aufgeteilt werden. Warum nicht einfach das ganze Dokument übergeben? Weil Vektordatenbanken besser funktionieren, wenn die Einheiten semantisch kohärent und überschaubar groß sind – typischerweise 256–512 Tokens.

from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.document_loaders import PyPDFLoader

# Dokument laden
loader = PyPDFLoader("produkthandbuch.pdf")
docs = loader.load()

# In Chunks aufteilen (512 Tokens, 50 Token Overlap)
splitter = RecursiveCharacterTextSplitter(
    chunk_size=512,
    chunk_overlap=50,
    length_function=len
)
chunks = splitter.split_documents(docs)
print(f"{len(chunks)} Chunks erstellt")

RecursiveCharacterTextSplitter ist der empfohlene Standard: Er versucht, Absätze und Sätze zusammenzuhalten, anstatt mitten im Satz zu schneiden.

Phase 2: Embeddings generieren und speichern

Jeder Chunk wird jetzt in einen Vektor umgewandelt und in die Vektordatenbank geschrieben. Wir nutzen OpenAI text-embedding-3-small und Qdrant als lokale Datenbank:

from langchain_openai import OpenAIEmbeddings
from langchain_qdrant import QdrantVectorStore
from qdrant_client import QdrantClient

embedding_model = OpenAIEmbeddings(model="text-embedding-3-small")

# Qdrant lokal starten: docker run -p 6333:6333 qdrant/qdrant
client = QdrantClient(host="localhost", port=6333)

# Alle Chunks auf einmal indexieren
vectorstore = QdrantVectorStore.from_documents(
    documents=chunks,
    embedding=embedding_model,
    url="http://localhost:6333",
    collection_name="produkthandbuch"
)
print("Indexierung abgeschlossen")

Für einen ersten Prototyp kannst du chromadb verwenden – das läuft ohne Docker direkt im Speicher.

Phase 3: Retrieval – die passenden Chunks finden

Bei einer Nutzeranfrage wird die Frage ebenfalls in einen Vektor umgewandelt und dann nach den ähnlichsten Chunks gesucht:

# Top-3 ähnlichste Chunks zur Anfrage finden
results = vectorstore.similarity_search(
    query="Wie setze ich das Passwort zurück?",
    k=3
)

for i, doc in enumerate(results):
    print(f"--- Chunk {i+1} ---")
    print(doc.page_content[:200])

Die Suche nutzt Cosine Similarity: Je kleiner der Winkel zwischen zwei Vektoren, desto ähnlicher sind die Texte.

Phase 4: Antwort generieren

Die gefundenen Chunks werden als Kontext in den Prompt eingebaut:

from openai import OpenAI

client = OpenAI()

kontext = "\n\n".join([doc.page_content for doc in results])
frage = "Wie setze ich das Passwort zurück?"

prompt = f"""Du bist ein hilfreicher Support-Assistent. Beantworte die Frage
nur auf Basis der folgenden Dokumentauszüge. Wenn die Antwort nicht
im Kontext steht, sage das ehrlich.

Kontext:
{kontext}

Frage: {frage}"""

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": prompt}]
)
print(response.choices[0].message.content)

Den ganzen Flow mit n8n automatisieren

Keine Lust auf Python-Code? n8n bietet fertige RAG-Nodes für die komplette Pipeline:

1. Trigger: HTTP-Request-Node oder Chat-Interface
2. Embeddings: OpenAI Embeddings Node (text-embedding-3-small)
3. Vector Store: Qdrant- oder Pinecone-Node zum Schreiben und Lesen
4. LLM: OpenAI Chat Node mit Kontext-Variablen
5. Antwort: Response-Node zurück zum Nutzer

Der n8n-Template "Basic RAG Chat" gibt dir einen fertigen Startpunkt, den du in 15 Minuten konfigurieren kannst. Das n8n-Blog listet über 600 RAG-Workflow-Templates in der Community.

Vollständige Pipeline auf einen Blick

Dokument (PDF/DOCX/MD)
    ↓ Loader
Text-Chunks (512 Tokens, 50 Overlap)
    ↓ Embedding-Modell (text-embedding-3-small)
Vektoren (1536 Dimensionen)
    ↓ Vektordatenbank (Qdrant/Chroma)
    ←--- gespeichert ---

Nutzeranfrage
    ↓ Embedding
Query-Vektor
    ↓ Similarity Search (Top-K)
Relevante Chunks
    ↓ Prompt-Building
LLM (GPT-4o)
    ↓
Antwort mit Quellenangabe

Zusammenfassung

Eine RAG-Pipeline ist in wenigen Stunden aufgebaut: Dokumente laden, in Chunks aufteilen, Embeddings generieren, in einer Vektordatenbank speichern. Bei jeder Anfrage werden die passenden Chunks gesucht und dem LLM als Kontext mitgegeben. Das Ergebnis ist ein Chatbot, der verlässlich aus deinen eigenen Daten antwortet – kein Halluzinieren, keine veralteten Fakten.

---

Quellen:

• Build a Custom Knowledge RAG Chatbot using n8n – n8n Blog
• How to Build a RAG Pipeline from Scratch in 2026 – kapa.ai
• Building a Production-Ready RAG Pipeline with n8n – Medium