AI Prompt Engineering · Leçon

Maintenir le contexte entre les segments

Utilisez le chevauchement, le contexte glissant et l’injection de métadonnées pour assurer la continuité.

Leçon 4 sur 413 étapes

Maintenir le contexte entre les segments est une leçon AI Prompt Engineering gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage AI Prompt Engineering, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours AI Prompt Engineering comprend 4 leçons au total.

Le problème du contexte entre les segments

Lorsqu’un document est divisé en segments, des informations du segment N peuvent être nécessaires pour interpréter correctement le segment N+1. Par exemple, un terme défini dans le segment 3 est utilisé dans le segment 7. Sans mise en relation du contexte, le modèle qui traite le segment 7 ne connaît pas cette définition.

Quatre stratégies permettent de résoudre ce problème : le chevauchement, l’injection d’une synthèse glissante, les balises de métadonnées et les références aux numéros de page.

Stratégie 1 : chevauchement de jetons

Le chevauchement répète les N derniers jetons du segment N au début du segment N+1. Cela garantit qu’une phrase ou un argument qui s’étend sur une limite apparaît intégralement dans au moins un segment.

Chevauchement habituel : 100 à 200 jetons (environ 75 à 150 mots). Un chevauchement trop important augmente la redondance et le coût ; un chevauchement trop faible laisse des lacunes aux limites.

import tiktoken

enc = tiktoken.get_encoding('cl100k_base')

def chunk_with_overlap(text, max_tokens=1000, overlap=200):
    tokens = enc.encode(text)
    chunks = []
    step = max_tokens - overlap
    i = 0
    while i < len(tokens):
        chunk = tokens[i:i + max_tokens]
        chunks.append(enc.decode(chunk))
        i += step
    return chunks

chunks = chunk_with_overlap(document, max_tokens=1000, overlap=200)
print(f'{len(chunks)} chunks with 200-token overlap')

Chevauchement pour la récupération et la synthèse

Le chevauchement se comporte différemment selon la tâche :

Récupération : le chevauchement est utile : une requête correspond à la zone commune dans l’un ou l’autre des deux segments adjacents, ce qui améliore le rappel. Utilisez un chevauchement représentant 10 à 20 % de la taille du segment.
Synthèse : le chevauchement peut provoquer des répétitions : la même phrase est synthétisée deux fois. Utilisez un chevauchement plus faible (5 à 10 %) ou supprimez le chevauchement avant la synthèse.

def strip_overlap(chunks, overlap_tokens=200):
    '''Remove the leading overlap from each chunk (except the first).'''
    cleaned = [chunks[0]]
    for chunk in chunks[1:]:
        tokens = enc.encode(chunk)
        trimmed = enc.decode(tokens[overlap_tokens:])
        cleaned.append(trimmed)
    return cleaned

Stratégie 2 : Injection d’un résumé glissant

Un résumé glissant est une synthèse évolutive de tous les segments traités jusqu’à présent. Avant de traiter le segment N, injectez le résumé glissant dans l’invite comme contexte. Cela donne au modèle les informations du contenu précédent sans dépasser la fenêtre de contexte.

import openai
client = openai.OpenAI(api_key='sk-...')

def process_with_rolling_summary(chunks):
    rolling_summary = ''
    results = []

    for i, chunk in enumerate(chunks):
        context = ''
        if rolling_summary:
            context = f'Summary of previous sections:\n{rolling_summary}\n\n'

        prompt = context + f'Current section:\n{chunk}'
        resp = client.chat.completions.create(
            model='gpt-4o',
            messages=[
                {'role': 'system', 'content': 'Answer questions or summarize, using prior context.'},
                {'role': 'user', 'content': prompt}
            ]
        )
        result = resp.choices[0].message.content
        results.append(result)

        # Update rolling summary
        rolling_summary = update_rolling_summary(rolling_summary, chunk)

    return results

Mise à jour du résumé glissant

Le résumé glissant doit s’enrichir progressivement. Après avoir traité chaque segment, demandez au LLM de mettre à jour le résumé en y intégrant les nouvelles informations de ce segment. Maintenez le résumé glissant à une longueur réduite — 200 à 400 jetons — afin de laisser de la place au segment actuel.

