recherche-itérative

Modèle de Recherche 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 jusqu'à ce qu'ils commencent à travailler.

Quand l'activer

• Lors du lancement de sous-agents qui ont besoin d'un contexte de codebase qu'ils ne peuvent pas prédire à l'avance
• Lors de la construction de workflows multi-agents où le contexte est affiné progressivement
• Face à des erreurs de type "contexte trop volumineux" ou "contexte manquant" dans les tâches d'agent
• Lors de la conception de pipelines de récupération de type RAG pour l'exploration de code
• Pour 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 base de code
• Quelle terminologie le projet utilise

Les approches standards é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 incorrect

La Solution : Recherche Itérative

Une boucle en 4 phases qui affine progressivement le contexte :

┌─────────────────────────────────────────────┐
│                                             │
│   ┌──────────┐      ┌──────────┐            │
│   │ DISPATCH │─────│ EVALUATE │            │
│   └──────────┘      └──────────┘            │
│        ▲                  │                 │
│        │                  ▼                 │
│   ┌──────────┐      ┌──────────┐            │
│   │   LOOP   │─────│  REFINE  │            │
│   └──────────┘      └──────────┘            │
│                                             │
│        Max 3 cycles, then proceed           │
└─────────────────────────────────────────────┘

Phase 1 : DISPATCH

Requête initiale large pour rassembler des fichiers candidats :

// Commencez par une intention de haut niveau
const initialQuery = {
  patterns: ['src/**/*.ts', 'lib/**/*.ts'],
  keywords: ['authentication', 'user', 'session'],
  excludes: ['*.test.ts', '*.spec.ts']
};

// Envoyer à l'agent de récupération
const candidates = await retrieveFiles(initialQuery);

Phase 2 : EVALUATE

É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 liés
• Faible (0.2-0.4) : Lié tangentiellement
• Aucune (0-0.2) : Pas pertinent, exclure

Phase 3 : REFINE

Mettre à jour les critères de recherche en fonction de l'évaluation :

function refineQuery(evaluation, previousQuery) {
  return {
    // Ajouter de nouveaux motifs découverts dans les fichiers de haute pertinence
    patterns: [...previousQuery.patterns, ...extractPatterns(evaluation)],

    // Ajouter la terminologie trouvée dans la base de code
    keywords: [...previousQuery.keywords, ...extractKeywords(evaluation)],

    // Exclure les chemins confirmés 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 : LOOP

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 disposons d'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 :
  DISPATCH : Rechercher "token", "auth", "expiry" dans src/**
  EVALUATE : Trouvé auth.ts (0.9), tokens.ts (0.8), user.ts (0.3)
  REFINE : Ajouter les mots-clés "refresh", "jwt" ; exclure user.ts

Cycle 2 :
  DISPATCH : Rechercher les termes affinés
  EVALUATE : Trouvé session-manager.ts (0.95), jwt-utils.ts (0.85)
  REFINE : Contexte suffisant (2 fichiers de haute pertinence)

Résultat : auth.ts, tokens.ts, session-manager.ts, jwt-utils.ts

Exemple 2 : Implémentation de Fonctionnalité

Tâche : "Ajouter une limite de débit aux points de terminaison API"

Cycle 1 :
  DISPATCH : Rechercher "rate", "limit", "api" dans routes/**
  EVALUATE : Aucune correspondance - la codebase utilise la terminologie "throttle"
  REFINE : Ajouter les mots-clés "throttle", "middleware"

Cycle 2 :
  DISPATCH : Rechercher les termes affinés
  EVALUATE : Trouvé throttle.ts (0.9), middleware/index.ts (0.7)
  REFINE : Besoin des motifs de routeur

Cycle 3 :
  DISPATCH : Rechercher les motifs "router", "express"
  EVALUATE : Trouvé router-setup.ts (0.8)
  REFINE : 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 du contexte pour cette tâche :
1. Commencez par une recherche large par mots-clés
2. Évaluez la pertinence de chaque fichier (échelle 0-1)
3. Identifiez le contexte qui manque encore
4. Affinez les critères de recherche et répétez (max 3 cycles)
5. Renvoyez les fichiers avec une pertinence >= 0.7

Meilleures Pratiques

1. Commencez large, affinez progressivement - Ne spécifiez pas trop les requêtes initiales
2. Apprenez la terminologie de la codebase - Le premier cycle révèle souvent les conventions de nommage
3. Suivez ce qui manque - L'identification explicite des lacunes guide l'affinement
4. Arrêtez-vous à "assez bien" - 3 fichiers de haute pertinence valent mieux que 10 médiocres
5. Excluez en toute confiance - Les fichiers de faible pertinence ne deviendront pas pertinents

Liés

• 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 incluses avec ECC (chemin d'installation manuelle : agents/)