---
title: "Taille des chunks RAG et chevauchement : recherche et coût"
description: "Comment la taille des chunks et le chevauchement changent le rappel, l’index, le coût d’embedding et les tokens envoyés au LLM, avec résultats publiés et calculs."
url: https://broadrouter.com/fr/blog/rag-chunk-size-overlap/
lang: fr
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Traduit de l’anglais avec l’aide de l’IA. [Lire l’original en anglais](https://broadrouter.com/blog/rag-chunk-size-overlap/) (mis à jour le 2026-11-16).

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

Par l’équipe BroadNet Inference · 7 min de lecture · Publié 2026-11-15 · Mis à jour 2026-11-16

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.

## À retenir

-   L’entrée par requête vaut à peu près top-k × taille de chunk + prompt. Passer de 5 × 400 à 8 × 1 024 tokens envoie environ 3,4 fois plus d’entrée à chaque requête.
-   Le chevauchement gonfle l’index d’un facteur taille ÷ (taille − chevauchement) : 15 % de chevauchement ajoutent jusqu’à environ 18 % (17 % sur les documents de 10 000 tokens mesurés ici), et 50 % le doublent.
-   Dans l’évaluation de Chroma de 2024, des chunks de 200 à 400 tokens sans chevauchement ont égalé ou battu des chunks de 800 tokens avec 400 de chevauchement, le réglage par défaut de la recherche de fichiers d’OpenAI.
-   Les tests de NVIDIA en 2025 n’ont trouvé aucune taille idéale unique : les questions factuelles favorisaient 256 à 512 tokens, les questions analytiques 1 024 tokens ou une page.
-   Mesurez la taille des chunks en tokens de votre modèle d’embedding. Certains découpeurs comptent des caractères par défaut.

**Sur cette page**

1.  Que changent la taille des chunks et le chevauchement ?
2.  Que disent les tests publiés sur la taille des chunks ?
3.  De combien le chevauchement gonfle-t-il l’index ?
4.  Quel effet la taille des chunks a-t-elle sur la facture LLM ?
5.  Comment découper par tokens sans couper les mots ?
6.  Comment choisir les valeurs pour vos données ?
7.  La place de BroadNet Inference

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](https://broadrouter.com/fr/blog/long-context-vs-rag/). Pour des documents en arabe, lisez aussi [le RAG en arabe](https://broadrouter.com/fr/blog/arabic-rag-search/) et [la normalisation du texte arabe](https://broadrouter.com/fr/blog/arabic-text-normalization-search/).

## 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](https://broadrouter.com/tools/embedding-cost-calculator/).

## 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](https://broadrouter.com/fr/models/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](https://broadrouter.com/fr/models/qwen3.8-27b/) ($0.175 en entrée) ou [GLM 5.3](https://broadrouter.com/fr/models/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](https://broadrouter.com/fr/blog/cached-input-tokens-explained/) 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](https://broadrouter.com/fr/blog/long-context-vs-rag/), et cette comparaison a ses propres calculs. Le [calculateur de découpage RAG](https://broadrouter.com/tools/rag-chunking-calculator/) 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](https://broadrouter.com/fr/blog/tokens-per-word-arabic-english/). 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.

```python
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](https://broadrouter.com/fr/blog/evaluate-llm-before-switching/) 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](https://broadrouter.com/fr/blog/estimate-llm-api-cost-before-launch/).

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](https://broadrouter.com/fr/blog/long-context-vs-rag/) peut battre le découpage tout court.

Outils gratuits sur ce sujet (en anglais)

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[Outils gratuits (en anglais)](https://broadrouter.com/tools/)

## Termes de cet article

[Token](https://broadrouter.com/fr/glossary/token/)

Un token est l’unité de texte qu’un modèle de langage lit et écrit : un mot, une partie de mot, un signe de ponctuation ou une suite d’octets produite par le tokenizer du modèle. Les API LLM comptent, limitent et facturent généralement l’usage en tokens.

[Embeddings (plongements vectoriels)](https://broadrouter.com/fr/glossary/embeddings/)

Les embeddings sont des listes de nombres à virgule flottante (des vecteurs) qu’un modèle produit pour représenter un texte, une image ou une autre entrée. Des entrées de sens proche obtiennent des vecteurs voisins : la distance entre vecteurs permet de classer des résultats de recherche, de regrouper des documents ou de trouver des éléments apparentés.

[RAG (génération augmentée par récupération)](https://broadrouter.com/fr/glossary/rag/)

Le RAG (retrieval-augmented generation, génération augmentée par récupération) est une approche dans laquelle une application récupère d’abord, dans une source externe comme un index de recherche ou un index vectoriel, les passages pertinents pour une question, puis les ajoute au prompt pour qu’un modèle de langage réponde à partir de ce texte et pas seulement de sa mémoire.

[Prompt système (system prompt)](https://broadrouter.com/fr/glossary/system-prompt/)

Le prompt système est le texte d’instructions qu’une application envoie à un modèle de langage avant la conversation, généralement sous forme de message au rôle system ou developer. Il fixe le rôle, les règles, le ton et le format de sortie du modèle, qui est censé le suivre même face à des messages contradictoires de l’utilisateur.

[Appel d’outils (tool calling, function calling)](https://broadrouter.com/fr/glossary/tool-calling/)

L’appel d’outils, aussi appelé function calling, est une fonctionnalité des API LLM dans laquelle le modèle renvoie une demande structurée d’exécution d’une fonction définie par le développeur, avec des arguments JSON. L’application exécute la fonction et renvoie le résultat ; le modèle n’exécute jamais de code lui-même.

[Base de données vectorielle (vector database)](https://broadrouter.com/fr/glossary/vector-database/)

Une base de données vectorielle est un système de stockage qui conserve des vecteurs d’embedding, souvent avec leur texte source et des métadonnées, et répond aux requêtes de plus proches voisins : pour un vecteur de requête, elle renvoie les vecteurs stockés les plus similaires, en général selon la distance cosinus, la distance euclidienne ou le produit scalaire.

[Chunking (découpage pour le RAG)](https://broadrouter.com/fr/glossary/chunking/)

Le chunking est l’étape d’un pipeline de récupération qui découpe les documents en morceaux plus petits, les chunks, avant de les vectoriser et de les indexer. La taille de chunk fixe la quantité de texte par morceau, et le chevauchement répète un peu de texte entre chunks voisins pour ne pas perdre les idées coupées à une frontière.

[Crédit prépayé (prepaid credit)](https://broadrouter.com/fr/glossary/prepaid-credit/)

Le crédit prépayé est de l’argent versé sur un compte API avant utilisation. Chaque requête déduit son coût du solde, et quand le solde est épuisé, les requêtes facturées s’arrêtent jusqu’à la prochaine recharge. Les dépenses sont ainsi plafonnées à ce que vous avez versé.

## 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 ensuite

-   [Contexte long ou RAG : quand 1M de tokens remplace la base vectorielle](https://broadrouter.com/fr/blog/long-context-vs-rag/)
-   [RAG en arabe : normalisation, chunking et recherche qui fonctionnent](https://broadrouter.com/fr/blog/arabic-rag-search/)
-   [Normaliser le texte arabe pour la recherche et le RAG : quoi changer](https://broadrouter.com/fr/blog/arabic-text-normalization-search/)
-   [Estimer le coût d’une API LLM avant de lancer une fonctionnalité](https://broadrouter.com/fr/blog/estimate-llm-api-cost-before-launch/)
-   [Tokens d’entrée en cache : réduire la facture d’une API LLM](https://broadrouter.com/fr/blog/cached-input-tokens-explained/)
-   [Matériel GPU et serving de BroadNet, tels que BroadNet les décrit](https://broadrouter.com/fr/blog/broadnet-gpu-fleet-and-serving/)
-   [Mettre en cache les réponses d’API LLM : un cache exact en Python](https://broadrouter.com/fr/blog/cache-llm-responses-cut-cost/)
-   [Guide : Utiliser le SDK Python d’OpenAI avec BroadNet Inference](https://broadrouter.com/fr/guides/openai-python-sdk/)

Essayez-le sur votre vraie charge de travail. Les nouveaux comptes démarrent avec USD 5 de crédit pour Gemma et transcription. DeepSeek, GLM et Qwen3.8 nécessitent une recharge.

[Commencer](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-blog-rag-chunk-size-overlap&utm_content=page-cta) ·

**Sources**

-   [Smith et Troynikov, Evaluating Chunking Strategies for Retrieval, rapport technique de Chroma, juillet 2024 (vérifié le 2026-11-15)](https://research.trychroma.com/evaluating-chunking)
-   [NVIDIA Technical Blog, Finding the Best Chunking Strategy for Accurate AI Responses, juin 2025 (vérifié le 2026-11-15)](https://developer.nvidia.com/blog/finding-the-best-chunking-strategy-for-accurate-ai-responses/)
-   [Guide de retrieval d’OpenAI : chunks de 800 tokens avec 400 tokens de chevauchement par défaut, limites de chunking\_strategy (vérifié le 2026-11-15)](https://developers.openai.com/api/docs/guides/retrieval)
-   [Documentation LangChain, RecursiveCharacterTextSplitter : taille des chunks mesurée par length\_function, en caractères par défaut (vérifié le 2026-11-15)](https://docs.langchain.com/oss/python/integrations/splitters/recursive_text_splitter)
-   [Prix et référence de l’API de BroadNet Inference : modèles, longueurs de contexte, entrée en cache (vérifié le 2026-11-15) (en anglais)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-blog-rag-chunk-size-overlap&utm_content=sources)
