Agent d’enseignement adaptatif dans LangGraph : état de l’apprenant, routage, révision par des humains

Les modèles de langage peuvent expliquer presque n’importe quel sujet avec une grande fluidité, mais la fluidité ne mesure pas l’apprentissage. Un étudiant peut lire un récit élaboré sur la génération augmentée par la récupération d’informations, acquiescer, et pourtant être incapable de distinguer la récupération d’informations de l’ajustement fin, ou de repérer une citation sans aucun soutien. Ce qui manque, ce n’est pas la génération de texte, mais un contrôle pédagogique : rassembler des preuves que quelqu’un a compris, choisir une intervention adaptée, et vérifier si elle a fonctionné.

Ceci est un croquis de conception pour un agent pédagogique adaptatif basé sur LangGraph, un système à état qui suit les objectifs d’apprentissage, les réponses des apprenants, les idées fausses, les éléments d’évaluation et les actions à entreprendre. Il relie l’ingénierie actuelle des agents aux concepts éducatifs plus anciens, notamment l’évaluation formative et l’apprentissage par maîtrise. L’objectif n’est pas de remplacer l’éducateur par l’automatisation, mais de rendre le cycle formatif de diagnostic, d’explication, de pratique, d’évaluation, d’adaptation et d’approfondissement explicite, inspectable et testable. Une précision : il s’agit d’une conception technique et non d’une preuve que tel ou tel agent améliore les résultats. Un déploiement réel nécessite une conception d’étude appropriée, une analyse d’accessibilité, des mesures de protection de la vie privée et une gouvernance par les enseignants.

Générer des réponses versus s’adapter à l’apprenant

Un chatbot axé sur la réponse prend une demande et renvoie une réponse. Cela peut être pratique, mais rien ne lui indique de manière fiable si l’apprenant a compris, si une erreur persiste ou quelle étape suivre. Il peut sembler pédagogique alors qu’en réalité il ne fait que fonctionner comme un complétion automatique sophistiqué.

Un tuteur adaptatif fonctionne selon un principe différent, celui de l’épisode d’apprentissage. Un épisode commence avec un objectif mesurable, collecte des éléments dans les réponses de l’apprenant, les interprète à l’aide d’une grille d’évaluation, choisit une action pédagogique et enregistre ce qui s’est passé, ce qui implique que l’état de l’apprentissage doit persister à travers toutes ces étapes.

La conception s’inspire d’une idée fondamentale de l’évaluation formative, où l’enseignement et l’évaluation interagissent et où les preuves de compréhension guident le choix pédagogique suivant. Elle s’inspire également de l’apprentissage par maîtrise, qui propose des exercices correctifs et du temps supplémentaire avant que l’apprenant ne passe à du matériel dépendant de sujets antérieurs. Ces idées existent depuis des décennies avant l’IA générative. Ce qui est nouveau, c’est la possibilité de mettre en œuvre leurs boucles de feedback dans un logiciel visible, plutôt que de les cacher dans un seul et unique prompt.

Pourquoi un graphe est supérieur à une chaîne de prompts

Au cœur se trouve un graphe dirigé, G = (V, E). Les nœuds représentent des actions pédagogiques définies, les arêtes indiquent les transitions autorisées entre eux, et les arêtes conditionnelles encodent les décisions éducatives : avancer une fois que la maîtrise est suffisamment démontrée, corriger après une erreur identifiée, ou transférer le cas lorsque la situation est incertaine ou présente des enjeux importants.

LangGraph est adapté car il structure une application autour d’un état partagé, de nœuds qui le lisent et le mettent à jour, ainsi que de transitions explicites. Cela convient bien mieux aux workflows d’apprentissage qu’une simple instruction opaque agissant comme un tuteur utile, et il vous permet de poser des questions concrètes au système. Quelles preuves ont déclenché des actions correctives ? Quelle version du critère d’évaluation a été appliquée ? Une demande risquée a-t-elle atteint un examinateur humain ? L’agent est-il entré en boucle indéfiniment ? L’état de l’apprenant se trouve au centre, et les nœuds doivent le mettre à jour intentionnellement, sans considérer les conversations précédentes comme un simple enregistrement non structuré.

Un état minimal de l’apprenant

Conservez uniquement ce que l’objectif actuel et ses règles de gestion exigent. L’état ne doit pas devenir un dossier vague de données personnelles. Six champs couvrent les éléments essentiels :

