AI Engineering Academy · Leçon

Stratégies pour rester dans les limites du contexte

Implémentez une mémoire à fenêtre glissante, le résumé des messages et la réduction sélective du contexte afin de gérer les longues conversations sans dépasser les limites de tokens.

Leçon 4 sur 413 étapes

Stratégies pour rester dans les limites du contexte est une leçon AI Engineering Academy 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 Engineering Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours AI Engineering Academy comprend 4 leçons au total.

Le problème croissant des conversations

Chaque message échangé dans une conversation de discussion augmente le nombre de jetons du prochain appel d'API. Lors d'une longue session d'assistance client ou d'une session de programmation de plusieurs heures, l'historique cumulé de la conversation peut facilement dépasser 20 000 à 50 000 jetons — que vous devez tous envoyer à l'API à chaque tour, en payant de nouveau pour les jetons déjà traités.

Sans stratégie de gestion du contexte, votre application atteindra la limite de contexte et plantera, ou vous finirez par tronquer silencieusement des messages, auquel cas le modèle perdra la trace d'éléments importants du contexte antérieur. Toute application LLM en production a besoin d'une stratégie explicite pour gérer la croissance du contexte.

Stratégie 1 : fenêtre glissante (N derniers messages)

La stratégie la plus simple consiste à ne conserver que les N derniers messages dans le contexte et à supprimer les plus anciens. C'est ce qu'on appelle une fenêtre glissante. Cette méthode est facile à mettre en œuvre, prévisible en matière de coûts et suffisante pour de nombreux cas d'utilisation où le contexte récent compte davantage que les échanges plus anciens.

import openai

client = openai.OpenAI()

class SlidingWindowConversation:
    def __init__(self, system_prompt, window_size=10):
        self.system = system_prompt
        self.window_size = window_size
        self.history = []

    def chat(self, user_message):
        self.history.append({'role': 'user', 'content': user_message})

        # Keep only the last N messages
        windowed = self.history[-self.window_size:]
        messages = [{'role': 'system', 'content': self.system}] + windowed

        response = client.chat.completions.create(
            model='gpt-4o-mini',
            messages=messages
        )
        reply = response.choices[0].message.content
        self.history.append({'role': 'assistant', 'content': reply})
        print(f'Context: {len(windowed)} messages ({len(self.history)} total)')
        return reply

conv = SlidingWindowConversation('You are a helpful assistant.', window_size=6)
print(conv.chat('Hello! My name is Alice.'))
print(conv.chat('What is the capital of France?'))
print(conv.chat('What is my name?'))  # Might forget if window is small

Stratégie 2 : troncature tenant compte des jetons

Plutôt que de tronquer selon le nombre de messages, la troncature tenant compte des jetons supprime des messages jusqu'à ce que le nombre total de jetons soit inférieur à un seuil. Cette méthode est plus précise, car la longueur des messages varie fortement : une limite en nombre de messages peut inclure 10 messages courts ou 3 messages très longs, avec des coûts en jetons très différents.

import tiktoken

def trim_to_token_budget(
    messages, system_prompt, model='gpt-4o-mini', max_input_tokens=8000
):
    enc = tiktoken.encoding_for_model(model)

    def count(msgs):
        return sum(len(enc.encode(m.get('content',''))) + 4 for m in msgs) + 3

    # System prompt token count
    system_tokens = len(enc.encode(system_prompt)) + 4
    budget = max_input_tokens - system_tokens

    # Trim from the oldest messages until we fit
    trimmed = list(messages)
    while trimmed and count(trimmed) > budget:
        trimmed.pop(0)  # Remove oldest message

    removed = len(messages) - len(trimmed)
    if removed:
        print(f'Trimmed {removed} old messages to stay within {max_input_tokens} tokens')
    return trimmed

Stratégie 3 : résumé de la conversation

Le résumé compresse les anciens tours de conversation en un résumé concis tout en conservant les faits essentiels, les décisions et le contexte mentionnés par l'utilisateur. Cette méthode est plus sophistiquée que les fenêtres glissantes, car elle conserve l'essentiel des échanges passés au lieu de les supprimer purement et simplement.

Le fonctionnement est le suivant : lorsque la conversation dépasse un seuil, envoyez les N tours les plus anciens au modèle avec l'invite « Résumez la conversation jusqu'à présent », remplacez ces tours par un seul message système contenant le résumé, puis poursuivez la conversation avec ce nouvel historique compressé.

import openai

client = openai.OpenAI()

