RAG-Architekturen: KI mit Unternehmensdaten verbinden

Was ist Retrieval Augmented Generation (RAG)?

Large Language Models wie GPT-4 oder Claude verfügen über beeindruckendes Allgemeinwissen, kennen aber Ihre internen Unternehmensdaten nicht. Retrieval Augmented Generation (RAG) löst dieses Problem, indem es LLMs mit Ihren eigenen Dokumenten, Datenbanken und Wissenssystemen verbindet.

Statt das Modell aufwändig neu zu trainieren, reichert RAG jeden Prompt dynamisch mit relevanten Informationen aus Ihrer Datenbasis an. Das Ergebnis: präzise, faktisch korrekte Antworten basierend auf Ihrem Unternehmenswissen – ohne Halluzinationen.

Die Architektur eines RAG-Systems

Ein produktionsreifes RAG-System besteht aus mehreren Komponenten, die nahtlos zusammenarbeiten:

1. Document Processing Pipeline

Bevor Dokumente durchsuchbar werden, müssen sie verarbeitet werden:

Ingestion: Dokumente aus verschiedenen Quellen laden (PDFs, Word, Confluence, Notion)
Chunking: Texte in semantisch sinnvolle Abschnitte aufteilen
Embedding: Textabschnitte in Vektoren umwandeln
Indexing: Vektoren in einer Vektordatenbank speichern

2. Vector Database

Die Vektordatenbank ist das Herzstück jedes RAG-Systems. Sie ermöglicht semantische Suche – also das Finden von Inhalten basierend auf Bedeutung, nicht nur Schlüsselwörtern.

Bewährte Optionen für den Enterprise-Einsatz:

Pinecone: Vollständig gemanagt, hohe Skalierbarkeit
Weaviate: Open Source, GraphQL-API, Hybrid-Suche
Qdrant: Rust-basiert, performant, self-hosted möglich
pgvector: PostgreSQL-Extension, ideal bei bestehender Postgres-Infrastruktur

3. Retrieval Engine

Die Retrieval Engine orchestriert die Suche und kombiniert verschiedene Strategien:

Semantic Search: Ähnlichkeitssuche basierend auf Vektorabständen
Keyword Search: Klassische BM25-Suche für exakte Begriffe
Hybrid Search: Kombination beider Ansätze für optimale Ergebnisse

Praktische Implementierung mit Python

Ein grundlegendes RAG-System lässt sich mit wenigen Komponenten aufbauen. Hier ein Beispiel mit LangChain und OpenAI:

from langchain.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Qdrant
from langchain.chains import RetrievalQA
from langchain.llms import ChatOpenAI

# Dokumente laden und chunken
loader = PyPDFLoader("unternehmensdoku.pdf")
documents = loader.load()

text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200,
    separators=["

", "
", ". ", " "]
)
chunks = text_splitter.split_documents(documents)

# Embeddings erstellen und in Qdrant speichern
embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
vectorstore = Qdrant.from_documents(
    chunks,
    embeddings,
    location=":memory:",  # Für Produktion: URL zur Qdrant-Instanz
    collection_name="unternehmenswissen"
)

# RAG-Chain aufbauen
llm = ChatOpenAI(model="gpt-4-turbo", temperature=0)
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=vectorstore.as_retriever(search_kwargs={"k": 5})
)

# Anfrage stellen
antwort = qa_chain.run("Wie funktioniert unser Rückgabeprozess?")

Chunking-Strategien für optimale Ergebnisse

Die Art, wie Sie Dokumente in Chunks aufteilen, beeinflusst die Qualität Ihrer RAG-Antworten erheblich:

Fixed-Size Chunking

Einfachste Methode: Texte in gleich große Abschnitte teilen. Schnell, aber semantisch oft suboptimal.

Semantic Chunking

Intelligentere Aufteilung basierend auf Bedeutungseinheiten. Verwendet Embedding-Ähnlichkeit, um natürliche Grenzen zu finden:

from langchain_experimental.text_splitter import SemanticChunker

semantic_splitter = SemanticChunker(
    embeddings=OpenAIEmbeddings(),
    breakpoint_threshold_type="percentile",
    breakpoint_threshold_amount=95
)
chunks = semantic_splitter.split_documents(documents)

Document-Structure Chunking

Nutzt die natürliche Dokumentstruktur (Überschriften, Absätze, Listen) für die Aufteilung. Ideal für strukturierte Dokumente wie technische Dokumentation.

Hybrid Search: Das Beste aus beiden Welten

Reine Vektorsuche funktioniert hervorragend für semantische Ähnlichkeit, versagt aber bei exakten Begriffen wie Produktnummern oder Fachbegriffen. Hybrid Search kombiniert semantische und Keyword-Suche:

from qdrant_client import QdrantClient
from qdrant_client.models import SparseVector, NamedSparseVector

client = QdrantClient(url="http://localhost:6333")

# Hybrid-Suche mit Qdrant
results = client.query_points(
    collection_name="unternehmenswissen",
    query=dense_vector,  # Semantische Suche
    using="dense",
    query_filter=None,
    with_payload=True,
    limit=10,
    search_params={
        "exact": False,
        "hnsw_ef": 128
    }
).points

# Sparse-Vektor für Keyword-Matching
sparse_results = client.query_points(
    collection_name="unternehmenswissen",
    query=NamedSparseVector(
        name="sparse",
        vector=SparseVector(indices=[1, 7, 9], values=[0.5, 0.8, 0.2])
    ),
    using="sparse",
    limit=10
).points

Reranking für präzisere Ergebnisse

