Qu’est-ce que le RAG Indexing et comment ça fonctionne ?

Qu’est-ce que le RAG Indexing et comment ça fonctionne ?

3 principaux points à retenir.

  • Le RAG Indexing est une chaîne d’ingestion, pas une simple base vectorielle : parsing → chunking → embeddings → index ANN + index lexical. Chaque maillon conditionne la qualité finale des réponses.
  • La pertinence se gagne au retrieval : recherche hybride (BM25 + vecteurs), fusion RRF et reranking par cross-encoder apportent en général un gain net par rapport à la seule similarité cosinus, à condition de le mesurer sur votre corpus.
  • Un index RAG se pilote comme un produit data : métriques de retrieval (Recall@k, MRR), indexation incrémentale, versionnage du modèle d’embedding et des paramètres de chunking.

Qu’est-ce que le RAG Indexing

Le RAG (Retrieval-Augmented Generation) a été formalisé en 2020 par Lewis et al. (Meta AI) dans l’article « Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks ». L’idée : plutôt que de compter uniquement sur la mémoire paramétrique d’un LLM (figée à sa date d’entraînement), on lui fournit au moment de la requête des passages extraits d’une base de connaissances externe. Le modèle génère alors sa réponse conditionnée par ces passages.

Le RAG Indexing désigne la partie amont de ce système : la façon dont on transforme un corpus brut (PDF, pages web, tickets, base Notion, documentation technique, exports CRM…) en une structure interrogeable en quelques millisecondes. C’est la phase la moins visible, et pourtant celle qui explique la majorité des problèmes rencontrés en production : un mauvais découpage ou un mauvais modèle d’embedding, et le meilleur LLM du marché répondra à côté.

Un système RAG se décompose en deux pipelines distincts :

                 ┌──────────────── PIPELINE OFFLINE (indexation) ────────────────┐
  Sources        │                                                               │
 ┌────────┐      │  ┌─────────┐   ┌──────────┐   ┌────────────┐   ┌───────────┐  │
 │ PDF    │─────►│  │ Parsing │──►│ Chunking │──►│ Embeddings │──►│ Index ANN │  │
 │ HTML   │      │  │ + clean │   │ + méta   │   │ (dense)    │   │ (HNSW…)   │  │
 │ Notion │      │  └─────────┘   └────┬─────┘   └────────────┘   └─────┬─────┘  │
 │ SQL    │      │                     └──────►  Index lexical BM25 ────┤        │
 └────────┘      └──────────────────────────────────────────────────────┼────────┘
                                                                        │
                 ┌──────────────── PIPELINE ONLINE (requête) ───────────┼────────┐
                 │                                                      ▼        │
  Question ─────►│ Embedding requête ──► Recherche hybride ──► Reranking ──► Top-k│
                 │                       (dense + BM25, RRF)   (cross-enc.)   │   │
                 │                                                            ▼   │
  Réponse  ◄─────│ ◄──────────── LLM : prompt = consignes + contexte + question    │
  + sources      └────────────────────────────────────────────────────────────────┘

Pourquoi ne pas simplement fine-tuner le modèle ou tout mettre dans une fenêtre de contexte longue ? Parce que ces approches répondent à des besoins différents :

Entre nous, on le sait bien, faire appel à un consultant en automatisation intelligente et en agent IA, c’est souvent le raccourci le plus malin. On en parle ?

Critère RAG Fine-tuning Contexte long (tout dans le prompt)
Données à jour Oui, dès la réindexation Non, nécessite un réentraînement Oui, mais à chaque appel
Traçabilité (citations) Native : chaque passage a une source Faible Possible mais diluée
Coût par requête Faible (quelques chunks) Faible Élevé (des centaines de milliers de tokens)
Volume de corpus Millions de documents Limité par le dataset d’entraînement Limité par la fenêtre du modèle
Contrôle d’accès par utilisateur Oui, via filtres de métadonnées Impossible À gérer manuellement
Ce que ça améliore vraiment Les connaissances factuelles Le style, le format, un comportement Le raisonnement sur un document précis