def update_rolling_summary(current_summary, new_chunk, max_words=150):
    if not current_summary:
        prompt = f'Summarize the following in under {max_words} words:\n\n{new_chunk}'
    else:
        prompt = (
            f'Current running summary (under {max_words} words):\n{current_summary}\n\n'
            f'New section to incorporate:\n{new_chunk}\n\n'
            f'Update the summary to include the new section. Stay under {max_words} words.'
        )
    resp = client.chat.completions.create(
        model='gpt-4o-mini',
        messages=[{'role': 'user', 'content': prompt}]
    )
    return resp.choices[0].message.content

Stratégie 3 : Balises de métadonnées

Les balises de métadonnées associent des informations structurées à chaque segment afin que le LLM sache ce qu’il traite et puisse maintenir la continuité logique.

Balises courantes : document_title, chapter, section, page, chunk_index, total_chunks. Insérez-les comme en-tête dans l’invite, et non dans le texte du segment, afin de séparer le contenu des métadonnées.

def build_prompt_with_metadata(chunk, metadata):
    header = (
        f'Document: {metadata["title"]}\n'
        f'Chapter: {metadata["chapter"]}\n'
        f'Section: {metadata["section"]}\n'
        f'Page: {metadata["page"]}\n'
        f'Chunk: {metadata["chunk_index"] + 1} of {metadata["total_chunks"]}\n'
        '---\n'
    )
    return header + chunk

prompt = build_prompt_with_metadata(
    chunk=chunks[5],
    metadata={
        'title': 'Annual Report 2024',
        'chapter': '3. Financial Results',
        'section': '3.2 Revenue Breakdown',
        'page': 42,
        'chunk_index': 5,
        'total_chunks': 120
    }
)

Stratégie 4 : Références aux numéros de page

Lorsqu’un segment fait référence à un élément d’une page précédente, le modèle peut le citer si les numéros de page sont intégrés. Insérez les sauts de page sous forme de marqueurs dans le texte avant la segmentation, afin qu’ils soient conservés dans les segments :

def inject_page_markers(pages):
    '''pages: list of strings, one per page.'''
    marked = []
    for i, page_text in enumerate(pages):
        marked.append(f'[PAGE {i+1}]\n{page_text}')
    return '\n\n'.join(marked)

# When the model sees [PAGE 12] in context, it can say
# 'As defined on page 12...' in its output, enabling traceability.
document_with_markers = inject_page_markers(pdf_pages)
chunks = chunk_with_overlap(document_with_markers)

Combinaison des stratégies

En production, combinez les quatre stratégies pour une fidélité maximale au contexte :

Ajoutez des marqueurs de page avant la segmentation
Segmentez avec un chevauchement de 200 jetons
Ajoutez un en-tête de métadonnées à l’invite de chaque segment
Injectez le résumé glissant avant chaque segment

Cette approche combinée garantit que le modèle sait toujours où il se trouve dans le document, ce qui précède et comment le segment actuel se rapporte à l’ensemble.

def process_document(pages, doc_metadata):
    # Step 1: inject page markers
    full_text = inject_page_markers(pages)
    # Step 2: chunk with overlap
    chunks = chunk_with_overlap(full_text, max_tokens=900, overlap=150)
    total = len(chunks)
    rolling_summary = ''
    results = []

    for i, chunk in enumerate(chunks):
        meta = {**doc_metadata, 'chunk_index': i, 'total_chunks': total}
        prompt = build_prompt_with_metadata(chunk, meta)
        if rolling_summary:
            prompt = 'Prior context:\n' + rolling_summary + '\n\n' + prompt
        result = call_llm(prompt)
        results.append(result)
        rolling_summary = update_rolling_summary(rolling_summary, chunk)

    return results

Évaluation de la conservation du contexte

Pour vérifier que votre stratégie de contexte fonctionne, créez des questions d’essai qui nécessitent des informations provenant de plusieurs segments :

