Comment l'IA décide ce qu'elle doit lire dans vos documents ? Le secret des stratégies de chunking

LE PROBLÈME : UNE QUESTION MAL COMPRIIS, UN RÉSULTAT VIDE

Prenez un CV et la question "quel est le nom ?". Si l'IA cherche le mot "nom" dans le texte, elle ne trouvera rien : un CV ne contient pas ce mot. Pourtant, un humain comprendrait immédiatement qu'il s'agit du nom du candidat. Pour que l'IA fasse de même, elle a besoin d'un contexte : le type de document (CV, contrat, facture) et sa structure (où se trouve l'information). Sans ces indices, l'IA est perdue.

LA SOLUTION : LE PARSER, CERVEAU DE L'IA QUI ANALYSE VOS QUESTIONS

Le parser est un programme qui analyse votre question et le document avant de décider comment répondre. Il ne se contente pas de chercher des mots-clés : il interprète votre demande en fonction du type de document. Par exemple, pour un contrat d'assurance, il sait que "la prime annuelle" correspond à un montant précis, tandis que "les exclusions" renvoient à une liste dispersée dans le document.

Le parser produit deux briefs consommateurs : un pour la Recherche (où trouver l'information) et un pour la génération (comment formuler la réponse). Ces briefs sont créés à partir de votre question et du profil du document, qui contient des informations comme le type de fichier (PDF, Word), la présence d'une table des matières, ou la langue utilisée.

LE PROFIL DU DOCUMENT : LA CARTE D'IDENTITÉ DE VOTRE FICHIER

Le profil du document est une fiche technique qui décrit ses caractéristiques. Par exemple :

class DocumentProfile(BaseModel):
    format: Literal["pdf", "docx", "html", "txt", "xlsx"]
    has_toc: bool = False
    has_tables: bool = False
    n_pages: int | None = None
    languages: list[str] = Field(default_factory=list)
    is_scanned: bool = False

Ce profil permet au parser de personnaliser son approche. Si le document est un fichier Word, l'IA sait qu'elle ne peut pas extraire de numéros de page précis. Si c'est un PDF scanné, elle s'attend à plus d'erreurs d'orthographe à cause de l'OCR.

LE PLAN D'EXÉCUTION : COMMENT L'IA VA TRAITER VOTRE QUESTION

Le plan d'exécution est une liste d'instructions qui dit à l'IA comment traiter votre question. Voici quelques-unes de ces instructions :

class ExecutionPlan(BaseModel):
    usetocnavigation: bool = True
    usekeywordretrieval: bool = True
    use_embeddings: bool = False
    followcrossreferences: bool = False
    decompose_compound: bool = False
    iterateonfeedback: bool = True
    extractpagenumbers: bool = True

Par exemple, si votre question est "listez les exclusions du contrat", l'IA va :

• Utiliser la navigation par table des matières (usetocnavigation)
• Chercher des mots-clés comme "exclusion" (usekeywordretrieval)
• Décomposer la question en sous-questions si nécessaire (decompose_compound)
• Demander des clarifications si la question est ambiguë (iterateonfeedback)

LA STRATÉGIE DE CHUNKING : COMMENT L'IA DÉCOUPE VOTRE DOCUMENT

Le chunking (ou découpage) est la façon dont l'IA divise votre document pour trouver la réponse. Elle peut choisir entre deux stratégies :

La stratégie dépend de la forme de la réponse attendue :

• Chunking séquentiel : pour une réponse simple (un montant, une date, un oui/non). L'IA lit les chunks un par un dans l'ordre et s'arrête dès qu'elle trouve la réponse. Cela économise des tokens (et donc de l'argent) si la réponse est dans le premier chunk.
• Chunking combiné : pour une réponse complexe (une liste d'exclusions dispersées, une définition avec sa note de bas de page). L'IA lit tous les chunks en une seule fois pour synthétiser l'information.

La décision est prise par le parser dès le début, en fonction de la forme de la réponse (answer_shape) et du concept associé (matched_concept). Par exemple :

def resolvechunkstrategy(
    answer_shape: str,
    matched_concept: str | None,
    answershapesdf: pd.DataFrame,
    concepts_df: pd.DataFrame,
) -> Literal["combined", "sequential"]:
    """Override conceptuel > valeur par défaut de la forme > valeur par défaut du projet."""
    if matched_concept is not None:
        row = conceptsdf[conceptsdf["concept"] == matched_concept]
        if not row.empty and pd.notna(row.iloc[0].get("defaultchunkstrategy")):
            return row.iloc[0]["defaultchunkstrategy"]
    row = answershapesdf[answershapesdf["shape"] == answer_shape]
    if not row.empty:
        return row.iloc[0]["defaultchunkstrategy"]
    return "combined"

LE CONTEXTE DE RÉPONSE : COMBIEN DE TEXTE L'IA DOIT-ELLE LIRE ?

L'IA ne lit pas tout le document. Elle se concentre sur une partie précise, en fonction de la forme de la réponse attendue :

• Ligne : pour une réponse très courte (un montant, une date).
• Section : pour une réponse moyenne (une clause de contrat).
• Chapitre : pour une réponse longue (une liste d'exclusions).

Par exemple, pour la question "quel est le montant de la prime annuelle ?", l'IA sait qu'elle doit chercher une ligne précise dans le contrat. Pour "listez les exclusions", elle va lire tout un chapitre.

Ces choix sont faits à partir de deux tables satellites :

• answershapesdf : contient les valeurs par défaut pour chaque forme de réponse.
• concepts_df : contient les overrides par concept (par exemple, les exclusions sont toujours dans un chapitre).

LE MODÈLE À UTILISER : GPT-4.1 OU UN AUTRE ?

L'IA ne se contente pas de choisir où chercher l'information : elle choisit aussi quel modèle de langage utiliser. Le modèle dépend de :

• La forme de la réponse (answer_shape)
• Le concept associé (matched_concept)
• Le type de réponse (answer_type)

Par exemple, pour une question complexe comme "comparez les clauses d'indemnisation de ce contrat avec la version précédente", l'IA va utiliser un modèle plus puissant comme gpt-4.5 plutôt que gpt-4.1-mini.

La résolution suit une cascade d'overrides :

def resolve_model(
    answer_type: str,
    matched_concept: str | None,
    answertypesdf: pd.DataFrame,
    concepts_df: pd.DataFrame,
    fallback: str = "gpt-4.1-mini",
) -> str:
    """Override conceptuel > valeur par défaut du type > fallback du projet."""
    if matched_concept is not None:
        row = conceptsdf[conceptsdf["concept"] == matched_concept]
        if not row.empty and pd.notna(row.iloc[0].get("default_model")):
            return row.iloc[0]["default_model"]
    row = answertypesdf[answertypesdf["type"] == answer_type]
    if not row.empty and pd.notna(row.iloc[0].get("default_model")):
        return row.iloc[0]["default_model"]
    return fallback

LES MOTS-CLÉS : COMMENT L'IA COMPREND VOTRE QUESTION

Le parser extrait des mots-clés de votre question pour mieux comprendre ce que vous cherchez. Par exemple, pour "quel est le montant de la prime annuelle ?", il identifie :

• prime (avec un poids de 1.0)
• montant (poids 0.8)
• annuelle (poids 0.7)
• premium (poids 0.9, trouvé dans un dictionnaire expert)
• cotisation (poids 0.9, trouvé dans un dictionnaire expert)
• Un motif regex pour détecter les montants en euros (poids 0.8)

Ces mots-clés servent à :

• Identifier le concept associé (ici, prime)
• Déterminer la forme de la réponse (single pour une réponse unique)
• Choisir le contexte de réponse (ligne pour un montant précis)

LA DÉCOMPOSITION : QUAND VOTRE QUESTION EST TROP COMPLEXE

Si votre question est composée de plusieurs sous-questions indépendantes, le parser la décompose. Par exemple :

ParsedQuestion(
    original_question="What is the annual premium and what are the main exclusions?",
    decomposition=Decomposition(
        pattern="independent",
        sub_questions=[
            "What is the annual premium?",
            "What are the main exclusions?",
        ],
    ),
    activations=ExecutionPlan(decompose_compound=True),
    parsing_notes=["Compound question detected. Decomposed into 2 independent sub-questions."],
)

L'IA va alors traiter chaque sous-question séparément et combiner les résultats. Cela permet d'éviter les erreurs de compréhension et d'améliorer la précision des réponses.

LES CLARIFICATIONS : QUAND VOTRE QUESTION EST AMBIGUË

Si votre question est trop vague ou ambiguë, le parser peut demander une clarification. Par exemple :

ParsedQuestion(
    original_question="What's the limit?",
    suggested_clarification=(
        "Several types of limits exist in this contract: coverage limit, sublimit, "
        "deductible, aggregate limit. Which one are you asking about?"
    ),
    ambiguityreason="singletermwithmultiple_referents",
    parsing_notes=["Ambiguous question; clarification suggested before running pipeline."],
)

Cela évite à l'IA de faire des hypothèses hasardeuses et garantit une réponse plus précise.

L'AUDIT : COMMENT L'IA JUSTIFIE SES CHOIX

Chaque réponse de l'IA est accompagnée d'un bloc d'audit (_meta) qui explique comment elle a été générée. Par exemple :

{
  "answer": "The premium is €125,000 annually.",
  "page_number": 4,
  "line_start": 12,
  "line_end": 14,
  "quote": "Annual premium: €125,000",
  "_meta": {
    "decomposition": "single",
    "activations": {
      "usetocnavigation": true,
      "usekeywordretrieval": true,
      "use_embeddings": false,
      "extractpagenumbers": true
    },
    "skipped": [],
    "parsing_notes": [],
    "iterations": 1,
    "retrievalmethodsused": ["toc", "keyword"],
    "model": "gpt-4.1",
    "promptversions": {"questionparsing": "v2.4", "generation": "v4.2"}
  }
}

Ce bloc contient :

• La décomposition utilisée (ici, single)
• Les activations activées (navigation par table des matières, recherche par mots-clés)
• Les méthodes de récupération utilisées (table des matières et mots-clés)
• Le modèle utilisé (gpt-4.1)
• Les versions des prompts utilisées

LA PERSISTANCE : COMMENT L'IA STOCKE VOS QUESTIONS

Pour éviter de reparser la même question plusieurs fois, l'IA stocke les résultats dans un fichier JSON. Par exemple :

output///questions//parsed_question.json

Ce fichier contient toutes les informations nécessaires pour reproduire la réponse, y compris le profil du document, la stratégie de chunking, et le modèle utilisé.

UN EXEMPLE CONCRET : QUELLE STRATÉGIE POUR UN CONTRAT D'ASSURANCE ?

Prenons une question sur un contrat d'assurance : "quel est le montant de la prime annuelle ?". Voici comment l'IA va procéder :

1. Analyse de la question : Le parser identifie les mots-clés prime, montant, annuelle et détermine qu'il s'agit d'une question sur le concept prime.
2. Détermination du contexte : Le concept prime a une valeur par défaut de chapitre dans la table concepts_df. L'IA va donc lire un chapitre entier.
3. Choix de la stratégie de chunking : La forme de la réponse est single (une seule valeur). La stratégie choisie est donc séquentielle.
4. Sélection du modèle : Le concept prime n'a pas de modèle spécifique, mais le type de réponse est amount. L'IA utilise donc le modèle par défaut pour ce type.
5. Exécution : L'IA lit le document chapitre par chapitre jusqu'à trouver la ligne contenant "Annual premium: €125,000".
6. Génération de la réponse : L'IA extrait la réponse et génère un bloc d'audit pour justifier ses choix.

POURQUOI TOUT ÇA COMPTE : ÉCONOMIES ET PRÉCISION

Ces mécanismes peuvent sembler techniques, mais ils ont un impact concret :

• Économies de coûts : En lisant seulement ce qui est nécessaire, l'IA utilise moins de tokens et réduit la facture des API comme OpenAI.
• Réduction des erreurs : En décomposant les questions complexes et en demandant des clarifications, l'IA évite les malentendus.
• Meilleure compréhension : En utilisant le profil du document, l'IA comprend mieux ce que vous cherchez, même si votre question est mal formulée.

En résumé, ces stratégies transforment une IA basique en un assistant intelligent qui comprend vos documents comme un humain, mais en mieux.

EN PRATIQUE : COMMENT UTILISER CES STRATÉGIES ?

Si vous développez un système RAG (Retrieval-Augmented Generation), voici comment intégrer ces stratégies :

1. Créez un profil de document : Définissez le type de document, sa structure et ses particularités.
2. Définissez des overrides par concept : Pour chaque concept (prime, exclusion, etc.), précisez le contexte de réponse, la stratégie de chunking et le modèle à utiliser.
3. Utilisez un parser : Intégrez un outil comme OpenAI gpt-4.1 pour analyser vos questions et générer les briefs consommateurs.
4. Stockez les résultats : Sauvegardez les questions parsées dans des fichiers JSON pour éviter de les reparser.
5. Optimisez les coûts : Choisissez la stratégie de chunking et le modèle en fonction de la complexité de la question.

LE FUTUR : VERS DES SYSTÈMES ENCORE PLUS INTELLIGENTS

Ces stratégies sont déjà impressionnantes, mais elles ne sont qu'un début. À l'avenir, on peut imaginer :

• Des profils de document dynamiques qui s'adaptent en temps réel à la structure du document.
• Des modèles spécialisés pour chaque type de document (contrats, CV, factures).
• Des systèmes d'apprentissage qui améliorent leurs stratégies en fonction des retours des utilisateurs.

L'objectif ? Une IA qui comprend vos documents aussi bien qu'un humain, mais sans les limites humaines.

EN CONCLUSION : L'IA N'EST PLUS UNE MACHINE, MAIS UN ASSISTANT INTELLIGENT

Grâce à ces stratégies de parsing, de chunking et de dispatching, l'IA ne se contente plus de chercher des mots-clés : elle comprend vos documents et vos questions. Elle s'adapte au type de document, choisit la meilleure stratégie pour trouver l'information, et justifie ses choix avec un audit transparent.

La prochaine fois que vous utiliserez un outil d'IA pour analyser un document, souvenez-vous : derrière la réponse se cache tout un système de décisions intelligentes qui a fait le travail à votre place.