1. Pourquoi RAG ?

Un LLM brut a deux faiblesses : knowledge cutoff (ne connaît pas vos données ni les événements récents) et hallucinations. Le RAG y répond en récupérant les passages pertinents d'une base documentaire et en les injectant dans le prompt.

Lewis P. et al., « Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks », NeurIPS 2020, arXiv:2005.11401 — papier fondateur RAG par Facebook AI.

2. Pipeline RAG canonique

1. INGESTION (offline)
   Documents → Parse (PDF/HTML/MD) → Chunk → Embed → Vector DB

2. QUERY (online)
   User question → Embed → Vector search (top-k)
                    ↓
              Pass(es) → LLM with context → Answer

3. Parsing de documents

4. Stratégies de chunking

from langchain_text_splitters import RecursiveCharacterTextSplitter

splitter = RecursiveCharacterTextSplitter(
    chunk_size=512,
    chunk_overlap=64,
    separators=["\n\n", "\n", ". ", " ", ""]
)
chunks = splitter.split_text(long_text)

5. Embeddings — choisir le modèle

Référence comparative : MTEB Leaderboard (Massive Text Embedding Benchmark)

6. Vector databases — comparatif

6.1 Index ANN

• HNSW (Hierarchical Navigable Small World) — défaut moderne, rapide et précis
• IVF (Inverted File) — bon pour volumes énormes
• IVF-PQ — quantization produit pour économiser la RAM
• SCANN (Google) — variante optimisée

from qdrant_client import QdrantClient, models
from openai import OpenAI

client = QdrantClient(url="http://localhost:6333")
oai = OpenAI()

# Création collection
client.recreate_collection(
    collection_name="docs",
    vectors_config=models.VectorParams(size=3072, distance=models.Distance.COSINE)
)

# Ingestion
points = []
for i, chunk in enumerate(chunks):
    emb = oai.embeddings.create(model="text-embedding-3-large", input=chunk).data[0].embedding
    points.append(models.PointStruct(id=i, vector=emb, payload={"text": chunk, "source": doc_id}))
client.upsert(collection_name="docs", points=points)

# Query
q = "Comment fonctionne Spark ?"
q_emb = oai.embeddings.create(model="text-embedding-3-large", input=q).data[0].embedding
results = client.search(collection_name="docs", query_vector=q_emb, limit=5)
for r in results:
    print(r.score, r.payload["text"][:100])

7. Hybrid search — BM25 + dense

Le dense (embeddings) capture la sémantique mais peut louper les termes rares (noms propres, identifiants techniques). BM25 (Okapi 1995) capture les termes exacts. La combinaison RRF (Reciprocal Rank Fusion) est nettement supérieure.

def reciprocal_rank_fusion(rankings, k=60):
    scores = {}
    for ranking in rankings:
        for rank, doc_id in enumerate(ranking):
            scores[doc_id] = scores.get(doc_id, 0) + 1.0 / (k + rank)
    return sorted(scores.items(), key=lambda x: -x[1])

Cormack G., Clarke C., Buettcher S., « Reciprocal Rank Fusion outperforms Condorcet and individual Rank Learning Methods », SIGIR 2009.

8. Évaluer un RAG basique

• Hit Rate @ K : le bon passage est-il dans le top-K ?
• MRR (Mean Reciprocal Rank) : position moyenne du premier bon doc
• nDCG : gain cumulé pondéré par rang
• Faithfulness : la réponse cite-t-elle les passages récupérés ?
• Answer Relevancy : la réponse adresse-t-elle la question ?

Voir leçon 5 pour les frameworks Ragas et LangSmith.

9. Synthèse et points-clés

• RAG = ingestion + chunking + embedding + retrieval + génération
• Chunk 256-1024 tokens, overlap 10-20 %, RecursiveCharacterTextSplitter en défaut
• text-embedding-3-large ou BGE-large = défaut 2026
• Qdrant / Pinecone / Weaviate = top vector DBs
• HNSW = index ANN moderne
• Hybrid search BM25 + dense avec RRF = standard
• Mesurer : Hit Rate @ K, MRR, Faithfulness, Answer Relevancy

Pour aller plus loin

• Lewis et al., RAG paper, NeurIPS 2020
• LangChain — RAG Tutorial
• LlamaIndex Documentation
• Qdrant Documentation
• MTEB Leaderboard