1. Qu'est-ce que RAG et Quand l'Utiliser
La Génération Augmentée par Récupération (RAG) connecte un LLM à une base de connaissances externe au moment de la requête. Au lieu de s'appuyer uniquement sur ce que le modèle a appris lors de l'entraînement, RAG récupère des chunks de documents pertinents et les injecte dans le prompt comme contexte.
Utilisez RAG quand :
- Vos documents changent fréquemment (wikis internes, catalogues produits, contrats juridiques)
- Les données sont privées et n'ont jamais été dans un dataset d'entraînement (dossiers clients, rapports internes)
- Vous avez besoin d'attribution des sources — les utilisateurs doivent pouvoir vérifier les réponses
- Le fine-tuning est trop coûteux ou trop lent pour itérer
N'utilisez pas RAG quand : le modèle connaît déjà bien le domaine (questions générales de code, connaissances communes), ou quand vous avez besoin que le LLM apprenne un nouveau comportement plutôt que de nouveaux faits — c'est ce pour quoi sert le fine-tuning.
Comparaison des coûts : Le fine-tuning de GPT-4o coûte ~25 USD/1M tokens d'entraînement + 5-15 USD/heure de calcul. Mettre à jour une base de connaissances RAG coûte ~0,02 USD/1M tokens pour ré-embedder les chunks modifiés. Pour des documents qui changent chaque semaine, RAG est 100-500x moins cher à maintenir à jour.
2. Configuration de l'Environnement
Nous utilisons LangChain 0.3+, ChromaDB (open-source, tourne localement), et supportons à la fois OpenAI et Ollama (gratuit, inférence locale). Python 3.11+ requis.
# Créer et activer l'environnement virtuel
python -m venv .venv
source .venv/bin/activate # Windows: .venv\Scripts\activate
# Packages LangChain core
pip install langchain==0.3.0 langchain-community==0.3.0 langchain-openai==0.2.0
# Chargeurs de documents
pip install pypdf unstructured[pdf] python-docx
# Vector store
pip install chromadb==0.5.0
# Framework d'évaluation
pip install ragas==0.2.0 datasets
# Optionnel : inférence locale (sans coût API)
# Installez Ollama depuis https://ollama.ai/, puis :
# ollama pull llama3.3:70b
# ollama pull nomic-embed-text
pip install langchain-ollama # Intégration LangChain pour Ollama
Configurez les clés API — ou ignorez si vous utilisez Ollama :
# Fichier .env (ne jamais committer)
OPENAI_API_KEY=sk-...
# Chargement en Python
from dotenv import load_dotenv
load_dotenv()
# Vérification
import openai
print(openai.models.list().data[0].id) # Doit afficher un nom de modèle
3. Chargement et Traitement des Documents
LangChain fournit des loaders pour 50+ formats. Tous retournent une liste d'objets Document avec page_content et metadata, rendant le reste de votre pipeline agnostique au format.
from langchain_community.document_loaders import (
PyPDFLoader,
UnstructuredWordDocumentLoader,
WebBaseLoader,
DirectoryLoader,
)
from langchain.text_splitter import RecursiveCharacterTextSplitter
from pathlib import Path
# ── Loaders de fichiers individuels ──────────────────────────────────────────
pdf_docs = PyPDFLoader("rapport_annuel.pdf").load()
word_docs = UnstructuredWordDocumentLoader("contrat.docx").load()
web_docs = WebBaseLoader("https://docs.exemple.fr/api").load()
# ── Charger un répertoire entier de PDFs ─────────────────────────────────────
dir_loader = DirectoryLoader(
"./base_connaissance/",
glob="**/*.pdf",
loader_cls=PyPDFLoader,
show_progress=True,
)
tous_docs = dir_loader.load()
print(f"Chargé {len(tous_docs)} pages depuis {len(set(d.metadata['source'] for d in tous_docs))} fichiers")
# ── Ajouter des métadonnées personnalisées avant le découpage ─────────────────
for doc in tous_docs:
doc.metadata["departement"] = "ingenierie"
doc.metadata["indexe_le"] = "2026-04-07"
# ── Découper en chunks ────────────────────────────────────────────────────────
# RecursiveCharacterTextSplitter essaie paragraphe → phrase → mot
splitter = RecursiveCharacterTextSplitter(
chunk_size=1000, # Caractères par chunk (pas des tokens)
chunk_overlap=200, # Chevauchement pour préserver le contexte entre chunks
separators=["\n\n", "\n", ". ", " ", ""],
)
chunks = splitter.split_documents(tous_docs)
print(f"Découpé en {len(chunks)} chunks")
print(f"Taille moyenne des chunks : {sum(len(c.page_content) for c in chunks) // len(chunks)} caractères")
# Résultat attendu :
# Chargé 87 pages depuis 5 fichiers
# Découpé en 412 chunks
# Taille moyenne des chunks : 847 caractères
Règles de taille de chunk : Documentation technique → 800-1200 caractères. Textes juridiques → 1500-2000 caractères (les clauses ont besoin de contexte complet). Entrées FAQ → 300-500 caractères (une paire Q&R par chunk). Fichiers de code → découpez par fonction ou classe, pas par nombre de caractères.
4. Indexation : Embeddings et Vector Store
Les embeddings convertissent le texte en vecteurs numériques. Un texte sémantiquement similaire produit des vecteurs similaires, permettant une recherche rapide par plus proches voisins. Nous utilisons ChromaDB — open-source, zéro infrastructure, tourne en-process ou en tant que serveur.
from langchain_openai import OpenAIEmbeddings
from langchain_ollama import OllamaEmbeddings # alternative locale
from langchain_community.vectorstores import Chroma
import os
# ── Option A : Embeddings OpenAI (coût : 0,02 USD / 1M tokens) ───────────────
embeddings_openai = OpenAIEmbeddings(model="text-embedding-3-small")
# ── Option B : Ollama local (coût : 0 EUR, nécessite GPU ou CPU rapide) ──────
embeddings_local = OllamaEmbeddings(model="nomic-embed-text") # 768 dimensions
# Choisissez l'un ou l'autre :
embeddings = embeddings_openai # ou embeddings_local
PERSIST_DIR = "./chroma_db"
if os.path.exists(PERSIST_DIR):
# Charger l'index existant — pas besoin de ré-embedder
vectorstore = Chroma(
persist_directory=PERSIST_DIR,
embedding_function=embeddings,
)
print(f"Vector store chargé : {vectorstore._collection.count()} chunks")
else:
# Indexation initiale
vectorstore = Chroma.from_documents(
documents=chunks,
embedding=embeddings,
persist_directory=PERSIST_DIR,
collection_metadata={"hnsw:space": "cosine"}, # similarité cosinus
)
print(f"Indexé {vectorstore._collection.count()} chunks")
# ── Mise à jour incrémentale (ajouter de nouveaux docs sans tout réindexer) ───
nouveaux_chunks = splitter.split_documents([nouveau_doc])
vectorstore.add_documents(nouveaux_chunks)
print("Mise à jour incrémentale terminée")
5. Stratégies de Récupération : Similarité, MMR et Hybride
La récupération est la variable la plus impactante sur la qualité du RAG. Le modèle d'embedding et la taille des chunks définissent le plafond ; la stratégie de récupération détermine à quel point vous l'approchez.
5a. Recherche par Similarité (Baseline)
Retourne les k chunks avec la similarité cosinus la plus élevée avec le vecteur de la requête. Rapide, simple, suffisant pour les petites bases de connaissances homogènes.
# Retriever par similarité de base
retriever_sim = vectorstore.as_retriever(
search_type="similarity",
search_kwargs={"k": 4},
)
resultats = retriever_sim.invoke("Quelle est notre politique de remboursement ?")
for doc in resultats:
print(f"[{doc.metadata.get('source', '?')}] {doc.page_content[:120]}...")
# Faiblesse : peut retourner 4 chunks presque identiques de la même section
5b. MMR — Maximal Marginal Relevance (Pertinence Marginale Maximale)
MMR équilibre pertinence et diversité. Il récupère des candidats par similarité, puis sélectionne itérativement celui qui est le plus pertinent pour la requête et le moins similaire aux chunks déjà sélectionnés. Utilisez-le quand votre corpus contient de nombreux documents similaires.
# Retriever MMR
retriever_mmr = vectorstore.as_retriever(
search_type="mmr",
search_kwargs={
"k": 4, # Nombre final de chunks retournés
"fetch_k": 20, # Pool de candidats initiaux
"lambda_mult": 0.6, # 0 = max diversité, 1 = max pertinence (0.5-0.7 optimal)
},
)
# Exemple MMR : requête sur la politique de remboursement
# Similarité retourne : [clause remboursement, clause remboursement (paraphrase), clause remboursement (alt), FAQ remboursement]
# MMR retourne : [clause remboursement, politique retours, politique échange, politique livraison]
# → Contexte beaucoup plus informatif pour le LLM
5c. Recherche Hybride (BM25 + Sémantique)
La recherche hybride combine la recherche par mots-clés (BM25, correspondance exacte de termes) avec la recherche sémantique (similarité d'embeddings). Elle résout le problème de "décalage de vocabulaire" : la recherche sémantique rate les codes produit exacts ou les noms propres ; BM25 rate les paraphrases. Ensemble, elles excellent sur les deux.
from langchain_community.retrievers import BM25Retriever
from langchain.retrievers import EnsembleRetriever
# Retriever BM25 par mots-clés (sans embeddings, fréquence de termes pure)
bm25_retriever = BM25Retriever.from_documents(chunks)
bm25_retriever.k = 4
# Retriever sémantique
semantic_retriever = vectorstore.as_retriever(search_kwargs={"k": 4})
# Hybride : combinaison pondérée (0.5 = poids égal)
hybrid_retriever = EnsembleRetriever(
retrievers=[bm25_retriever, semantic_retriever],
weights=[0.4, 0.6], # Donner légèrement plus de poids au sémantique
)
# La recherche hybride excelle sur les requêtes avec des identifiants spécifiques
query = "Que dit la section 4.2.1 sur la rétention des données ?"
# BM25 trouve "4.2.1" exactement ; le sémantique trouve le contexte "politique de rétention"
resultats = hybrid_retriever.invoke(query)
print(f"Hybride : {len(resultats)} chunks uniques récupérés")
5d. Reranking avec un Cross-Encoder
Le reranking utilise un second modèle plus précis pour re-scorer les résultats de récupération initiaux. Ajoute ~200ms de latence mais améliore typiquement le Recall@4 de 8 à 12 points de pourcentage. Rentable pour les systèmes en production.
from langchain.retrievers import ContextualCompressionRetriever
from langchain_community.cross_encoders import HuggingFaceCrossEncoder
from langchain.retrievers.document_compressors import CrossEncoderReranker
# Charger le modèle de reranking (tourne localement, pas de clé API nécessaire)
# Première exécution : télécharge ~67 Mo de modèle
model = HuggingFaceCrossEncoder(model_name="BAAI/bge-reranker-base")
compressor = CrossEncoderReranker(model=model, top_n=3)
# Envelopper n'importe quel retriever avec le reranking
reranking_retriever = ContextualCompressionRetriever(
base_compressor=compressor,
base_retriever=hybrid_retriever, # Récupérer plus de candidats, reranker vers top 3
)
resultats = reranking_retriever.invoke("rétention données clients UE")
# Les résultats sont maintenant triés par score cross-encoder, pas seulement similarité d'embedding
6. Chaîne de Génération avec Attribution des Sources
Avec un retriever prêt, nous construisons la chaîne de génération avec LCEL (LangChain Expression Language). La chaîne est retriever → prompt → LLM → parseur, tous composables avec l'opérateur |.
from langchain_openai import ChatOpenAI
from langchain_ollama import ChatOllama # alternative locale
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough, RunnableParallel
# ── Configuration du LLM ──────────────────────────────────────────────────────
llm_openai = ChatOpenAI(model="gpt-4o-mini", temperature=0)
llm_local = ChatOllama(model="llama3.3:70b", temperature=0)
llm = llm_openai # remplacer par llm_local pour zéro coût API
# ── Template de prompt ────────────────────────────────────────────────────────
SYSTEM = """Vous êtes un assistant précis qui répond aux questions en se basant
strictement sur le contexte fourni. Règles :
- N'utilisez que les informations du contexte ci-dessous.
- Si le contexte ne contient pas la réponse, dites "Cette information ne figure
pas dans les documents fournis" — ne fabriquez pas d'informations.
- Citez le document source quand vous référencez des faits spécifiques.
Contexte :
{context}"""
prompt = ChatPromptTemplate.from_messages([
("system", SYSTEM),
("human", "{question}"),
])
def format_docs(docs: list) -> str:
"""Formater les documents récupérés avec des étiquettes de source."""
parts = []
for i, doc in enumerate(docs, 1):
source = doc.metadata.get("source", "inconnu")
parts.append(f"[Source {i} : {source}]\n{doc.page_content}")
return "\n\n---\n\n".join(parts)
# ── Chaîne RAG avec attribution des sources ───────────────────────────────────
rag_chain_avec_sources = RunnableParallel(
{
"reponse": (
{"context": reranking_retriever | format_docs, "question": RunnablePassthrough()}
| prompt
| llm
| StrOutputParser()
),
"sources": reranking_retriever,
}
)
# ── Requête ───────────────────────────────────────────────────────────────────
resultat = rag_chain_avec_sources.invoke("Quelle est la durée de rétention des données pour les utilisateurs UE ?")
print("Réponse :", resultat["reponse"])
print("\nSources :")
for doc in resultat["sources"]:
print(f" - {doc.metadata.get('source')} (page {doc.metadata.get('page', '?')})")
# Résultat attendu :
# Réponse : Selon [Source 1 : politique_confidentialite.pdf], les données des utilisateurs UE
# sont conservées 30 jours après la suppression du compte, conformément à l'article 17 RGPD.
#
# Sources :
# - politique_confidentialite.pdf (page 4)
# - accord_traitement_donnees.pdf (page 12)
7. Évaluation avec RAGAS
Cette section est le différenciateur central de ce guide. Sans évaluation, vous ne pouvez pas savoir si passer de la similarité à MMR a vraiment aidé, ou si un changement de prompt a amélioré la fidélité. RAGAS vous donne quatre métriques clés :
| Métrique | Ce qu'elle mesure | Cible |
|---|
| Fidélité | La réponse n'affirme que des faits présents dans le contexte récupéré | > 0,85 |
| Pertinence de la réponse | La réponse adresse effectivement la question posée | > 0,80 |
| Précision du contexte | Les chunks récupérés contiennent des informations pertinentes | > 0,75 |
| Rappel du contexte | Toutes les informations nécessaires ont été récupérées | > 0,80 |
7a. Construire un Dataset d'Évaluation
RAGAS nécessite un ensemble de test avec des questions, des réponses attendues et les contextes récupérés. Commencez avec 20-30 paires Q&R créées manuellement couvrant les sujets importants de votre base de connaissances.
from datasets import Dataset
# Ensemble d'évaluation (minimum viable : 20 exemples)
eval_data = [
{
"question": "Quelle est la durée de remboursement pour les produits numériques ?",
"ground_truth": "Les produits numériques sont éligibles à un remboursement de 14 jours s'ils n'ont pas été téléchargés.",
},
{
"question": "Quels data centers stockent les données des clients UE ?",
"ground_truth": "Les données des clients UE sont stockées exclusivement dans les régions AWS de Francfort (eu-central-1) et Dublin (eu-west-1).",
},
{
"question": "Quelle est la taille maximale des fichiers pour les uploads ?",
"ground_truth": "La taille maximale d'upload est de 500 Mo par fichier, avec un total de 5 Go par compte par jour.",
},
# Ajoutez 17+ exemples supplémentaires couvrant votre base de connaissances...
]
# Récupérer les contextes pour chaque question
def construire_dataset_eval(eval_data: list, retriever) -> Dataset:
lignes = []
for item in eval_data:
docs = retriever.invoke(item["question"])
lignes.append({
"question": item["question"],
"ground_truth": item["ground_truth"],
"contexts": [doc.page_content for doc in docs],
"answer": rag_chain_avec_sources.invoke(item["question"])["reponse"],
})
return Dataset.from_list(lignes)
eval_dataset = construire_dataset_eval(eval_data, reranking_retriever)
print(f"Dataset d'évaluation : {len(eval_dataset)} exemples")
7b. Lancer l'Évaluation RAGAS
from ragas import evaluate
from ragas.metrics import (
faithfulness,
answer_relevancy,
context_precision,
context_recall,
)
# Évaluer les quatre métriques
resultats = evaluate(
dataset=eval_dataset,
metrics=[faithfulness, answer_relevancy, context_precision, context_recall],
llm=llm, # Utilise votre LLM pour scorer les réponses
embeddings=embeddings_openai, # Utilise les embeddings pour le scoring de pertinence
)
print(resultats)
# Résultat attendu (bon système RAG) :
# {'faithfulness': 0.89, 'answer_relevancy': 0.84,
# 'context_precision': 0.78, 'context_recall': 0.82}
# Exporter les résultats détaillés par question
df = resultats.to_pandas()
df.to_csv("resultats_evaluation_rag.csv", index=False)
# Trouver les questions les moins performantes
pires = df.nsmallest(5, "faithfulness")[["question", "faithfulness", "contexts"]]
print("\nTop 5 questions avec faible fidélité :")
print(pires.to_string())
7c. Interpréter les Résultats et Itérer
| Symptôme | Cause racine | Correctif |
|---|
| Fidélité faible (<0,75) | Le LLM ajoute des informations absentes du contexte | Renforcer le prompt système : "Utilisez uniquement le contexte fourni". Utiliser temperature=0. |
| Précision contexte faible (<0,60) | La récupération ramène des chunks hors-sujet | Réduire chunk_size, ajouter des filtres de métadonnées, passer à MMR ou hybride |
| Rappel contexte faible (<0,70) | L'info pertinente n'est pas du tout récupérée | Augmenter k, vérifier le chunk_overlap, essayer le reranking |
| Pertinence réponse faible (<0,70) | La réponse dérive de la question ; prompt pauvre | Ajouter une instruction explicite de rester sur le sujet, améliorer le template de prompt |
# Test A/B des stratégies de récupération avec RAGAS
def benchmark_retriever(retriever, label: str):
dataset = construire_dataset_eval(eval_data, retriever)
scores = evaluate(dataset, metrics=[faithfulness, context_precision, context_recall], llm=llm, embeddings=embeddings_openai)
print(f"\n{label} :")
print(f" Fidélité : {scores['faithfulness']:.3f}")
print(f" Précision contexte: {scores['context_precision']:.3f}")
print(f" Rappel contexte: {scores['context_recall']:.3f}")
return scores
benchmark_retriever(retriever_sim, "Similarité (baseline)")
benchmark_retriever(retriever_mmr, "MMR")
benchmark_retriever(hybrid_retriever, "Hybride BM25+Sémantique")
benchmark_retriever(reranking_retriever, "Hybride + Reranking")
# Résultats réels sur une base de 5000 chunks :
# Similarité (baseline): Fidélité=0.79 Précision=0.64 Rappel=0.71
# MMR : Fidélité=0.81 Précision=0.70 Rappel=0.73
# Hybride BM25+Sémantique : Fidélité=0.84 Précision=0.76 Rappel=0.79
# Hybride + Reranking : Fidélité=0.89 Précision=0.81 Rappel=0.84
# → Le reranking ajoute +10pp de fidélité vs. baseline pour ~200ms de latence
8. Meilleures Pratiques de Production
Mettre en Cache les Embeddings pour Réduire les Coûts
from langchain.embeddings import CacheBackedEmbeddings
from langchain.storage import LocalFileStore
store = LocalFileStore("./cache_embeddings/")
embeddings_cached = CacheBackedEmbeddings.from_bytes_store(
underlying_embeddings=embeddings_openai,
document_embedding_cache=store,
namespace="text-embedding-3-small",
)
# Les requêtes répétées utilisent le cache disque, pas OpenAI — économise ~60% des coûts d'embeddings
Ajouter des Guardrails de Sécurité
def requete_securisee(question: str, longueur_max: int = 500) -> dict:
"""Valider et assainir l'entrée avant le traitement RAG."""
# Vérification de la longueur
if len(question) > longueur_max:
return {"erreur": "Question trop longue. Veuillez être plus concis."}
# Bloquer les tentatives d'injection de prompt
patterns_injection = ["ignore les instructions", "system prompt", "jailbreak"]
if any(p in question.lower() for p in patterns_injection):
return {"erreur": "Format de requête invalide."}
return rag_chain_avec_sources.invoke(question)
Surveiller la Latence en Production
import time
from dataclasses import dataclass
@dataclass
class MetriquesRequete:
question: str
retrieval_ms: float
generation_ms: float
total_ms: float
chunks_recuperes: int
def requete_avec_metriques(question: str) -> tuple[dict, MetriquesRequete]:
t0 = time.time()
docs = reranking_retriever.invoke(question)
t1 = time.time()
contexte = format_docs(docs)
reponse = (prompt | llm | StrOutputParser()).invoke(
{"context": contexte, "question": question}
)
t2 = time.time()
metriques = MetriquesRequete(
question=question,
retrieval_ms=(t1 - t0) * 1000,
generation_ms=(t2 - t1) * 1000,
total_ms=(t2 - t0) * 1000,
chunks_recuperes=len(docs),
)
return {"reponse": reponse, "sources": docs}, metriques
resultat, m = requete_avec_metriques("Quel est notre SLA pour les clients entreprise ?")
print(f"Total : {m.total_ms:.0f}ms (retrieval={m.retrieval_ms:.0f}ms, génération={m.generation_ms:.0f}ms)")
# Cible : retrieval < 200ms, génération < 2000ms, total < 2500ms
Prochaines Étapes
- RAG multi-documents : Combiner des données structurées (SQL), du texte non structuré et des APIs en temps réel dans un seul graphe de connaissances
- RAG conversationnel : Ajouter
ConversationBufferWindowMemory pour maintenir le contexte de session entre les tours - RAG agentique : Laisser LangGraph décider quand récupérer, quand raisonner et quand demander des clarifications
- Self-querying retriever : Le LLM génère automatiquement des filtres de métadonnées depuis le langage naturel
Pour une formation structurée sur ces sujets avancés :
- RAG et Agents en Production (3 jours intensifs) — RAG avancé, systèmes multi-agents LangGraph, déploiement production sur AWS Lambda
- Claude API pour Développeurs (2 jours) — Construire des systèmes RAG avec la fenêtre de contexte 200K tokens de Claude pour les grands ensembles de documents
Questions Fréquentes
Qu'est-ce qui différencie ce tutoriel RAG des autres ?
La plupart des tutoriels s'arrêtent quand la première réponse apparaît. Ce guide va plus loin : il inclut l'évaluation avec RAGAS — vous mesurez la fidélité, la pertinence des réponses et le rappel de contexte avec des chiffres réels, pas des impressions subjectives. Il couvre également les stratégies de récupération avancées (MMR, recherche hybride, reranking) qui font la différence entre un prototype et un système en production.
Ai-je besoin d'une clé API OpenAI pour suivre ce tutoriel ?
Non. Chaque exemple de code propose une alternative locale avec Ollama (gratuit, tourne sur votre machine). La version OpenAI est présentée en premier pour la clarté, mais les alternatives Ollama sont toujours fournies. Vous avez besoin d'au moins 16 Go de RAM et ~10 Go de disque pour les modèles locaux.
Qu'est-ce que RAGAS et pourquoi l'utiliser ?
RAGAS (Retrieval Augmented Generation Assessment) est un framework open-source qui évalue automatiquement quatre métriques clés : Fidélité (la réponse affirme-t-elle uniquement des faits présents dans le contexte récupéré ?), Pertinence de la réponse (la réponse répond-elle à la question posée ?), Précision du contexte (les chunks récupérés sont-ils pertinents ?), et Rappel du contexte (tous les faits nécessaires ont-ils été récupérés ?). Sans évaluation, vous pilotez à l'aveugle — des systèmes RAG qui 'semblent bien fonctionner' obtiennent souvent moins de 70% en fidélité.
Quand utiliser MMR plutôt que la recherche par similarité ?
Utilisez MMR (Maximal Marginal Relevance) quand votre base de connaissances contient beaucoup de documents similaires et que vous obtenez un contexte répétitif dans vos réponses. MMR pénalise explicitement la redondance en récupérant des chunks diversifiés-mais-pertinents au lieu des k plus similaires. Cas typique : une FAQ produit où beaucoup de questions se chevauchent — MMR récupère un chunk pertinent par sujet au lieu de cinq paraphrases de la même réponse.
Comment gérer les documents mis à jour fréquemment ?
Utilisez upsert de ChromaDB avec des IDs stables dérivés du hash du contenu ou du chemin du fichier + date de modification. Pour les mises à jour quotidiennes : récupérez les fichiers nouveaux/modifiés, faites un upsert uniquement des chunks modifiés (gardez les IDs stables pour le contenu inchangé). Hebdomadairement : lancez une vérification de cohérence complète en comparant votre système de fichiers au vector store et supprimez les chunks orphelins. Cela évite la réindexation complète qui peut prendre des heures sur de grands corpus.