RAG-Systeme On-Premise — Ihre Dokumente, Ihr Wissen

RAG-Architektur im Überblick

Ein RAG-System besteht aus drei Hauptkomponenten, die in einer Pipeline zusammenarbeiten:

Jede Komponente kann unabhängig skaliert und ausgetauscht werden. Das ist ein entscheidender Vorteil gegenüber monolithischen Lösungen: Sie können die Vektordatenbank wechseln, ohne die Ingestion-Pipeline anzupassen, oder das LLM austauschen, ohne die Retrieval-Logik zu ändern.

Document Processing Pipeline

Die Qualität Ihres RAG-Systems steht und fällt mit der Document Processing Pipeline. Hier werden Ihre Rohdokumente in semantische Einheiten zerlegt und als Vektoren gespeichert.

Schritt 1: Document Loading

Unterstützen Sie alle relevanten Formate in Ihrem Unternehmen:

• PDF: PyMuPDF (fitz) oder Unstructured — OCR-Unterstützung für gescannte Dokumente
• DOCX/PPTX/XLSX: python-docx, python-pptx, openpyxl
• E-Mail: IMAP-Integration, MSG/EML-Parser
• Confluence/SharePoint: REST-API-Konnektoren
• Datenbanken: SQL-Connectors für strukturierte Daten

# Beispiel: Document Loading mit LangChain
from langchain_community.document_loaders import (
    PyMuPDFLoader,
    UnstructuredWordDocumentLoader,
    ConfluenceLoader,
)

# PDF laden
pdf_loader = PyMuPDFLoader("/data/vertraege/vertrag_2024.pdf")
documents = pdf_loader.load()

# Confluence-Wiki laden (On-Premise Confluence)
wiki_loader = ConfluenceLoader(
    url="https://confluence.intern.example.de",
    username="rag-service",
    api_key="INTERNAL_KEY",
    space_key="DOCS",
)
wiki_docs = wiki_loader.load()

Schritt 2: Chunking — die kritischste Entscheidung

Die Chunking-Strategie hat den größten Einfluss auf die RAG-Qualität. Zu große Chunks verwässern die Relevanz, zu kleine verlieren den Kontext.

# Empfohlene Chunking-Strategie für deutsche Texte
from langchain.text_splitter import RecursiveCharacterTextSplitter

splitter = RecursiveCharacterTextSplitter(
    chunk_size=800,           # ~800 Zeichen pro Chunk
    chunk_overlap=200,        # 200 Zeichen Überlappung
    separators=[
        "\n\n",               # Absätze
        "\n",                 # Zeilenumbrüche
        ". ",                 # Satzenden (Deutsch: Punkt + Leerzeichen)
        "! ",                 # Ausrufezeichen
        "? ",                 # Fragezeichen
        "; ",                 # Semikolon
        ", ",                 # Komma
        " ",                  # Wortgrenzen
    ],
    length_function=len,
)

chunks = splitter.split_documents(documents)

Schritt 3: Metadata-Enrichment

Reichern Sie jeden Chunk mit Metadaten an, die beim Retrieval als Filter dienen:

# Metadaten für jeden Chunk hinzufügen
for chunk in chunks:
    chunk.metadata.update({
        "source": "vertrag_2024.pdf",
        "department": "legal",
        "date": "2024-03-15",
        "document_type": "vertrag",
        "access_level": "confidential",  # DSGVO-relevantes Zugangslevel
        "language": "de",
    })

Embedding-Modelle für deutsche Texte

Embedding-Modelle wandeln Text in hochdimensionale Vektoren um, die semantische Ähnlichkeit abbilden. Für On-Premise-Betrieb nutzen Sie Open-Source-Modelle, die lokal auf Ihrer GPU laufen.

Unsere Top-Empfehlung für deutsche Enterprise-Dokumente ist BAAI/bge-m3: Es bietet exzellente multilinguale Performance, unterstützt lange Kontexte (8192 Tokens) und benötigt nur ~2 GB VRAM — das passt neben dem LLM auf dieselbe GPU.

