Wie man einen RAG-Chatbot erstellt: Vollständiges Schritt-für-Schritt-Tutorial

TL;DR

Der Aufbau eines RAG-Chatbots umfasst 7 Schlüssel Schritte: (1) Dokumente sammeln und vorbereiten, (2) Dokumente in kleinere Teile (chunks) aufteilen, (3) Embeddings für jeden chunk erzeugen, (4) Embeddings in einer vector-Datenbank speichern, (5) Retrieval-Logik implementieren, (6) Mit einem LLM zur Generierung verbinden, (7) Mit einer Chat-Oberfläche deployen. Dieser Leitfaden erläutert jeden Schritt mit Codebeispielen und Best Practices.

Was ist ein RAG-Chatbot?

Ein RAG-Chatbot (Retrieval-Augmented Generation) ist ein KI-Assistent, der Fragen beantwortet durch:

1. Abrufen der relevanten Informationen aus Ihren Dokumenten
2. Anreichern des LLM-Prompts mit diesem Kontext
3. Generieren präziser und fundierter Antworten

Im Gegensatz zu traditionellen Chatbots mit skriptbasierten Antworten verstehen RAG-Chatbots natürliche Sprache und können Fragen zu Ihrem spezifischen Inhalt beantworten.

Architekturüberblick

Benutzerfrage
     │
     ▼
┌─────────────┐
│  Embedding  │ ─── Frage in Vektor umwandeln
└─────────────┘
     │
     ▼
┌─────────────┐
│Vektorsuche  │ ─── Ähnliche Chunks finden
└─────────────┘
     │
     ▼
┌─────────────┐
│  Reranking  │ ─── (Optional) Relevanz verbessern
└─────────────┘
     │
     ▼
┌─────────────┐
│     LLM     │ ─── Antwort mit Kontext generieren
└─────────────┘
     │
     ▼
   Antwort

Voraussetzungen

Bevor Sie Ihren RAG-Chatbot erstellen, benötigen Sie:

• Dokumente: Ihre Wissensbasis (PDFs, Docs, Markdown-Dateien)
• Python 3.9+: Für die Backend-Implementierung
• API-Schlüssel: OpenAI oder ein anderer LLM-Anbieter
• Vektordatenbank: Qdrant, Pinecone, ChromaDB oder ähnlich

Schritt 1: Dokumente vorbereiten

Wissensbasis zusammenstellen

Sammeln Sie alle Dokumente, die Ihr Chatbot kennen soll:

• FAQ-Dokumente
• Produktdokumentation
• Support-Artikel
• Richtlinien-Dokumente
• Jegliche domänenspezifische Inhalte

Dokumentenverarbeitung

DEVELOPERpython
from langchain.document_loaders import (
    PyPDFLoader,
    Docx2txtLoader,
    TextLoader
)

def load_documents(file_paths):
    """Dokumente aus verschiedenen Formaten laden."""
    documents = []

    for path in file_paths:
        if path.endswith('.pdf'):
            loader = PyPDFLoader(path)
        elif path.endswith('.docx'):
            loader = Docx2txtLoader(path)
        elif path.endswith('.txt') or path.endswith('.md'):
            loader = TextLoader(path)
        else:
            continue

        documents.extend(loader.load())

    return documents

# Laden Sie Ihre Dokumente
docs = load_documents(['faq.pdf', 'produkt-leitfaden.docx', 'support.md'])

Schritt 2: Dokumente aufteilen

Dokumente müssen in kleinere Chunks aufgeteilt werden, um ein effizientes Retrieval zu ermöglichen.

Warum Chunking wichtig ist

• Kontextfenster-Grenzen: LLMs können nur eine begrenzte Textmenge verarbeiten
• Retrieval-Genauigkeit: Kleinere Chunks = präzisere Zuordnung
• Relevanz: Jeder Chunk sollte vollständige Gedanken enthalten

Chunking-Strategien

DEVELOPERpython
from langchain.text_splitter import RecursiveCharacterTextSplitter

# Rekursives chunking (empfohlen für die meisten Fälle)
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=500,        # Zeichen pro chunk
    chunk_overlap=50,      # Überlappung zwischen chunks
    separators=["\n\n", "\n", ". ", " ", ""]
)

chunks = text_splitter.split_documents(docs)
print(f"{len(chunks)} Chunks aus {len(docs)} Dokumenten erstellt")

Leitfaden für Chunk-Größen

Schritt 3: Embeddings generieren

Embeddings wandeln Text in numerische Vektoren um, die die semantische Bedeutung erfassen.

Ein Embedding-Modell wählen

Beliebte Optionen:

• OpenAI text-embedding-3-small: Gutes Gleichgewicht zwischen Qualität und Kosten
• OpenAI text-embedding-3-large: Höhere Qualität, höhere Kosten
• Cohere embed-v4: Hervorragende mehrsprachige Unterstützung
• Sentence Transformers: Kostenlos, selbst gehostet

DEVELOPERpython
from langchain.embeddings import OpenAIEmbeddings

