Avancé 15 minOptimisation

Stratégies de chunking

Le chunking — découper un document en morceaux avant de l'indexer — est le paramètre le plus sous-estimé d'un RAG. Un mauvais chunking annule l'intérêt du meilleur embedding et du meilleur LLM. Ce guide montre les 5 stratégies courantes, leurs impacts mesurables, et quand utiliser laquelle.

Par Mohamed Meguedmi·Màj 2026-02-18·Testé sur Windows, macOS, Linux

#Pourquoi ça compte plus que l'embedding

Changer l'embedding peut donner +5 % de pertinence. Changer de chunking peut donner +30 %. L'embedding place le chunk dans l'espace sémantique — si le chunk est mal découpé, l'espace est mal peuplé et toute la pipeline part en vrille.

i
L'intuition
Un chunk idéal contient une seule idée complète. Trop petit : l'idée est coupée en deux, l'embedding est flou. Trop grand : plusieurs idées se mélangent, la recherche sélectionne trop de bruit.

#Quelle taille de chunk ?

200-400 tokens
Court. Bon pour questions très précises ("quelle est la date X dans le contrat Y ?"). Risque : perd le contexte autour.
500-800 tokens
Sweet spot général. Une idée développée tient, l'embedding est encore précis.
1000-1500 tokens
Long. Conserve le contexte, mais dilue le signal. Utile pour des docs où les idées sont très étendues (essais, thèses).
> 2000 tokens
Trop. Le chunk devient un résumé flou d'un gros bloc. Préférez un chunking hiérarchique (voir plus bas).
→
Règle de pouce
Commencez à 700 tokens avec 150 de recouvrement. Ajustez seulement après avoir mesuré la qualité.

#Recouvrement (overlap)

Le recouvrement, c'est les derniers N tokens d'un chunk qui sont répétés au début du chunk suivant. Il évite de couper en plein milieu d'une idée.

0 tokens
Aucun recouvrement. Simple mais perd les idées qui chevauchent deux chunks.
100-200 tokens (15-25 %)
Valeur courante. Compromis coût/qualité raisonnable.
300+ tokens (40 %+)
Beaucoup de redondance. Utile pour des domaines très denses (code, texte juridique). Coût : plus de chunks à stocker.

#5 stratégies classées du pire au meilleur

#1. Par caractères fixes (le pire)

text[i:i+chunk_size]. Coupe au milieu des mots, des phrases, des idées. Ne l'utilisez que pour prototyper.

#2. Par phrases / paragraphes

Découper sur les doubles retours à la ligne (paragraphes) ou les points (phrases). Gros progrès par rapport au caractère brut.

#3. Récursif (LangChain, LlamaIndex)

Essaye d'abord de couper sur les gros délimiteurs (\n\n, \n, ., espace), en dernier recours sur le caractère. Le défaut dans la plupart des frameworks. Correct.

#4. Structure-aware (Markdown, HTML, code)

Respecte les titres, sections, listes. Un titre reste avec son paragraphe. Un bloc de code ne se coupe jamais au milieu. Gros bond qualité sur du contenu structuré.

#5. Sémantique (le meilleur, le plus cher)

On génère des embeddings par phrase, on détecte les ruptures sémantiques (distance cosinus qui dépasse un seuil), on coupe là. Qualité inégalée sur du texte libre mal structuré. Coût en CPU significatif à l'indexation.

#Implémentations

#Récursif (LlamaIndex)

SentenceSplitter
from llama_index.core.node_parser import SentenceSplitter

splitter = SentenceSplitter(
    chunk_size=700,
    chunk_overlap=150,
    paragraph_separator="\n\n",
)
nodes = splitter.get_nodes_from_documents(docs)

#Structure-aware Markdown

MarkdownNodeParser
from llama_index.core.node_parser import MarkdownNodeParser

parser = MarkdownNodeParser()
nodes = parser.get_nodes_from_documents(docs)
# Les titres #, ##, ### deviennent des métadonnées attachées à chaque chunk

#Sémantique

SemanticSplitterNodeParser
from llama_index.core.node_parser import SemanticSplitterNodeParser
from llama_index.embeddings.huggingface import HuggingFaceEmbedding

embed = HuggingFaceEmbedding(model_name="BAAI/bge-m3")
splitter = SemanticSplitterNodeParser(
    embed_model=embed,
    buffer_size=1,
    breakpoint_percentile_threshold=95,
)
nodes = splitter.get_nodes_from_documents(docs)

#Évaluer son chunking

Sans mesure, on tourne dans le noir. Protocole minimal :

  1. 01
    Jeu de 30-50 questions-réponses
    Questions que vous poseriez vraiment, réponses que vous attendez. Ne trichez pas : écrivez-les avant d'évaluer.
  2. 02
    Métrique : recall@k
    Pour chaque question, le passage attendu est-il dans les top-k (ex : top-5) retrouvés ? Pourcentage = recall@5.
  3. 03
    A/B entre deux stratégies
    Indexez votre corpus avec stratégie A puis B. Mesurez recall@5 sur les 2. L'écart est très éloquent.
  4. 04
    Tunez
    Changez chunk_size (400 / 700 / 1000), overlap (50 / 150 / 250), et regardez la courbe.

#Pièges fréquents

Tables coupées
Un PDF avec tableaux : parseur par défaut casse la structure. Utilisez unstructured.io ou PyMuPDF avec extraction de tables.
Code source dans un chunk texte
Le markdown-aware splitter préserve les blocs ```. Sans lui, un bloc se coupe et tout est cassé.
Documents multilingues
Un chunk moitié français moitié anglais a un embedding moyen inutile. Séparez par langue avant.
Chunks avec uniquement des titres
"Section 3.2.1 — Obligations" sans le texte qui suit, c'est du bruit. Filtrez les chunks < 100 chars.
Ce guide vous a aidé ?

Un retour, une erreur, une précision ? Faites-nous signe, ça améliore le guide pour tout le monde.