# Lokales Embedding mit Ollama
# ollama pull nomic-embed-text

from langchain_community.embeddings import OllamaEmbeddings

embeddings = OllamaEmbeddings(
    base_url="http://localhost:11434",
    model="nomic-embed-text",
)

# Oder mit Sentence Transformers (mehr Kontrolle)
from sentence_transformers import SentenceTransformer

model = SentenceTransformer("BAAI/bge-m3")
vectors = model.encode(
    ["Dieser Vertrag regelt die Zusammenarbeit..."],
    normalize_embeddings=True,
)

Vektordatenbanken im Vergleich

Die Vektordatenbank speichert Ihre Embeddings und ermöglicht die schnelle Ähnlichkeitssuche. Für On-Premise-Betrieb kommen drei Hauptkandidaten in Frage:

Qdrant — unsere Enterprise-Empfehlung

Qdrant bietet den besten Kompromiss aus Performance, Einfachheit und Enterprise-Features. In Rust geschrieben, ist es extrem speichereffizient und schnell. Das Docker-Deployment ist in unter 5 Minuten erledigt:

# Qdrant mit Docker starten
docker run -d \
  --name qdrant \
  -p 6333:6333 -p 6334:6334 \
  -v qdrant_data:/qdrant/storage \
  --restart unless-stopped \
  qdrant/qdrant:latest

# Collection erstellen
curl -X PUT "http://localhost:6333/collections/documents" \
  -H "Content-Type: application/json" \
  -d '{
    "vectors": {
      "size": 1024,
      "distance": "Cosine"
    },
    "optimizers_config": {
      "indexing_threshold": 20000
    }
  }'

Milvus — für sehr große Datenmengen

Milvus ist die richtige Wahl, wenn Sie >100 Millionen Vektoren verwalten müssen. Das Deployment ist komplexer (etcd, MinIO als Dependencies), aber die Skalierung ist nahezu unbegrenzt. Nutzen Sie Milvus, wenn Sie Kubernetes und ein MLOps-Team haben.

ChromaDB — für Prototypen und kleine Teams

ChromaDB ist die einfachste Option — ein einziger pip install chromadb genügt. Ideal für Prototypen und Teams mit <10.000 Dokumenten. Für Produktion fehlen jedoch wichtige Features wie Hochverfügbarkeit und granulares Access Control.

Retrieval-Strategien

Die einfachste Retrieval-Strategie — „finde die ähnlichsten Vektoren" — funktioniert für viele Fälle, aber es gibt deutlich bessere Ansätze:

Hybrid Search: Semantic + Keyword

Kombinieren Sie semantische Vektorsuche mit klassischer Keyword-Suche (BM25). Das verbessert die Retrieval-Qualität besonders bei Fachbegriffen und Eigennamen, die in Embeddings manchmal nicht gut abgebildet werden.

# Hybrid Search mit Qdrant
from qdrant_client.models import models

results = client.query_points(
    collection_name="documents",
    query=dense_vector,           # Semantische Suche
    using="dense",
    query_filter=models.Filter(   # Metadata-Filter
        must=[
            models.FieldCondition(
                key="department",
                match=models.MatchValue(value="legal"),
            ),
            models.FieldCondition(
                key="access_level",
                match=models.MatchAny(any=["public", "internal"]),
            ),
        ]
    ),
    limit=10,
)

Re-Ranking mit Cross-Encoder

Nach dem initialen Retrieval können Sie die Ergebnisse mit einem Cross-Encoder re-ranken. Cross-Encoder sind langsamer als Bi-Encoder (Embeddings), aber deutlich genauer bei der Relevanzbeurteilung:

# Re-Ranking mit Cross-Encoder
from sentence_transformers import CrossEncoder

reranker = CrossEncoder("cross-encoder/ms-marco-MiniLM-L-12-v2")

