La taille des chunks et le chevauchement sont les deux nombres que tout pipeline RAG fixe tôt et revoit rarement. Ils déterminent combien de vecteurs vous stockez, combien de tokens vous vectorisez, combien de tokens chaque question envoie au LLM, et si le bon passage est seulement trouvé. Cet article présente ce qu’ont montré des tests publiés, puis déroule le calcul en tokens pour que vous voyiez le coût de chaque réglage avant de vectoriser quoi que ce soit.
Si vous hésitez encore à utiliser le RAG, commencez par contexte long ou RAG. Pour des documents en arabe, lisez aussi le RAG en arabe et la normalisation du texte arabe.
Que changent la taille des chunks et le chevauchement ?
- La taille des chunks est le nombre de tokens de chaque morceau que vous vectorisez et récupérez.
- Le chevauchement est le nombre de tokens partagés par deux chunks consécutifs, pour qu’une phrase coupée à une frontière apparaisse entière dans au moins un chunk.
- Le top-k est le nombre de chunks récupérés par question.
Ensemble, ils fixent quatre grandeurs :
| Grandeur | Formule (documents longs) |
|---|---|
| Chunks stockés | tokens du corpus ÷ (taille − chevauchement) |
| Tokens vectorisés | tokens du corpus × taille ÷ (taille − chevauchement) |
| Contexte par requête | top-k × taille |
| Entrée LLM par requête | top-k × taille + prompt système + question |
Les deux premières se paient une fois par indexation, puis de nouveau à chaque redécoupage. La dernière se paie à chaque question, indéfiniment.
Que disent les tests publiés sur la taille des chunks ?
Deux évaluations publiques méritent d’être connues, car elles ont mesuré des choses différentes.
Chroma (Smith et Troynikov, juillet 2024) a mesuré la recherche au niveau du token : quelle part du texte pertinent a été récupérée (rappel), et quelle part du texte récupéré était pertinente. L’évaluation utilisait cinq chunks récupérés et text-embedding-3-large d’OpenAI. Quelques lignes :
| Découpeur | Taille (tokens) | Chevauchement | Rappel | IoU |
|---|---|---|---|---|
| Recursive | 800 | 400 | 85,4 % | 1,5 % |
| Token | 800 | 400 | 87,9 % | 1,4 % |
| Recursive | 400 | 200 | 88,1 % | 3,3 % |
| Recursive | 400 | 0 | 89,5 % | 3,6 % |
| Recursive | 200 | 0 | 88,1 % | 6,9 % |
L’IoU (intersection over union) mesure quelle part du texte récupéré était pertinente : elle sert donc aussi de mesure des tokens gaspillés. Les lignes 800/400 correspondent au réglage par défaut de la recherche de fichiers d’OpenAI ; en supposant un découpeur par tokens, Chroma a trouvé que ce réglage donnait un rappel légèrement inférieur à la moyenne et les scores les plus bas sur les autres métriques. Des chunks plus petits sans chevauchement rappelaient autant ou plus, avec beaucoup moins de texte non pertinent.
NVIDIA (juin 2025) a mesuré la précision des réponses de bout en bout sur cinq jeux de données, avec des chunks de 128 à 2 048 tokens à 15 % de chevauchement, plus un découpage par page et par section. Le découpage par page a obtenu la meilleure précision moyenne (0,648) et la plus faible variance. La meilleure taille en tokens dépendait des questions : les jeux factuels favorisaient 256 à 512 tokens, les jeux analytiques 1 024 tokens ou des pages entières. Les deux extrêmes, 128 et 2 048, faisaient généralement moins bien.
Les deux s’accordent sur un point : il n’existe pas de taille idéale universelle, et de très gros chunks avec un fort chevauchement sont rarement le bon réglage par défaut.
De combien le chevauchement gonfle-t-il l’index ?
Chaque chunk avance de taille − chevauchement tokens : l’index contient donc taille ÷ (taille − chevauchement) copies du corpus. Pour un corpus de 2 000 000 tokens composé de documents de 10 000 tokens :
| Taille | Chevauchement | Chunks | Tokens vectorisés | Gonflement |
|---|---|---|---|---|
| 200 | 0 | 10 000 | 2 000 000 | 1,00× |
| 400 | 0 | 5 000 | 2 000 000 | 1,00× |
| 512 | 77 (15 %) | 4 600 | 2 338 800 | 1,17× |
| 1 024 | 154 (15 %) | 2 400 | 2 338 800 | 1,17× |
| 800 | 400 (50 %) | 4 800 | 3 840 000 | 1,92× |
| 400 | 200 (50 %) | 9 800 | 3 920 000 | 1,96× |
Les documents courts gonflent un peu moins, car leur dernier chunk est partiel. La formule donne la limite : 15 % de chevauchement coûtent environ 18 % de plus, et 50 % environ 100 % de plus, en tokens d’embedding, en stockage vectoriel et en temps de réindexation.
Le chevauchement coûte aussi au moment de la requête. Avec 50 % de chevauchement, deux chunks voisins récupérés pour la même question répètent la moitié de leur texte. Vous payez ces tokens en double, et ils poussent d’autres passages pertinents hors du top-k.
BroadNet ne vend pas d’embeddings : cette partie de la facture revient à votre fournisseur d’embeddings. Chiffrez-la avec le calculateur de coût d’embedding.
Quel effet la taille des chunks a-t-elle sur la facture LLM ?
Chaque question envoie top-k chunks plus le prompt. Prenons 100 000 questions par mois, 600 tokens de prompt système et de question, et la même réponse de 300 tokens à chaque fois :
| Taille × top-k | Contexte par requête | Entrée par requête | Entrée par mois |
|---|---|---|---|
| 200 × 10 | 2 000 | 2 600 | 260 millions |
| 400 × 5 | 2 000 | 2 600 | 260 millions |
| 512 × 5 | 2 560 | 3 160 | 316 millions |
| 800 × 5 | 4 000 | 4 600 | 460 millions |
| 1 024 × 5 | 5 120 | 5 720 | 572 millions |
| 1 024 × 8 | 8 192 | 8 792 | 879 millions |
La sortie fait 30 millions de tokens par mois sur chaque ligne : seule l’entrée change. Avec un prix par million de tokens, le coût d’entrée mensuel vaut le nombre de millions de la dernière colonne multiplié par ce prix. Sur Gemma 4 VL 26B, à $0.10 par million de tokens d’entrée, le réglage 1 024 × 8 coûte 879 × $0.10 par mois en entrée, contre 260 × $0.10 pour 400 × 5. C’est 3,4 fois plus, pour un réglage dont les tests publiés ne montrent pas un meilleur rappel. Sur Qwen3.8 27B ($0.175 en entrée) ou GLM 5.3 ($0.78 en entrée), le rapport est le même et les totaux sont plus élevés.
Deux leviers pèsent plus que le prix du modèle :
- Baissez k quand vous augmentez la taille. 200 × 10 et 400 × 5 envoient le même contexte. Gardez le contexte par requête à peu près fixe pendant que vous testez les tailles, pour comparer la qualité de la recherche et non le budget de contexte.
- Mettez en cache la partie fixe. Placez le prompt système en premier et gardez-le identique à l’octet près, pour qu’il puisse être facturé au tarif de l’entrée en cache sur les modèles qui en ont un. Les chunks récupérés changent à chaque question et se mettent rarement en cache.
Les limites de contexte comptent aussi. Gemma 4 VL 26B accepte 32 768 tokens par requête, largement assez pour chaque ligne ci-dessus. Si vous poussez k × taille vers des dizaines de milliers de tokens, vous êtes passé du RAG au contexte long, et cette comparaison a ses propres calculs. Le calculateur de découpage RAG applique ces formules à votre corpus, votre taille de chunk, votre chevauchement et votre top-k.
Comment découper par tokens sans couper les mots ?
Comptez en tokens, mais coupez sur la structure. Le RecursiveCharacterTextSplitter de LangChain mesure la taille avec sa length_function, qui compte les caractères par défaut. Une « taille » de 512 représente alors 512 caractères, soit grosso modo 100 à 150 tokens en anglais, et encore un autre nombre en arabe ; voir tokens par mot en arabe. Les limites d’embedding et les factures LLM sont en tokens.
Ce découpeur regroupe des paragraphes entiers jusqu’à un budget de tokens et reporte les derniers paragraphes comme chevauchement. Couper aux frontières de paragraphes évite de scinder des mots ou des caractères arabes multioctets, ce que peuvent faire des fenêtres de tokens brutes.
import tiktoken
enc = tiktoken.get_encoding("o200k_base") # an estimate: count with your embedder's tokenizer
count = lambda s: len(enc.encode(s))
def chunk(text, size=512, overlap=64):
"""Pack whole paragraphs up to `size` tokens; repeat trailing paragraphs up to `overlap` tokens."""
chunks, cur, cur_len = [], [], 0
for para in (p.strip() for p in text.split("\n\n")):
if not para:
continue
n = count(para)
if cur and cur_len + n > size:
chunks.append("\n\n".join(cur))
tail, t = [], 0
for q in reversed(cur): # carry the end of this chunk forward
if t + count(q) > overlap:
break
tail.insert(0, q); t += count(q)
cur, cur_len = tail, t
cur.append(para); cur_len += n # a paragraph over `size` stays whole
if cur:
chunks.append("\n\n".join(cur))
return chunks
def plan(corpus_tokens, size, overlap, k, queries_per_month, prompt_tokens=600):
index_tokens = corpus_tokens * size / (size - overlap) # long-document limit
per_query = k * size + prompt_tokens
return {"chunks": round(index_tokens / size), "tokens_to_embed": round(index_tokens),
"input_per_query": per_query, "input_per_month": per_query * queries_per_month}
print(plan(2_000_000, 512, 64, 5, 100_000))
# {'chunks': 4464, 'tokens_to_embed': 2285714, 'input_per_query': 3160, 'input_per_month': 316000000}
Le chevauchement s’entend ici « jusqu’à » : un paragraphe plus long que le budget de chevauchement n’est pas répété. Un paragraphe isolé plus long que size reste entier ; scindez d’abord ces paragraphes en phrases si vos documents s’y prêtent. Préfixez chaque chunk avec le titre du document et l’intitulé de la section, pour qu’un chunk récupéré dise encore de quoi il parle. Cela ajoute quelques tokens par chunk et aide souvent davantage que le chevauchement.
Comment choisir les valeurs pour vos données ?
- Constituez un jeu d’évaluation. 50 à 200 vraies questions, chacune avec le passage qui y répond. Le guide d’évaluation des LLM traite de la notation.
- Fixez le budget de contexte. Maintenez k × taille près d’une valeur, par exemple 2 000 tokens, pendant que vous comparez les tailles.
- Essayez trois tailles et deux chevauchements. Par exemple 256, 512 et 1 024 tokens, chacun à 0 et 15 % de chevauchement. Mesurez le rappel du bon passage à k.
- Essayez la structure. Si vos documents ont des pages ou des sections numérotées, testez un découpage par page ou par section face aux tailles en tokens. NVIDIA a trouvé le découpage par page le plus régulier.
- Choisissez le réglage le moins cher à un ou deux points du meilleur rappel, puis chiffrez-le à votre volume de requêtes avec la méthode du coût mensuel.
Faites-le sur un échantillon avant de vectoriser tout le corpus. Changer de découpage plus tard implique de refaire tous les embeddings.
La place de BroadNet Inference
BroadNet Inference sert l’étape de réponse du RAG, pas la recherche. BroadNet ne vend ni embeddings ni stockage vectoriel : associez-le à un fournisseur d’embeddings et à la base vectorielle de votre choix. Pour la réponse, Gemma 4 VL 26B est l’option économique et fonctionne avec le crédit de départ de $5. Qwen3.8 27B (contexte de 262 144 tokens) et GLM 5.3 (1 048 576) conviennent à un top-k plus grand ou à des documents longs, après une recharge. Les prompts et les passages récupérés ne sont pas conservés après la requête. Si votre corpus est assez petit et stable pour tenir dans la fenêtre de contexte, le contexte long peut battre le découpage tout court.
