Hoe LlamaIndex op te zetten: Een praktische gids voor enterprise AI-teams

# Installeer het kernpakket (minimale afhankelijkheden)
pip install llama-index-core

# Installeer de volledige suite (inclusief multimodaal, agents, etc.)
pip install llama-index

# Verifieer de installatie
python -c "from llama_index.core import VectorStoreIndex; print('LlamaIndex v0.10.28 gereed')"
# Verwachte uitvoer: LlamaIndex v0.10.28 gereed

npm install llamaindex
# of
yarn add llamaindex

# Verifieer de installatie
node -e "const { VectorStoreIndex } = require('llamaindex'); console.log('LlamaIndex.TS v0.3.12 gereed')"
# Verwachte uitvoer: LlamaIndex.TS v0.3.12 gereed

from llama_index.core import SimpleDirectoryReader

# Laad documenten uit een directory (ondersteunt PDF, DOCX, CSV, etc.)
documents = SimpleDirectoryReader("data/").load_data()
print(f"{len(documents)} documenten geladen")
# Verwachte uitvoer: 3 documenten geladen

# Parseer naar nodes (chunks met metadata)
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)} nodes aangemaakt")
# Verwachte uitvoer: 42 nodes aangemaakt

from llama_index.core import VectorStoreIndex

# Maak een vectorindex aan (gebruikt standaard OpenAI-embeddings)
index = VectorStoreIndex.from_documents(documents)

# Bewaar op schijf
index.storage_context.persist("storage/")

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

from llama_index.core import KeywordTableIndex

keyword_index = KeywordTableIndex.from_documents(documents)

from llama_index.core import TreeIndex

tree_index = TreeIndex.from_documents(documents)
# Voer een query uit met een child-branch-traversal
query_engine = tree_index.as_query_engine(child_branch_factor=2)
response = query_engine.query("Vat de belangrijkste punten samen")
print(response)

query_engine = index.as_query_engine()
response = query_engine.query("Wat zijn de risico's van AI in 2026?")
print(response)

De risico's van AI in 2026 zijn onder andere:
1. Banenverlies in creatieve sectoren.
2. Toename van desinformatie via deepfakes.
3. Regelgevingshiaten bij multimodale modellen.
Bron: data/rapport.pdf (pagina 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]:
        # Filter nodes op tijd (bijv. "documenten uit 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

# Genereer synthetische vraag-antwoordparen
qa_dataset = generate_question_context_pairs(documents, num_questions_per_chunk=2)

# Evalueer retriever
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)}

# Start met: uvicorn app:app --reload

{
  "response": "De risico's van AI in 2026 omvatten banenverlies en desinformatie."
}

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-...",
)