TL;DR
- Installez LlamaIndex en 2 minutes avec
pip install llama-index(Python) ounpm install llamaindex(TypeScript) Guide Complet. - Chargez des documents depuis plus de 200 sources (PDF, SQL, Notion) et parsez-les en nœuds structurés Chargeurs de Données.
- Construisez des pipelines RAG prêts pour la production avec une recherche hybride (vectorielle + par mots-clés) et un réordonnancement Guide RAG.
- Déployez avec une observabilité (Arize, LangSmith) et scalez avec LlamaCloud Inscription.
- Points d'attention : Les grands index nécessitent 16 Go+ de RAM ; le RAG multimodal requiert des APIs payantes Coûts Multimodaux.
1. Installation et Démarrage Rapide
Python (LlamaIndex.Py)
# 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
Version vérifiée depuis GitHub Releases.
Points d'attention :
- Si vous voyez
ImportError: No module named 'llama_index', assurez-vous d'utiliser Python 3.9+ et un environnement virtuel. - Pour une accélération GPU, installez PyTorch en premier :
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118.
TypeScript (LlamaIndex.TS)
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
Support TypeScript documenté dans le Guide TS.
2. Chargement et Parsing des Documents
Charger un PDF et le Parser en Nœuds
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
Documentation des chargeurs de données disponible dans Chargeurs de Données.
Fonctionnalités Clés :
- Plus de 200 connecteurs de données : Chargez depuis Notion, Slack, SQL, et plus encore Chargeurs de Données.
- LlamaParse : API payante pour parser des PDF complexes (tableaux, mises en page multi-colonnes). Niveau gratuit disponible LlamaParse.
from llama_parse import LlamaParse parser = LlamaParse(api_key="llx-...", result_type="markdown") documents = parser.load_data("data/rapport.pdf")
Points d'attention :
- Les PDF volumineux (>100 pages) peuvent expirer avec
SimpleDirectoryReader. UtilisezLlamaParsepour de meilleurs résultats LlamaParse. - Pour les bases de données SQL, utilisez
SQLTableRetrieverQueryEnginepour générer automatiquement des requêtes à partir du langage naturel.
3. Types d'Index
Index Vectoriel (Par défaut pour le RAG)
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/")
Sortie Attendue :
INFO:llama_index.core.storage.storage_context:Saved VectorStoreIndex to storage/
Index par Mots-Clés (Recherche Lexicale)
from llama_index.core import KeywordTableIndex
keyword_index = KeywordTableIndex.from_documents(documents)
Index en Arbre (Résumé Hiérarchique)
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)
Quand Utiliser Lequel :
| Type d'Index | Cas d'Usage | Avantages | Inconvénients |
|---|---|---|---|
| Vectoriel | Recherche sémantique, RAG. | Haute précision, supporte la recherche hybride. | Plus lent pour les grands jeux de données. |
| Mots-Clés | Recherche lexicale (ex. correspondances exactes). | Rapide, pas besoin d'embeddings. | Pas de compréhension sémantique. |
| Arbre | Données hiérarchiques (ex. documents juridiques). | Préserve la structure. | Requêtes complexes. |
Points d'attention :
- Les index vectoriels nécessitent un modèle d'embedding (par défaut : OpenAI's
text-embedding-3-small). Pour des embeddings locaux, utilisezHuggingFaceEmbedding:from llama_index.embeddings.huggingface import HuggingFaceEmbedding embed_model = HuggingFaceEmbedding(model_name="BAAI/bge-small-en-v1.5") index = VectorStoreIndex.from_documents(documents, embed_model=embed_model)
4. Configuration du Moteur de Requête
Moteur de Requête Basique
query_engine = index.as_query_engine()
response = query_engine.query("Quels sont les risques de l'IA en 2026 ?")
print(response)
Sortie Attendue :
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)
Recherche Hybride (Vectorielle + Mots-Clés)
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)
Techniques de récupération avancées documentées dans le Guide RAG.
Points d'attention :
- La recherche hybride ajoute ~200-500 ms de latence. Utilisez
similarity_top_k=2pour limiter les résultats. - Pour la production, ajoutez un réordonnanceur (ex.
CohereRerank) :from llama_index.postprocessor.cohere_rerank import CohereRerank reranker = CohereRerank(api_key="...", top_n=3) query_engine = index.as_query_engine(node_postprocessors=[reranker])
5. Récupérateurs Personnalisés
Construire un Récupérateur Basé sur le Temps
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)
Cas d'Usage :
- ASSESS (Cadre de Posture de Sécurité IA) : Récupérer les logs d'une fenêtre temporelle spécifique pour évaluer l'exposition.
- COMPLY : Filtrer les documents par balises de conformité (ex. "GDPR", "HIPAA").
6. Évaluation et Métriques
Exécuter une Évaluation RAG
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)
Sortie Attendue :
{'mrr': 0.85, 'hit_rate': 0.92}
Métriques Clés :
| Métrique | Description | Valeur Cible |
|---|---|---|
| MRR | Mean Reciprocal Rank. | >0.8 |
| Hit Rate | % de requêtes avec des résultats pertinents. | >0.9 |
| Faithfulness | % de réponses fondées sur le contexte. | >0.95 |
Points d'attention :
- La génération de paires Q&A synthétiques nécessite un LLM (par défaut : OpenAI). Pour une évaluation locale, utilisez
LlamaCPP:from llama_index.llms.llama_cpp import LlamaCPP llm = LlamaCPP(model_path="models/llama-2-7b.Q4_K_M.gguf") qa_dataset = generate_question_context_pairs(documents, llm=llm)
7. Conseils pour le Déploiement en Production
Déployer avec FastAPI
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
Sortie Attendue (API) :
{
"response": "Les risques de l'IA en 2026 incluent le déplacement d'emplois et la désinformation."
}
Observabilité avec Arize
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
)
Fonctionnalités d'observabilité documentées dans Observabilité.
Scaler avec LlamaCloud
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-...",
)
Documentation LlamaCloud disponible à Inscription.
Points d'attention :
- Les index LlamaCloud sont éventuellement cohérents (les mises à jour peuvent prendre ~1 minute).
- Pour le RAG multimodal, utilisez
LlamaCloudMultiModalIndexMultimodal.
Alternatives en Un Coup d'Œil
| Outil | Meilleur Pour | Limite Principale |
|---|---|---|
| LlamaIndex | RAG en entreprise, applications multimodales. | Version TS moins mature [Feuille de Route TS](https://github |
