---
title: "Le chunking en IA : un guide pratique clair"
description: "Le chunking est une méthode de prétraitement en IA qui consiste à diviser de grands textes ou ensembles de données en petites parties plus faciles à gérer."
locale: "fr"
slug: "le-chunking-en-ia-un-guide-pratique-clair"
type: "insights"
canonical: "https://sechak.com/fr/insights/le-chunking-en-ia-un-guide-pratique-clair"
markdown: "https://sechak.com/fr/insights/le-chunking-en-ia-un-guide-pratique-clair.md"
published: "2026-05-22T00:46:01.469Z"
updated: "2026-05-22T00:46:01.268Z"
category: "IA"
read_time_minutes: "3"
---
# Le chunking en IA : un guide pratique clair

Le chunking est une méthode de prétraitement en IA qui consiste à diviser de grands textes ou ensembles de données en petites parties plus faciles à gérer.

Le chunking est le processus qui consiste à découper des documents longs en unités plus petites afin que les modèles de langage puissent les indexer, les récupérer et raisonner dessus de manière plus efficace. Dans les systèmes de récupération, le chunking est important parce que le modèle ne recherche pas des livres entiers ou des rapports d’un seul coup ; il recherche les chunks qui les représentent, donc la qualité des chunks influence directement la pertinence, le rappel et la fidélité des réponses.

Un bon chunk est suffisamment petit pour rentrer dans les limites du modèle et des embeddings, mais assez grand pour préserver une idée cohérente. C’est pourquoi les bibliothèques modernes exposent plusieurs stratégies de chunking plutôt qu’une valeur par défaut universelle : les différentes structures de documents, les domaines et les objectifs de récupération nécessitent des frontières différentes.

## Pourquoi le chunking compte

Les documents longs dépassent les limites d’entrée pratiques des modèles d’embedding et des pipelines de récupération, il faut donc les décomposer en unités plus petites et récupérables. Les approches basées sur la longueur sont simples et constantes, alors que les approches conscientes de la structure ou sémantiques tentent de préserver le sens, l’organisation ou les deux.

En pratique, un mauvais chunking engendre deux problèmes récurrents. Si les chunks sont trop petits, le sens est fragmenté et la récupération renvoie des faits isolés sans contexte suffisant ; si les chunks sont trop grands, des textes non pertinents diluent la recherche de similarité et gaspillent le budget de la fenêtre de contexte.

## Les grandes familles de chunking

### 1. Chunking de taille fixe

Le chunking de taille fixe découpe le texte selon un nombre constant de caractères ou de tokens. Sa principale force est sa prévisibilité : chaque chunk suit la même limite, ce qui rend l’indexation simple et efficace, surtout pour les baselines et les pipelines volumineux.

Sa faiblesse est l’aveuglement sémantique. Un chunk peut commencer au milieu d’un argument et finir au milieu d’une phrase, ce qui nuit souvent à la qualité de la récupération pour des contenus riches en concepts, comme les documents juridiques, scientifiques ou techniques.

```python
from langchain_text_splitters import CharacterTextSplitter

text_splitter = CharacterTextSplitter.from_tiktoken_encoder(
    encoding_name="cl100k_base",
    chunk_size=300,
    chunk_overlap=40,
)

chunks = text_splitter.split_text(document)
```

Quand l’utiliser :
- Pour des expériences rapides de baseline.
- Sur des corpus très volumineux où la simplicité compte.
- Dans des pipelines où un reranking downstream compensera des frontières approximatives.

### 2. Chunking récursif

Le chunking récursif est une stratégie consciente de la structure qui essaie de garder d’abord des unités de langage plus grandes intactes, comme les paragraphes, et redescend seulement sur des unités plus petites comme les phrases ou les mots lorsque le chunk est encore trop grand. Le `RecursiveCharacterTextSplitter` de LangChain est construit autour de cette idée.

C’est souvent une bonne valeur par défaut car il équilibre contrôle de la taille et flux naturel du texte. Il produit en général des chunks plus lisibles et plus récupérables que le découpage fixe sans besoin d’embeddings lors de la segmentation.

```python
from langchain_text_splitters import RecursiveCharacterTextSplitter

text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=500,
    chunk_overlap=80,
    separators=["\\\\n\\\\n", "\\\\n", ". ", " ", ""],
)

chunks = text_splitter.split_text(document)
```

Quand l’utiliser :
- Pour des systèmes RAG généralistes.
- Pour du texte non structuré mixte.
- Pour des documents où les frontières de paragraphes correspondent à peu près aux idées.

### 3. Chunking sémantique