• learning_goal, un objectif observable pour l’épisode, comme distinguer RAG du fine-tuning.
• learner_answer : les éléments fournis par l’apprenant, par exemple une explication écrite ou une analyse de code.
• misconceptions : les erreurs spécifiques identifiées, comme l’idée que les citations sont vérifiées automatiquement.
• rubric_score : un indicateur d’évaluation transparent, par exemple 0,65 sur une grille d’évaluation basée sur des critères.
• attempts : un mécanisme de prévention contre des tentatives répétées sans fin, comme deux essais sur la même épreuve.
• next_action permet de visualiser la décision de progression (correction ou avancement), tandis que needs_human_review est un indicateur de sécurité et d’incertitude, activé pour les cas ambigus ou sensibles.

L’exemple ci-dessous utilise un routage déterministe afin que la décision pédagogique reste lisible. En environnement de production, un modèle peut aider à rédiger des retours ou à identifier d’éventuelles erreurs de compréhension chez les apprenants, mais les critères de transition doivent rester vérifiables de manière indépendante.

from typing import Literal
from typing_extensions import TypedDict

class TutorState(TypedDict):
    learning_goal: str
    learner_answer: str
    misconceptions: list[str]
    rubric_score: float
    attempts: int
    needs_human_review: bool
    next_action: str
def choose_next_action(state: TutorState) -> Literal[
    "advance", "remediate", "human_review"
]:
    """Route using visible, reviewable instructional policy."""
    if state["needs_human_review"]:
        return "human_review"
    if state["rubric_score"] >= 0.80 and not state["misconceptions"]:
        return "advance"
    return "remediate"

Le seuil n’est pas universel et doit être choisi et validé pour chaque objectif. Ce qui compte, c’est que la règle soit déclarée, versionnée et testable. Le système ne qualifie pas un apprenant de faible ; il indique simplement que les éléments fournis n’ont pas encore satisfait à un critère défini.

Le graphe pédagogique

Voici un squelette compact de LangGraph où le diagnostic, l’explication, la pratique, l’évaluation, la remédiation, l’avancement et la révision par un humain sont conservés en tant que nœuds distincts. Chaque nœud dans un système en production s’appuierait sur du contenu vérifié, une grille d’évaluation, ainsi qu’un modèle ou un service de recherche fourni à l’extérieur, et non sur une réponse codée à l’avance.

from langgraph.graph import END, START, StateGraph

def diagnose(state: TutorState) -> dict:
    # Replace with a rubric-guided classifier or instructor-approved LLM call.
    answer = state["learner_answer"].lower()
    misconception = "citations are automatically verified" in answer
    return {
        "misconceptions": (
            ["Confuses generated citations with source verification"]
            if misconception else []
        )
    }
def explain(state: TutorState) -> dict:
    # In production: retrieve approved sources, then generate grounded feedback.
    return {"next_action": "practice"}
def practice(state: TutorState) -> dict:
    # In production: generate a new, equivalent item—not the same question again.
    return {"attempts": state["attempts"] + 1}
def evaluate(state: TutorState) -> dict:
    # Placeholder for a criterion-referenced evaluator with stored evidence.
    return {"next_action": choose_next_action(state)}
def route_after_evaluation(state: TutorState) -> str:
    return choose_next_action(state)
builder = StateGraph(TutorState)
builder.add_node("diagnose", diagnose)
builder.add_node("explain", explain)
builder.add_node("practice", practice)
builder.add_node("evaluate", evaluate)
builder.add_node("remediate", explain)
builder.add_node("advance", lambda state: {"next_action": "complete"})
builder.add_node("human_review", lambda state: {"next_action": "review"})builder.add_edge(START, "diagnose")
builder.add_edge("diagnose", "explain")
builder.add_edge("explain", "practice")
builder.add_edge("practice", "evaluate")
builder.add_conditional_edges(
    "evaluate",
    route_after_evaluation,
    {
        "advance": "advance",
        "remediate": "remediate",
        "human_review": "human_review",
    },
)
builder.add_edge("remediate", "practice")
builder.add_edge("advance", END)
builder.add_edge("human_review", END)tutor_graph = builder.compile()

Deux fonctionnalités ont été conçues délibérément. La boucle renvoie des solutions correctives pour une nouvelle opportunité de pratique, et non simplement une explication plus longue. La condition d’arrêt met fin au parcours automatisé dès qu’un élément sort des limites de la politique en vigueur, et redirige l’affaire vers un formateur ou un autre examinateur autorisé.

Le rôle du RAG

Pour les sujets à forte teneur en contenu, le nœud d’explication ne devrait pas s’appuyer uniquement sur les connaissances internes du modèle. Il devrait puiser dans un ensemble de matériaux pédagogiques approuvés et versionnés, transmettre les passages pertinents au modèle et exiger des citations que l’apprenant puisse vérifier. C’est là la véritable fonction du RAG : ancrer une explication dans une base de connaissances soigneusement sélectionnée.

