Le pattern de réflexion : quand les agents se corrigent

IA
Agents
LLM
Patterns
Découvrez le pattern de réflexion : un agent qui s’auto-évalue et améliore ses réponses en boucle.
Date de publication

12 mai 2025

Version Audio IA

⚡ Résumé Rapide (0m13)

Après avoir vu qu’est-ce qu’un agent, passons aux patterns agentiques popularisés par Andrew Ng. Dans cette série, nous implémentons chaque pattern de zéro, en Python pur avec des LLM comme Groq, sans frameworks (pas de LlamaIndex ou CrewAI pour l’instant).

Pourquoi ? Pour bien comprendre ce qui se passe sous le capot. On commence par le pattern de réflexion, le plus simple, mais qui apporte des gains de qualité surprenants.

Illustration du pattern de réflexion

Illustration du pattern de réflexion

Le pattern de réflexion en bref

Le pattern de réflexion permet à un agent d’évaluer sa propre production et de l’améliorer itérativement. L’idée : générer une réponse, la critiquer, l’ajuster, et recommencer.

C’est une boucle simple en 4 étapes :
1. Génération : Le LLM produit une première version.
2. Réflexion : Le LLM critique cette version (erreurs, améliorations possibles).
3. Correction : Le LLM intègre les critiques pour raffiner la sortie.
4. Répétition : Retour à l’étape 1

Quand arrêter la boucle ?
- Après un nombre fixe d’itérations (ex. : 3 tours).
- Quand le LLM génère un signal d’arrêt (ex. : “OK”, “Parfait”, “Final”).

Malgré sa simplicité, ce pattern booste la qualité des réponses, surtout pour du code, des analyses ou des textes complexes.

Implémentation de zéro : la boucle de réflexion

Testons sur un cas concret : demander à Llama3 70B (via Groq) d’implémenter l’algorithme Merge Sort en Python.

Étape 1 : Génération initiale

On initialise un client Groq et un historique de chat avec un prompt système : “Tu es un programmeur Python qui accepte les feedbacks.”

Prompt utilisateur : “Implémente Merge Sort en Python.”

Résultat typique (version 1) :

def merge_sort(arr):
    if len(arr) <= 1:
        return arr
    mid = len(arr) // 2
    left = merge_sort(arr[:mid])
    right = merge_sort(arr[mid:])
    return merge(left, right)

def merge(left, right):
    result = []
    i, j = 0, 0
    while i < len(left) and j < len(right):
        if left[i] <= right[j]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1
    result.extend(left[i:])
    result.extend(right[j:])
    return result

Fonctionnel, mais perfectible (pas de docstrings complètes, gestion d’erreurs, etc.).

Étape 2 : Phase de réflexion

Nouveau prompt système : “Tu es un expert comme Andrej Karpathy. Critique ce code Python : erreurs, style, améliorations, tests.”

On passe le code généré comme message utilisateur.

Critiques typiques :
- Ajouter des type hints (PEP 484).
- Améliorer les noms de variables (left → left_half).
- Ajouter docstrings détaillées et gestion d’erreurs.
- Inclure tests unitaires.

Étape 3 : Intégration et nouvelle génération

On ajoute les critiques à l’historique de génération. Le LLM produit une version 2 : classe orientée objet, tests unittest, edge cases gérés.

La boucle continue jusqu’au critère d’arrêt. Résultat final : un code production-ready avec classe, tests complets (vides, doublons, négatifs), complexité indiquée.

Le repo GitHub de la série contient une classe ReflectionAgent qui encapsule tout ça proprement.

L’agent de réflexion en action

Installation : pip install agentic-patterns (lib perso pour la série).

Usage simple :

agent = ReflectionAgent(model="llama3-70b")
response = agent.run("Implémente Merge Sort avec tests")
print(response.final_output)

Sortie finale : un module complet MergeSort avec __init__, _merge privé, tests exhaustifs. Amélioration massive en quelques itérations !

Pourquoi ça marche si bien ?

  • Auto-correction : L’agent simule un pair-review infini.
  • Spécialisation : Un prompt pour générer, un autre pour critiquer.
  • Itératif : Chaque tour affine, comme un humain qui révise.

Idéal pour : génération de code, rédaction d’essais, analyses de données, où la première tentative est souvent imparfaite.

Prochaines étapes

Prochain article : les outils, ingrédient clé pour rendre les agents vraiment utiles.

🛠 Projets Actifs

Découvrez ces implémentations pratiques pour voir le Pattern de Réflexion en action. Vous pouvez trouver le code source complet sur GitHub.

📝 Générateur de Résumés Auto-Correcteur

Cet agent prend un bloc de texte, génère un résumé, puis critique sa propre production, et enfin réécrit le résumé en fonction de cette réflexion. Il fonctionne en trois étapes clés : Générer → Réfléchir → Réviser—tout cela géré en interne.

  • Flux métacognitif : Démontre comment les agents peuvent “penser à leur façon de penser”.
  • Réflexion flexible : Peut utiliser une logique simple ou un LLM pour la phase de critique.
  • Architecture extensible : Conçu pour être facilement étendu vers des boucles de raisonnement plus complexes.
# Étape 1 : Générer un résumé
def generer_resume(texte: str) -> str:
    return texte[:100] + "..." if len(texte) > 100 else texte
 
