LlamaIndex met de Gemini API

LlamaIndex en Gemini

LlamaIndex is een framework dat specifiek is gebouwd voor RAG (Retrieval-Augmented Generation) en data-gebaseerde AI-applicaties. Waar LangChain algemener is, focust LlamaIndex op het efficient doorzoekbaar maken van grote hoeveelheden documenten voor gebruik als context in LLM-prompts.

Je combineert Gemini hierin op twee plekken: als LLM dat de antwoorden genereert, en als embedding-model dat je documenten omzet naar vectoren voor retrieval.

Installatie

pip install llama-index llama-index-llms-google-genai llama-index-embeddings-google-genai

Basisinstellingen

import os
from llama_index.llms.google_genai import GoogleGenAI
from llama_index.embeddings.google_genai import GoogleGenAIEmbedding
from llama_index.core import Settings

Settings.llm = GoogleGenAI(
    model="gemini-2.5-flash",
    api_key=os.environ["GEMINI_API_KEY"],
    temperature=0.1
)

Settings.embed_model = GoogleGenAIEmbedding(
    model_name="gemini-embedding-001",
    api_key=os.environ["GEMINI_API_KEY"],
    embed_batch_size=100
)

Documenten indexeren

from llama_index.core import SimpleDirectoryReader, VectorStoreIndex

documenten = SimpleDirectoryReader("./documenten/").load_data()

index = VectorStoreIndex.from_documents(
    documenten,
    show_progress=True
)

index.storage_context.persist(persist_dir="./opgeslagen_index")

SimpleDirectoryReader leest een hele map met documenten in en herkent automatisch veelvoorkomende bestandstypen. Met persist schrijf je de index naar schijf, zodat je niet bij elke run opnieuw hoeft te embedden.

Query engine gebruiken

from llama_index.core import StorageContext, load_index_from_storage

storage_context = StorageContext.from_defaults(persist_dir="./opgeslagen_index")
index = load_index_from_storage(storage_context)

query_engine = index.as_query_engine(
    similarity_top_k=3,
    response_mode="tree_summarize"
)

response = query_engine.query("Wat zijn de openingstijden van de klantenservice?")
print(response)

print("Bronnen:")
for node in response.source_nodes:
    print(f"Score: {node.score:.4f} | {node.metadata.get('file_name', 'onbekend')}")

De source_nodes op het antwoord laten zien welke chunks zijn gebruikt en met welke score. Dat is essentieel om te controleren of het model zijn antwoord echt op je documenten baseert en niet hallucineert.

Chat engine voor conversationele RAG

chat_engine = index.as_chat_engine(
    chat_mode="condense_plus_context",
    similarity_top_k=3,
    system_prompt="Je bent een expert over onze producten. Gebruik alleen informatie uit de documenten."
)

response1 = chat_engine.chat("Wat is de garantie op laptops?")
print(response1)

response2 = chat_engine.chat("En geldt dat ook voor tablets?")
print(response2)

De modus condense_plus_context herschrijft de vervolgvraag eerst tot een zelfstandige vraag (zodat "geldt dat ook voor tablets" begrijpelijk wordt) en haalt daarna pas relevante context op. Zo blijft een gesprek met meerdere beurten coherent.

Documenten per type laden

from llama_index.core import Document
from llama_index.readers.file import PDFReader
from llama_index.readers.web import SimpleWebPageReader

pdf_reader = PDFReader()
pdf_docs = pdf_reader.load_data("handleiding.pdf")

web_reader = SimpleWebPageReader()
web_docs = web_reader.load_data(["https://docs.example.com/api"])

custom_doc = Document(
    text="Onze retourpolicy: 30 dagen retourneren zonder opgaaf van reden.",
    metadata={"bron": "retourbeleid", "datum": "2024-01"}
)

alle_docs = pdf_docs + web_docs + [custom_doc]
index = VectorStoreIndex.from_documents(alle_docs)

Metadata filtering

Met metadata-filters beperk je het zoeken tot een specifieke deelverzameling, bijvoorbeeld alleen documenten in een bepaalde categorie. Dat maakt antwoorden preciezer en sneller.

from llama_index.core.vector_stores import MetadataFilters, ExactMatchFilter

query_engine = index.as_query_engine(
    filters=MetadataFilters(
        filters=[
            ExactMatchFilter(key="categorie", value="garantie")
        ]
    ),
    similarity_top_k=5
)

response = query_engine.query("Hoe lang is de garantietermijn?")

Geavanceerde retrieval: HyDE

Hypothetical Document Embeddings (HyDE) verbetert retrieval door eerst een hypothetisch antwoord te genereren en dat te embedden. De embedding van een volzin lijkt vaak meer op je documenten dan de embedding van een korte vraag, waardoor je relevantere chunks terugvindt.

from llama_index.core.indices.query.query_transform import HyDEQueryTransform
from llama_index.core.query_engine import TransformQueryEngine

hyde_transform = HyDEQueryTransform(include_original=True)
hyde_engine = TransformQueryEngine(query_engine, hyde_transform)

response = hyde_engine.query("Welke producten hebben 2 jaar garantie?")

Index opslaan in een vectordatabase

Voor productie wil je je vectoren niet op schijf in losse bestanden, maar in een echte vectordatabase. Hieronder een voorbeeld met Chroma.

import chromadb
from llama_index.vector_stores.chroma import ChromaVectorStore
from llama_index.core import StorageContext

chroma_client = chromadb.PersistentClient(path="./chroma_db")
collection = chroma_client.get_or_create_collection("kennisbank")

vector_store = ChromaVectorStore(chroma_collection=collection)
storage_context = StorageContext.from_defaults(vector_store=vector_store)

index = VectorStoreIndex.from_documents(
    documenten,
    storage_context=storage_context
)

Praktisch voorbeeld: kennisbank-chatbot

Een complete minimale flow voor een interne kennisbank ziet er zo uit: