LlamaIndex RAG : un assistant sur votre documentation interne, et comment mesurer sa qualité

LlamaIndex RAG auto-hébergé sur vos runbooks et procédures : montez-le pas à pas, puis mesurez hit rate, MRR, fidélité et pertinence des réponses.
LlamaIndex RAG : un assistant sur votre documentation interne, et comment mesurer sa qualité

Construire un RAG LlamaIndex sur votre documentation interne est l’un des projets IA les plus rentables pour une équipe ops : runbooks, procédures d’astreinte, post-mortems et pages de wiki dorment dans des dossiers que personne ne relit au milieu de la nuit. Un assistant fondé sur LlamaIndex (RAG : génération augmentée par récupération), capable de retrouver le bon passage et de citer sa source, fait gagner de précieuses minutes pendant un incident.

Le piège est connu : un prototype de RAG impressionne en démo, puis répond à côté dès qu’on lui pose une vraie question. La différence entre les deux ne tient pas au modèle, mais à la mesure. Sans jeu de questions de référence ni métriques de récupération, on modifie la taille des fragments ou le modèle d’embedding à l’aveugle.

Cet article montre comment monter un RAG LlamaIndex auto-hébergé sur une documentation interne, puis comment évaluer sa qualité de façon reproductible. Il s’inscrit dans notre comparatif des briques IA open source auto-hébergées.

Pourquoi LlamaIndex pour un RAG sur documentation interne ?

LlamaIndex est un framework Python (il existe aussi une version TypeScript) centré sur la connexion entre des données et un LLM. Là où d’autres frameworks se concentrent sur l’orchestration d’agents, LlamaIndex met l’accent sur l’ingestion, le découpage, l’indexation et l’interrogation de documents. C’est précisément le cœur d’un RAG (Retrieval-Augmented Generation).

Ses briques principales :

  • Readers : chargent des fichiers (Markdown, PDF, HTML…) ou des sources externes via des connecteurs ;
  • Node parsers : découpent les documents en fragments (nodes) avec leurs métadonnées ;
  • Index : le plus courant, VectorStoreIndex, calcule des embeddings et les range dans un magasin vectoriel ;
  • Query engines et retrievers : récupèrent les fragments pertinents et construisent la réponse ;
  • Module d’évaluation : des évaluateurs prêts à l’emploi pour la fidélité, la pertinence et la qualité de la récupération.

Le projet est modulaire : le cœur s’installe avec llama-index-core, et chaque intégration (LLM, embeddings, base vectorielle) est un paquet séparé. Pour rester entièrement en interne, on peut s’appuyer sur un modèle servi localement par Ollama.

Architecture cible : LlamaIndex, RAG et sources internes

Pour une documentation de quelques milliers de pages, une architecture simple suffit :

  1. un export de la documentation en Markdown ou HTML dans un dossier versionné ;
  2. un script d’ingestion qui découpe, calcule les embeddings et persiste l’index ;
  3. un service de requête qui charge l’index et interroge un LLM local ;
  4. un jeu d’évaluation rejoué à chaque changement de configuration.

Le stockage par défaut de LlamaIndex est en mémoire, persistable sur disque. Au-delà d’un certain volume, ou pour partager l’index entre plusieurs instances, une base vectorielle dédiée (Qdrant, pgvector, Chroma, etc.) prend le relais via le paquet d’intégration correspondant.

En pratique : monter un RAG LlamaIndex pas à pas

Étape 1 — Installer les paquets

On installe le cœur et les intégrations Ollama pour le LLM et les embeddings. Vérifiez les noms exacts dans la documentation, car les intégrations évoluent.

python -m venv .venv && source .venv/bin/activate
pip install llama-index-core llama-index-llms-ollama llama-index-embeddings-ollama
ollama pull llama3.1
ollama pull nomic-embed-text

Étape 2 — Configurer le LLM et le modèle d’embedding

L’objet Settings fixe les valeurs par défaut utilisées par tous les composants. Le modèle d’embedding doit rester le même entre l’ingestion et la requête.

from llama_index.core import Settings
from llama_index.llms.ollama import Ollama
from llama_index.embeddings.ollama import OllamaEmbedding

Settings.llm = Ollama(model="llama3.1", request_timeout=120.0)
Settings.embed_model = OllamaEmbedding(model_name="nomic-embed-text")
Settings.chunk_size = 512
Settings.chunk_overlap = 64

Étape 3 — Ingérer et persister l’index

from llama_index.core import SimpleDirectoryReader, VectorStoreIndex

docs = SimpleDirectoryReader("./docs-internes", recursive=True).load_data()
index = VectorStoreIndex.from_documents(docs, show_progress=True)
index.storage_context.persist(persist_dir="./storage")

Le lecteur conserve le chemin du fichier dans les métadonnées de chaque fragment : c’est ce qui permettra de citer la source dans la réponse.

Étape 4 — Interroger et afficher les sources

from llama_index.core import StorageContext, load_index_from_storage

ctx = StorageContext.from_defaults(persist_dir="./storage")
index = load_index_from_storage(ctx)
engine = index.as_query_engine(similarity_top_k=4)

resp = engine.query("Comment redémarrer le collecteur de logs en production ?")
print(resp)
for node in resp.source_nodes:
    print(round(node.score or 0, 3), node.metadata.get("file_path"))