Le chunking sémantique regroupe des phrases proches en sens plutôt que seulement proches en position. LlamaIndex décrit son `SemanticSplitterNodeParser` comme un parseur qui crée des nœuds à partir de groupes de phrases sémantiquement liées, en utilisant un modèle d’embedding et une règle de seuil de similarité.

Cette méthode améliore généralement la cohérence conceptuelle, surtout lorsque les sujets changent à l’intérieur de longs paragraphes. Son coût est une plus grande complexité, car le splitteur a lui‑même besoin d’embeddings et d’ajustement de seuils, et les longueurs de chunks peuvent devenir irrégulières si aucune limite dure n’est ajoutée.

```python
from llama_index.core.node_parser import SemanticSplitterNodeParser
from llama_index.embeddings.openai import OpenAIEmbedding

splitter = SemanticSplitterNodeParser.from_defaults(
    embed_model=OpenAIEmbedding(),
    buffer_size=1,
    breakpoint_percentile_threshold=95,
)

nodes = splitter.build_semantic_nodes_from_documents(documents)
```

Quand l’utiliser :
- Pour des bases de connaissances avec de nombreuses transitions conceptuelles denses.
- Pour des documents scientifiques, juridiques ou de documentation produit.
- Pour une récupération haute précision où la cohérence sémantique compte plus que la taille uniforme.

### 4. Chunking basé sur la structure du document

Certains documents contiennent déjà des frontières significatives : titres Markdown, sections HTML, objets JSON ou fonctions de code. LangChain recommande de découper ces contenus selon leur propre structure car cela préserve l’organisation logique et garde souvent ensemble le texte sémantiquement lié.

C’est l’une des stratégies les plus sous‑utilisées dans les systèmes de production. Si la source définit déjà des sections, la meilleure frontière est souvent celle que l’auteur a écrite, plutôt qu’une inférée plus tard par un splitteur générique.

```python
from langchain_text_splitters import MarkdownHeaderTextSplitter

headers_to_split_on = [
    ("#", "h1"),
    ("##", "h2"),
    ("###", "h3"),
]

splitter = MarkdownHeaderTextSplitter(headers_to_split_on=headers_to_split_on)
chunks = splitter.split_text(markdown_text)
```

D’autres schémas utiles guidés par la structure incluent :
- HTML par section ou balise.
- JSON par objet ou élément de tableau.
- Code par classe, fonction ou bloc de fichier.

### 5. Chunking basé sur les éléments et aware des tableaux

Le chunking basé sur les éléments découpe un document selon des éléments détectés tels que titres, paragraphes, listes, tableaux, figures ou blocs de code, plutôt que de traiter le fichier entier comme un texte continu. Il diffère ainsi du chunking par phrases ou par paragraphes : les méthodes phrases/paragraphes préservent les frontières linguistiques, alors que les méthodes basées sur les éléments préservent les objets de document et la sémantique de mise en page.

Le chunking aware des tableaux est une forme spécifique de chunking basée sur les éléments pour du contenu structuré. Son but est de garder les lignes, les en‑têtes et les relations entre cellules intactes, car un tableau perd son sens lorsque les valeurs sont séparées de leurs noms de colonne ou lorsque des lignes sont coupées sur des fenêtres de texte arbitraires.

Cette distinction est importante dans les PDF, rapports annuels, factures, articles scientifiques et catalogues produits. Dans ces sources, un tableau n’est pas juste un autre paragraphe ; c’est une structure relationnelle compacte qui a souvent besoin de sa propre stratégie de parsing et de sérialisation avant l’embedding.

```python
def serialize_table(headers, rows):
    chunks = []
    for row in rows:
        item = ", ".join(f"{h}: {v}" for h, v in zip(headers, row))
        chunks.append(item)
    return chunks

headers = ["Product", "Price", "Stock"]
rows = [
    ["Widget A", "$29", "150"],
    ["Widget B", "$35", "80"],
]

table_chunks = serialize_table(headers, rows)
```

Un pipeline pratique basé sur les éléments ressemble souvent à ceci :
- Détecter les éléments du document avec un parseur ou un outil de layout/OCR.
- Garder les titres, paragraphes et listes comme unités séparées.
- Sérialiser les tableaux en snippets texte ligne‑par‑ligne ou tableau‑par‑tableau avec les en‑têtes attachés.
- Appliquer un splitting récursif ou sémantique seulement à l’intérieur des éléments trop gros.

### 6. Chunking par phrases ou par paragraphes

Le chunking par phrases préserve les frontières de phrases, alors que le chunking par paragraphes préserve les paragraphe tels que définis par l’auteur. Ces méthodes sont simples, interprétables et souvent performantes sur du contenu éditorial ou scientifique où les phrases et paragraphes portent déjà des unités cohérentes de pensée.

