Le vocabulaire agentique, au mot près

Système logiciel qui s'appuie sur un modèle de langage pour décider lui-même de la suite des actions à entreprendre afin d'atteindre un objectif. Contrairement à une chaîne (pipeline figé), un agent choisit dynamiquement les outils à invoquer et le moment de s'arrêter, en bouclant tant que la tâche n'est pas résolue.

Voir aussi ReActTool callingGraphe d'état

Capacité d'un agent à conserver de l'information. La mémoire court-terme est l'état d'un thread (l'historique de la conversation courante) ; la mémoire long-terme persiste des connaissances entre threads via un Store, souvent indexé sémantiquement pour la recherche.

Voir aussi CheckpointerThreadRAG agentique

Capacité d'un modèle à renvoyer, dans un format structuré, le nom d'une fonction et ses arguments plutôt qu'un texte libre. Le runtime exécute alors la fonction et renvoie le résultat au modèle. C'est le mécanisme qui permet à un agent d'interagir avec le monde extérieur (API, bases, code).

Voir aussi AgentReAct

Transition dont la cible est décidée à l'exécution par une fonction de routage qui inspecte l'état. C'est le mécanisme qui donne à un graphe LangGraph son comportement agentique : continuer à boucler, appeler un outil, déléguer à un autre agent ou terminer.

Voir aussi Nœud (Node)Graphe d'étatReAct

Composant qui sauvegarde l'état du graphe après chaque étape, associé à un thread. Il rend l'agent durable : on peut reprendre une exécution interrompue, implémenter le human-in-the-loop, autoriser le retour en arrière (time-travel) et conserver la mémoire court-terme d'une conversation.

Voir aussi ThreadHuman-in-the-loopInterruption (interrupt)

Objet typé (souvent un TypedDict ou un modèle Pydantic) qui circule entre les nœuds du graphe et porte toute l'information de la conversation et du calcul. Chaque nœud reçoit l'état courant et renvoie une mise à jour partielle ; la façon dont ces mises à jour fusionnent est définie par les reducers.

Voir aussi ReducerGraphe d'étatNœud (Node)

Structure centrale de LangGraph : on modélise l'application comme un graphe orienté dont les nœuds transforment un état partagé et dont les arêtes décrivent les transitions possibles. Le graphe est compilé en un objet exécutable qui peut être invoqué, streamé, interrompu et repris.

Voir aussi Nœud (Node)Arête conditionnelleReducerÉtat (State)

Mécanisme qui met en pause le graphe à un point défini — soit statiquement (interrupt_before/after un nœud), soit dynamiquement via la fonction interrupt() à l'intérieur d'un nœud. L'exécution reprend avec Command(resume=...) une fois l'entrée humaine fournie.

Voir aussi Human-in-the-loopCheckpointer

Unité de calcul du graphe : une fonction (ou un objet exécutable) qui prend l'état en entrée et renvoie une mise à jour de cet état. Un nœud peut appeler un LLM, exécuter un outil, interroger une base ou orchestrer un sous-graphe.

Voir aussi Graphe d'étatArête conditionnelleÉtat (State)

Fonction qui décrit comment fusionner la valeur courante d'un champ d'état avec la mise à jour renvoyée par un nœud. Sans reducer, la nouvelle valeur écrase l'ancienne ; avec add_messages, les nouveaux messages sont ajoutés à l'historique plutôt que de le remplacer.

Voir aussi État (State)Graphe d'état

Identifiant qui regroupe une suite d'exécutions partageant le même état persisté. Passer un thread_id dans la configuration permet au checkpointer de retrouver l'historique : c'est ainsi qu'un agent distingue deux conversations simultanées.

Voir aussi CheckpointerMémoire

Mesure systématique de la qualité des sorties d'un agent. LangFuse permet d'attacher des scores aux traces — manuels, calculés par code, ou produits par un LLM-juge — et de suivre leur évolution sur des jeux de données (datasets) pour détecter régressions et progrès.

Voir aussi TraceSpan / Observation

Nœud d'une trace LangFuse représentant une opération individuelle. Un span couvre n'importe quelle étape ; une generation est un span spécialisé pour les appels LLM, qui capture le modèle, les messages, le nombre de tokens et le coût estimé.

Voir aussi TraceToken

Enregistrement complet d'une exécution de l'agent dans LangFuse : l'arbre hiérarchique de toutes les étapes (appels LLM, outils, sous-graphes) avec leurs entrées/sorties, durées, coûts et métadonnées. C'est l'unité de base de l'observabilité agentique.

Voir aussi Span / ObservationÉvaluation (Eval)

Pattern où l'exécution de l'agent est suspendue pour solliciter une validation, une correction ou une saisie humaine avant de poursuivre. En LangGraph, il repose sur l'interruption et le checkpointer : l'état est gelé, soumis à un humain, puis l'exécution reprend exactement où elle s'était arrêtée.

Voir aussi Interruption (interrupt)Checkpointer

Variante du RAG où la décision de récupérer, la reformulation de la requête et l'évaluation de la pertinence des documents sont prises par l'agent lui-même, dans une boucle. L'agent peut décider de re-chercher, de corriger la question ou de répondre directement.

Voir aussi AgentMémoireTool calling

Boucle agentique fondatrice où le modèle alterne raisonnement (Thought), action (invocation d'outil) et observation (résultat de l'outil), jusqu'à produire une réponse finale. C'est le pattern le plus simple pour transformer un LLM en agent ; LangGraph le fournit clé en main via create_react_agent.

Voir aussi AgentTool callingNœud (Node)

Architecture où plusieurs agents spécialisés collaborent. Les topologies courantes sont le superviseur (un agent routeur délègue aux spécialistes) et le swarm (les agents se passent la main de pair à pair). LangGraph modélise chaque agent comme un sous-graphe ou un nœud du graphe parent.

Voir aussi AgentGraphe d'étatArête conditionnelle

Service AWS managé donnant accès, via une API unique (la Converse API), à de nombreux modèles de fondation (Anthropic Claude, Amazon Nova, Llama, Mistral, Cohere…) avec tool use, streaming, Guardrails, Knowledge Bases et évaluations. C'est la porte d'entrée par défaut pour brancher un moteur LLM à un agent LangGraph sur AWS, via ChatBedrockConverse.

Voir aussi Tool callingBedrock GuardrailsBedrock Knowledge BasesAmazon SageMaker AI

Plateforme AWS pour entraîner, fine-tuner et héberger ses propres modèles sur des endpoints contrôlés. Complémentaire de Bedrock : on y recourt pour un modèle absent de Bedrock, un fine-tuning poussé, ou des embeddings/rerankers sur-mesure alimentant un RAG. Un endpoint SageMaker s'intègre à LangGraph comme tout modèle.

Voir aussi Amazon BedrockRAG agentiqueToken

Ensemble de services AWS 2026 pour exécuter des agents en production, agnostique du framework : Runtime (exécution serverless isolée), Memory, Gateway (API exposées comme outils), Identity, Code Interpreter, Browser et Observability. AgentCore héberge et outille un graphe LangGraph — il ne remplace pas l'orchestration, il la déploie.

Voir aussi Amazon BedrockMémoireCheckpointer

Couche de sécurité managée de Bedrock, attachable à toute inférence : filtres de contenu, déni de sujets, caviardage de PII et vérification d'ancrage (anti-hallucination). C'est une brique de défense en profondeur, à combiner avec les garde-fous applicatifs de l'agent — elle ne les remplace pas.

Voir aussi Amazon BedrockHuman-in-the-loop

RAG managé de bout en bout sur AWS : ingestion d'une source, chunking, embeddings, index (OpenSearch, Aurora, S3 Vectors), récupération hybride et reranking, derrière les API retrieve et retrieveAndGenerate. S'intègre comme outil de récupération d'un agent LangGraph via AmazonKnowledgeBasesRetriever.

Voir aussi RAG agentiqueRAG hybrideAmazon Bedrock

Récupération combinant une recherche dense (kNN sur des vecteurs, pour le sens) et une recherche sparse (BM25 sur le texte, pour les termes exacts), fusionnées (souvent par RRF) puis reclassées par un reranker. Sur AWS, OpenSearch Serverless réalise les deux dans un même index. Elle couvre l'angle mort de chaque méthode prise seule.

Voir aussi RAG agentiqueBedrock Knowledge BasesAmazon Bedrock

Plus petite unité de texte manipulée par un LLM (souvent un fragment de mot). Le coût et la latence d'un agent sont gouvernés par le nombre de tokens en entrée et en sortie ; surveiller la consommation par étape est un réflexe essentiel d'optimisation, que LangFuse rend visible.

Voir aussi Span / ObservationTrace