LlamaIndex: Framework für RAG- und Agenten-Apps

Was dieser Artikel behandelt

• Wofür Du LlamaIndex einsetzen kannst und wie es aufgebaut ist.
• Die wichtigsten Konzepte: Data Ingestion, Indexing, Query Engine und Agents.
• Wie Du eigene Dokumente in einen Index überführst und abfragst.
• Einen lokalen RAG-Workflow mit Ollama und LlamaIndex.
• Wie Agenten mit Tools und Query Engines kombiniert werden.
• Typische Fehler und Stolpersteine beim Einstieg.

Einleitung

LlamaIndex ist ein Open-Source-Framework für Python, mit dem Du Large Language Models mit eigenen Daten verbindest. Der Fokus liegt auf sogenanntem Data Ingestion, dem Aufbau von Indizes und der Beantwortung von Fragen aus diesen Daten. Dabei spielt Retrieval-Augmented Generation, kurz RAG, eine zentrale Rolle. Statt ein Modell nur mit seinem Trainingswissen zu befragen, holt LlamaIndex passende Textpassagen und übergibt sie als Kontext an das LLM.

Die Architektur ist modular. Du kannst Dokumente laden, sie in kleine Chunks zerlegen, Embeddings berechnen und in einem Vector Store speichern. Über eine Query Engine fragst Du den Index ab. Wenn Du zusätzlich Entscheidungen automatisieren möchtest, baust Du Agenten, die selbstständig Tools auswählen. Das macht LlamaIndex zu einem beliebten Werkzeug für datengetriebene Anwendungen.

Warum brauche ich LlamaIndex?

Sprachmodelle kennen nur das, worauf sie trainiert wurden. Sobald Du firmenspezifische Handbücher, wissenschaftliche Artikel oder interne Dokumentationen einbeziehen willst, reicht ein reines LLM nicht aus. LlamaIndex hilft Dir, diese Informationen aufzubereiten und dem Modell gezielt zuzuführen.

Der Vorteil gegenüber einer manuellen Lösung ist die Anzahl fertiger Bausteine. Loader für PDFs, Textdateien und Webseiten, verschiedene Splitter, mehrere Vector-Store-Integrationen und vorgefertigte Query Engines sparen Dir viel Zeit. Außerdem bleibt Dein Code lesbar, weil der Ablauf klar in Ladephase, Indexierung und Abfrage getrennt ist.

LlamaIndex lässt sich außerdem gut mit lokalen Modellen betreiben. Wenn Du Ollama nutzt, bleiben Deine Daten auf Deinem Rechner. Das ist besonders für vertrauliche Inhalte interessant.

LlamaIndex kurz erklärt

Das Framework gliedert sich in mehrere Ebenen:

• Data Ingestion: Dokumente aus verschiedenen Quellen laden und in ein einheitliches Format bringen.
• Node Parser: Aufspaltung großer Dokumente in kleine Chunks, sogenannte Nodes.
• Embeddings: Umwandlung von Text in Vektoren, die semantische Ähnlichkeit ausdrücken.
• Index: Ein Container, der Nodes und deren Vektoren verwaltet, etwa ein Vector Store Index.
• Retriever: Komponente, die die passendsten Nodes zu einer Frage zurückgibt.
• Query Engine: Kombiniert Retrieval und LLM-Aufruf zu einer Antwort.
• Agent: Ein ReAct-Agent oder Function Agent, der mehrere Tools und Query Engines nutzt.
• Tool: Eine Funktion oder Query Engine, die ein Agent aufrufen kann.

Die Idee ist einfach: Daten aufnehmen, passende Passungen finden und das LLM gezielt damit füttern. Das Ergebnis ist ein RAG-System, das aktuellere und genauere Antworten liefert.

Für wen ist dieser Artikel gedacht?

Dieser Artikel richtet sich an Einsteiger, die bereits Grundkenntnisse in Python haben. Du solltest verstehen, wie ein Sprachmodell funktioniert, musst aber kein RAG-Experte sein. Wenn Du lernen möchtest, eigene Daten an ein LLM anzubinden, ist LlamaIndex ein guter Startpunkt.

Kenntnisse in Embeddings oder Vektordatenbanken helfen, sind aber nicht zwingend notwendig. Wichtiger ist der Wille, mit Pipelines und APIs zu experimentieren. Falls Du das Thema RAG vertiefen willst, findest Du bei RAG Grundlagen und Vektordatenbanken ergänzende Hintergründe.

Wichtige Begriffe

Begriff	Bedeutung
Document	Ein geladenes Dokument, etwa aus einer PDF- oder Textdatei.
Node	Ein kleiner Textabschnitt aus einem Document, typischerweise ein Chunk.
Chunk	Ein zusammenhängender Textblock, der separat indexiert werden kann.
Embedding	Ein Vektor, der die Bedeutung eines Textes in Zahlen abbildet.
Vector Store	Speicher für Embeddings, der Ähnlichkeitssuchen erlaubt.
Index	Die Datenstruktur, die Nodes und deren Vektoren verwaltet.
Retriever	Komponente, die relevante Nodes anhand einer Query findet.
Query Engine	Verbindung aus Retriever, Synthesizer und LLM zur Beantwortung.
Agent	System, das eigenständig Schritte und Tools wählt.
Tool	Eine Funktion oder Query Engine, die ein Agent aufrufen kann.