Retenez cette règle : le fine-tuning apprend une façon de répondre, le RAG apporte de quoi répondre. Les deux se combinent très bien. Et le RAG réduit les hallucinations sans les supprimer : si le retrieval ramène un mauvais passage, le modèle produira une réponse fausse mais bien argumentée. D’où l’importance de soigner l’indexation.

Comment fonctionne l’indexation dans le RAG

Passons à la mécanique. Voici les six étapes d’un pipeline d’indexation de qualité production, avec le code correspondant en Python.

1. Parsing et normalisation des sources

Un PDF n’est pas du texte : c’est une suite d’instructions de positionnement. Tableaux, colonnes, en-têtes de page répétés, notes de bas de page… tout cela pollue les chunks si on extrait le texte naïvement. Quelques outils selon le cas :

  • PyMuPDF : extraction rapide pour les PDF « propres » nés numériques.
  • Docling (IBM, open source) ou Unstructured : détection de la mise en page, des titres et des tableaux, export en Markdown structuré.
  • Apache Tika : couteau suisse multi-formats (DOCX, PPTX, e-mails…).
  • OCR (Tesseract ou un modèle vision) pour les documents scannés.

Mon conseil : convertissez tout en Markdown avant le chunking. La hiérarchie des titres (#, ##, ###) devient alors un signal exploitable pour découper intelligemment.

2. Chunking : découper sans casser le sens

Le chunking est le paramètre qui a le plus d’impact sur la qualité du retrieval. Trop gros, le chunk dilue l’information et son embedding devient « moyen » ; trop petit, il perd son contexte.

Stratégie Principe Avantages Limites Cas d’usage
Taille fixe + overlap N tokens, chevauchement de 10–20 % Simple, prévisible Coupe en plein milieu d’une idée Baseline, textes homogènes
Récursif Coupe d’abord sur les paragraphes, puis phrases, puis mots Bon compromis par défaut Ignore la structure sémantique La majorité des corpus
Par structure (titres Markdown/HTML) Un chunk = une section Respecte la logique du document Sections de tailles très inégales Documentation technique, wikis
Sémantique Coupe quand la similarité entre phrases consécutives chute Chunks thématiquement cohérents Coûteux (embedding de chaque phrase) Textes longs sans structure
Parent / enfant On indexe des petits chunks, on renvoie le chunk parent Précision du petit + contexte du grand Double stockage, plus complexe Contrats, rapports, manuels

Exemple avec le splitter récursif de LangChain, en enrichissant chaque chunk de métadonnées (source, section, date) qui serviront au filtrage et aux citations :

from langchain_text_splitters import RecursiveCharacterTextSplitter

splitter = RecursiveCharacterTextSplitter(
    chunk_size=1200,        # en caractères (≈ 250-300 tokens en français)
    chunk_overlap=150,
    separators=["\n## ", "\n### ", "\n\n", "\n", ". ", " "],
)

def build_chunks(doc_id: str, markdown: str, meta: dict) -> list[dict]:
    chunks = []
    for i, text in enumerate(splitter.split_text(markdown)):
        chunks.append({
            "id": f"{doc_id}::{i}",
            "text": text,
            "metadata": {**meta, "doc_id": doc_id, "position": i},
        })
    return chunks

chunks = build_chunks(
    "plan-marquage-ga4",
    open("plan_marquage.md", encoding="utf-8").read(),
    {"source": "Confluence", "service": "data", "updated_at": "2026-10-01"},
)

Astuce sous-estimée : préfixez chaque chunk avec le titre du document et de sa section (« Plan de marquage GA4 > Événements e-commerce > »). Un chunk qui commence par « Il faut ensuite configurer le paramètre… » est inexploitable une fois isolé ; avec son fil d’Ariane, son embedding redevient discriminant.

3. Embeddings : transformer le texte en vecteurs

Chaque chunk est converti par un modèle d’embedding en un vecteur dense (typiquement 384 à 3072 dimensions). Deux textes proches sémantiquement auront des vecteurs proches, mesurés par similarité cosinus ou produit scalaire. Le choix du modèle est crucial, surtout pour un corpus en français :

Modèle Type Dimensions Multilingue Points forts
OpenAI text-embedding-3-small API 1536 (réductible) Oui Bon rapport qualité/prix, dimensions ajustables
OpenAI text-embedding-3-large API 3072 (réductible) Oui Haute qualité, plus coûteux à stocker
Mistral mistral-embed API 1024 Oui Hébergement européen
Cohere embed-multilingual-v3.0 API 1024 Oui Solide en multilingue, se marie avec Cohere Rerank
intfloat/multilingual-e5-large Open source 1024 Oui Auto-hébergeable, préfixes « query: » / « passage: »
BAAI/bge-m3 Open source 1024 Oui Dense + sparse + multi-vecteurs, entrées jusqu’à 8192 tokens

Les classements évoluent vite : consultez le benchmark MTEB (onglet français) et, surtout, testez deux ou trois modèles sur vos questions réelles. Règle absolue : le même modèle doit encoder les documents et les requêtes, et changer de modèle impose de réindexer tout le corpus.

4. L’index ANN : retrouver les plus proches voisins à grande échelle

Comparer la requête à chaque vecteur (recherche exacte) fonctionne jusqu’à quelques centaines de milliers de chunks. Au-delà, on utilise un index de recherche approximative des plus proches voisins (ANN), qui sacrifie un peu de rappel contre un gain de vitesse énorme.

Type d’index Principe Paramètres clés Vitesse Mémoire Quand l’utiliser
Flat (brute force) Compare à tous les vecteurs Aucun Lente à grande échelle 100 % des vecteurs < 100 k vecteurs, vérité terrain pour évaluer
IVF Partitionne en clusters (k-means), ne fouille que les plus proches nlist, nprobe Rapide Modérée Gros volumes, index reconstruit périodiquement
HNSW Graphe de proximité multi-niveaux M, efConstruction, efSearch Très rapide, excellent rappel Élevée Le standard de fait (pgvector, Qdrant, Weaviate…)
IVF-PQ / quantification Compresse les vecteurs (product / scalar / binary quantization) m, nbits Très rapide Faible Dizaines de millions de vecteurs, budget RAM serré

Exemple complet d’indexation dense avec sentence-transformers et FAISS (HNSW) :

import faiss
import numpy as np
from sentence_transformers import SentenceTransformer

model = SentenceTransformer("intfloat/multilingual-e5-base")  # 768 dimensions

# E5 attend le préfixe "passage: " pour les documents
texts = [c["text"] for c in chunks]
vectors = model.encode(
    ["passage: " + t for t in texts],
    batch_size=64,
    normalize_embeddings=True,   # vecteurs normalisés : produit scalaire = cosinus
    show_progress_bar=True,
).astype("float32")

dim = vectors.shape[1]
index = faiss.IndexHNSWFlat(dim, 32, faiss.METRIC_INNER_PRODUCT)  # M = 32
index.hnsw.efConstruction = 200   # qualité du graphe à la construction
index.add(vectors)
index.hnsw.efSearch = 64          # compromis rappel / latence à la requête

faiss.write_index(index, "rag.index")

def dense_search(query: str, k: int = 20) -> list[tuple[int, float]]:
    q = model.encode(["query: " + query], normalize_embeddings=True).astype("float32")
    scores, ids = index.search(q, k)
    return [(int(i), float(s)) for i, s in zip(ids[0], scores[0]) if i != -1]

5. Index lexical et recherche hybride

Les embeddings excellent pour la paraphrase (« résilier mon abonnement » ≈ « mettre fin au contrat »), mais ils sont médiocres sur les termes exacts : références produit, codes d’erreur, noms propres, acronymes (« GA4 », « ERR_403 », « article L1234-5 »). Le vieux BM25 fait exactement l’inverse. On combine donc les deux, puis on fusionne les classements avec la Reciprocal Rank Fusion (RRF, Cormack et al., 2009), qui ne dépend que des rangs et évite d’avoir à normaliser des scores incomparables :

from rank_bm25 import BM25Okapi
import re

def tokenize(text: str) -> list[str]:
    return re.findall(r"\w+", text.lower())

bm25 = BM25Okapi([tokenize(t) for t in texts])

def lexical_search(query: str, k: int = 20) -> list[tuple[int, float]]:
    scores = bm25.get_scores(tokenize(query))
    top = np.argsort(scores)[::-1][:k]
    return [(int(i), float(scores[i])) for i in top]

def rrf(rankings: list[list[tuple[int, float]]], k: int = 60) -> list[int]:
    """Reciprocal Rank Fusion : score(d) = Σ 1 / (k + rang(d))"""
    fused: dict[int, float] = {}
    for ranking in rankings:
        for rank, (doc_id, _) in enumerate(ranking, start=1):
            fused[doc_id] = fused.get(doc_id, 0.0) + 1.0 / (k + rank)
    return sorted(fused, key=fused.get, reverse=True)

def hybrid_search(query: str, k: int = 20) -> list[int]:
    return rrf([dense_search(query, k), lexical_search(query, k)])[:k]

6. Reranking : la dernière marche de la pertinence

Le bi-encodeur (embedding) encode requête et document séparément : c’est rapide mais approximatif. Un cross-encoder lit la paire (question, passage) ensemble et produit un score de pertinence bien plus fin. Trop lent pour tout le corpus, il est idéal pour reclasser les 20 à 50 candidats issus de la recherche hybride :

from sentence_transformers import CrossEncoder

reranker = CrossEncoder("BAAI/bge-reranker-v2-m3")

def retrieve(query: str, k_candidates: int = 30, k_final: int = 5) -> list[dict]:
    candidate_ids = hybrid_search(query, k_candidates)
    pairs = [(query, texts[i]) for i in candidate_ids]
    scores = reranker.predict(pairs)
    ranked = sorted(zip(candidate_ids, scores), key=lambda x: x[1], reverse=True)
    return [{**chunks[i], "score": float(s)} for i, s in ranked[:k_final]]

Alternatives managées : Cohere Rerank, Voyage AI rerank, Jina Reranker. Ce pipeline à trois étages (dense + lexical → RRF → rerank) est aujourd’hui l’architecture de référence. Le RAG permet ainsi d’analyser des documents volumineux en extrayant uniquement les sections nécessaires, ce qui évite de noyer le modèle sous une masse de données peu pertinentes. Grâce à des frameworks comme LangChain ou LlamaIndex, ces briques s’assemblent rapidement pour cibler les informations clés d’un rapport de 200 pages.

La même chose en production avec PostgreSQL + pgvector

Pas besoin d’une base dédiée pour démarrer : si vous avez déjà PostgreSQL (ou Supabase), l’extension pgvector gère les index HNSW et IVFFlat, et la recherche plein texte native couvre la partie lexicale. Avantage majeur : filtres SQL, jointures et droits d’accès au même endroit que vos données.

CREATE EXTENSION IF NOT EXISTS vector;

CREATE TABLE chunks (
    id          text PRIMARY KEY,
    doc_id      text NOT NULL,
    content     text NOT NULL,
    metadata    jsonb,
    content_sha text NOT NULL,           -- pour l'indexation incrémentale
    embedding   vector(768),
    tsv         tsvector GENERATED ALWAYS AS (to_tsvector('french', content)) STORED
);

CREATE INDEX ON chunks USING hnsw (embedding vector_cosine_ops)
    WITH (m = 16, ef_construction = 64);
CREATE INDEX ON chunks USING gin (tsv);

-- Recherche hybride avec fusion RRF directement en SQL
WITH dense AS (
    SELECT id, ROW_NUMBER() OVER (ORDER BY embedding <=> $1) AS rnk
    FROM chunks
    WHERE metadata->>'service' = 'data'          -- filtre de métadonnées
    ORDER BY embedding <=> $1
    LIMIT 30
),
lexical AS (
    SELECT id, ROW_NUMBER() OVER (ORDER BY ts_rank_cd(tsv, q) DESC) AS rnk
    FROM chunks, websearch_to_tsquery('french', $2) AS q
    WHERE tsv @@ q AND metadata->>'service' = 'data'
    ORDER BY ts_rank_cd(tsv, q) DESC
    LIMIT 30
)
SELECT c.id, c.content,
       COALESCE(1.0 / (60 + d.rnk), 0) + COALESCE(1.0 / (60 + l.rnk), 0) AS rrf_score
FROM dense d
FULL OUTER JOIN lexical l USING (id)
JOIN chunks c USING (id)
ORDER BY rrf_score DESC
LIMIT 10;

Finalement, la puissance du RAG réside dans cette capacité à lier des données disparates en un tout cohérent. Avec une indexation intelligente, on ne se contente pas de récupérer de l’information : on la rend exploitable, filtrable et citable. Pour un aperçu plus complet, vous pouvez également consulter cet article sur le RAG Indexing.

Pourquoi utiliser le RAG Indexing pour les applications IA

Le RAG est devenu l’architecture par défaut dès qu’un LLM doit répondre à partir de connaissances propres à une organisation. Quelques cas d’usage concrets, avec leurs exigences d’indexation spécifiques :

Cas d’usage Corpus typique Point d’attention à l’indexation
Assistant métier interne Confluence, Notion, Google Drive, procédures Filtrage par droits d’accès (ACL) dans les métadonnées
Support client FAQ, tickets résolus, documentation produit Fraîcheur : réindexation quotidienne, déduplication des tickets
Juridique / conformité Contrats, réglementation, jurisprudence Chunking par article/clause, recherche lexicale indispensable
Data & analytics Plan de marquage, dictionnaire de données, schémas SQL Indexer descriptions de tables et de colonnes, exemples de requêtes
Agents d’automatisation (n8n, Make…) Bases de connaissances, historiques d’actions Le retrieval devient un « outil » appelé par l’agent : latence faible exigée

Choisir sa base vectorielle

Solution Type Recherche hybride Filtres métadonnées Idéal pour
FAISS Bibliothèque (Meta), en mémoire Non (à combiner avec BM25) Très limités Prototypes, benchmarks, batch offline
Chroma Embarquée / serveur léger, open source Limitée Oui POC et petites applications
pgvector / Supabase Extension PostgreSQL Oui, avec le full-text Postgres Oui (SQL complet) Équipes déjà sur Postgres, jusqu’à quelques dizaines de millions de vecteurs
Qdrant Moteur dédié open source (Rust), cloud dispo Oui (vecteurs sparse + fusion) Très riches Production avec filtrage avancé
Weaviate Moteur dédié open source, cloud dispo Oui (BM25 + vecteur natif) Oui Hybride clé en main, modules intégrés
Pinecone SaaS managé (serverless) Oui (sparse-dense) Oui Zéro infra à gérer
Milvus / Zilliz Moteur distribué open source Oui Oui Très gros volumes (centaines de millions et plus)
Elasticsearch / OpenSearch Moteur de recherche Oui (BM25 natif + kNN) Très riches Organisations ayant déjà une stack de recherche

Mon conseil pragmatique : commencez avec pgvector si vous avez déjà Postgres, Qdrant si vous voulez un moteur dédié open source. Ne migrez que lorsqu’une métrique (latence, coût, volume) vous y oblige.

Indexation incrémentale : ne réencodez que ce qui change

Réindexer tout le corpus chaque nuit coûte cher et ne passe pas à l’échelle. On calcule une empreinte (hash) de chaque chunk et on ne réencode que les chunks nouveaux ou modifiés :

import hashlib
import json

def sha(text: str) -> str:
    return hashlib.sha256(text.encode("utf-8")).hexdigest()

def sync_document(conn, doc_id: str, new_chunks: list[dict]) -> None:
    with conn.cursor() as cur:
        cur.execute("SELECT id, content_sha FROM chunks WHERE doc_id = %s", (doc_id,))
        existing = dict(cur.fetchall())

        to_embed = [c for c in new_chunks if existing.get(c["id"]) != sha(c["text"])]
        if to_embed:
            vecs = model.encode(["passage: " + c["text"] for c in to_embed],
                                normalize_embeddings=True)
            for c, v in zip(to_embed, vecs):
                cur.execute("""
                    INSERT INTO chunks (id, doc_id, content, metadata, content_sha, embedding)
                    VALUES (%s, %s, %s, %s, %s, %s)
                    ON CONFLICT (id) DO UPDATE SET content = EXCLUDED.content,
                        metadata = EXCLUDED.metadata, content_sha = EXCLUDED.content_sha,
                        embedding = EXCLUDED.embedding
                """, (c["id"], doc_id, c["text"], json.dumps(c["metadata"]),
                      sha(c["text"]), str(v.tolist())))

        # Supprime les chunks qui n'existent plus dans la nouvelle version
        stale = set(existing) - {c["id"] for c in new_chunks}
        if stale:
            cur.execute("DELETE FROM chunks WHERE id = ANY(%s)", (list(stale),))
    conn.commit()

Mesurer la qualité du retrieval

Sans évaluation, on optimise à l’aveugle. Constituez un jeu de 50 à 200 questions réelles, annotez pour chacune le ou les chunks attendus, puis suivez ces métriques à chaque changement (taille de chunk, modèle, reranker) :

Métrique Ce qu’elle mesure Niveau
Recall@k Part des questions dont un bon chunk figure dans les k premiers Retrieval
MRR Rang moyen (inversé) du premier bon résultat Retrieval
nDCG@k Qualité du classement avec pertinence graduée Retrieval
Faithfulness La réponse est-elle fondée sur le contexte fourni ? Génération
Context precision / recall Le contexte envoyé est-il pertinent et complet ? Bout en bout
def evaluate(eval_set: list[dict], k: int = 5) -> dict:
    """eval_set = [{"question": "...", "expected_ids": {"plan-marquage-ga4::3"}}, ...]"""
    hits, rr = 0, 0.0
    for item in eval_set:
        ids = [r["id"] for r in retrieve(item["question"], k_final=k)]
        ranks = [i for i, cid in enumerate(ids, start=1) if cid in item["expected_ids"]]
        if ranks:
            hits += 1
            rr += 1.0 / ranks[0]
    n = len(eval_set)
    return {f"recall@{k}": hits / n, "mrr": rr / n}

Pour les métriques de génération, des frameworks comme Ragas, DeepEval ou les outils d’observabilité Langfuse et LangSmith automatisent l’évaluation et le traçage en production.

La génération : assembler un prompt qui cite ses sources

import os
from openai import OpenAI

client = OpenAI()
MODEL = os.environ.get("LLM_MODEL")  # le modèle de votre choix

SYSTEM = """Tu réponds uniquement à partir du CONTEXTE fourni.
Cite tes sources sous la forme [n]. Si le contexte ne permet pas de répondre,
dis-le clairement au lieu d'inventer."""

def answer(question: str) -> str:
    passages = retrieve(question, k_final=5)
    context = "\n\n".join(
        f"[{n}] ({p['metadata']['source']} – {p['id']})\n{p['text']}"
        for n, p in enumerate(passages, start=1)
    )
    resp = client.chat.completions.create(
        model=MODEL,
        temperature=0,
        messages=[
            {"role": "system", "content": SYSTEM},
            {"role": "user", "content": f"CONTEXTE :\n{context}\n\nQUESTION : {question}"},
        ],
    )
    return resp.choices[0].message.content

print(answer("Quels paramètres envoie l'événement purchase dans notre plan de marquage ?"))

Les pièges les plus fréquents en production

  • Chunks orphelins : pas de titre ni de contexte, embedding non discriminant. Solution : fil d’Ariane en préfixe, ou contextual retrieval (un LLM rédige une phrase de contexte pour chaque chunk avant l’embedding).
  • Tableaux massacrés par l’extraction PDF. Solution : parser orienté mise en page (Docling, Unstructured) et conversion en Markdown.
  • Requêtes trop courtes ou ambiguës. Solution : réécriture de requête, multi-query ou HyDE (on génère une réponse hypothétique et on cherche avec son embedding).
  • Doublons (versions successives d’un même document) qui monopolisent le top-k. Solution : déduplication à l’ingestion et métadonnée de version.
  • Fuite de données : un utilisateur obtient un passage qu’il ne devrait pas voir. Solution : filtrer par ACL dans la requête au moteur, jamais après coup dans le prompt.
  • Changement silencieux de modèle d’embedding. Solution : stocker le nom et la version du modèle avec l’index, et réindexer intégralement en cas de changement.

Alors, le RAG Indexing est-il la clé pour exploiter pleinement les LLM ?

Pour toute application qui doit répondre à partir de connaissances privées, évolutives ou vérifiables : oui, c’est aujourd’hui l’architecture la plus robuste et la plus économique. Mais le RAG n’a rien de magique : sa qualité est exactement celle de son index. Les équipes qui réussissent ne sont pas celles qui utilisent le plus gros modèle, mais celles qui traitent leur pipeline d’indexation comme un vrai produit data, avec un jeu d’évaluation, des métriques suivies et des itérations mesurées.

Ma checklist de démarrage :

  1. Parser proprement et convertir en Markdown.
  2. Chunking récursif (≈ 300 tokens, 10–15 % d’overlap) + fil d’Ariane en préfixe.
  3. Un modèle d’embedding multilingue testé sur vos propres questions.
  4. Recherche hybride dense + BM25 avec fusion RRF.
  5. Reranking cross-encoder sur les 20–50 meilleurs candidats.
  6. Un jeu d’évaluation de 50 questions minimum, Recall@5 et MRR suivis à chaque changement.
  7. Indexation incrémentale et filtres d’accès dès le premier jour.

Maîtriser le RAG, c’est gagner en pertinence et en robustesse sans augmenter inutilement la taille du modèle. Pour tout pro de la Data ou de l’IA, c’est la brique qui transforme un chatbot généraliste en assistant métier fiable. Si vous souhaitez aller plus loin et passer à la pratique, allez faire un tour ici.

FAQ

Qu’est-ce que RAG Indexing en IA ?

Le RAG Indexing est la phase de préparation d’un système RAG (Retrieval-Augmented Generation) : les documents sont parsés, découpés en chunks, convertis en vecteurs (embeddings) et stockés dans un index vectoriel et/ou lexical. Au moment d’une question, cet index permet de retrouver en quelques millisecondes les passages pertinents, qui sont transmis au LLM pour produire une réponse précise, contextualisée et sourcée.

Comment un index est-il créé pour le RAG ?

On extrait le texte des sources (PDF, HTML, bases de connaissances), on le segmente en chunks de quelques centaines de tokens enrichis de métadonnées, puis on encode chaque chunk avec un modèle d’embedding. Les vecteurs sont stockés dans un index ANN (le plus souvent HNSW) au sein d’une base vectorielle, généralement complété par un index lexical BM25 pour la recherche hybride.

Quels outils utiliser pour le RAG Indexing ?

Pour l’orchestration : LangChain ou LlamaIndex. Pour le parsing : Docling, Unstructured ou PyMuPDF. Pour les embeddings : OpenAI, Mistral, Cohere ou des modèles open source comme bge-m3 et multilingual-e5. Pour le stockage : FAISS pour prototyper, pgvector/Supabase, Qdrant, Weaviate, Pinecone ou Milvus en production. Pour le reranking : un cross-encoder comme bge-reranker ou Cohere Rerank. Pour l’évaluation : Ragas ou DeepEval.

Quels sont les avantages du RAG par rapport aux LLM classiques ?

Le RAG donne accès à des informations privées et à jour sans réentraîner le modèle, permet de citer les sources de chaque réponse, réduit fortement les hallucinations, s’adapte à des corpus de millions de documents bien au-delà de la fenêtre de contexte, et autorise un contrôle d’accès par utilisateur grâce au filtrage des métadonnées. Le tout pour un coût par requête bien inférieur à l’envoi de documents entiers dans le prompt.

Est-ce que le RAG Indexing est accessible aux débutants ?

Oui : un premier prototype fonctionnel tient en une centaine de lignes de Python avec LangChain ou LlamaIndex, et des outils no-code comme n8n proposent des nœuds RAG prêts à l’emploi. La vraie expertise se situe ensuite dans l’optimisation : choix du chunking, recherche hybride, reranking et évaluation. Un data engineer ou un développeur IA peut monter en compétence rapidement avec une approche méthodique.

 

 

A propos de l’auteur

Je suis Franck Scandolera, consultant expert en Data Engineering, IA générative et automatisation basée sur le no-code. Depuis plus de dix ans, j’aide entreprises et agences à maîtriser les technologies avancées comme le RAG et les LLM. Avec une expertise technique solide en ingestion de données, prompt engineering et déploiement de workflows IA, je forme et accompagne mes clients pour transformer leurs données en leviers business concrets et durables.

Défiler vers le haut