Définir un terme introduit dans le segment 2 et dont la définition est demandée dans le segment 8
Calculer un total couvrant plusieurs pages
Repérer une contradiction entre le chapitre 1 et le chapitre 5

Exécutez la chaîne de traitement et vérifiez si les réponses font correctement référence au contenu précédent. Si elles échouent, augmentez le chevauchement ou la taille du résumé glissant.

test_questions = [
    {
        'question': 'What is the definition of "net recurring revenue" used in this report?',
        'defined_in_chunk': 2,
        'asked_in_chunk': 9,
        'expected_keywords': ['net recurring revenue', 'subscription', 'exclude']
    }
]

def evaluate_context_retention(pipeline_results, test_questions):
    for test in test_questions:
        answer = pipeline_results[test['asked_in_chunk']]
        for kw in test['expected_keywords']:
            if kw.lower() not in answer.lower():
                print(f'FAIL: missing "{kw}" in answer to chunk {test["asked_in_chunk"]}')

Résumé des compromis

Chaque stratégie présente des coûts et des avantages :

Chevauchement : simple, augmente le nombre de jetons de chevauchement %, peut entraîner des répétitions lors de la synthèse
Résumé glissant : puissant, ajoute un appel au LLM par segment, le résumé peut dériver ou perdre des détails
Balises de métadonnées : gratuites à ajouter, aident le modèle à se repérer, ne remplacent pas le contenu
Marqueurs de page : assurent la traçabilité, ajoutent des caractères au texte, mais très peu de jetons supplémentaires

Commencez par le chevauchement et les métadonnées. N’ajoutez le résumé glissant que lorsque des échecs de contexte entre segments sont observés lors des essais.

Guide pratique de dimensionnement

Tailles pratiques pour un document de 100 pages (moyenne de 500 jetons par page = 50 000 jetons au total) :

Taille des segments : 800 jetons, chevauchement de 150 jetons → environ 73 segments
Résumé glissant : 200 jetons maximum (mis à jour après chaque segment)
En-tête de métadonnées : environ 30 jetons par segment
Entrée effective par appel d’API : 800 + 200 + 30 = 1030 jetons
Coût de la mise en correspondance (gpt-4o-mini à 0,15 $/1 M) : 73 × 1030 × 0,15 $/1 M ≈ 0,011 $

Les stratégies de contexte ajoutent un coût minime tout en améliorant considérablement la cohérence.

Vérification des connaissances

Quel est le rôle d’un résumé glissant dans le traitement d’un document segment par segment ?

Réponds-y dans la leçon interactive

Récapitulatif : Contexte entre les segments

Quatre stratégies pour maintenir le contexte entre les segments :

Chevauchement : répéter les N derniers jetons du segment N au début du segment N+1
Résumé glissant : injecter une courte synthèse évolutive avant chaque segment
Balises de métadonnées : en-tête contenant les informations sur le document, le chapitre, la section et la page
Marqueurs de page : intégrer les numéros de page au texte avant la segmentation

Combinez les quatre stratégies dans les chaînes de traitement de production. Évaluez la conservation du contexte entre segments à l’aide de questions portant sur plusieurs segments. Cette section conclut le cours 16 sur les stratégies de traitement des documents longs.

Gratuit pour commencer

Apprends AI Prompt Engineering avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 53
Leçons: 199

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « Maintenir le contexte entre les segments » est-elle gratuite ?

Oui — le texte complet de « Maintenir le contexte entre les segments » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours AI Prompt Engineering, passe à CoddyKit PRO. Le cours AI Prompt Engineering comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Maintenir le contexte entre les segments » ?

Utilisez le chevauchement, le contexte glissant et l’injection de métadonnées pour assurer la continuité. Tu pratiques AI Prompt Engineering avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer AI Prompt Engineering ?

Aucune expérience préalable n'est requise. AI Prompt Engineering sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Maintenir le contexte entre les segments » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon AI Prompt Engineering ?

Oui. Chaque leçon AI Prompt Engineering inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Stratégies de segmentation des textes longs
Modèle de résumé Map-Reduce
Résumé hiérarchique
Maintenir le contexte entre les segments

← Retour à AI Prompt Engineering