Configurer un environnement RAG
Un RAG qui répond mal, c'est l'ingestion. Voici la stack complète : Qdrant, bge-m3, rerank, et le harnais qui mesure le rappel avant de brancher le LLM.
Un RAG qui répond mal, ce n'est presque jamais la faute du LLM. C'est l'ingestion. Tu peux brancher le meilleur modèle du marché sur ta documentation, si tes chunks sont coupés au milieu d'une procédure, il improvisera une réponse avec un aplomb parfait.
Voici l'environnement que je monte pour chaque projet RAG : trois conteneurs, un modèle d'embedding multilingue, un reranker, et une centaine de lignes de Python. Compte 45 minutes et 4 Go de RAM pour le faire tourner sur un VPS à 6 €/mois.
Le matériel : ce qu'un RAG réclame vraiment
Le réflexe est de surdimensionner la base vectorielle. C'est une erreur de calcul. Sur 10 000 pages de PDF à 500 tokens la page, avec des chunks de 512 tokens et 15 % de recouvrement, tu obtiens environ 11 500 chunks.
En 1024 dimensions et en float32, ces 11 500 vecteurs pèsent 0,04 Go. La RAM de Qdrant n'est pas ton problème. Le seul poste qui coûte vraiment, c'est le modèle d'embedding : bge-m3 fait 568 M de paramètres, soit environ 1,1 Go en fp16.
| Composant | RAM / VRAM | Tourne sur CPU ? |
|---|---|---|
| Qdrant (11 500 vecteurs, 1024d) | < 300 Mo | Oui |
| bge-m3 (embedding, fp16) | ~1,1 Go | Oui, 40–80 chunks/s sur 4 vCPU |
| bge-reranker-v2-m3 | ~1,2 Go | Oui, 300–800 ms pour 50 paires |
| LLM de génération | dépend du modèle | À externaliser |
Conclusion pratique : garde le LLM chez un provider, héberge le retrieval. Un 4 vCPU / 8 Go suffit très largement jusqu'à quelques centaines de milliers de chunks.
La stack : trois services, pas dix
Le docker-compose.yml ci-dessous monte Qdrant pour le stockage, Ollama pour servir bge-m3 en local, et le Text Embeddings Inference de Hugging Face pour le reranker. Les versions sont épinglées, sinon tu récoltes une migration de collection en pleine prod.
services:
qdrant:
image: qdrant/qdrant:v1.19.2
ports: ["6333:6333", "6334:6334"]
volumes: ["qdrant_data:/qdrant/storage"]
ollama:
image: ollama/ollama:0.40.6
ports: ["11434:11434"]
volumes: ["ollama_models:/root/.ollama"]
reranker:
image: ghcr.io/huggingface/text-embeddings-inference:cpu-latest
command: ["--model-id", "BAAI/bge-reranker-v2-m3"]
ports: ["8081:80"]
volumes: ["tei_cache:/data"]
volumes:
qdrant_data:
ollama_models:
tei_cache:
Un docker compose up -d puis docker exec -it ollama ollama pull bge-m3. Le téléchargement fait 1,2 Go, prévois le coup la première fois.
Qdrant expose son dashboard sur http://localhost:6333/dashboard. C'est le seul outil de debug dont tu as besoin pour vérifier qu'une collection contient ce que tu crois qu'elle contient.
Découper les documents sans casser le rappel
Un chunk de 512 tokens coupé à l'aveugle perd son contexte. « Relance le service » sans le nom du service, c'est un chunk inutilisable. Deux règles suffisent pour régler 80 % du problème.
Première règle : découpe d'abord sur la structure (titres, articles de loi, sections de doc), ensuite sur la taille. Deuxième règle : préfixe chaque chunk par son chemin de titres. Le vecteur porte alors le contexte sans que tu paies un appel LLM.
def chunk_document(doc: dict, size: int = 512, overlap: int = 0.15) -> list[dict]:
chunks, buf, path = [], [], doc["title"]
step = int(size * (1 - overlap))
for block in doc["blocks"]: # blocs déjà découpés sur les titres
if block["type"] == "heading":
path = block["text"]
buf = []
continue
buf.append(block["text"])
words = " ".join(buf).split()
while len(words) >= size:
chunks.append({"text": f"{doc['title']} > {path}\n" + " ".join(words[:size])})
words = words[step:]
buf = [" ".join(words)] if words else []
if buf:
chunks.append({"text": f"{doc['title']} > {path}\n" + " ".join(buf)})
return chunks
Anthropic a mesuré l'effet du contexte ajouté aux chunks sur un corpus de documentation : le taux d'échec du retrieval top-20 passe de 5,7 % à 3,7 % avec des embeddings contextualisés, à 2,9 % en y ajoutant du BM25 contextualisé, et à 1,9 % avec un rerank. Soit deux tiers d'échecs en moins pour un coût d'ingestion marginal.
La version complète fait générer un résumé contextuel par le LLM pour chaque chunk. Mon préfixe de titres est une approximation gratuite qui capte l'essentiel sur une doc bien structurée. Si ton corpus est fait de mails ou de comptes rendus sans structure, paie la génération de contexte.
bge-m3 en dense + sparse : une collection, deux vecteurs
bge-m3 sort trois représentations à la fois : dense (1024 dimensions), sparse (poids par token) et multi-vecteurs en ColBERT. Ollama ne t'en rend que le dense, ce qui suffit pour démarrer. Le sparse, lui, attrape les références produit et les codes article que le dense lisse.
Qdrant gère les deux dans une seule collection grâce aux vecteurs nommés.
from qdrant_client import QdrantClient, models
client = QdrantClient(url="http://localhost:6333")
client.create_collection(
collection_name="docs",
vectors_config={
"dense": models.VectorParams(size=1024, distance=models.Distance.COSINE),
},
sparse_vectors_config={
"sparse": models.SparseVectorParams(),
},
)
Passe ensuite en int8 pour les quantifications : 0,95 Go pour un million de chunks en 1024d, contre 3,81 Go en float32. La perte de rappel est sous le point de pourcentage sur la plupart des corpus, pour quatre fois moins de RAM.
La recherche hybride, puis le rerank
Récupérer 50 chunks, en garder 5 : c'est le schéma qui marche. La fusion RRF (Reciprocal Rank Fusion) combine les deux classements sans avoir à normaliser des scores qui n'ont rien à voir.
res = client.query_points(
collection_name="docs",
prefetch=[
models.Prefetch(query=dense_vec, using="dense", limit=50),
models.Prefetch(
query=models.SparseVector(indices=idx, values=vals),
using="sparse", limit=50,
),
],
query=models.FusionQuery(fusion=models.Fusion.RRF),
limit=50,
)
# puis POST http://localhost:8081/rerank sur les 50 textes, garder les 5 premiers
Le rerank est l'étape que 90 % des tutos sautent, et c'est celle qui change le plus la donne. Un bi-encoder compare une question et un chunk séparément ; un cross-encoder lit les deux ensemble. Sur mon dernier projet, le bon chunk était dans le top 50 dans 94 % des cas, mais dans le top 5 seulement 71 % du temps. Le reranker a ramené ce 71 % à 89 %.
Accepte le coût : 300 à 800 ms de latence selon le CPU. Si ton budget est à 200 ms, garde le bi-encoder et augmente le nombre de chunks envoyés au LLM.
Mesurer avant de brancher le LLM
La tentation est de tester à l'œil, en posant trois questions au chatbot. Ça ne prouve rien. Il te faut 50 questions dont tu connais le chunk source, et deux métriques : le rappel@5 et le taux de chunks hors sujet.
golden = [{"q": "Quel est le délai de rétractation ?", "source": "cgv.md#4"}]
hits = 0
for case in golden:
top5 = retrieve(case["q"], k=5)
hits += any(case["source"] in c["source"] for c in top5)
print(f"rappel@5 = {hits / len(golden):.1%}")
Sous 70 %, ne touche pas au prompt : retravaille le découpage. Entre 70 et 85 %, ajoute du rerank et du sparse. Au-dessus de 90 %, le LLM devient le facteur limitant et tu peux enfin optimiser la génération.
J'ai détaillé la construction du golden set et le garde-fou en CI dans le guide pratique de l'évaluation des RAG. Et si tu partais déjà d'une base Chroma, la mécanique de migration est décrite dans Intégrer Chroma dans une stack existante.
L'ingestion : traiter 10 000 pages sans y passer la nuit
L'embedding est l'étape lente, et elle est parfaitement parallélisable. Ollama sérialise mal les requêtes : envoie des lots de 32 chunks et garde quatre workers, tu passes de 12 chunks/s à 60 sur un 4 vCPU.
Le vrai piège n'est pas la vitesse, c'est l'idempotence. Si ton script plante à la page 6 000 et que tu le relances à zéro, tu paies deux fois l'embedding et tu te retrouves avec des doublons dans la collection.
import hashlib
def point_id(text: str) -> str:
return hashlib.sha1(text.encode()).hexdigest()
# upsert avec le même id = réécriture, jamais de doublon
client.upsert("docs", points=[
models.PointStruct(id=point_id(c["text"]), vector={"dense": vec}, payload=c)
for c, vec in zip(batch, vectors)
])
L'upsert sur un id déterministe rend la ré-ingestion gratuite en stockage et te donne au passage la déduplication : deux copies du même paragraphe dans deux PDF n'occupent qu'un point. Sur mon dernier corpus, 6 % des chunks étaient des doublons de politique interne recopiés dans chaque filiale.
Le suivi se fait dans une petite table de statut, pas dans les logs : un fichier, son hash, son nombre de chunks, son état. Quand un document change, tu supprimes ses points par filtre source et tu réinsères. Le RAG se met à jour sans recharger les 9 950 autres fichiers.
Les quatre réglages qui ruinent un RAG
| Réglage | Valeur par défaut | Ce qu'il faut faire |
|---|---|---|
| Taille de chunk | 1000+ tokens | 512 tokens, 15 % de recouvrement |
| Recherche | dense seul | dense + sparse + RRF |
| Rerank | absent | 50 → 5 avec un cross-encoder |
| Filtres | aucun | filter par source/date avant le KNN |
Le filtre mérite un mot. Post-filtrer en Python après avoir récupéré 50 résultats te fait perdre la moitié de ton rappel. Qdrant applique le filtre pendant la recherche HNSW, et le coût est quasi nul si tu as un index de payload sur le champ.
models.Filter(must=[models.FieldCondition(
key="source", match=models.MatchValue(value="cgv.md"))])
Ce que tu obtiens au bout du compte
Une requête complète tourne en 250–400 ms hors génération : embedding 30 ms, deux recherches Qdrant en parallèle 15 ms, fusion, rerank 400 ms sur 50 paires, et le top 5 part chez le LLM.
Le tout tient dans 3 Go de RAM et se relance avec un docker compose up -d. La vraie valeur du montage n'est pas là : elle est dans le harnais d'évaluation, qui te dit en une commande si ta dernière modification du découpage a amélioré ou cassé le rappel.
Brancher le LLM : trois lignes de prompt suffisent
Une fois le retrieval propre, le prompt n'a plus besoin d'être une usine à gaz. Trois contraintes : répondre uniquement depuis les extraits fournis, citer le numéro du chunk utilisé, et dire explicitement quand les extraits ne contiennent pas la réponse.
La troisième ligne est celle qui fait la différence en production. Sans elle, le modèle comble les trous avec du plausible, et tu passes trois semaines à chercher un bug de retrieval qui est en réalité un bug de formulation.
instructions = (
"Réponds uniquement avec les extraits ci-dessous. "
"Cite le numéro de chaque extrait utilisé, entre crochets. "
"Si les extraits ne suffisent pas, écris : information absente des sources."
)
prompt = instructions + "\n\n" + extraits + "\n\nQuestion : " + question
Garde 5 extraits maximum. Au-delà, le modèle commence à moyenner des passages qui se contredisent, et la qualité perçue baisse alors que le rappel monte.
Questions fréquentes
Faut-il un GPU pour un RAG local ?
Pas pour le retrieval. Un CPU 4 vCPU suffit pour embedder quelques documents par seconde et reranker 50 paires en moins d'une seconde. Le GPU ne devient utile que si tu veux aussi servir le LLM de génération sur la même machine.
Qdrant ou pgvector ?
pgvector si ta base Postgres existe déjà et que ton corpus reste sous le million de chunks : un composant de moins à exploiter. Qdrant au-delà, ou dès que tu veux du sparse natif et une quantification sans bricolage.
Pourquoi bge-m3 plutôt qu'un modèle OpenAI ?
Pour le multilingue et le coût. bge-m3 gère le français, l'anglais et le chinois dans le même espace vectoriel, tourne hors ligne, et ne facture rien. Sur un corpus très anglophone et déjà propre, un modèle propriétaire reste compétitif en qualité.
Quelle taille de chunk pour des PDF techniques ?
512 tokens avec un découpage sur les titres. En dessous de 256, tu perds le contexte des tableaux et des procédures numérotées. Au-dessus de 800, tu dilues le signal et le reranker décroche.