# Embedding-Modell initialisieren
embeddings = OpenAIEmbeddings(
    model="text-embedding-3-small",
    openai_api_key="ihr-api-schluessel"
)

# Embeddings für die chunks erzeugen
chunk_texts = [chunk.page_content for chunk in chunks]
chunk_embeddings = embeddings.embed_documents(chunk_texts)

print(f"{len(chunk_embeddings)} Embeddings erzeugt")
print(f"Embedding-Dimension: {len(chunk_embeddings[0])}")

Schritt 4: In einer Vektordatenbank speichern

Vektordatenbanken ermöglichen eine schnelle Ähnlichkeitssuche über Millionen von Embeddings.

Qdrant verwenden (Empfohlen)

DEVELOPERpython
from qdrant_client import QdrantClient
from qdrant_client.models import VectorParams, Distance, PointStruct

# Qdrant-Client initialisieren
client = QdrantClient(url="http://localhost:6333")

# Collection erstellen
client.create_collection(
    collection_name="mein_chatbot",
    vectors_config=VectorParams(
        size=1536,  # Dimension Ihrer Embeddings
        distance=Distance.COSINE
    )
)

# Chunks mit ihren embeddings einfügen
points = [
    PointStruct(
        id=i,
        vector=embedding,
        payload={
            "text": chunks[i].page_content,
            "source": chunks[i].metadata.get("source", "unbekannt")
        }
    )
    for i, embedding in enumerate(chunk_embeddings)
]

client.upsert(collection_name="mein_chatbot", points=points)

ChromaDB verwenden (Einfachere Einrichtung)

DEVELOPERpython
import chromadb
from chromadb.utils import embedding_functions

# ChromaDB initialisieren
chroma_client = chromadb.Client()

# Collection mit OpenAI-embeddings erstellen
openai_ef = embedding_functions.OpenAIEmbeddingFunction(
    api_key="ihr-api-schluessel",
    model_name="text-embedding-3-small"
)

collection = chroma_client.create_collection(
    name="mein_chatbot",
    embedding_function=openai_ef
)

# Dokumente hinzufügen
collection.add(
    documents=[chunk.page_content for chunk in chunks],
    metadatas=[chunk.metadata for chunk in chunks],
    ids=[f"chunk_{i}" for i in range(len(chunks))]
)

Schritt 5: Retrieval implementieren

Der Retrieval-Schritt findet die relevantesten Chunks für die Frage eines Nutzers.

Einfache Ähnlichkeitssuche

DEVELOPERpython
def retrieve_context(question: str, top_k: int = 5):
    """Relevante chunks für eine Frage abrufen."""

    # Frage-embedding erstellen
    question_embedding = embeddings.embed_query(question)

    # In der vector-Datenbank suchen
    results = client.search(
        collection_name="mein_chatbot",
        query_vector=question_embedding,
        limit=top_k
    )

    # Text aus den Ergebnissen extrahieren
    context = "\n\n".join([
        result.payload["text"]
        for result in results
    ])

    return context, results

Hybride Suche (Empfohlen)

Semantische Suche und Stichwortsuche kombinieren:

DEVELOPERpython
from qdrant_client.models import Filter, FieldCondition, MatchText

def hybrid_retrieve(question: str, top_k: int = 5):
    """Hybride retrieval, das semantische Suche und Stichwortsuche kombiniert."""

    # Semantische Suche
    question_embedding = embeddings.embed_query(question)
    semantic_results = client.search(
        collection_name="mein_chatbot",
        query_vector=question_embedding,
        limit=top_k * 2  # Mehr für das Re-Ranking
    )

    # Filter nach Stichwörtern
    keyword_results = client.scroll(
        collection_name="mein_chatbot",
        scroll_filter=Filter(
            must=[
                FieldCondition(
                    key="text",
                    match=MatchText(text=question)
                )
            ]
        ),
        limit=top_k
    )

    # Kombinieren und Duplikate entfernen
    all_results = {r.id: r for r in semantic_results}
    for r in keyword_results[0]:
        all_results[r.id] = r

    return list(all_results.values())[:top_k]

Schritt 6: Mit dem LLM zur Generierung verbinden

Kombinieren Sie nun den abgerufenen Kontext mit einem LLM, um Antworten zu generieren.

Die RAG-Kette erstellen

DEVELOPERpython
from openai import OpenAI

client = OpenAI(api_key="ihr-api-schluessel")

def generate_response(question: str, context: str) -> str:
    """Eine Antwort generieren unter Verwendung des abgerufenen Kontexts."""

    system_prompt = """Du bist ein hilfreicher Assistent, der Fragen anhand des bereitgestellten Kontexts beantwortet.

Regeln:
- Antworte ausschließlich auf Grundlage des bereitgestellten Kontexts
- Wenn der Kontext die Antwort nicht enthält, sage "Ich habe diese Information nicht"
- Nenne nach Möglichkeit deine Quellen
- Halte die Antworten prägnant und hilfreich"""

    user_prompt = f"""Kontext:
{context}

Frage: {question}

Antwort:"""

    response = client.chat.completions.create(
        model="gpt-5",
        messages=[
            {"role": "system", "content": system_prompt},
            {"role": "user", "content": user_prompt}
        ],
        temperature=0.7,
        max_tokens=500
    )

    return response.choices[0].message.content

