Stratégies de découpage de texte

Premier chantier concret du RAG : le découpage de texte (chunking), l’une des étapes les plus critiques du pipeline. La façon dont vous découpez vos documents impacte directement la qualité de tout le système — et l’effet est en cascade : une mauvaise stratégie produit des chunks qui tronquent les idées, la recherche retrouve des fragments incomplets, du contexte non pertinent entre dans vos prompts, et les réponses finissent complètement fausses. Autant choisir sa stratégie en connaissance de cause.

Trois stratégies principales

1. Découpage par taille

L’approche la plus simple : diviser le texte en chaînes de longueur égale — tous les 150 caractères, par exemple. Facile à implémenter, elle fonctionne avec tout type de document, du code au texte océrisé, puisqu’elle ne suppose rien du contenu.

Ses inconvénients découlent de cette même indifférence : les mots sont coupés en pleine phrase, les chunks perdent le contexte du texte environnant, et le contenu relié peut être scindé entre plusieurs chunks — une idée à cheval sur deux fragments n’est entière nulle part.

Avec chevauchement (overlap) : la parade classique. Chaque chunk inclut des caractères des chunks voisins, fournissant du contexte additionnel aux frontières — aucune idée n’est orpheline de ses deux côtés.

def chunk_by_char(text, chunk_size=150, chunk_overlap=20):
    chunks = []
    start_idx = 0

    while start_idx < len(text):
        end_idx = min(start_idx + chunk_size, len(text))
        chunk_text = text[start_idx:end_idx]
        chunks.append(chunk_text)
        start_idx = (
            end_idx - chunk_overlap if end_idx < len(text) else len(text)
        )

    return chunks

La mécanique du chevauchement tient dans le calcul de start_idx : au lieu de repartir de la fin du chunk, on recule de chunk_overlap caractères — les 20 derniers caractères de chaque chunk ouvrent le suivant. Le garde-fou else len(text) évite la boucle infinie sur le dernier fragment.

2. Découpage par phrase

Un cran plus haut en respect du contenu : couper aux frontières de phrases, par groupes. C’est un bon équilibre entre contexte et sens pour la prose :

def chunk_by_sentence(text, max_sentences_per_chunk=5, overlap_sentences=1):
    sentences = re.split(r"(?<=[.!?])\s+", text)
    chunks = []
    start_idx = 0

    while start_idx < len(sentences):
        end_idx = min(start_idx + max_sentences_per_chunk, len(sentences))
        current_chunk = sentences[start_idx:end_idx]
        chunks.append(" ".join(current_chunk))
        start_idx += max_sentences_per_chunk - overlap_sentences

    return chunks

L’expression régulière coupe après chaque ponctuation finale, puis on regroupe par paquets de cinq phrases, avec une phrase de chevauchement entre paquets. Le pire défaut du découpage par caractères — la phrase tranchée en son milieu — disparaît pour trois lignes de plus.

3. Découpage par section

Quand les documents ont un formatage cohérent — du Markdown avec des en-têtes clairs —, autant exploiter cette structure :

def chunk_by_section(document_text):
    pattern = r"\n## "
    return re.split(pattern, document_text)

Deux lignes, et chaque section devient un chunk dont les frontières épousent celles des idées — par construction, puisque l’auteur du document a lui-même organisé son contenu en sections. Excellents résultats pour les documents bien structurés, mais la méthode nécessite des garanties sur la structure : le pattern qui fonctionne pour un corpus Markdown ne trouvera rien dans un texte brut.

Choisir la bonne stratégie

La logique du tableau : exploitez la structure quand elle existe (c’est l’information la plus riche), les phrases pour la prose sans structure fiable, les caractères quand rien n’est garanti. Et retenez la méthode plus que le choix initial : le découpage est souvent un processus itératif. Commencez simple, testez avec vos documents spécifiques — dix secondes à lire quelques chunks produits attrapent les découpages absurdes qu’aucune métrique ne signale —, puis affinez en fonction de la qualité des résultats.

Points clés à retenir

• Le découpage conditionne tout le pipeline : mauvais chunks → mauvaise recherche → réponses fausses
• Par caractères : universel mais brutal — toujours avec chevauchement
• Par phrases : le bon compromis pour la prose ; par sections : imbattable quand les en-têtes existent
• Le chevauchement évite les idées orphelines aux frontières des chunks
• Itérez : découpez, lisez quelques chunks, ajustez — le contrôle le moins cher du pipeline