BroadRouter

Taille des chunks et chevauchement en RAG : effets sur rappel et coût

Par l’équipe BroadNet Inference · 7 min de lecture · Publié · Mis à jour

Commencez avec des chunks d’environ 256 à 512 tokens, 0 à 15 % de chevauchement et un top-k réglé sur vos propres requêtes. Des chunks plus grands augmentent les tokens que chaque requête envoie au LLM. Le chevauchement multiplie les tokens vectorisés et stockés par taille ÷ (taille − chevauchement) : 50 % de chevauchement doublent l’index. Des tests publiés montrent que de petits chunks sans chevauchement rappellent souvent aussi bien, voire mieux.

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 :

  1. 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.
  2. 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 ?

  1. 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.
  2. Fixez le budget de contexte. Maintenez k × taille près d’une valeur, par exemple 2 000 tokens, pendant que vous comparez les tailles.
  3. 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.
  4. 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.
  5. 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.

Questions fréquentes

Quelle est une bonne taille de chunk pour le RAG ?

Commencez vers 256 à 512 tokens et testez. L’évaluation de Chroma a trouvé que 200 à 400 tokens sans chevauchement donnaient de bons résultats. NVIDIA a trouvé que 256 à 512 tokens convenaient aux questions factuelles, tandis que les questions analytiques réussissaient mieux avec des chunks de 1 024 tokens ou d’une page.

Quel chevauchement de chunks utiliser ?

Moins que la plupart des valeurs par défaut. Parmi les 10 %, 15 % et 20 % testés sur un jeu de données, NVIDIA a trouvé 15 % le meilleur. Chroma a constaté que les réglages sans chevauchement obtenaient souvent un score aussi bon, voire meilleur. Chaque point de chevauchement ajoute des tokens à vectoriser, stocker et envoyer.

Une taille de chunk plus grande coûte-t-elle plus cher ?

Pas à l’embedding, sans chevauchement : le corpus compte le même nombre de tokens. Elle coûte plus par requête, car chaque chunk récupéré est plus long, donc top-k × taille augmente. Baissez k quand vous augmentez la taille.

La taille des chunks se mesure-t-elle en tokens ou en caractères ?

Cela dépend du découpeur. Le RecursiveCharacterTextSplitter de LangChain mesure avec sa length_function, qui compte les caractères par défaut. Les limites d’embedding et les factures LLM sont en tokens : passez-lui un compteur de tokens.

Faut-il refaire les embeddings quand je change la taille des chunks ?

Oui. De nouvelles frontières créent de nouveaux chunks, et chacun a besoin d’un nouveau vecteur. Refaire les embeddings coûte à nouveau tout l’index : fixez donc le découpage sur un échantillon avant de vectoriser tout le corpus.

Lire en MarkdownDemander à ChatGPTDemander à ClaudeDemander à Perplexity