LlamaIndex en pratique

LlamaIndex est le framework RAG le plus mature pour Python. Là où ChromaDB + sentence-transformers à la main demandent 80 lignes de code, LlamaIndex en réclame 10, tout en offrant des features avancées : multi-documents, agents, query engines hiérarchiques. Ce guide installe, fait un RAG local minimal, et montre ce qui dépasse la simple recherche vectorielle.

Par Mohamed Meguedmi·Màj 2026-03-15·Testé sur Windows, macOS, Linux

#Pourquoi LlamaIndex

Abstractions claires: Document, Node, VectorStoreIndex, QueryEngine. Chaque concept a sa place, pas de magie cachée.
250+ connecteurs: Notion, Google Drive, Slack, Confluence, bases SQL… via llama-hub. Prêts à l'emploi.
Query engines avancés: Sub-question, tree-summarize, routeur, multi-step. Là où ChromaDB s'arrête, LlamaIndex commence.
Fait vraiment le local: Contrairement à LangChain qui penche OpenAI-first, LlamaIndex expose Ollama et les embeddings HF comme citoyens de première classe.

#1. Installation

Core + providers Ollama/HF

pip install llama-index \
            llama-index-llms-ollama \
            llama-index-embeddings-huggingface \
            llama-index-readers-file

#2. RAG en 10 lignes

rag.py (avec OpenAI par défaut)

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader

docs = SimpleDirectoryReader("./docs").load_data()
index = VectorStoreIndex.from_documents(docs)

query = index.as_query_engine()
print(query.query("Résume les points clés du contrat X"))

OpenAI par défaut

Sans configuration explicite, LlamaIndex tape chez OpenAI (embeddings text-embedding-ada et GPT-4o-mini). Pour du 100 % local, suivez la section suivante.

#3. Full local (Ollama + embeddings HF)

rag_local.py

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, Settings
from llama_index.llms.ollama import Ollama
from llama_index.embeddings.huggingface import HuggingFaceEmbedding

# Configuration globale : tout est local
Settings.llm = Ollama(
    model="mistral",
    base_url="http://localhost:11434",
    request_timeout=120.0,
)
Settings.embed_model = HuggingFaceEmbedding(model_name="BAAI/bge-m3")
Settings.chunk_size = 700
Settings.chunk_overlap = 100

# Pipeline
docs = SimpleDirectoryReader("./docs").load_data()
index = VectorStoreIndex.from_documents(docs, show_progress=True)

# Persister
index.storage_context.persist(persist_dir="./storage")

# Requêter
query_engine = index.as_query_engine(similarity_top_k=5)
reponse = query_engine.query("Quels sont les risques identifiés ?")
print(reponse)
for src in reponse.source_nodes:
    print(f"  - {src.metadata.get('file_name')} ({src.score:.2f})")

Recharger un index existant

from llama_index.core import load_index_from_storage, StorageContext

storage = StorageContext.from_defaults(persist_dir="./storage")
index = load_index_from_storage(storage)

#4. Charger des sources variées

Notion, Slack, GitHub…

# Notion
from llama_index.readers.notion import NotionPageReader
docs = NotionPageReader(integration_token=TOKEN).load_data(page_ids=["abc"])

# GitHub (issues, code)
from llama_index.readers.github import GithubRepositoryReader
docs = GithubRepositoryReader(github_token=TOKEN, owner="org", repo="proj").load_data()

# Confluence
from llama_index.readers.confluence import ConfluenceReader
docs = ConfluenceReader(base_url=URL, user_name=EMAIL, api_token=TOK).load_data()

Tout reste local

Les loaders vont chercher les données en ligne (forcément, c'est Notion ou Slack). Mais dès que c'est chargé, l'indexation et la requête sont 100 % locales via vos embeddings et votre LLM Ollama.

#5. Différents modes de requête

similarity_top_k: Classique : top-k passages, LLM résume. Bon défaut.
response_mode="tree_summarize": Pour des questions qui demandent de synthétiser beaucoup de passages : résume par groupes, puis résume les résumés.
SubQuestionQueryEngine: Décompose une question complexe en sous-questions. "Compare les stratégies 2024 et 2025" → deux requêtes séparées + synthèse.
RouterQueryEngine: Route la question vers le bon sous-index (ex : contrats vs jurisprudence).

#6. Agents et tool use

LlamaIndex permet de transformer votre index en un outil pour un agent qui peut aussi faire des calculs, appeler des APIs, etc.

Agent avec tool RAG

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

tool = QueryEngineTool.from_defaults(
    query_engine=query_engine,
    name="contrats",
    description="Répond aux questions sur les contrats clients.",
)

agent = ReActAgent.from_tools([tool], llm=Settings.llm, verbose=True)
print(agent.chat("Y a-t-il une clause de non-concurrence chez Acme Corp ?"))

#LlamaIndex vs LangChain

LlamaIndex: Orienté données/RAG. APIs plus stables. Documentation plus claire pour le use-case "discuter avec mes docs".
LangChain: Orienté orchestration. Plus flexible, plus verbeux. Meilleur pour agents complexes avec beaucoup d'outils externes.
Règle empirique: RAG pur → LlamaIndex. Agents multi-outils avec logique complexe → LangChain ou LlamaIndex Workflows.

Ce guide vous a aidé ?

Un retour, une erreur, une précision ? Faites-nous signe, ça améliore le guide pour tout le monde.

Suite logique

RAG · 25 min