LlamaIndex einrichten: Ein praktischer Leitfaden für Enterprise-AI-Teams

# Kernpaket installieren (minimale Abhängigkeiten)
pip install llama-index-core

# Vollständige Suite installieren (inkl. Multi-Modal, Agents usw.)
pip install llama-index

# Installation überprüfen
python -c "from llama_index.core import VectorStoreIndex; print('LlamaIndex v0.10.28 bereit')"
# Erwartete Ausgabe: LlamaIndex v0.10.28 bereit

npm install llamaindex
# oder
yarn add llamaindex

# Installation überprüfen
node -e "const { VectorStoreIndex } = require('llamaindex'); console.log('LlamaIndex.TS v0.3.12 bereit')"
# Erwartete Ausgabe: LlamaIndex.TS v0.3.12 bereit

from llama_index.core import SimpleDirectoryReader

# Dokumente aus einem Verzeichnis laden (unterstützt PDF, DOCX, CSV usw.)
documents = SimpleDirectoryReader("data/").load_data()
print(f"{len(documents)} Dokumente geladen")
# Erwartete Ausgabe: 3 Dokumente geladen

# In Knoten parsen (Chunks mit Metadaten)
from llama_index.core.node_parser import SentenceSplitter
parser = SentenceSplitter(chunk_size=512, chunk_overlap=20)
nodes = parser.get_nodes_from_documents(documents)
print(f"{len(nodes)} Knoten erstellt")
# Erwartete Ausgabe: 42 Knoten erstellt

from llama_index.core import VectorStoreIndex

# Einen Vektorindex erstellen (verwendet standardmäßig OpenAI-Embeddings)
index = VectorStoreIndex.from_documents(documents)

# Auf Festplatte speichern
index.storage_context.persist("storage/")

INFO:llama_index.core.storage.storage_context:VectorStoreIndex in storage/ gespeichert

from llama_index.core import KeywordTableIndex

keyword_index = KeywordTableIndex.from_documents(documents)

from llama_index.core import TreeIndex

tree_index = TreeIndex.from_documents(documents)
# Abfrage mit Kind-Zweig-Traversierung
query_engine = tree_index.as_query_engine(child_branch_factor=2)
response = query_engine.query("Fassen Sie die wichtigsten Punkte zusammen")
print(response)

query_engine = index.as_query_engine()
response = query_engine.query("Welche Risiken birgt KI im Jahr 2026?")
print(response)

Die Risiken von KI im Jahr 2026 umfassen:
1. Arbeitsplatzverluste in kreativen Branchen.
2. Zunahme von Desinformation durch Deepfakes.
3. Regulatorische Lücken bei Multi-Modal-Modellen.
Quelle: data/report.pdf (Seite 42)

from llama_index.core import QueryBundle
from llama_index.core.retrievers import BaseRetriever

class HybridRetriever(BaseRetriever):
    def __init__(self, vector_index, keyword_index):
        self.vector_retriever = vector_index.as_retriever()
        self.keyword_retriever = keyword_index.as_retriever()

    def _retrieve(self, query_bundle: QueryBundle):
        vector_nodes = self.vector_retriever.retrieve(query_bundle)
        keyword_nodes = self.keyword_retriever.retrieve(query_bundle)
        return vector_nodes + keyword_nodes

retriever = HybridRetriever(index, keyword_index)
query_engine = index.as_query_engine(retriever=retriever)

from llama_index.core import get_response_synthesizer
from llama_index.core.retrievers import BaseRetriever
from llama_index.core.schema import NodeWithScore
from typing import List

class TimeBasedRetriever(BaseRetriever):
    def __init__(self, index, time_field="date"):
        self.index = index
        self.time_field = time_field

    def _retrieve(self, query_bundle: QueryBundle) -> List[NodeWithScore]:
        # Knoten nach Zeit filtern (z. B. "Dokumente aus 2025-2026")
        nodes = self.index.docstore.get_nodes()
        filtered_nodes = [
            node for node in nodes
            if node.metadata.get(self.time_field, "").startswith("2025")
        ]
        return [NodeWithScore(node=node, score=1.0) for node in filtered_nodes]

retriever = TimeBasedRetriever(index)
query_engine = index.as_query_engine(retriever=retriever)

from llama_index.core.evaluation import (
    generate_question_context_pairs,
    EmbeddingQAFinetuneDataset,
)
from llama_index.evaluation import RetrieverEvaluator

# Synthetische Frage-Antwort-Paare generieren
qa_dataset = generate_question_context_pairs(documents, num_questions_per_chunk=2)

# Retriever evaluieren
retriever = index.as_retriever(similarity_top_k=2)
evaluator = RetrieverEvaluator.from_metric_names(
    ["mrr", "hit_rate"], retriever=retriever
)
eval_results = await evaluator.aevaluate_dataset(qa_dataset)
print(eval_results)

{'mrr': 0.85, 'hit_rate': 0.92}

from fastapi import FastAPI
from llama_index.core import VectorStoreIndex
from pydantic import BaseModel

app = FastAPI()
index = VectorStoreIndex.from_documents(documents)

class QueryRequest(BaseModel):
    query: str

@app.post("/query")
async def query_index(request: QueryRequest):
    query_engine = index.as_query_engine()
    response = query_engine.query(request.query)
    return {"response": str(response)}

# Ausführen mit: uvicorn app:app --reload

{
  "response": "Die Risiken von KI im Jahr 2026 umfassen Arbeitsplatzverluste und Desinformation."
}

from llama_index.core.callbacks import CallbackManager
from llama_index.callbacks.arize_ai import ArizeCallbackHandler

arize_callback = ArizeCallbackHandler(
    api_key="...",
    space_key="...",
)
callback_manager = CallbackManager([arize_callback])
index = VectorStoreIndex.from_documents(
    documents, callback_manager=callback_manager
)

from llama_index.indices.managed.llama_cloud import LlamaCloudIndex

index = LlamaCloudIndex.from_documents(
    documents,
    name="my-production-index",
    project_name="my-project",
    api_key="llx-...",
)