def summarize_conversation(messages_to_summarize, model='gpt-4o-mini'):
    summary_prompt = [
        {'role': 'system', 'content': 'You summarize conversations. Be concise but preserve key facts, decisions, and any specific information the user shared (names, numbers, preferences).'},
        {'role': 'user', 'content': 'Summarize this conversation:\n' + '\n'.join(
            f"{m['role'].upper()}: {m['content']}" for m in messages_to_summarize
        )}
    ]
    resp = client.chat.completions.create(model=model, messages=summary_prompt, max_tokens=500)
    return resp.choices[0].message.content

def compress_history(history, keep_recent=4):
    if len(history) <= keep_recent:
        return history
    to_summarize = history[:-keep_recent]
    summary = summarize_conversation(to_summarize)
    summary_msg = {'role': 'system', 'content': f'Earlier conversation summary: {summary}'}
    return [summary_msg] + history[-keep_recent:]

print('Summarization strategy compresses old turns into a single summary message')

Stratégie 4 : mémoire des entités

La mémoire des entités extrait et conserve une représentation structurée des faits importants mentionnés dans la conversation — préférences de l'utilisateur, noms, détails du projet, décisions prises — plutôt que de stocker l'historique brut des messages. Avant chaque tour, les faits stockés sont injectés dans l'invite système.

Cette méthode utilise moins de jetons que l'historique complet, car vous n'incluez que les éléments importants sur le plan sémantique, et non chaque mot de chaque tour. La mémoire des entités fonctionne particulièrement bien pour les assistants utilisés sur de longues périodes, lorsque les utilisateurs font référence à des préférences et à des faits établis beaucoup plus tôt dans la conversation.

import openai
import json

client = openai.OpenAI()

def extract_entities(messages, model='gpt-4o-mini'):
    prompt = [
        {'role': 'system', 'content': 'Extract key facts from this conversation as JSON: {"user_name": null, "preferences": [], "key_facts": []}'},
        {'role': 'user', 'content': '\n'.join(f"{m['role']}: {m['content']}" for m in messages)}
    ]
    resp = client.chat.completions.create(
        model=model,
        messages=prompt,
        response_format={'type': 'json_object'}
    )
    return json.loads(resp.choices[0].message.content)

conversation = [
    {'role': 'user', 'content': 'Hi, I am Alice and I prefer Python over JavaScript.'},
    {'role': 'assistant', 'content': 'Great to meet you, Alice! Python is an excellent choice.'},
    {'role': 'user', 'content': 'I am building a REST API for my e-commerce startup.'}
]
entities = extract_entities(conversation)
print(json.dumps(entities, indent=2))

Quand appliquer chaque stratégie

Choisissez votre stratégie en fonction des caractéristiques de votre application :

Fenêtre glissante : applications de discussion simples où seul le contexte récent compte et où les utilisateurs ne font pas référence aux anciens échanges. C'est la solution la moins coûteuse à mettre en œuvre.
Troncature tenant compte des jetons : toute application en production où la longueur des messages varie considérablement. C'est toujours préférable à une troncature fondée sur le nombre de messages.
Résumé : assistants utilisés sur de longues périodes, sessions d'assistance client, robots de gestion de projet. Les utilisateurs s'attendent à ce que l'assistant se souvienne des faits importants issus d'échanges datant de plusieurs heures.
Mémoire des entités : assistants personnels, robots de discussion tenant compte des préférences de l'utilisateur, systèmes de tutorat où le profil de l'utilisateur importe pendant toute la session.

Ces stratégies peuvent également être combinées : utilisez la mémoire des entités pour les faits essentiels et une fenêtre glissante pour la conversation récente.

RAG comme solution de remplacement au remplissage du contexte

Pour les applications riches en connaissances, la meilleure stratégie de gestion du contexte consiste à ne pas placer les documents dans le contexte — utilisez plutôt RAG (génération augmentée par récupération) pour récupérer uniquement les extraits précis qui sont pertinents pour la requête actuelle. Le contexte reste ainsi ciblé, le coût est réduit et les réponses sont souvent meilleures que lorsque l'on injecte un document entier.

L'idée essentielle est que les longues fenêtres de contexte résolvent le problème « est-ce que cela peut tenir ? », mais pas le problème « le modèle saura-t-il bien l'utiliser ? ». Une récupération précise répond aux deux questions en ne fournissant au modèle que les informations dont il a réellement besoin pour la question actuelle.

Gérer correctement les erreurs de contexte maximal

Malgré tous vos efforts, vous pouvez rencontrer des erreurs de limite de contexte en production, notamment à cause de contenus générés par les utilisateurs dont la longueur est inattendue. Gérez toujours explicitement l'erreur context_length_exceeded, plutôt que de la laisser remonter comme une exception non gérée jusqu'à l'utilisateur.

import openai
import tiktoken

client = openai.OpenAI()