Ils ne sont pas identiques au chunking basé sur les éléments. Un splitteur par phrases opère sur les frontières du texte continu, tandis qu’un splitteur d’éléments commence par se demander quel type d’objet il traite ; par exemple, un paragraphe, une liste à puces ou un tableau peuvent chacun demander une politique différente.

Ils sont moins adaptatifs que les méthodes récursives ou sémantiques, mais plus faciles à déboguer. Dans de nombreux systèmes, le chunking par paragraphes avec un léger chevauchement est un compromis pratique entre fenêtres fixe brutes et un splitting sémantique plus coûteux.

```python
paragraphs = [p.strip() for p in document.split("\\n\\n") if p.strip()]

chunks = []
current = ""
for p in paragraphs:
    candidate = (current + "\\n\\n" + p).strip() if current else p
    if len(candidate) < 800:
        current = candidate
    else:
        if current:
            chunks.append(current)
        current = p
if current:
    chunks.append(current)
```

### 7. Chunking sensible aux tokens

Les contraintes de longueur dans les systèmes modernes d’IA sont, en fin de compte, des contraintes de tokens, pas de caractères. LangChain expose un splitting basé sur les tokens parce que les compteurs de tokens correspondent plus directement aux fenêtres de contexte des modèles et aux limites d’embedding que les compteurs de caractères bruts.

Cela compte lorsqu’on travaille avec plusieurs langues, du code ou du markup, où le même nombre de caractères peut se traduire par des nombres de tokens très différents. Le chunking sensible aux tokens est donc plus sûr que la simple comptabilité de caractères lorsque la précision du budget est importante.

```python
from langchain_text_splitters import CharacterTextSplitter

splitter = CharacterTextSplitter.from_tiktoken_encoder(
    encoding_name="cl100k_base",
    chunk_size=256,
    chunk_overlap=32,
)
chunks = splitter.split_text(document)
```

## Chevauchement et contrôle des frontières

Le chevauchement de chunks répète une petite partie du texte voisin afin que les informations proches des frontières soient moins susceptibles d’être perdues. Le chevauchement peut améliorer la continuité de la récupération, mais un trop grand chevauchement augmente la taille de l’index, la redondance et la probabilité de récupérer des passages quasi‑dupliqués.

Une règle pratique simple est d’utiliser du chevauchement lorsque l’on découpe par longueur ou par récursion, et d’en utiliser moins lorsque les chunks sont déjà alignés sur des structures fortes telles que les titres ou les ruptures sémantiques. Par exemple, un splitteur récursif avec 10 à 20 pour cent de chevauchement est souvent un point de départ raisonnable pour du texte technique, puis ajusté après observation des résultats de récupération.

```python
splitter = RecursiveCharacterTextSplitter(
    chunk_size=600,
    chunk_overlap=90,
)
```

## Exemples de frameworks

### LangChain

LangChain fournit plusieurs familles de splitters, incluant les splitters récursifs, basés sur les tokens et basés sur la structure pour des formats tels que Markdown, HTML, JSON et code. Cela en fait un choix pratique lorsque la stratégie de chunking doit être changée rapidement pendant l’expérimentation.

```python
from langchain_text_splitters import (
    RecursiveCharacterTextSplitter,
    MarkdownHeaderTextSplitter,
)

recursive = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50)
plain_chunks = recursive.split_text(document)

md_splitter = MarkdownHeaderTextSplitter(
    headers_to_split_on=[("#", "h1"), ("##", "h2")]
)
md_chunks = md_splitter.split_text(markdown_text)
```

### LlamaIndex

LlamaIndex propose un splitting sémantique via `SemanticSplitterNodeParser`, où les points de rupture sont guidés par la dissimilarité sémantique entre groupes de phrases et peuvent être réglés via des paramètres tels que `buffer_size` et `breakpoint_percentile_threshold`. C’est particulièrement utile lorsque les frontières de chunks doivent suivre les transitions de sujet plutôt que les symboles de formatage.

```python
from llama_index.core import Document
from llama_index.core.node_parser import SemanticSplitterNodeParser
from llama_index.embeddings.openai import OpenAIEmbedding

parser = SemanticSplitterNodeParser.from_defaults(
    embed_model=OpenAIEmbedding(),
    buffer_size=1,
    breakpoint_percentile_threshold=95,
)

nodes = parser.build_semantic_nodes_from_documents([
    Document(text=document)
])
```

### Chunker sémantique minimal personnalisé

Un chunker sémantique personnalisé est utile lorsque l’adoption complète d’un framework n’est pas nécessaire. L’idée de base est de découper en phrases, d’encoder chaque phrase en embedding, de calculer la similarité entre voisines, puis d’ouvrir un nouveau chunk lorsque la distance sémantique franchit un seuil.

