RAG-Pipeline mit LangChain und Milvus: Ein Praxisguide

Was ist RAG und warum braucht man es?

Retrieval-Augmented Generation (RAG) löst eines der größten Probleme von Large Language Models: Halluzinationen und veraltetes Wissen. Statt sich nur auf Trainingsdaten zu verlassen, sucht ein RAG-System zuerst relevante Dokumente und generiert darauf basierend eine Antwort.

In einem kürzlich abgeschlossenen Projekt habe ich eine RAG-Pipeline für eine Gesundheitsplattform mit 500+ Video- und PDF-Wissensinhalten gebaut. Hier sind die wichtigsten Learnings.

Die Architektur im Überblick

Eine RAG-Pipeline besteht aus drei Kernkomponenten:

Ingestion Pipeline – Dokumente werden geladen, in Chunks aufgeteilt und als Vektoren in eine Datenbank geschrieben

Retrieval – Bei einer Nutzeranfrage werden die relevantesten Chunks per Similarity Search gefunden

Generation – Die gefundenen Chunks werden als Kontext an das LLM übergeben, das daraus eine Antwort formuliert

Tech Stack

LangChain als Orchestrierungsframework

OpenAI GPT-4o für die Antwortgenerierung

Milvus als Vektordatenbank (selbst-gehostet via Docker)

FastAPI für die REST-API

Python 3.12 als Basis

Schritt 1: Dokumente vektorisieren

Der erste Schritt ist das Laden und Chunking der Dokumente. LangChain bietet dafür Document Loaders für verschiedene Formate:

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

loader = PyPDFLoader("dokument.pdf")
docs = loader.load()

splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200,
)
chunks = splitter.split_documents(docs)

Wichtig: Die Chunk-Größe und der Overlap haben enormen Einfluss auf die Qualität. Zu kleine Chunks verlieren Kontext, zu große verwässern die Relevanz. In unserem Projekt hat sich chunk_size=1000 mit chunk_overlap=200 als guter Kompromiss erwiesen.

Schritt 2: Embeddings und Vektordatenbank

Die Chunks werden mit OpenAI Embeddings vektorisiert und in Milvus gespeichert:

from langchain_openai import OpenAIEmbeddings
from langchain_milvus import Milvus

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

vectorstore = Milvus.from_documents(
    documents=chunks,
    embedding=embeddings,
    connection_args={"host": "localhost", "port": "19530"},
    collection_name="knowledge_base",
)

Warum Milvus? Im Vergleich zu Pinecone oder Weaviate bietet Milvus den Vorteil der Selbst-Hostbarkeit – wichtig in regulierten Branchen wie dem Gesundheitswesen, wo Daten das Unternehmen nicht verlassen dürfen.

Schritt 3: Retrieval und Antwortgenerierung

from langchain_openai import ChatOpenAI
from langchain.chains import RetrievalQA

llm = ChatOpenAI(model="gpt-4o", temperature=0)

qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=vectorstore.as_retriever(
        search_kwargs={"k": 5}
    ),
)

answer = qa_chain.invoke("Was sind die Symptome von X?")

Lessons Learned

Chunk-Qualität schlägt Quantität – Lieber weniger, aber sauber aufbereitete Chunks als eine riesige Menge an Rohdaten.

Metadata-Filtering ist Gold wert – Neben der Similarity Search kann man Chunks nach Metadaten filtern (z.B. Dokumenttyp, Datum, Kategorie).

Evaluierung von Anfang an einplanen – Wir haben von Tag 1 ein Evaluierungs-Set mit erwarteten Fragen und Antworten gepflegt.

Milvus-Performance – Bei 500+ Dokumenten und ~50.000 Chunks liefert Milvus Ergebnisse in unter 100ms.

Fazit

RAG ist kein Hexenwerk – aber die Details machen den Unterschied. Die Kombination aus LangChain, OpenAI und Milvus hat sich in der Praxis bewährt und lässt sich gut in bestehende Systeme integrieren.

Sie planen ein ähnliches Projekt? Ich unterstütze Sie gerne bei der Architektur und Implementierung Ihrer RAG-Pipeline.