Gestion du contexte

Les LLM ont une fenetre de contexte limitee. GPT-4o supporte 128 000 tokens, Claude 200 000. Ca parait enorme, mais quand tu inclus le contenu de plusieurs fichiers, l'historique de conversation, et le system prompt, ca fond comme neige au soleil. Un seul fichier de 5000 lignes peut consommer 30 000 tokens.

Le vrai Claude Code gere ca intelligemment. Quand la conversation devient trop longue, il resume les echanges anciens. Il decide aussi quels fichiers inclure dans le contexte : pas tous, juste ceux qui sont pertinents pour la question en cours.

Ecris une classe GestionnaireContexte qui gere la fenetre de contexte de l'agent.

La classe prend un max_tokens (par defaut 100000) a la construction.

Methodes :

compter_tokens(texte) : estime le nombre de tokens d'un texte (1 token = 4 caracteres).

ajouter_fichier(chemin, contenu) : ajoute un fichier au contexte. Si l'ajout depasse la limite, renvoie False.

retirer_fichier(chemin) : retire un fichier du contexte.

resumer_historique(historique) : prend une liste de messages et renvoie une version resumee. La regle de resume : garder le system prompt, garder les 4 derniers messages, et remplacer les anciens par un message unique "Resume des echanges precedents : N messages resumes."

construire_contexte(system_prompt, historique, fichiers_demandes=None) : assemble le contexte complet. Si fichiers_demandes est fourni (liste de chemins), inclure seulement ces fichiers. Renvoie un dict avec les messages et les tokens utilises.

obtenir_utilisation() : renvoie le pourcentage d'utilisation de la fenetre de contexte.

Format de retour de construire_contexte :

{
"messages": [...],
"fichiers_inclus": ["app.py", "config.py"],
"tokens_utilises": 5432,
"tokens_max": 100000,
"pourcentage": 5.4
}

Exemple :

ctx = GestionnaireContexte(max_tokens=1000)
ctx.ajouter_fichier("app.py", "print('hello')")

ctx.compter_tokens("Bonjour le monde")
renvoie 4

resultat = ctx.construire_contexte("Tu es un assistant.", [
{"role": "user", "content": "Lis app.py"}
], fichiers_demandes=["app.py"])
# resultat contient les messages + le contenu de app.py

Tests (4/5)

Compter les tokens

ctx = GestionnaireContexte()
assert ctx.compter_tokens("Bonjour le monde !") == len("Bonjour le monde !") // 4
assert ctx.compter_tokens("") == 0
assert ctx.compter_tokens("abcd") == 1

Ajouter et retirer des fichiers

ctx = GestionnaireContexte(max_tokens=100)
assert ctx.ajouter_fichier("petit.py", "x = 1") == True
assert ctx.obtenir_utilisation() > 0
assert ctx.retirer_fichier("petit.py") == True
assert ctx.obtenir_utilisation() == 0.0

Refuser un fichier trop gros

ctx = GestionnaireContexte(max_tokens=10)
gros_contenu = "x" * 200  # 50 tokens, depasse 10
assert ctx.ajouter_fichier("gros.py", gros_contenu) == False

Resumer l'historique long

ctx = GestionnaireContexte()
historique = [{"role": "system", "content": "Sys"}]
for i in range(10):
    historique.append({"role": "user", "content": f"Q{i}"})
    historique.append({"role": "assistant", "content": f"R{i}"})
resume = ctx.resumer_historique(historique)
# Doit contenir : system original + resume + 4 derniers messages
assert len(resume) < len(historique), "Le resume doit etre plus court que l'original"
assert any("Resume" in m.get("content", "") for m in resume), "Doit contenir un message de resume"
# Les 4 derniers messages doivent etre la
derniers = [m for m in resume if m["role"] != "system"]
assert len(derniers) == 4

+ 0 tests cachés

Indices (3 disponibles)

Solution officielle

class GestionnaireContexte:
    def __init__(self, max_tokens=100000):
        self.max_tokens = max_tokens
        self.fichiers = {}
        self.tokens_utilises = 0

    def compter_tokens(self, texte):
        return len(texte) // 4

    def ajouter_fichier(self, chemin, contenu):
        tokens_fichier = self.compter_tokens(contenu)
        if self.tokens_utilises + tokens_fichier > self.max_tokens:
            return False
        self.fichiers[chemin] = contenu
        self.tokens_utilises += tokens_fichier
        return True

    def retirer_fichier(self, chemin):
        if chemin in self.fichiers:
            self.tokens_utilises -= self.compter_tokens(self.fichiers[chemin])
            del self.fichiers[chemin]
            return True
        return False

    def resumer_historique(self, historique):
        if len(historique) <= 5:
            return historique
        system = [m for m in historique if m["role"] == "system"]
        autres = [m for m in historique if m["role"] != "system"]
        if len(autres) <= 4:
            return historique
        nb_resumes = len(autres) - 4
        resume_msg = {"role": "system", "content": f"Resume des echanges precedents : {nb_resumes} messages resumes."}
        return system + [resume_msg] + autres[-4:]

    def construire_contexte(self, system_prompt, historique, fichiers_demandes=None):
        messages = [{"role": "system", "content": system_prompt}]

        fichiers_inclus = []
        if fichiers_demandes:
            for chemin in fichiers_demandes:
                if chemin in self.fichiers:
                    messages.append({
                        "role": "system",
                        "content": f"Contenu de {chemin} :\n{self.fichiers[chemin]}"
                    })
                    fichiers_inclus.append(chemin)
        messages.extend([m for m in historique if m.get("role") != "system"])

        total_tokens = sum(self.compter_tokens(m["content"]) for m in messages)
        pourcentage = round(total_tokens / self.max_tokens * 100, 1)

        return {
            "messages": messages,
            "fichiers_inclus": fichiers_inclus,
            "tokens_utilises": total_tokens,
            "tokens_max": self.max_tokens,
            "pourcentage": pourcentage,
        }

    def obtenir_utilisation(self):
        return round(self.tokens_utilises / self.max_tokens * 100, 1)

← Conversation interactive Securite et permissions →

solution.py

Bravo!

Gestion du contexte

Tests (4/5)

Indices (3 disponibles)

Solution officielle