```python
from sentence_transformers import SentenceTransformer
from sklearn.metrics.pairwise import cosine_similarity
import numpy as np
import re

model = SentenceTransformer("all-MiniLM-L6-v2")
sentences = [s.strip() for s in re.split(r"(?<=[.!?])\\s+", document) if s.strip()]
emb = model.encode(sentences)

chunks, current = [], [sentences]
for i in range(1, len(sentences)):
    sim = cosine_similarity([emb[i-1]], [emb[i]])
    if sim < 0.65:
        chunks.append(" ".join(current))
        current = [sentences[i]]
    else:
        current.append(sentences[i])
if current:
    chunks.append(" ".join(current))
```

## Choisir la bonne stratégie

Aucune méthode de chunking n’est meilleure dans tous les cas. La bonne méthode dépend du format de la source, de l’objectif de récupération et du compromis acceptable entre simplicité, coût et fidélité sémantique.

| Scénario | Stratégie recommandée | Pourquoi |
|---|---|---|
| Corpus de texte brut | Chunking récursif | Préserve les frontières naturelles tout en gardant la taille sous contrôle. |
| Documents Markdown ou HTML | Chunking basé sur la structure | Les titres et sections encodent déjà le sens. |
| Texte scientifique ou juridique | Chunking sémantique | La continuité thématique compte plus que la longueur de chunk égale. |
| Rapports PDF avec tableaux | Chunking basé sur les éléments ou aware des tableaux | Préserve les objets de mise en page et garde les relations tabulaires intactes. |
| Système baseline rapide | Chunking de taille fixe ou basé sur les tokens | Facile à implémenter et à benchmarker. |
| Dépôt de code | Découpage structurel du code | Les fonctions et classes sont plus significatives que des fenêtres arbitraires. |

Un workflow d’ingénierie pratique est simple :
1. Commencer par un splitting récursif ou basé sur la structure.
2. Mesurer la qualité de récupération sur de vraies requêtes.
3. Passer au chunking sémantique lorsque les échecs viennent du mélange de sujets ou de mauvaises frontières conceptuelles.
4. Ajuster la taille des chunks et le chevauchement seulement après inspection des passages récupérés.

## Erreurs courantes

Plusieurs erreurs de chunking sont évitables :
- Utiliser une seule taille de chunk globale pour tous les types de documents.
- Ignorer la structure du document même quand des titres ou sections existent.
- Utiliser le chunking sémantique sans limites dures, ce qui crée des longueurs de chunks instables.
- Ajouter un chevauchement excessif, ce qui gonfle le stockage et crée des duplicatas.
- Évaluer la qualité des réponses du modèle sans inspecter d’abord les chunks récupérés.

Ces erreurs sont importantes car les systèmes de récupération échouent en amont, avant même la génération. Dans beaucoup de soi‑disant « erreurs de modèle », le vrai problème est que le récupérateur a reçu des chunks faibles, pas que le modèle de langage a mal raisonné.

## Pour aller plus loin

Les références suivantes sont utiles pour les lecteurs qui souhaitent approfondir les détails d’implémentation, les APIs et les compromis en production :

- [LangChain Text Splitter integrations](https://docs.langchain.com/oss/python/integrations/splitters) pour les splitters récursifs, sensibles aux tokens et basés sur la structure.
- [LangChain TextSplitter reference](https://reference.langchain.com/python/langchain-text-splitters/base/TextSplitter) pour l’interface de base et le comportement des splitters.
- [LlamaIndex SemanticSplitterNodeParser](https://docs.llamaindex.ai/en/latest/api/llama_index.node_parser.SemanticSplitterNodeParser.html) pour le chunking sémantique avec points de rupture basés sur les embeddings.
- [Pinecone: Chunking Strategies for LLM Applications](https://www.pinecone.io/learn/chunking-strategies/) pour une vue d’ensemble pratique des compromis de chunking dans les systèmes de récupération.

## Perspective finale

Le chunking n’est pas un détail de pré‑traitement ; c’est une décision de modélisation intégrée au pipeline de récupération. Les méthodes de taille fixe, récursives, basées sur la structure, basées sur les éléments, au niveau phrase, sensibles aux tokens et sémantiques codent chacune une hypothèse différente sur l’endroit où se situe le sens dans le texte.

Une valeur par défaut pratique forte est le chunking récursif ou structurel pour du texte brut, le chunking basé sur les éléments pour des documents de mise en page mixte, puis le chunking sémantique pour des collections où la continuité conceptuelle est le principal défi de récupération. Les meilleurs systèmes traitent le chunking comme une variable de conception à tester, pas comme une constante à supposer.

---

*HTML version: https://sechak.com/fr/insights/le-chunking-en-ia-un-guide-pratique-clair*