Afficher systématiquement les sources et leur score est la première mesure de qualité : un utilisateur d’astreinte doit pouvoir vérifier d’un clic.

Étape 5 — Construire un jeu d’évaluation

Deux approches se complètent. La première : rédiger à la main 30 à 50 questions réelles (tirées des tickets ou des canaux d’astreinte) avec le document attendu. La seconde : générer des paires question/contexte à partir des fragments, avec un générateur de jeux de données de LlamaIndex (par exemple DatasetGenerator du module d’évaluation ; les utilitaires disponibles varient selon les versions), puis les relire. Les questions générées sont souvent trop proches du texte ; les questions humaines révèlent les vrais trous.

Étape 6 — Mesurer la récupération et la génération

On évalue séparément les deux étages du RAG :

  • Récupération : le bon fragment figure-t-il dans les résultats ? Le RetrieverEvaluator calcule notamment le hit rate et le MRR (rang réciproque moyen).
  • Génération : la réponse est-elle fidèle au contexte récupéré (FaithfulnessEvaluator) et pertinente vis-à-vis de la question (RelevancyEvaluator) ?
from llama_index.core.evaluation import (
    FaithfulnessEvaluator, RelevancyEvaluator, RetrieverEvaluator)

retriever = index.as_retriever(similarity_top_k=4)
ret_eval = RetrieverEvaluator.from_metric_names(
    ["hit_rate", "mrr"], retriever=retriever)

faith = FaithfulnessEvaluator()
relev = RelevancyEvaluator()
resp = engine.query(question)
print(faith.evaluate_response(response=resp).passing,
      relev.evaluate_response(query=question, response=resp).passing)

Les évaluateurs de génération utilisent eux-mêmes un LLM comme juge. Avec un petit modèle local, leurs verdicts sont bruités : utilisez-les pour comparer deux configurations sur le même jeu, pas comme une note absolue. Les signatures exactes peuvent varier selon la version ; la documentation officielle de LlamaIndex fait foi.

Comment mesurer la qualité d’un RAG dans la durée ?

L’évaluation hors ligne ne suffit pas. En production, trois familles de signaux comptent :

  • Qualité perçue : retours utilisateurs (pouce haut ou bas), questions reformulées juste après une réponse, taux de réponses « je ne sais pas » ;
  • Qualité de récupération : distribution des scores de similarité, part des requêtes dont le meilleur score est sous un seuil (signe d’un sujet non documenté) ;
  • Performance et coût : latence de récupération et de génération séparées, tokens consommés par requête, taille du contexte injecté.

LlamaIndex expose des points d’instrumentation qui permettent d’envoyer ces étapes sous forme de traces OpenTelemetry, via des bibliothèques comme OpenLLMetry ou OpenInference. Nous détaillons la mise en place dans l’article Langfuse et OpenLLMetry. Pour relier ces traces au reste de votre application, voir aussi OpenTelemetry de bout en bout.

Bonnes pratiques

  • Nettoyez la source avant d’indexer : pages obsolètes, doublons et brouillons dégradent plus la qualité qu’un mauvais modèle.
  • Ajoutez des métadonnées utiles (équipe propriétaire, date de mise à jour, environnement) et filtrez dessus à la requête.
  • Versionnez ensemble l’index, le modèle d’embedding, la taille des fragments et le jeu d’évaluation.
  • Ne changez qu’un paramètre à la fois et rejouez l’évaluation complète.
  • Respectez les droits d’accès : un RAG ne doit pas exposer une page que l’utilisateur ne pourrait pas lire.
  • Demandez au modèle de répondre « je ne sais pas » faute de contexte suffisant, et mesurez ce taux.

Questions fréquentes

LlamaIndex ou LangChain pour un RAG ?

Les deux savent faire du RAG. LlamaIndex est plus spécialisé dans l’ingestion et l’indexation de documents ; LangChain et LangGraph sont plus orientés orchestration et agents. Notre article LangChain et LangGraph détaille ce second usage.

Faut-il une base vectorielle dédiée ?

Pas pour démarrer : la persistance sur disque suffit pour un prototype. Une base dédiée devient utile dès que l’index est volumineux, partagé entre plusieurs instances ou mis à jour en continu.

Combien de questions pour évaluer un RAG ?

Quelques dizaines de questions réelles et représentatives suffisent pour comparer des configurations. L’important est de garder le même jeu d’une version à l’autre et de l’enrichir avec les échecs constatés en production.

Conclusion

Un RAG LlamaIndex sur documentation interne se monte en quelques dizaines de lignes. Ce qui le rend fiable, c’est la discipline autour : sources propres, jeu d’évaluation versionné, métriques de récupération et de génération mesurées séparément, puis traces en production. Avec ces garde-fous, l’assistant devient un outil d’astreinte crédible plutôt qu’une démo.

span.observer est un blog indépendant de la communauté, non affilié à Dynatrace LLC ni aux projets cités. Les marques citées appartiennent à leurs propriétaires. Les outils évoluent vite : vérifiez les commandes et options dans leur documentation officielle.

Total
0
Shares
Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Previous Post
Agents LangGraph et LangChain : construire un agent et tracer chacune de ses étapes

Agents LangChain/LangGraph : construire un agent et tracer chacune de ses étapes

Next Post
Dify et n8n : orchestrer des workflows IA open source, cas d'usage ops

Dify et n8n : orchestrer des workflows IA open source, cas d’usage ops

Related Posts