# Étape 2 : Réflexion sur la qualité du résumé
def reflechir_sur_resume(resume: str) -> str:
    if len(resume.split()) < 20:
        return "Le résumé est trop court et manque de détails."
    elif "..." in resume:
        return "Le résumé semble incomplet ou s'arrête brusquement."
    return "Le résumé est clair et suffisamment détaillé."
 
# Étape 3 : Améliorer le résumé
def ameliorer_resume(texte: str, reflexion: str) -> str:
    if "too short" in reflexion or "incomplet" in reflexion:
        return texte[:200] + "..." if len(texte) > 200 else texte
    return generer_resume(texte)
 
# Agent de Réflexion Complet
def agent_resume_reflexion(texte: str) -> str:
    resume = generer_resume(texte)
    print("📝 Résumé initial :", resume)
 
    reflexion = reflechir_sur_resume(resume)
    print("🔍 Réflexion :", reflexion)
 
    ameliore = ameliorer_resume(texte, reflexion)
    print("✅ Résumé amélioré :", ameliore)
    return ameliore
 
# 🧪 Exemple
texte = (
    "L'intelligence artificielle (IA) révolutionne les industries en permettant aux machines de réaliser "
    "des tâches qui nécessitent normalement l'intelligence humaine. De la santé à la finance, l'IA "
    "optimise les flux de travail, fait des prédictions et transforme les processus décisionnels."
)
 
agent_resume_reflexion(texte)
📝 Résumé initial : L'intelligence artificielle (IA) révolutionne les industries en permettant aux machines de réaliser...
🔍 Réflexion : Le résumé semble incomplet ou s'arrête brusquement.
✅ Résumé amélioré : L'intelligence artificielle (IA) révolutionne les industries en permettant aux machines de réaliser des tâches qui nécessitent normalement l'intelligence humaine. De la santé à la finance, l'IA optimise les flux de travail, fait des prédictions et transforme les processus décisionnels...
  • Assistants d’écriture qui révisent leurs propres brouillons pour plus de clarté.
  • Résumeurs de recherche qui auto-améliorent la précision des synthèses.
  • ** Flux de génération de contenu** où la qualité est une priorité absolue.

🎓 Agent Évaluateur de Dissertations

Cet agent prend une courte dissertation, l’évalue selon des critères de clarté et de structure, puis suggère des réécritures. Il imite le travail de révision d’un étudiant ou d’un tuteur IA.

  • Réflexion sur contenu externe : Analyse les entrées utilisateur plutôt que ses propres sorties.
  • Feedback de type tutorat : Simule le retour d’un enseignant ou d’un expert.
  • Piloté par des critères : Utilise des métriques précises pour orienter les corrections.
# Étape 1 : Évaluer la dissertation
def evaluer_dissertation(texte: str) -> str:
    score = 0
    feedback = []
 
    if len(texte.split()) < 100:
        feedback.append("La dissertation est trop courte.")
    else:
        score += 1
 
    if "cependant" in texte or "pourtant" in texte:
        feedback.append("Bonne utilisation des connecteurs logiques.")
        score += 1
    else:
        feedback.append("Essayez d'ajouter des transitions pour fluidifier le texte.")
 
    if "parce que" in texte or "car" in texte:
        feedback.append("L'argument est soutenu par un raisonnement.")
        score += 1
    else:
        feedback.append("Pensez à justifier vos opinions avec des faits.")
 
    return f"🧠 Réflexion :\n" + "\n".join(feedback), score
 
# Étape 2 : Réécriture basée sur le feedback
def reviser_dissertation(texte: str, feedback: str) -> str:
    if "trop courte" in feedback:
        return texte + " En conclusion, ce sujet mérite une exploration plus approfondie."
    if "justifier" in feedback:
        return texte + " Ceci est crucial car cela impacte de nombreux aspects de la société."
    return texte
 
# Pipeline complet de l'agent
def agent_evaluateur_dissertation(texte: str) -> str:
    print("✍️ Dissertation originale :\n", texte, "\n")
    feedback, score = evaluer_dissertation(texte)
    print(feedback)
    print(f"📝 Score : {score}/3")
 
    revisee = reviser_dissertation(texte, feedback)
    print("\n✅ Dissertation révisée :\n", revisee)
    return revisee
 
# 🧪 Exemple
texte_essai = (
    "La technologie a changé notre façon de communiquer. Les réseaux sociaux permettent de rester connectés. "
    "C'est positif, mais cela crée aussi des problèmes de vie privée."
)
 
agent_evaluateur_dissertation(texte_essai)
✍️ Dissertation originale :
La technologie a changé notre façon de communiquer...
 
🧠 Réflexion :
La dissertation est trop courte.
Essayez d'ajouter des transitions pour fluidifier le texte.
Pensez à justifier vos opinions avec des faits.
📝 Score : 0/3
 
✅ Dissertation révisée :
La technologie a changé notre façon de communiquer... Ceci est crucial car cela impacte de nombreux aspects de la société.
  • Tuteurs IA d’aide à la rédaction pour les plateformes éducatives.
  • Notation automatisée avec feedback constructif immédiat.
  • Outils d’aide à la décision analysant la force des arguments.

Ressources

Série Agent Design Patterns
← Article précédent Qu’est-ce qu’un agent ? Article suivant → Le pattern d’utilisation d’outils
Retour au sommet