Fenêtres de contexte longues : travailler avec des modèles IA à un million de tokens

Évolution de la fenêtre de contexte

Le parcours

Ce que le long contexte permet

Comprendre les limites de tokens

Les bases des tokens

Les tokens sont les unités que les modèles traitent :

"Hello, world!" = 4 tokens
"artificial intelligence" = 2 tokens
"supercalifragilisticexpialidocious" = 7 tokens (découpé)

Estimations approximatives :
- 1 token ≈ 4 caractères en anglais
- 1 token ≈ 0,75 mots
- 1 000 tokens ≈ 750 mots ≈ 1,5 pages

Contexte = entrée + sortie

Important : la fenêtre de contexte inclut à la fois l'entrée ET la sortie :

Si fenêtre de contexte = 100 000 tokens

Et votre entrée = 90 000 tokens
Sortie maximale = 10 000 tokens

Si vous avez besoin de 20 000 tokens en sortie :
Entrée maximale = 80 000 tokens

Comparaison des modèles (2026)

Cas d'usage du long contexte

1. Analyse de base de code

Cas d'usage : compréhension d'un dépôt entier

Entrée :
- Tous les fichiers sources (~500K tokens)
- Documentation (~50K tokens)
- Fichiers de tests (~100K tokens)
- Configuration (~10K tokens)

Requête : "Identifiez les vulnérabilités de sécurité potentielles
          dans l'ensemble de la base de code, en considérant comment
          les modules interagissent."

Avantage : analyse inter-fichiers sans découpage

2. Analyse de collections de documents

Cas d'usage : revue juridique

Entrée :
- 500 contrats et documents juridiques
- Archives de communication
- Documents de politique

Requête : "Trouvez toutes les clauses dans ces documents qui
          pourraient entrer en conflit avec les exigences du RGPD."

Avantage : détecter des patterns dans l'ensemble du corpus

3. Contenu de la longueur d'un livre

Cas d'usage : analyse de roman

Entrée :
- Texte complet du livre (~200K tokens)

Requêtes :
- "Suivez les arcs de développement des personnages"
- "Identifiez les éléments de préfiguration de la fin"
- "Analysez la progression thématique"

Avantage : compréhension holistique

4. Synthèse multi-documents

Cas d'usage : synthèse de recherche

Entrée :
- 50 articles de recherche dans un domaine
- Texte intégral de chacun

Requête : "Synthétisez l'état actuel de la recherche
          sur [sujet], en identifiant les consensus,
          les conflits et les lacunes."

Avantage : vue d'ensemble complète de la littérature

5. Historique de conversation

Cas d'usage : projets de longue durée

Entrée :
- Des mois d'historique de conversation
- Documents associés référencés
- Modifications de code effectuées

Requête : Continuer à travailler avec le contexte complet de
         tout ce qui a été discuté et décidé.

Avantage : pas d'« oubli » du contexte précédent

Stratégies pour le long contexte

Stratégie 1 : inclusion du contexte complet

Quand l'utiliser :

• →Les documents doivent être analysés ensemble
• →Les relations de références croisées comptent
• →La cohérence entre les contenus est requise

Implémentation :

def full_context_analysis(documents):
    combined = "\n\n---\n\n".join(documents)
    
    prompt = f"""
    Je fournis {len(documents)} documents pour analyse.
    Veuillez les analyser de manière holistique.
    
    {combined}
    
    En vous basant sur tous les documents, répondez : [question]
    """
    
    return model.generate(prompt)

Stratégie 2 : découpage structuré

Quand le contexte dépasse les limites ou pour plus d'efficacité :

def structured_chunking(content, chunk_size=50000):
    chunks = split_into_chunks(content, chunk_size)
    
    # Premier passage : analyser chaque segment
    chunk_summaries = []
    for i, chunk in enumerate(chunks):
        summary = model.generate(f"""
            Analysez la section {i+1}/{len(chunks)} :
            {chunk}
            
            Fournissez les conclusions clés pertinentes pour : [question]
        """)
        chunk_summaries.append(summary)
    
    # Deuxième passage : synthétiser
    final = model.generate(f"""
        Synthétisez ces analyses de sections en une
        réponse complète :
        
        {chunk_summaries}
        
        Question : [question]
    """)
    
    return final

Stratégie 3 : traitement hiérarchique

Pour les contenus très volumineux :

Niveau 1 : Documents individuels → Points clés
Niveau 2 : Points clés regroupés → Résumés thématiques
Niveau 3 : Résumés thématiques → Synthèse finale

Exemple :
100 documents (1M tokens au total)
  → 100 résumés de points clés (50K tokens)
    → 10 résumés thématiques (10K tokens)
      → Réponse finale (2K tokens)

Stratégie 4 : augmenté par la récupération (RAG)

Combiner récupération et long contexte :

def rag_with_long_context(query, document_store):
    # Récupérer les segments les plus pertinents
    relevant = document_store.search(query, top_k=50)
    
    # Inclure le contenu récupéré (rentre dans le long contexte)
    prompt = f"""
    Question : {query}
    
    Informations pertinentes de nos documents :
    {format_chunks(relevant)}
    
    En vous basant sur ces informations, fournissez une réponse complète.
    """
    
    return model.generate(prompt)

Bonnes pratiques

1. Structurez votre entrée

Bonne organisation :

