Stratégies de découpage de texte

Le découpage est l’une des étapes les plus décisives d’un pipeline RAG : la façon dont vous coupez les documents conditionne la qualité de tout le système. Un mauvais découpage injecte du contexte hors sujet dans le prompt, et Claude répond à côté avec aplomb.

Un exemple : un rapport contient une section de recherche médicale et une section d’ingénierie logicielle. La section médicale parle d’un « bug », au sens d’un agent infectieux. Avec un mauvais découpage, la question « Combien de bugs les ingénieurs ont-ils corrigés cette année ? » risque de remonter le passage médical, simplement parce que le mot y figure. Le but est d’obtenir des morceaux cohérents, qui apportent un contexte utile quand on les récupère.

Trois stratégies

• Par taille : des morceaux de longueur égale, en caractères ou en mots.
• Par structure : un découpage qui suit les titres, les paragraphes, les sections.
• Par sens : des phrases regroupées selon leur sens, avec des techniques de traitement du langage.

Découper par taille

C’est la méthode la plus simple, et elle marche sur n’importe quel texte. Ses défauts : des mots coupés en plein milieu, des phrases séparées de leur contexte, des idées partagées entre deux morceaux. Le remède est le chevauchement : chaque morceau reprend quelques caractères de son voisin. On duplique un peu de texte, mais chaque morceau garde son contexte de bord.

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

La vérification en tête n’est pas décorative : avec un chevauchement supérieur ou égal à la taille, la boucle n’avancerait plus.

Découper par phrases

import re


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

Le découpage par phrases respecte mieux le sens de la prose, mais il trébuche sur le code ou les textes techniques, où les points apparaissent ailleurs qu’en fin de phrase. La version du cours officiel peut renvoyer un dernier morceau entièrement contenu dans le précédent ; celle-ci s’arrête dès que la fin du texte est atteinte.

Découper par sections

Quand vos documents ont une structure fiable, comme du Markdown avec des titres réguliers, le découpage par sections donne d’excellents résultats :

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 devant chaque titre de niveau 2 sans le retirer : chaque morceau garde son titre complet, précieux pour la recherche. Le cours officiel coupe sur \n## , ce qui retire le marqueur ## des titres. Cette méthode exige une garantie sur la structure : elle échoue sur du texte brut ou mal formaté.

Choisir

• Par taille : le repli le plus sûr, pour tout type de document, notamment ceux que déposent vos utilisateurs.
• Par phrases : un bon équilibre pour la prose.
• Par sections : le meilleur choix pour des documents internes bien structurés.

Le découpage s’ajuste par itération : commencez simple, mesurez la qualité des réponses sur vos documents, puis affinez.

À vous de jouer

Trois découpages, une question. Découpez un même document de votre choix avec les trois fonctions. Comptez les morceaux, regardez le plus court et le plus long, puis cherchez à la main lequel contient la réponse à une question précise. Quel découpage la sert le mieux ?

Sources officielles : Text chunking strategies (Claude Academy) · re, Regular expression operations (documentation Python)

Points clés à retenir

• Le découpage conditionne la qualité de tout le RAG : un morceau hors sujet fausse la réponse.
• Par taille avec chevauchement : simple et universel ; par phrases : adapté à la prose ; par sections : idéal sur des documents structurés.
• Vérifiez les paramètres : un chevauchement trop grand bloque la boucle.
• Gardez les titres dans les morceaux ; mesurez, puis ajustez.