# Top-20 Ergebnisse holen, dann re-ranken auf Top-5
pairs = [(query, doc.text) for doc in initial_results]
scores = reranker.predict(pairs)

# Nach Score sortieren
ranked_results = sorted(
    zip(initial_results, scores),
    key=lambda x: x[1],
    reverse=True,
)[:5]

Multi-Query Retrieval

Lassen Sie das LLM mehrere Varianten der Nutzeranfrage generieren und suchen Sie für jede Variante separat. Das verbessert die Abdeckung deutlich:

# Multi-Query: LLM generiert 3 Varianten der Frage
original: "Welche Kündigungsfristen gelten für unsere Mietverträge?"
variant1: "Mietvertrag Kündigungsfrist Regelung"
variant2: "Wie lang ist die Frist zur Kündigung eines Mietverhältnisses?"
variant3: "Vertragliche Bestimmungen zur Beendigung von Mietverträgen"

# Ergebnisse aller Varianten kombinieren (Union + Deduplizierung)

Antwortgenerierung & Prompting

Der letzte Schritt ist die Generierung einer Antwort durch das LLM. Der entscheidende Faktor ist das Prompt-Design:

SYSTEM_PROMPT = """
Sie sind ein hilfreicher Assistent für die Example GmbH.
Beantworten Sie Fragen ausschließlich basierend auf den bereitgestellten Dokumenten.

Regeln:
1. Zitieren Sie die relevanten Quellen in Ihrer Antwort.
2. Wenn die Dokumente keine Antwort enthalten, sagen Sie das ehrlich.
3. Spekulieren Sie nicht und erfinden Sie keine Informationen.
4. Antworten Sie immer auf Deutsch in professionellem Ton.
5. Bei rechtlichen Fragen weisen Sie darauf hin, dass dies keine Rechtsberatung ist.

Bereitgestellte Dokumente:
{context}
"""

Qualitätssicherung & Evaluation

Ein RAG-System ohne Evaluierung ist ein Risiko. Messen Sie regelmäßig die Qualität Ihres Systems mit diesen Metriken:

Tools wie RAGAS (Retrieval Augmented Generation Assessment) automatisieren diese Evaluierung und erzeugen Reports, die auch für DSGVO-Audits nützlich sind.

Praxisbeispiel: RAG für eine Kanzlei

Eine mittelgroße Kanzlei mit 50 Anwälten möchte ihre Mandantenakten durchsuchbar machen, ohne Daten an Cloud-Dienste zu übertragen (Pflicht gemäß § 203 StGB).

Setup:

• Hardware: 1x Server mit NVIDIA A100 80 GB (→ GPU-Guide)
• LLM: Llama 3.1 70B via Ollama
• Embedding: bge-m3 (1024 Dim., lokal auf derselben GPU)
• Vektordatenbank: Qdrant (Docker, gleicher Server)
• Dokumente: ~50.000 PDFs (Verträge, Schriftsätze, Urteile)

Architektur-Highlights:

• Access Control: Metadata-Filter stellt sicher, dass Anwälte nur auf ihre eigenen Mandate zugreifen können
• Audit-Trail: Jede Anfrage wird mit Timestamp, User-ID und Quelldokumenten protokolliert
• Air-Gap: Der Server hat keinen Internet-Zugang — DSGVO-konform by Design
• Quellenangabe: Jede Antwort enthält Links zu den Quelldokumenten

Weiterführende Ressourcen

• Privater KI-Assistent — Pilotumfang und Abnahmekriterien
• Ollama Enterprise Setup Guide — LLM-Server für RAG
• vLLM vs. Ollama — Welche Engine für RAG?
• Open-Source LLM Vergleich — Das richtige Modell für RAG
• GPU-Server Kaufguide — Hardware für RAG-Systeme
• LLM für Kanzleien — Branchenspezifischer Guide
• DSGVO & KI — Compliance für RAG-Systeme