Maîtriser les Fenêtres de Contexte Claude : Limites, Optimisation et Migration Réussie

Bonnes Pratiques d'Utilisation des Fenêtres de Contexte

Gestion des Documents Longs

Entreposage de Mémoire Vectorielle

import chromadb
from sentence_transformers import SentenceTransformer

class HybridMemorySystem:
    """
    Système hybride combinant contexte direct et mémoire vectorielle.
    Optimisé pour les applications avec historique étendu.
    """
    
    def __init__(self, embedding_model="sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2"):
        self.embedder = SentenceTransformer(embedding_model)
        self.vector_db = chromadb.Client()
        self.collection = self.vector_db.create_collection("long_term_memory")
        
        # Fenêtre de contexte active
        self.active_context = []
        self.max_context_tokens = 160000
    
    def add_to_memory(self, text: str, metadata: dict):
        """Ajoute un élément à la mémoire à long terme."""
        embedding = self.embedder.encode(text).tolist()
        self.collection.add(
            embeddings=[embedding],
            documents=[text],
            metadatas=[metadata],
            ids=[metadata.get("id", str(hash(text)))]
        )
    
    def retrieve_relevant(self, query: str, top_k: int = 5) -> list:
        """Récupère les éléments les plus pertinents pour la requête."""
        query_embedding = self.embedder.encode(query).tolist()
        
        results = self.collection.query(
            query_embeddings=[query_embedding],
            n_results=top_k
        )
        
        return results
    
    def build_context(self, query: str, current_messages: list) -> list:
        """
        Construit le contexte optimisé en combinant
        messages actifs et souvenirs pertinents.
        """
        # Récupérer les souvenirs pertinents
        memories = self.retrieve_relevant(query)
        
        # Construire le message système avec les souvenirs
        memory_summary = self._format_memories(memories)
        
        # Insérer au début du contexte
        context = [
            {"role": "system", "content": f"Contexte additionnel:\n{memory_summary}"}
        ] + current_messages
        
        # Tronquer si nécessaire
        if self._estimate_tokens(context) > self.max_context_tokens:
            context = self._truncate_oldest_messages(context)
        
        return context
    
    def _estimate_tokens(self, messages: list) -> int:
        return sum(len(m.get("content", "")) // 4 for m in messages)
    
    def _format_memories(self, memories: dict) -> str:
        if not memories.get("documents"):
            return ""
        
        formatted = "## Mémoire à long terme\n\n"
        for doc, meta in zip(memories["documents"], memories["metadatas"]):
            formatted += f"- [{meta.get('timestamp', 'N/A')}] {doc[:500]}...\n"
        return formatted
    
    def _truncate_oldest_messages(self, context: list, keep_recent: int = 10) -> list:
        """Conserve seulement les N messages les plus récents."""
        system_msgs = [m for m in context if m["role"] == "system"]
        others = [m for m in context if m["role"] != "system"]
        return system_msgs + others[-keep_recent:]

Utilisation
memory = HybridMemorySystem()
memory.add_to_memory(
    "Le client prefers les recommandations bio et locaux",
    {"id": "client_12345_pref", "timestamp": "2025-11-15"}
)

context = memory.build_context(
    "Que recomendar a este cliente?",
    [{"role": "user", "content": "Sugiere productos para mi próximo pedido"}]
)

Erreurs Courantes et Solutions

Erreur 1 : Dépassement de Limite de Contexte

# ❌ ERREUR : ContextWindowExceededException
Message : "Input too long. Maximum size is 200000 tokens"

import anthropic

client = anthropic.Anthropic(
    api_key="YOUR_HOLYSHEEP_API_KEY",
    base_url="https://api.holysheep.ai/v1"
)

Cette requête échouera avec un document de 250 000 tokens
with open("livre_complet.txt", "r") as f:
    document = f.read()  # 250 000 tokens

response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[{"role": "user", "content": f"Analyse ce document:\n{document}"}]
)