Installation

Für die meisten Beispiele reichen folgende Pakete. Achte darauf, dass Python mindestens 3.9 installiert ist:

pip install llama-index llama-index-llms-ollama llama-index-embeddings-ollama

Falls Du PDFs laden möchtest, ergänze:

pip install pypdf

Ollama sollte laufen und mindestens ein Modell wie llama3.2 sowie ein Embedding-Modell wie nomic-embed-text bereithalten. Du kannst die Modelle mit ollama pull llama3.2 und ollama pull nomic-embed-text herunterladen.

Daten aufnehmen und indexieren

Der erste Schritt ist das Laden und Aufbereiten der Daten. LlamaIndex stellt verschiedene Loader bereit, die Dateien in Document-Objekte umwandeln. Anschließend teilst Du die Inhalte in überschaubare Nodes auf und berechnest Embeddings.

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, Settings
from llama_index.core.node_parser import SentenceSplitter
from llama_index.llms.ollama import Ollama
from llama_index.embeddings.ollama import OllamaEmbedding

Settings.llm = Ollama(model="llama3.2", request_timeout=120.0)
Settings.embed_model = OllamaEmbedding(model_name="nomic-embed-text")

documents = SimpleDirectoryReader("data").load_data()

parser = SentenceSplitter(chunk_size=512, chunk_overlap=50)
nodes = parser.get_nodes_from_documents(documents)

index = VectorStoreIndex(nodes)
index.storage_context.persist(persist_dir="./storage")

SimpleDirectoryReader liest alle Dateien aus einem Ordner. SentenceSplitter sorgt dafür, dass der Text in Chunks passt, die Dein Modell verarbeiten kann. Der VectorStoreIndex speichert die zugehörigen Embeddings. Mit persist legst Du den Index lokal ab, damit Du ihn später wiederverwenden kannst.

Query Engine und RAG

Sobald der Index steht, fragst Du ihn ab. Die Query Engine übernimmt dabei Retrieval und Antwortgenerierung:

query_engine = index.as_query_engine()

antwort = query_engine.query("Was steht im Dokument zu den Kosten?")
print(antwort)

Die Query Engine sucht automatisch nach den ähnlichsten Nodes und übergibt sie als Kontext an das LLM. Du kannst das Verhalten anpassen, etwa die Anzahl der zurückgegebenen Nodes erhöhen oder nur ähnlichste Teile verwenden:

query_engine = index.as_query_engine(similarity_top_k=5)
antwort = query_engine.query("Welche Schritte beschreibt die Anleitung?")
print(antwort)

Dieses Muster ist der Kern eines RAG-Systems. Mehr Hintergrund dazu findest Du in Lokales RAG und RAG Grundlagen. Wie Embeddings genau funktionieren, erklären wir in Embedding-Modelle.

Agenten mit LlamaIndex

Eine besondere Stärke von LlamaIndex sind Agenten. Ein Agent kann mehrere Tools benutzen, beispielsweise verschiedene Query Engines, Suchfunktionen oder selbstgeschriebene Python-Funktionen. Das folgende Beispiel zeigt einen einfachen ReAct-Agenten, der eine Multiplikation beherrscht.

from llama_index.core.tools import FunctionTool
from llama_index.core.agent import ReActAgent

def multiply(a: float, b: float) -> float:
    """Multiply two numbers and return the product."""
    return a * b

tool = FunctionTool.from_defaults(fn=multiply)

agent = ReActAgent.from_tools([tool], llm=Settings.llm, verbose=True)
antwort = agent.chat("Was ist 12 mal 15?")
print(antwort)

Derselbe Agent kann auch ganze Query Engines als Tools erhalten. Damit kombinierst Du gezieltes Retrieval mit dynamischer Entscheidungsfindung. Mehr zum Agentenkonzept liest Du in Was ist ein KI-Agent.

LlamaIndex und LangChain im Vergleich

LangChain und LlamaIndex überschneiden sich, haben aber unterschiedliche Schwerpunkte. LlamaIndex konzentriert sich auf das Verbinden eigener Daten mit LLMs. Die Begriffe Data Ingestion, Indexing und Query Engine sind zentral. LangChain bietet eine breitere Palette an Tools für Chains, Tools und Agenten.

Für reine RAG-Projekte ist LlamaIndex oft schneller einsatzbereit, weil viele Schritte out of the box funktionieren. Wenn Du allgemeine Agenten-Workflows oder komplexere Chains brauchst, ergänzt sich LlamaIndex gut mit LangChain. Beide Frameworks lassen sich auch kombinieren.

Typische Stolpersteine

