Modèle de Récupération Itérative
Résout le « problème de contexte » dans les workflows multi-agents où les sous-agents ne savent pas de quel contexte ils ont besoin avant de commencer à travailler.
Quand Activer
- Lancer des sous-agents qui ont besoin de contexte de codebase qu'ils ne peuvent pas prédire à l'avance
- Construire des workflows multi-agents où le contexte est affiné progressivement
- Rencontrer des échecs de type « contexte trop volumineux » ou « contexte manquant » dans les tâches d'agent
- Concevoir des pipelines de récupération de type RAG pour l'exploration de code
- Optimiser l'utilisation des tokens dans l'orchestration d'agents
Le Problème
Les sous-agents sont lancés avec un contexte limité. Ils ne savent pas :
- Quels fichiers contiennent le code pertinent
- Quels motifs existent dans la codebase
- Quelle terminologie le projet utilise
Les approches standard échouent :
- Tout envoyer : Dépasse les limites de contexte
- Ne rien envoyer : L'agent manque d'informations critiques
- Deviner ce qui est nécessaire : Souvent faux
La Solution : Récupération Itérative
Une boucle en 4 phases qui affine progressivement le contexte :
┌─────────────────────────────────────────────┐
│ │
│ ┌──────────┐ ┌──────────┐ │
│ │ LANCER │─────│ ÉVALUER │ │
│ └──────────┘ └──────────┘ │
│ ▲ │ │
│ │ ▼ │
│ ┌──────────┐ ┌──────────┐ │
│ │ RÉPÉTER │─────│ AFFINER │ │
│ └──────────┘ └──────────┘ │
│ │
│ Max 3 cycles, puis continuer │
└─────────────────────────────────────────────┘
Phase 1 : LANCER
Requête initiale large pour rassembler des fichiers candidats :
// Commencer avec une intention de haut niveau
const initialQuery = {
patterns: ['src/**/*.ts', 'lib/**/*.ts'],
keywords: ['authentication', 'user', 'session'],
excludes: ['*.test.ts', '*.spec.ts']
};
// Lancer vers l'agent de récupération
const candidates = await retrieveFiles(initialQuery);
Phase 2 : ÉVALUER
Évaluer la pertinence du contenu récupéré :
function evaluateRelevance(files, task) {
return files.map(file => ({
path: file.path,
relevance: scoreRelevance(file.content, task),
reason: explainRelevance(file.content, task),
missingContext: identifyGaps(file.content, task)
}));
}
Critères de notation :
- Élevée (0.8-1.0) : Implémente directement la fonctionnalité cible
- Moyenne (0.5-0.7) : Contient des motifs ou types connexes
- Faible (0.2-0.4) : Lié tangentiellement
- Aucune (0-0.2) : Non pertinent, exclure
Phase 3 : AFFINER
Mettre à jour les critères de recherche en fonction de l'évaluation :
function refineQuery(evaluation, previousQuery) {
return {
// Ajouter les nouveaux motifs découverts dans les fichiers à haute pertinence
patterns: [...previousQuery.patterns, ...extractPatterns(evaluation)],
// Ajouter la terminologie trouvée dans la codebase
keywords: [...previousQuery.keywords, ...extractKeywords(evaluation)],
// Exclure les chemins confirmés comme non pertinents
excludes: [...previousQuery.excludes, ...evaluation
.filter(e => e.relevance < 0.2)
.map(e => e.path)
],
// Cibler des lacunes spécifiques
focusAreas: evaluation
.flatMap(e => e.missingContext)
.filter(unique)
};
}
Phase 4 : RÉPÉTER
Répéter avec des critères affinés (max 3 cycles) :
async function iterativeRetrieve(task, maxCycles = 3) {
let query = createInitialQuery(task);
let bestContext = [];
for (let cycle = 0; cycle < maxCycles; cycle++) {
const candidates = await retrieveFiles(query);
const evaluation = evaluateRelevance(candidates, task);
// Vérifier si nous avons un contexte suffisant
const highRelevance = evaluation.filter(e => e.relevance >= 0.7);
if (highRelevance.length >= 3 && !hasCriticalGaps(evaluation)) {
return highRelevance;
}
// Affiner et continuer
query = refineQuery(evaluation, query);
bestContext = mergeContext(bestContext, highRelevance);
}
return bestContext;
}
Exemples Pratiques
Exemple 1 : Contexte de Correction de Bug
Tâche : « Corriger le bug d'expiration du jeton d'authentification »
Cycle 1 :
LANCER : Rechercher "token", "auth", "expiry" dans src/**
ÉVALUER : Trouvé auth.ts (0.9), tokens.ts (0.8), user.ts (0.3)
AFFINER : Ajouter les mots-clés "refresh", "jwt" ; exclure user.ts
Cycle 2 :
LANCER : Rechercher les termes affinés
ÉVALUER : Trouvé session-manager.ts (0.95), jwt-utils.ts (0.85)
AFFINER : Contexte suffisant (2 fichiers à haute pertinence)
Résultat : auth.ts, tokens.ts, session-manager.ts, jwt-utils.ts
Exemple 2 : Implémentation de Fonctionnalité
Tâche : « Ajouter une limitation de débit aux points d'accès API »
Cycle 1 :
LANCER : Rechercher "rate", "limit", "api" dans routes/**
ÉVALUER : Aucune correspondance - la codebase utilise la terminologie "throttle"
AFFINER : Ajouter les mots-clés "throttle", "middleware"
Cycle 2 :
LANCER : Rechercher les termes affinés
ÉVALUER : Trouvé throttle.ts (0.9), middleware/index.ts (0.7)
AFFINER : Besoin de motifs de routeur
Cycle 3 :
LANCER : Rechercher les motifs "router", "express"
ÉVALUER : Trouvé router-setup.ts (0.8)
AFFINER : Contexte suffisant
Résultat : throttle.ts, middleware/index.ts, router-setup.ts
Intégration avec les Agents
Utiliser dans les prompts d'agent :
Lors de la récupération de contexte pour cette tâche :
1. Commencer par une recherche large par mots-clés
2. Évaluer la pertinence de chaque fichier (échelle de 0 à 1)
3. Identifier quel contexte manque encore
4. Affiner les critères de recherche et répéter (max 3 cycles)
5. Retourner les fichiers avec une pertinence >= 0.7
Bonnes Pratiques
- Commencer large, affiner progressivement - Ne pas trop spécifier les requêtes initiales
- Apprendre la terminologie de la codebase - Le premier cycle révèle souvent les conventions de nommage
- Suivre ce qui manque - L'identification explicite des lacunes guide l'affinage
- S'arrêter à « assez bon » - 3 fichiers à haute pertinence valent mieux que 10 médiocres
- Exclure avec confiance - Les fichiers à faible pertinence ne deviendront pas pertinents
Associé
- The Longform Guide - Section sur l'orchestration des sous-agents
- Compétence
continuous-learning- Pour les motifs qui s'améliorent avec le temps - Définitions d'agents fournies avec ECC (chemin d'installation manuelle :
agents/)