✅ SOLUTION : Implémenter la segmentation
def process_long_document(client, document, chunk_size=8000, overlap=500):
    """
    Traite un document long en le segmentant intelligemment.
    Gère le chevauchement pour préserver le contexte transitoire.
    """
    chunks = []
    start = 0
    
    while start < len(document):
        end = start + chunk_size
        chunk = document[start:end]
        chunks.append(chunk)
        start = end - overlap  # Chevauchement pour continuité
    
    # Traiter le premier chunk et récupérer le résumé
    summaries = []
    
    for i, chunk in enumerate(chunks):
        is_first = i == 0
        is_last = i == len(chunks) - 1
        
        prompt = f"""{'Ceci est le début du document.' if is_first else 'Suite du document.'}
{'Ceci est la fin du document.' if is_last else 'Suite follows.'}

Contenu:
{chunk}

{'Génère un résumé structuré des points clés.' if is_last else 'Extrait les thèmes principaux de cette section.'}"""
        
        response = client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=512,
            messages=[{"role": "user", "content": prompt}]
        )
        
        summaries.append(response.content[0].text)
    
    # Synthèse finale
    final_prompt = "À partir de ces résumés partiels, fournis une analyse complète:\n\n" + "\n---\n".join(summaries)
    
    final_response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=2048,
        messages=[{"role": "user", "content": final_prompt}]
    )
    
    return final_response.content[0].text

Utilisation correcte
result = process_long_document(client, document)

Explication : Le dépassement de contexte génère une exception bloquante. La segmentation avec chevauchement préserve la continuité sémantique entre les sections tout en respectant les limites techniques.

Erreur 2 : Perte de Contexte Intermédiaire

# ❌ ERREUR : Perte d'informations dans les grandes conversations
Symptôme : Le modèle "oublie" des informations mentionnées au milieu

Conversation de 150 messages - le modèle ne se souvient plus
du nom du projet mentionné au message 75

client = anthropic.Anthropic(
    api_key="YOUR_HOLYSHEEP_API_KEY",
    base_url="https://api.holysheep.ai/v1"
)

❌ Conversation complète (risque de dépassement)
all_messages = load_conversation_history(150)  # 180 000 tokens

response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=all_messages  # Les infos du milieu sont diluées
)

✅ SOLUTION : Résumé dynamique avec sliding window
class ConversationMemory:
    """
    Gestionnaire de mémoire conversationnelle avec résumé automatique.
    Préserve l'historique pertinent sous forme compressée.
    """
    
    def __init__(self, client, max_messages=20, summary_trigger=15):
        self.client = client
        self.max_messages = max_messages  # Messages actifs en contexte
        self.summary_trigger = summary_trigger  # Quand résumer
        self.summaries = []  # Résumés des conversations passées
        self.current = []    # Messages actuels
    
    def add_message(self, role: str, content: str):
        """Ajoute un message à la conversation."""
        self.current.append({"role": role, "content": content})
        
        # Déclencher le résumé quand le seuil est atteint
        if len(self.current) >= self.summary_trigger:
            self._create_summary()
    
    def _create_summary(self):
        """Compresse les messages courants en résumé."""
        summary_prompt = """Résume cette conversation de manière concise.
Conserve :
- Les décisions importantes prises
- Les informations clés sur le projet/client
- Les préférences et contraintes exprimées
- Les points en suspens

Format : Liste à puces concise."""

        messages_to_summarize = [{"role": m["role"], "content": m["content"]} 
                                  for m in self.current]
        
        response = self.client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=512,
            messages=[{"role": "user", "content": summary_prompt}] + messages_to_summarize
        )
        
        # Stocker le résumé avec métadonnées
        self.summaries.append({
            "summary": response.content[0].text,
            "message_count": len(self.current)
        })
        
        # Réinitialiser avec juste le dernier message
        self.current = self.current[-3:]  # Garder les 3 derniers
    
    def get_context(self) -> list:
        """Construit le contexte complet pour l'API."""
        context = []
        
        # Ajouter les résumés antérieurs
        for i, summary_data in enumerate(self.summaries):
            context.append({
                "role": "system",
                "content": f"Résumé historique #{i+1} (conversation de {summary_data['message_count']} messages):\n{summary_data['summary']}"
            })
        
        # Ajouter les messages actuels
        context.extend(self.current)
        
        return context