• Falsche Modellklasse: Ollama und ChatOllama sind unterschiedlich. Für Chat-Nachrichten brauchst Du Klassen, die das Chat-Format unterstützen.
• Timeout zu kurz: Lokale Modelle brauchen länger als Cloud-APIs. Setze request_timeout hoch, etwa 120 Sekunden.
• Chunks zu groß: Wenn Nodes das Kontextfenster sprengen, werden Informationen abgeschnitten. Teste verschiedene chunk_size-Werte.
• Schlechte Treffer beim Retrieval: Die Qualität hängt vom Embedding-Modell und vom Splitter ab. Ein passendes Modell ist wichtiger als viele Nodes.
• Vergessene Persistierung: Ohne storage_context.persist verlierst Du den Index, sobald das Programm endet.
• Fehlende Fehlerbehandlung: API-Aufrufe, besonders bei Ollama, können wegen Zeitlimits oder Speicherproblemen abbrechen. Plane try-except-Blöcke ein.
• Veraltete Imports: LlamaIndex verändert Importpfade. Achte bei Tutorials auf die Version und installiere passende Pakete.

Hardware, Kosten und Sicherheit

LlamaIndex selbst ist kostenlos und Open Source. Kosten entstehen durch Cloud-APIs oder Deine eigene Hardware. Für den lokalen Betrieb zahlst Du für RAM, GPU und Strom, aber nicht pro Aufruf. Ein 7B-Modell läuft dank Quantisierung oft auf 8 GB VRAM. Größere Modelle oder viele parallele Anfragen benötigen deutlich mehr.

Bei RAG kommt zusätzliche Last durch Embeddings und den Vector Store hinzu. Das ist in der Regel vernachlässigbar, solange der Index nicht extrem groß wird. Sicherheit spielt eine Rolle, sobald Du sensible Dokumente verarbeitest. Nutze für vertrauliche Daten lokale Modelle und achte auf Zugriffsrechte am Dateisystem. Weitere Sicherheitstipps findest Du im Artikel Ollama.

Weiterführende Links

• Entwicklungs-Tools Übersicht für verwandte Frameworks.
• LangChain als Alternative für Chains und Agenten.
• Lokales RAG für den Gesamtkontext.
• RAG Grundlagen für die Theorie.
• Vektordatenbanken zur Auswahl eines passenden Speichers.
• Embedding-Modelle für Hintergründe zu Embeddings.
• Ollama für den lokalen Modellbetrieb.
• Was ist ein KI-Agent für Agentenkonzepte.

FAQ

Ist LlamaIndex kostenlos?

Ja, das Framework ist Open Source. Kosten fallen nur für APIs, Cloud-Hosting oder Deine eigene Hardware an.

Was ist der Unterschied zwischen LlamaIndex und LangChain?

LlamaIndex fokussiert sich auf RAG, Data Ingestion und Indexing. LangChain ist ein allgemeineres Framework für Chains, Tools und Agenten.

Kann ich LlamaIndex lokal betreiben?

Ja. Mit Ollama und lokalen Embedding-Modellen bleiben alle Daten auf Deinem Rechner.

Welche Datenformate unterstützt LlamaIndex?

PDFs, Textdateien, Markdown, Word-Dokumente, Webseiten und viele weitere über zusätzliche Loader.

Was ist ein Node?

Ein Node ist ein einzelner Chunk aus einem Dokument, der mit einem Embedding abgelegt werden kann.

Wie wähle ich ein Embedding-Modell?

Achte auf das Sprachgebiet und die Domäne Deiner Daten. nomic-embed-text funktioniert lokal gut und ist vielseitig einsetzbar.

Was ist eine Query Engine?

Die Query Engine führt Retrieval und Antwortgenerierung zusammen: Sie findet passende Nodes und ruft das LLM mit dem Kontext auf.

Wie baue ich einen Agenten?

Du erstellst Tools aus Python-Funktionen oder Query Engines und übergibst sie an einen ReActAgent.

Kann ich den Index speichern?

Ja. Mit storage_context.persist legst Du den Index lokal ab und lädst ihn später wieder.

Ist Python 3.9 ausreichend?

Ja, Python 3.9 oder neuer wird empfohlen.

Wie schnell ist RAG mit LlamaIndex?

Das hängt vom Modell, der Dokumentenmenge und der Hardware ab. Kleine lokale RAG-Systeme antworten oft innerhalb weniger Sekunden.

Gibt es Alternativen?

Ja. LangChain, Haystack und DSPy sind weitere Optionen.

Quellen

• LlamaIndex Documentation: https://docs.llamaindex.ai/
• LlamaIndex GitHub: https://github.com/run-llama/llama_index
• Ollama LlamaIndex LLM Integration: https://docs.llamaindex.ai/en/stable/examples/llm/ollama/
• Ollama LlamaIndex Embeddings: https://docs.llamaindex.ai/en/stable/examples/embeddings/ollama/
• ReAct Agent Example: https://docs.llamaindex.ai/en/stable/examples/agent/react_agent/