Comment Configurer LlamaIndex : Guide Pratique pour les Équipes IA en Entreprise

# Installer le package de base (dépendances minimales)
pip install llama-index-core

# Installer la suite complète (inclut multimodal, agents, etc.)
pip install llama-index

# Vérifier l'installation
python -c "from llama_index.core import VectorStoreIndex; print('LlamaIndex v0.10.28 prêt')"
# Sortie attendue : LlamaIndex v0.10.28 ready

npm install llamaindex
# ou
yarn add llamaindex

# Vérifier l'installation
node -e "const { VectorStoreIndex } = require('llamaindex'); console.log('LlamaIndex.TS v0.3.12 prêt')"
# Sortie attendue : LlamaIndex.TS v0.3.12 ready

from llama_index.core import SimpleDirectoryReader

# Charger des documents depuis un répertoire (supporte PDF, DOCX, CSV, etc.)
documents = SimpleDirectoryReader("data/").load_data()
print(f"{len(documents)} documents chargés")
# Sortie attendue : Loaded 3 documents

# Parser en nœuds (morceaux avec métadonnées)
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)} nœuds créés")
# Sortie attendue : Created 42 nodes

from llama_index.core import VectorStoreIndex

# Créer un index vectoriel (utilise les embeddings OpenAI par défaut)
index = VectorStoreIndex.from_documents(documents)

# Persister sur disque
index.storage_context.persist("storage/")

INFO:llama_index.core.storage.storage_context:Saved VectorStoreIndex to 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)
# Interroger avec un parcours de branche enfant
query_engine = tree_index.as_query_engine(child_branch_factor=2)
response = query_engine.query("Résumez les points clés")
print(response)

query_engine = index.as_query_engine()
response = query_engine.query("Quels sont les risques de l'IA en 2026 ?")
print(response)

Les risques de l'IA en 2026 incluent :
1. Le déplacement d'emplois dans les industries créatives.
2. L'augmentation de la désinformation via les deepfakes.
3. Les lacunes réglementaires dans les modèles multimodaux.
Source : data/rapport.pdf (page 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]:
        # Filtrer les nœuds par temps (ex. "documents de 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

# Générer des paires Q&A synthétiques
qa_dataset = generate_question_context_pairs(documents, num_questions_per_chunk=2)

# Évaluer le récupérateur
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)}

# Exécuter avec : uvicorn app:app --reload

{
  "response": "Les risques de l'IA en 2026 incluent le déplacement d'emplois et la désinformation."
}

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