# APERÇU DU CONTEXTE
Vous avez accès à [description du contenu]

# DOCUMENT 1 : [Titre]
[Contenu du document 1]

# DOCUMENT 2 : [Titre]
[Contenu du document 2]

# VOTRE TÂCHE
[Question ou instruction claire]

# FORMAT DE SORTIE ATTENDU
[Description du format souhaité]

2. Soyez explicite sur la pertinence

"Concentrez-vous particulièrement sur les sections traitant de [sujet].
Le reste du contenu est fourni pour le contexte mais peut être
moins pertinent pour cette question spécifique."

3. Demandez des citations

"Lorsque vous faites référence à une information, citez le document
et la section spécifiques, par ex. [Document 3, Section 2.1]"

4. Gérez le biais de position

Les modèles peuvent accorder plus d'attention au début et à la fin :

Stratégies :
- Placez le contexte le plus important en premier
- Répétez les informations clés
- Référencez explicitement les sections centrales dans les prompts
- Envisagez de varier l'ordre entre les requêtes

5. Surveillez l'utilisation des tokens

def estimate_tokens(text):
    # Estimation approximative : 4 caractères par token
    return len(text) // 4

def check_capacity(content, model_limit, output_reserve=4000):
    content_tokens = estimate_tokens(content)
    available = model_limit - output_reserve
    
    if content_tokens > available:
        print(f"Attention : {content_tokens} tokens dépasse "
              f"les {available} tokens disponibles")
        return False
    return True

Considérations de performance

Latence

Coût

La plupart des modèles facturent par token :

Exemple de tarification (hypothétique) :
Entrée : 0,01 $ pour 1K tokens
Sortie : 0,03 $ pour 1K tokens

Pour 500K tokens en entrée + 2K tokens en sortie :
Coût = (500 × 0,01 $) + (2 × 0,03 $) = 5,06 $ par requête

L'analyse complète d'une base de code peut coûter 5 à 20 $ par requête

Précision

Les recherches montrent que :

• →La performance est généralement bonne sur l'ensemble du contexte
• →Une certaine dégradation sur la recherche très spécifique au milieu
• →Les références explicites améliorent la précision
• →Le formatage structuré améliore la performance

Comparaison avec le RAG

Quand utiliser le long contexte :

• →Besoin de raisonnement inter-documents
• →Le contenu rentre dans les limites
• →La simplicité de mise en place est valorisée
• →La fréquence des requêtes est faible

Quand utiliser le RAG :

• →Le contenu dépasse largement les limites
• →Réponse rapide nécessaire
• →Beaucoup de requêtes attendues
• →Mises à jour fréquentes du contenu

Exemples pratiques

Exemple 1 : revue de code

# Charger la base de code entière
codebase = load_repository("./my-project")
all_code = format_codebase(codebase)  # ~200K tokens

prompt = f"""
# BASE DE CODE POUR REVUE
{all_code}

# DEMANDE DE REVUE
Effectuez une revue de code complète portant sur :
1. Vulnérabilités de sécurité
2. Problèmes de performance
3. Problèmes d'organisation du code
4. Gestion d'erreurs manquante

Pour chaque problème, fournissez :
- Référence du fichier et de la ligne
- Description du problème
- Correction recommandée
"""

response = long_context_model.generate(prompt)

Exemple 2 : analyse d'historique de réunions

# Charger toutes les notes de réunion
meetings = load_meetings_year(2025)  # 100 réunions
all_notes = format_meetings(meetings)  # ~150K tokens

prompt = f"""
# NOTES DE RÉUNION : Toutes les réunions 2025
{all_notes}

# DEMANDE D'ANALYSE
1. Quels sont les thèmes récurrents abordés ?
2. Quelles décisions ont été prises et quand ?
3. Quels éléments d'action restent non résolus ?
4. Quels sujets ont évolué au fil du temps ?
"""

response = long_context_model.generate(prompt)

Points clés à retenir

1. →

   Les fenêtres de contexte ont atteint 1 à 2 millions de tokens, permettant l'analyse de bases de code entières ou de collections de documents

2. →

   Le contexte inclut entrée et sortie — réservez des tokens pour la réponse

3. →

   Le contexte complet surpasse le découpage pour le raisonnement inter-documents quand le contenu rentre

4. →

   Structurez votre entrée avec une organisation claire et des instructions explicites

5. →

   Prenez en compte les compromis de performance : latence, coût et précision

6. →

   Choisissez entre long contexte et RAG en fonction des exigences du cas d'usage

7. →

   Le biais de position existe — structurez contenu et prompts pour l'atténuer

Maîtriser les fondamentaux de l'IA

Comprendre les fenêtres de contexte est fondamental pour travailler efficacement avec l'IA moderne. La bonne approche dépend de votre cas d'usage spécifique, de votre contenu et de vos exigences.

Dans notre Module 0 — Fondamentaux de l'IA, vous apprendrez :

• →Comment les modèles de langage traitent l'information
• →L'économie des tokens et l'optimisation
• →Quand utiliser différentes approches
• →Les critères de sélection de modèles
• →Le prompt engineering pratique
• →Rester à jour avec l'évolution de l'IA

Ces fondamentaux vous aident à prendre de meilleures décisions sur l'utilisation de l'IA.

→ Explorer le Module 0 : Fondamentaux de l'IA