Vollständige RAG-Funktion

DEVELOPERpython
def rag_chatbot(question: str) -> dict:
    """Vollständige RAG-Chatbot-Funktion."""

    # 1. Relevanten Kontext abrufen
    context, sources = retrieve_context(question, top_k=5)

    # 2. Antwort generieren
    answer = generate_response(question, context)

    # 3. Zurückgeben mit den Quellen
    return {
        "question": question,
        "answer": answer,
        "sources": [
            {
                "text": s.payload["text"][:200] + "...",
                "source": s.payload.get("source", "unbekannt"),
                "score": s.score
            }
            for s in sources
        ]
    }

# Chatbot testen
result = rag_chatbot("Wie setze ich mein Passwort zurück?")
print(result["answer"])

Schritt 7: Ihren Chatbot deployen

Option A: REST-API mit FastAPI

DEVELOPERpython
from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Question(BaseModel):
    text: str

class Answer(BaseModel):
    answer: str
    sources: list

@app.post("/chat", response_model=Answer)
async def chat(question: Question):
    result = rag_chatbot(question.text)
    return Answer(
        answer=result["answer"],
        sources=result["sources"]
    )

Option B: Einbettbares Widget

Für ein produktionsreifes, einbettbares Widget erwägen Sie eine RAG-as-a-Service-Plattform wie Ailog, die bietet:

• JavaScript-Widget mit Einzeiler-Integration
• Streaming-Antworten
• Responsives mobiles Design
• Analytics und Monitoring

Option C: Streamlit-Demo

DEVELOPERpython
import streamlit as st

st.title("RAG-Chatbot")

question = st.text_input("Stellen Sie eine Frage:")

if question:
    with st.spinner("Denke nach..."):
        result = rag_chatbot(question)

    st.write("**Antwort:**", result["answer"])

    with st.expander("Quellen"):
        for source in result["sources"]:
            st.write(f"- {source['source']} (Score: {source['score']:.2f})")

Best Practices für die Produktion

1. Caching implementieren

Embeddings und Antworten cachen, um Kosten und Latenz zu reduzieren:

DEVELOPERpython
from functools import lru_cache
import hashlib

@lru_cache(maxsize=1000)
def cached_embed(text: str):
    return tuple(embeddings.embed_query(text))

def get_cache_key(question: str) -> str:
    return hashlib.md5(question.lower().strip().encode()).hexdigest()

2. Konversationsgedächtnis hinzufügen

Für mehrstufige Konversationen:

DEVELOPERpython
conversation_history = []

def chat_with_memory(question: str) -> str:
    # Kontext aus dem Verlauf hinzufügen
    history_context = "\n".join([
        f"Nutzer: {h['question']}\nAssistent: {h['answer']}"
        for h in conversation_history[-3:]  # letzten 3 Runden
    ])

    result = rag_chatbot(question)

    conversation_history.append({
        "question": question,
        "answer": result["answer"]
    })

    return result["answer"]

3. Überwachen und verbessern

Verfolgen Sie diese Kennzahlen:

• Antwortlatenz: Unter 3 Sekunden halten
• Retrieval-Genauigkeit: Sind die Quellen relevant?
• Nutzerzufriedenheit: Feedback per Daumen hoch/runter
• Unbeantwortete Anfragen: Fragen ohne gute Übereinstimmungen

Schnellere Alternative: RAG as a Service

Einen RAG-Chatbot von Grund auf zu bauen ist lehrreich, aber für den Produktiveinsatz sollten Sie eine RAG-as-a-Service-Plattform wie Ailog in Betracht ziehen:

• Einrichtung in 5 Minuten statt tagelanger Entwicklung
• Keine Infrastrukturverwaltung
• Integriertes Widget, sofort einsatzbereit
• Automatische Updates und Verbesserungen
• Kostenloses Angebot zum Einstieg

Testen Sie Ailog kostenlos - bringen Sie Ihren RAG-Chatbot in wenigen Minuten live.

Fazit

Der Aufbau eines RAG-Chatbots umfasst:

1. Dokumente vorbereiten - Ihre Wissensbasis sammeln und bereinigen
2. Chunking - Dokumente in abrufbare Teile aufteilen
3. Embedding - Text in Vektoren umwandeln
4. Speicherung - In einer Vektordatenbank sichern
5. Retrieval - Relevanten Kontext finden
6. Generierung - Antworten mit einem LLM erstellen
7. Deployment - Für Nutzer zugänglich machen

Fangen Sie einfach an, messen Sie die Leistung und iterieren Sie basierend auf Nutzerfeedback.

Verwandte Leitfäden

• Einführung in RAG - Grundlagen von RAG
• Chunking-Strategien - Ihre Chunks optimieren
• Embedding-Modelle auswählen - Das richtige Modell wählen
• RAG as a Service - Komplexität vermeiden