Stratégies de découpage de texte

Le découpage (chunking) est l’une des étapes les plus décisives d’un pipeline RAG. La façon dont vous coupez vos documents détermine ce que la recherche pourra retrouver, et donc ce que Claude lira. Un mauvais découpage glisse du contexte hors sujet dans le prompt, et Claude répond à côté.

Pourquoi le découpage compte

Prenez un rapport qui contient une section sur la recherche médicale et une autre sur le développement logiciel. La section médicale parle d’un « bug » au sens de micro-organisme ; la section logicielle parle de « vecteurs d’infection » dans des systèmes informatiques. Si le découpage mélange ou isole mal ces passages, la question « Combien de bugs les ingénieurs ont-ils corrigés cette année ? » peut ramener la recherche médicale, simplement parce qu’elle contient le mot.

Le découpage par taille

L’approche la plus simple : couper le texte en morceaux de longueur égale. Elle fonctionne avec tout type de contenu, mais elle coupe des mots et des phrases en deux, sépare des titres de leur contenu, et prive chaque morceau du contexte qui l’entoure. On atténue ces défauts avec un chevauchement : chaque morceau reprend quelques caractères du précédent.

def chunk_by_char(text, chunk_size=150, chunk_overlap=20):
    if not 0 <= chunk_overlap < chunk_size:
        raise ValueError("chunk_overlap doit être positif et inférieur à chunk_size")
    chunks = []
    start = 0
    while start < len(text):
        end = min(start + chunk_size, len(text))
        chunks.append(text[start:end])
        start = end - chunk_overlap if end < len(text) else len(text)
    return chunks

Sur un texte de 325 caractères, avec des morceaux de 150 caractères et un chevauchement de 20, on obtient trois morceaux de 150, 150 et 65 caractères. La vérification du début n’est pas décorative : un chevauchement égal ou supérieur à la taille ferait tourner la boucle sans fin.

Le découpage par structure

On coupe selon la structure naturelle du document : titres, paragraphes, sections. Pour un document Markdown, il suffit de couper avant chaque titre de niveau 2 :

import re

def chunk_by_section(document_text):
    sections = re.split(r"\n(?=## )", document_text)
    return [section.strip() for section in sections if section.strip()]

L’expression (?=## ) coupe juste avant le titre sans le supprimer : chaque morceau commence par son titre, ce qui aide la recherche. C’est le découpage le plus propre, puisque chaque morceau est une section complète. Mais il suppose des garanties sur la structure : beaucoup de documents réels sont du texte brut ou des PDF sans repères fiables.

Le découpage sémantique

On découpe le texte en phrases, puis on mesure à quel point les phrases consécutives sont liées, avec un modèle de langage ou d’embeddings, pour regrouper celles qui parlent de la même chose. C’est l’approche qui produit les morceaux les plus cohérents, mais aussi la plus coûteuse en calcul et la plus complexe à mettre en place.

Le découpage par phrases

Un compromis pratique : couper en phrases avec une expression régulière, puis les regrouper par paquets, avec un chevauchement facultatif.

def chunk_by_sentence(text, max_sentences_per_chunk=5, overlap_sentences=1):
    if not 0 <= overlap_sentences < max_sentences_per_chunk:
        raise ValueError("overlap_sentences doit être inférieur à max_sentences_per_chunk")
    sentences = re.split(r"(?<=[.!?])\s+", text.strip())
    chunks = []
    start = 0
    while start < len(sentences):
        end = min(start + max_sentences_per_chunk, len(sentences))
        chunks.append(" ".join(sentences[start:end]))
        if end == len(sentences):
            break
        start = end - overlap_sentences
    return chunks

L’expression régulière est volontairement simple : elle coupe après un point, un point d’exclamation ou d’interrogation suivi d’un espace. Des abréviations comme « M. Dupont » ou « p. 12 » la trompent ; pour du texte réel, une bibliothèque de traitement du langage découpe mieux les phrases.

Choisir sa stratégie

Le cours officiel note que le découpage par taille avec chevauchement est souvent le choix par défaut en production : simple, fiable, il ne casse jamais le pipeline, même si ses morceaux ne sont pas parfaits. Anthropic indique de son côté que les morceaux font en général quelques centaines de jetons au plus. Il n’existe pas de meilleure stratégie dans l’absolu : la bonne dépend de vos documents, de vos questions, et de l’effort que vous acceptez pour la qualité des morceaux.

À vous de jouer

Comparer les trois découpages. Prenez un document Markdown que vous connaissez bien et découpez-le de trois façons : par taille (150 caractères, chevauchement de 20), par section, puis par phrases (5 phrases, chevauchement de 1). Pour trois questions que l’on pourrait poser sur ce document, notez quel découpage produit le morceau qui contient la réponse entière.

Sources officielles : Text chunking strategies (Claude Academy) · Contextual Retrieval (Anthropic : taille habituelle des morceaux)

Points clés à retenir

• Le découpage décide de ce que la recherche peut retrouver, et donc de ce que Claude lit.
• Par taille : universel, mais coupe le sens ; le chevauchement atténue le problème.
• Par structure : les morceaux les plus propres, à condition que la structure soit fiable.
• Par phrases : un compromis pratique ; sémantique : le plus cohérent, et le plus coûteux.
• Aucune stratégie n’est la meilleure partout : testez sur vos documents et vos questions.