Cela ne rend pas l’agent correct par défaut. Vous avez toujours besoin de règles de sélection des sources, de vérification des citations, de mesures de protection contre l’injection de prompts et de tests pour les affirmations non étayées. Une règle de sécurité utile consiste à faire en sorte que l’agent indique que les preuves sont insuffisantes lorsque la qualité de la récupération est faible, plutôt que de combler ce manque avec une histoire convaincante.

L’évaluation passe en premier

Avoir un graphe ne rend pas un agent adaptatif crédible. Ce qui le rend crédible, c’est un comportement pédagogique et de sécurité mesurable. Évaluez quatre niveaux : l’apprentissage (l’état de compréhension s’est-il amélioré, évalué par des tests de concepts avant/après ou des tâches de transfert), la pédagogie (l’intervention était-elle appropriée, évaluée par un examen expert des retours et de l’orientation), le système (le graphe respectait-il les politiques, évalué par la précision des itinéraires, le taux de boucles et la latence) et la sécurité (l’agent a-t-il fonctionné de manière sûre, évalué par les mécanismes de rappel en cas d’escalade ainsi que par des tests de confidentialité et d’injection).

Avant de perfectionner l’interface, constituez un petit ensemble d’exemples accompagné d’explications appropriées, de malentendus probables, de réponses ambiguës, d’instructions conflictuelles ainsi que d’exemples nécessitant une révision humaine. Le test ci-dessous ne permet pas de déterminer l’efficacité pédagogique, mais il permet de repérer une défaillance de base, à savoir un routage qui contredit la politique énoncée.

import pytest

@pytest.mark.parametrize(
    "state, expected",
    [
        ({
            "learning_goal": "Differentiate RAG and fine-tuning",
            "learner_answer": "A correct distinction",
            "misconceptions": [],
            "rubric_score": 0.92,
            "attempts": 1,
            "needs_human_review": False,
            "next_action": "",
        }, "advance"),
        ({
            "learning_goal": "Differentiate RAG and fine-tuning",
            "learner_answer": "Citations are automatically verified",
            "misconceptions": ["Citation-verification error"],
            "rubric_score": 0.45,
            "attempts": 1,
            "needs_human_review": False,
            "next_action": "",
        }, "remediate"),
    ],
)
def test_routing_policy(state, expected):
    assert choose_next_action(state) == expected

Ici, l’IA agente commence à ressembler à un génie logiciel discipliné. Les assertions, les fixtures, les versions du code source, les journaux de suivi et les enregistrements de décisions ne sont pas des éléments supplémentaires bureaucratiques. Ils transforment une démonstration impressionnante en un système responsable.

La supervision en tant que fonctionnalité

L’éducation n’est pas seulement un problème d’optimisation technique. Un système ne devrait pas attribuer de notes importantes de sa propre initiative, déduire des caractéristiques sensibles des apprenants ou faire des recommandations importantes concernant leur progression. Il devrait séparer les retours pédagogiques des évaluations officielles et afficher ouvertement son niveau d’incertitude.

Intégrez une supervision humaine dans le graphe sous forme de conditions de transfert : l’évaluateur n’est pas sûr, les tentatives échouent continuellement, l’intégrité académique peut être remise en question, l’accessibilité constitue un obstacle, une requête touche à des questions de sécurité, ou un apprenant a clairement besoin de jugement plus que d’un autre paragraphe généré. Insérez ces éléments dans la spécification avant d’appeler tout modèle. La vraie question est de savoir quelles décisions pédagogiques peuvent être déléguées, lesquelles nécessitent une révision, et quels éléments justifient chaque transition, et non de savoir si un agent peut enseigner. Avec cette approche, les éducateurs conservent l’autorité sur la conception de l’apprentissage, tandis que les ingénieurs reçoivent des exigences qu’ils peuvent tester.

Que faire ensuite

Le bénéfice réside dans le fait de traiter l’apprentissage comme un cycle de rétroaction contrôlé : partir d’un objectif, en déduire un diagnostic à partir des éléments fournis par l’apprenant, choisir une réponse adaptée, vérifier le résultat et orienter l’apprenant de manière responsable. Les affirmations concernant la transformation de l’éducation doivent attendre. Il convient de créer un petit système transparent autour d’un seul objectif d’apprentissage, d’ tester ses différentes approches, d’étudier son impact sur la compréhension et de l’améliorer avec l’aide des enseignants et des apprenants impliqués. C’est un standard plus exigeant que celui d’un chatbot qui semble utile, et c’est celui que l’IA éducative devrait atteindre.