def chat_with_context_guard(messages, model='gpt-4o-mini', max_tokens=100000):
    enc = tiktoken.encoding_for_model(model)
    total = sum(len(enc.encode(m.get('content',''))) + 4 for m in messages) + 3

    while total > max_tokens and len(messages) > 2:
        # Remove the second message (keep system prompt)
        removed = messages.pop(1)
        total -= len(enc.encode(removed.get('content',''))) + 4
        print(f'Trimmed a message. New total: {total} tokens')

    try:
        return client.chat.completions.create(model=model, messages=messages)
    except openai.BadRequestError as e:
        if 'context_length' in str(e):
            return {'error': 'Message history too long. Please start a new conversation.'}
        raise

Conserver le contexte entre les sessions

Dans une application réelle, les utilisateurs ferment et rouvrent l'application. Le serveur redémarre. La gestion du contexte doit prendre en compte la persistance entre les sessions, et pas seulement au sein d'une session unique. Cela signifie qu'il faut stocker l'historique des conversations dans une base de données et le charger au début de chaque session.

Une approche raisonnable consiste à stocker l'historique brut complet dans PostgreSQL à des fins d'audit et d'ajustement fin, mais, lors du chargement du contexte pour un nouvel appel d'API, à appliquer votre stratégie de résumé ou de troncature afin de respecter le budget de jetons. Ainsi, vous ne perdez jamais de données, tout en évitant de payer pour l'historique complet à chaque requête.

Surveiller la croissance du contexte en production

Enregistrez le nombre de jetons de chaque appel d'API et suivez son évolution au fil du temps pour chaque ID de conversation. Une conversation saine devrait montrer une croissance progressive suivie d'un plateau, lorsque le résumé commence à s'appliquer. Une conversation qui croît sans limite jusqu'à atteindre la limite de contexte indique que votre logique de troncature ne fonctionne pas correctement.

Surveillez également la longueur moyenne du contexte pour l'ensemble des conversations. Si elle augmente au fil du temps, cela peut indiquer que votre invite système par défaut s'allonge (en raison de l'ajout de fonctionnalités), que les utilisateurs collent des entrées plus longues ou que RAG renvoie des segments progressivement plus volumineux. Chacune de ces situations nécessite une correction différente.

Combiner les stratégies : un modèle pour la production

Un système robuste de gestion du contexte en production combine plusieurs stratégies en couches :

Avant d'assembler le contexte : vérifiez le budget de jetons et enregistrez-le
Appliquer l'extraction d'entités : injectez un bloc de mémoire structuré contenant les faits importants
Ajouter l'historique récent : incluez les 6 à 10 derniers messages tels quels
Résumer l'historique ancien : si un historique ancien existe, injectez un résumé évolutif
Vérification de protection : si le total dépasse toujours le budget, tronquez les messages tels quels les plus anciens

Cette approche en couches préserve les informations les plus importantes (mémoire des entités et contexte récent), tout en réduisant progressivement l'historique ancien en résumés, puis en ne le tronquant qu'en dernier recours.

Vérification rapide

Testez votre compréhension des concepts d'ingénierie de l'IA présentés dans cette leçon.

Réponds-y dans la leçon interactive

Récapitulatif de la leçon

Dans cette leçon, vous avez appris que : les fenêtres glissantes et la troncature tenant compte des jetons sont des stratégies simples qui suppriment l'ancien contexte pour rester dans les limites, le résumé compresse les anciens tours en une représentation concise qui conserve les faits importants, et la mémoire des entités extrait des faits structurés pour fournir une mémoire à long terme économe en jetons au fil d'une conversation. Nous allons maintenant explorer comment faire en sorte que les LLM renvoient un JSON fiable à l'aide du mode JSON et des sorties structurées.

Gratuit pour commencer

Apprends Python 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: 30
Leçons: 120

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « Stratégies pour rester dans les limites du contexte » est-elle gratuite ?

Oui — le texte complet de « Stratégies pour rester dans les limites du contexte » 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 Engineering Academy, passe à CoddyKit PRO. Le cours AI Engineering Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Stratégies pour rester dans les limites du contexte » ?

Implémentez une mémoire à fenêtre glissante, le résumé des messages et la réduction sélective du contexte afin de gérer les longues conversations sans dépasser les limites de tokens. Tu pratiques AI Engineering Academy 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 Engineering Academy ?

Aucune expérience préalable n'est requise. AI Engineering Academy 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 « Stratégies pour rester dans les limites du contexte » ?

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 Engineering Academy ?

Oui. Chaque leçon AI Engineering Academy 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

Qu’est-ce qu’un token ?
Fenêtres de contexte : taille et conséquences
Calculer et prévoir les coûts de l’API
Stratégies pour rester dans les limites du contexte

← Retour à AI Engineering Academy