Die initiale Retrieval-Phase liefert oft 20-50 potenziell relevante Dokumente. Ein Reranker bewertet diese neu und wählt die wirklich relevanten aus:

from sentence_transformers import CrossEncoder

reranker = CrossEncoder('cross-encoder/ms-marco-MiniLM-L-6-v2')

# Ergebnisse neu bewerten
pairs = [(query, doc.page_content) for doc in initial_results]
scores = reranker.predict(pairs)

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

Kontextfenster-Management

Moderne LLMs haben große Kontextfenster (128k+ Tokens), aber mehr Kontext bedeutet nicht automatisch bessere Antworten. Strategien für optimales Kontext-Management:

Relevanz-Filterung: Nur Chunks mit Mindest-Ähnlichkeit einbeziehen
Diversity Sampling: Verschiedene Perspektiven statt redundanter Information
Hierarchische Kompression: Zusammenfassungen für umfangreiche Kontexte
Metadata-Anreicherung: Quelle, Datum und Konfidenzscore mitliefern

DSGVO-konforme RAG-Systeme

Bei der Verarbeitung von Unternehmensdaten in Deutschland gelten strenge Datenschutzanforderungen:

Datenhoheit sicherstellen

Self-Hosted Embeddings: Modelle wie BGE oder E5 lokal betreiben
Europäische Cloud-Anbieter: Vektordatenbanken in EU-Rechenzentren
On-Premise Option: Für sensible Daten komplette Infrastruktur intern

Zugriffskontrollen implementieren

# Beispiel: Dokument-Level Berechtigungen
metadata = {
    "source": "vertraulich/strategie-2026.pdf",
    "access_level": "management",
    "department": "vorstand",
    "created_at": "2026-01-15"
}

# Bei Retrieval filtern
retriever = vectorstore.as_retriever(
    search_kwargs={
        "k": 5,
        "filter": {
            "access_level": {"$in": user.access_levels},
            "department": {"$in": user.departments}
        }
    }
)

Audit-Trail führen

Dokumentieren Sie, welche Daten wann von wem abgefragt wurden. Dies ist für Compliance-Audits essentiell.

Performance-Optimierung

RAG-Systeme in Produktion müssen schnell und zuverlässig arbeiten:

Caching-Strategien

Query Cache: Häufige Anfragen zwischenspeichern
Embedding Cache: Berechnete Vektoren wiederverwenden
Result Cache: Vollständige Antworten für identische Queries

Asynchrone Verarbeitung

import asyncio
from typing import List

async def parallel_retrieval(queries: List[str]) -> List[List[Document]]:
    tasks = [
        asyncio.create_task(vectorstore.asimilarity_search(q, k=5))
        for q in queries
    ]
    return await asyncio.gather(*tasks)

Batch-Processing für Ingestion

Bei großen Dokumentmengen ist Batch-Verarbeitung essentiell:

# Embeddings in Batches erstellen
BATCH_SIZE = 100

for i in range(0, len(chunks), BATCH_SIZE):
    batch = chunks[i:i + BATCH_SIZE]
    embeddings = embedding_model.embed_documents(
        [chunk.page_content for chunk in batch]
    )
    vectorstore.add_embeddings(
        texts=[chunk.page_content for chunk in batch],
        embeddings=embeddings,
        metadatas=[chunk.metadata for chunk in batch]
    )

Evaluation und Monitoring

Ein RAG-System ohne Metriken ist ein Blindflug. Wichtige KPIs:

Retrieval-Qualität

Precision@K: Anteil relevanter Dokumente in Top-K Ergebnissen
Recall: Werden alle relevanten Dokumente gefunden?
MRR (Mean Reciprocal Rank): Position des ersten relevanten Ergebnisses

Antwort-Qualität

Faithfulness: Basiert die Antwort auf den abgerufenen Dokumenten?
Relevance: Beantwortet die Antwort die Frage?
Hallucination Rate: Wie oft werden Fakten erfunden?

from ragas import evaluate
from ragas.metrics import faithfulness, answer_relevancy, context_precision

result = evaluate(
    dataset,
    metrics=[faithfulness, answer_relevancy, context_precision]
)
print(result)

Typische Anwendungsfälle

RAG-Architekturen eignen sich besonders für:

Interne Wissensdatenbanken: Mitarbeiter fragen Unternehmens-Know-how ab
Kundenservice-Bots: Automatische Antworten basierend auf Produktdokumentation
Vertragsanalyse: Juristische Dokumente durchsuchen und zusammenfassen
Technische Dokumentation: Entwickler finden schnell relevante API-Infos
Compliance-Prüfung: Regelwerke und Richtlinien durchsuchbar machen

Fazit: RAG als Brücke zwischen LLMs und Unternehmenswissen

RAG-Architekturen ermöglichen es, die Stärken großer Sprachmodelle mit Ihren spezifischen Unternehmensdaten zu verbinden. Der Schlüssel zum Erfolg liegt in der sorgfältigen Abstimmung aller Komponenten: vom Chunking über die Vektordatenbank bis zum Reranking.

Beginnen Sie mit einem fokussierten Use Case, messen Sie die Qualität kontinuierlich und iterieren Sie basierend auf echtem Nutzer-Feedback. So bauen Sie Schritt für Schritt ein RAG-System, das echten Mehrwert für Ihr Unternehmen schafft.

Sie planen ein RAG-Projekt? Als spezialisierter Softwareentwickler unterstützen wir Sie von der Architektur bis zur Produktion. Kontaktieren Sie uns für eine unverbindliche Beratung.