LlamaIndex Expliqué Simplement : Comment Connecter ChatGPT à vos Documents
Vous voulez que ChatGPT réponde sur vos documents, avec vos données ? C'est exactement ce que permet LlamaIndex. Ce framework est le pont entre les modèles de langage et vos données privées. Décryptage simple et tutoriel inclus.
Le problème que résout LlamaIndex
Les LLM comme GPT-4o ou Claude sont puissants, mais ils ont une limite fondamentale : ils ne connaissent que les données sur lesquelles ils ont été entraînés. Ils ne savent rien de vos documents internes, de votre base de connaissances ou de vos données métier.
C'est le problème du contexte privé. LlamaIndex est conçu pour le résoudre.
Le RAG en résumé
Le RAG (Retrieval-Augmented Generation) est la technique qui consiste à :
- Récupérer des documents pertinents en réponse à une question
- Augmenter le prompt du LLM avec ces documents
- Générer une réponse basée sur ce contexte
LlamaIndex est le framework le plus populaire pour implémenter le RAG.
Pour une comparaison avec d'autres frameworks RAG, consultez RAGFlow vs LlamaIndex.
Architecture de LlamaIndex
Les 5 composants fondamentaux
Vos données → Data Connectors → Documents → Index → Query Engine → Réponses
| Composant | Rôle | Analogie |
|---|---|---|
| Data Connectors | Chargement des données | Le livreur qui apporte les documents |
| Documents/Nodes | Structure des données | Les pages et paragraphes classés |
| Index | Organisation pour la recherche | Le sommaire et l'index du livre |
| Retrievers | Recherche des passages pertinents | Le bibliothécaire qui trouve les bonnes pages |
| Query Engine | Génération de la réponse | L'expert qui synthétise l'information |
Flux de données détaillé
- Ingestion : Les connecteurs chargent vos données (PDF, SQL, Notion, etc.)
- Transformation : Les documents sont découpés en "nodes" (chunks)
- Indexation : Les nodes sont indexés (vectorisation ou structure)
- Requête : L'utilisateur pose une question
- Retrieval : L'index retourne les nodes les plus pertinents
- Génération : Le LLM produit une réponse basée sur les nodes retrouvés
Les Data Connectors
Qu'est-ce qu'un Data Connector ?
Un Data Connector (connecteur de données) est un module qui sait lire un format de données spécifique et le convertir au format interne de LlamaIndex.
Connecteurs populaires
| Connecteur | Source | Installation |
|---|---|---|
| SimpleDirectoryReader | Fichiers locaux (PDF, TXT, MD, etc.) | Intégré |
| DatabaseReader | PostgreSQL, MySQL, SQLite | pip install llama-index-readers-database |
| NotionPageReader | Pages Notion | pip install llama-index-readers-notion |
| WebPageReader | Pages web | pip install llama-index-readers-web |
| SlackReader | Messages Slack | pip install llama-index-readers-slack |
| GitHubReader | Repos GitHub | pip install llama-index-readers-github |
Pour le crawling web avancé, consultez Firecrawl : Comment Transformer N'importe Quel Site Web en Donnée Exploitable.
Exemple de chargement
from llama_index.core import SimpleDirectoryReader
# Charger tous les fichiers d'un dossier
documents = SimpleDirectoryReader("./mes_documents").load_data()
# Résultat : liste de Document objects
print(f"Chargé {len(documents)} documents")
Les Index
Qu'est-ce qu'un Index ?
L'index est la structure de données qui permet de retrouver rapidement les passages pertinents quand une question est posée. C'est le cœur de LlamaIndex.
Types d'index
| Type | Fonctionnement | Quand l'utiliser |
|---|---|---|
| VectorStoreIndex | Embeddings + similarité cosinus | Usage général, le plus courant |
| SummaryIndex | Stocke tous les nodes en séquence | Résumé de documents complets |
| KeywordTableIndex | Table de mots-clés → nodes | Recherche par mots-clés exacts |
| TreeIndex | Arbre hiérarchique de résumés | Exploration de documents volumineux |
| PropertyGraphIndex | Graphe de propriétés | Données relationnelles, knowledge graph |
Le VectorStoreIndex en détail
Le VectorStoreIndex est le plus utilisé. Il fonctionne ainsi :
- Chaque node (chunk de texte) est converti en vecteur (embedding)
- Les vecteurs sont stockés dans un vector store
- Quand une question est posée, elle est aussi vectorisée
- Les nodes les plus similaires (similarité cosinus) sont retrouvés
- Ces nodes forment le contexte passé au LLM
Exemple de création d'index
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
# Charger les documents
documents = SimpleDirectoryReader("./mes_documents").load_data()
# Créer l'index (vectorise automatiquement)
index = VectorStoreIndex.from_documents(documents)
# Créer le moteur de requêtes
query_engine = index.as_query_engine()
# Poser une question
response = query_engine.query("Quelle est la politique de congés de l'entreprise ?")
print(response)
Les Query Engines
Qu'est-ce qu'un Query Engine ?
Le Query Engine est l'orchestrateur qui combine le retrieval (recherche) et la génération (réponse du LLM). Il gère le prompt, le contexte et la synthèse.
Types de Query Engines
| Type | Description | Usage |
|---|---|---|
| QueryEngine | Question → réponse simple | FAQ, questions factuelles |
| ChatEngine | Conversation avec mémoire | Chatbot interactif |
| SubQuestionQueryEngine | Décompose en sous-questions | Questions complexes multi-documents |
| RouterQueryEngine | Route vers le bon index | Multi-sources, multi-index |
Exemple avec ChatEngine
# Créer un chatbot avec mémoire
chat_engine = index.as_chat_engine(
chat_mode="condense_question",
verbose=True
)
# Conversation
response = chat_engine.chat("Quels sont les avantages du télétravail ?")
print(response)
# Question de suivi (avec contexte)
response = chat_engine.chat("Et les inconvénients ?")
print(response)
Tutoriel complet : RAG sur vos documents
Installation
pip install llama-index llama-index-llms-openai llama-index-embeddings-openai
Configuration
import os
os.environ["OPENAI_API_KEY"] = "votre-clé-api"
# Ou avec Ollama pour un usage local
from llama_index.llms.ollama import Ollama
from llama_index.embeddings.ollama import OllamaEmbedding
llm = Ollama(model="llama3.1:8b")
embed_model = OllamaEmbedding(model="nomic-embed-text")
# Configuration globale
from llama_index.core import Settings
Settings.llm = llm
Settings.embed_model = embed_model
Pour installer Ollama, consultez Ollama : Comment Faire Tourner un LLM en Local.
Pipeline complet
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, Settings
from llama_index.core.node_parser import SentenceSplitter
# 1. Charger les documents
documents = SimpleDirectoryReader("./mes_documents").load_data()
# 2. Découper en chunks
parser = SentenceSplitter(chunk_size=512, chunk_overlap=50)
nodes = parser.get_nodes_from_documents(documents)
# 3. Créer l'index
index = VectorStoreIndex(nodes)
# 4. Créer le moteur de requêtes
query_engine = index.as_query_engine(
similarity_top_k=3, # Récupérer les 3 passages les plus pertinents
response_mode="tree_summarize" # Synthèse structurée
)
# 5. Interroger
response = query_engine.query(
"Quelles sont les procédures pour demander un congé ?"
)
print(response)
# 6. Vérifier les sources
for source_node in response.source_nodes:
print(f"Source : {source_node.metadata['filename']}")
print(f"Score : {source_node.score}")
print(f"Texte : {source_node.text[:200]}...")
Stockage persistant
# Sauvegarder l'index sur disque
index.storage_context.persist("./index_storage")
# Recharger l'index (sans re-vectoriser)
from llama_index.core import load_index_from_storage, StorageContext
storage_context = StorageContext.from_defaults(persist_dir="./index_storage")
index = load_index_from_storage(storage_context)
Optimisations avancées
Chunking : bien découper ses documents
| Stratégie | Taille recommandée | Avantage |
|---|---|---|
| SentenceSplitter | 256-512 tokens | Équilibre standard |
| SemanticSplitter | Variable | Découpe par sens, pas par taille |
| TokenTextSplitter | 128-256 tokens | Chunks petits pour haute précision |
| HierarchicalNodeParser | Multi-niveaux | Contexte local + global |
Retrieval : améliorer la pertinence
# Augmenter le nombre de résultats
query_engine = index.as_query_engine(similarity_top_k=5)
# Utiliser le reranking pour affiner
from llama_index.core.postprocessor import SentenceTransformerRerank
rerank = SentenceTransformerRerank(model="cross-encoder/ms-marco-MiniLM-L-2-v2", top_n=3)
query_engine = index.as_query_engine(
similarity_top_k=10,
node_postprocessors=[rerank]
)
Intégration avec des plateformes no-code
Pour construire des applications RAG sans code, Dify offre un RAG intégré. Pour un framework RAG alternatif, consultez RAGFlow vs LlamaIndex. Pour automatiser l'ingestion de données web, Firecrawl est un excellent complément.
FAQ
Quelle est la différence entre LlamaIndex et LangChain ?
LlamaIndex se concentre spécifiquement sur le RAG (connecter des données à des LLM). LangChain est plus généraliste (agents, chaînes, outils). Pour du RAG pur, LlamaIndex est plus spécialisé et plus simple. Pour des applications complexes multi-étapes, LangChain offre plus de flexibilité.
LlamaIndex fonctionne-t-il avec des modèles locaux ?
Oui, LlamaIndex supporte Ollama, llama.cpp et d'autres backends locaux. Vous pouvez construire un RAG entièrement local et privé. Consultez Ollama : Comment Faire Tourner un LLM en Local pour la configuration.
Quels formats de documents sont supportés ?
LlamaIndex supporte nativement PDF, TXT, Markdown, CSV, DOCX et bien d'autres via ses connecteurs. Pour le web, utilisez Firecrawl pour convertir des sites en données exploitables.
Combien coûte l'utilisation de LlamaIndex ?
LlamaIndex lui-même est gratuit et open source. Les coûts proviennent des API LLM (OpenAI, etc.) et du stockage vectoriel. Avec Ollama, le coût est nul à part l'électricité. Pour les API cloud, comptez 1 à 10$ par million de tokens selon le modèle.
Peut-on utiliser LlamaIndex en production ?
Absolument. LlamaIndex est utilisé en production par des milliers d'entreprises. Pour la production, utilisez un vector store persistant (Qdrant, Weaviate), ajoutez du monitoring, et implémentez des stratégies de cache pour optimiser les coûts et la latence.
Mise à jour — Avril 2026
LlamaIndex a poursuivi sa maturation avec la version 0.12+ qui apporte une architecture modulaire améliorée, de nouveaux connecteurs, et une meilleure gestion des métadonnées. L'intégration avec les modèles locaux via Ollama a été simplifiée. Le framework reste la référence pour le RAG en Python, même si RAGFlow propose une alternative plus orientée UI. Les avancées les plus notables concernent le chunking sémantique (qui améliore significativement la qualité du retrieval) et le support natif du multimodal (documents avec images). Si vous démarrez un projet RAG, LlamaIndex est toujours le choix recommandé pour sa documentation, sa communauté et sa flexibilité. Pour un chatbot RAG clé en main, consultez aussi Construire un Chatbot qui Répond sur vos Documents avec RAGFlow.