Utilisation
memory = ConversationMemory(client)

Simuler une longue conversation
for i in range(100):
    memory.add_message("user", f"Message utilisateur #{i+1}")
    if i % 10 == 0:
        memory.add_message("assistant", f"Réponse #{i+1}")

Le contexte reste gérable malgré les 100 messages
context = memory.get_context()

Explication : Les modèles ont tendance à donner plus de poids aux messages récents et au début de la conversation. Le résumé dynamique compresse l'historique tout en préservant les informations critiques.

Erreur 3 : Incohérence des Réponses avec Grand Contexte

# ❌ ERREUR : Réponses contradictoires ou incohérentes
Cause : Contexte trop fragmenté ou mal structuré

Les informations se contredisent car elles viennent
de différentes parties du document non liées

✅ SOLUTION : Structure de contexte avec marqueurs explicites
class StructuredContextBuilder:
    """
    Constructeur de contexte structuré pour maximiser la cohérence.
    Utilise des marqueurs explicites pour guider le modèle.
    """
    
    SYSTEM_PROMPT = """Tu es un assistant analytique précis.
Quand tu réponds, cite explicitement les sections du document source.
Si une information apparaît plusieurs fois, indique les contradictions potentielles.
"""

    def __init__(self, client):
        self.client = client
    
    def build_structured_context(self, document_sections: list[dict]) -> list:
        """
        Construit un contexte structuré avec métadonnées explicites.
        
        Args:
            document_sections: Liste de dicts avec 'title', 'content', 'source'
        """
        context = [
            {"role": "system", "content": self.SYSTEM_PROMPT},
            {"role": "system", "content": "## Structure du Document Analysé\n"}
        ]
        
        # Ajouter la table des matières explicite
        toc = "**Table des matières :**\n"
        for i, section in enumerate(document_sections):
            toc += f"{i+1}. {section['title']} (source: {section.get('source', 'N/A')})\n"
        
        context.append({"role": "system", "content": toc + "\n---\n"})
        
        # Ajouter chaque section avec marqueur clair
        for i, section in enumerate(document_sections):
            section_header = f"\n### SECTION {i+1}: {section['title']}\n"
            section_marker = f"[SOURCE: {section.get('source', 'Document principal')} // SECTION {i+1}]\n"
            
            context.append({
                "role": "system", 
                "content": section_header + section_marker + section['content']
            })
        
        return context
    
    def query(self, document_sections: list[dict], question: str) -> str:
        """Effectue une requête avec contexte structuré."""
        context = self.build_structured_context(document_sections)
        context.append({"role": "user", "content": question})
        
        response = self.client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=2048,
            messages=context
        )
        
        return response.content[0].text

Exemple d'utilisation
sections = [
    {
        "title": "Politique de retour",
        "content": "Les clients peuvent retourner les produits dans un délai de 30 jours...",
        "source": "page_produits.html"
    },
    {
        "title": "Exceptions aux retours",
        "content": "Les produits personnalisés et les denrées périssables ne sont pas éligibles...",
        "source": "faq.html"
    },
    {
        "title": "Procédure de retour",
        "content": "Pour initier un retour, le client doit contacter le service après-vente...",
        "source": "aide.html"
    }
]

builder = StructuredContextBuilder(client)
answer = builder.query(sections, "Un client peut-il retourner un produit personnalisé ?")
print(answer)

Explication : La structure explicite avec marqueurs de section aide le modèle à maintenir la cohérence et à localiser précisément les informations sources, réduisant drastiquement les réponses contradictoires.

Guide de Décideur : Quand Optimiser le Contexte

Indicateurs Clés de Performance

Arbre de Décision pour l'Optimisation

Conclusion