Prompt Chaining

Aussi appelé : pipeline, workflow séquentiel, chaîne, sequential orchestration (Microsoft), linear delegation (Azure Architecture Center), deterministic flow (OpenAI Agents SDK), SequentialAgent ou sequential process (Google ADK, CrewAI)

Intention

Découper une tâche difficile en une suite fixe d'appels LLM plus petits et d'étapes de code ordinaire. Chaque étape reçoit une consigne étroite et la sortie de l'étape précédente, et du code peut vérifier le résultat entre deux étapes avant que la suite ne s'exécute.

L'ordre des étapes est écrit par le développeur. Le modèle ne décide jamais de ce qui s'exécute ensuite.

Problème

Une entreprise veut une note de risques en français pour chaque contrat fournisseur qu'elle reçoit en anglais. L'équipe juridique lit le français ; les contrats font environ 40 pages.

La première version est un seul prompt : « lis ce contrat, trouve les clauses risquées, note-les, rédige une note en français selon notre modèle ». Cela fonctionne sur certains contrats. Sur d'autres, cela échoue d'une manière difficile à voir :

Un contrat de 40 pages entre dans un seul prompt qui doit à la fois extraire, noter, rédiger, traduire et mettre en forme ; la note qui en sort oublie des clauses, invente des numéros de clause et est parfois en anglais. Contrat 40 pages, en anglais Un seul prompt fait tout extraire les clauses, noter les risques, rédiger la note, la traduire, remplir le modèle Note en français ? clauses oubliées numéros inventés parfois en anglais
Tout se passe dans un seul appel : il n'y a aucun résultat intermédiaire à vérifier et aucun moyen de savoir quelle partie a échoué.

Solution

Coupez la tâche là où la nature du travail change, donnez à chaque morceau son propre prompt court, et exécutez les morceaux dans un ordre fixé dans le code. Entre deux étapes, du code parse la sortie et la vérifie. Une vérification en échec peut relancer l'étape, arrêter la chaîne ou confier le cas à une personne. L'article d'Anthropic « Building effective agents » appelle ces vérifications des gates (ici, des portes) et présente le prompt chaining comme le premier workflow, et le plus simple.

Pour la note de risques, la chaîne compte cinq étapes :

  1. Extraire. Un petit modèle liste les clauses en JSON : [{id, title, text}]. Porte : le JSON se parse et contient au moins une clause.
  2. Classer. Un modèle puissant note chaque clause faible, moyen ou élevé selon une grille. Porte : chaque id de clause de l'étape 1 est présent et chaque note est l'une des trois valeurs.
  3. Rédiger. La note est rédigée en anglais à partir des seuls éléments à risque élevé ou moyen.
  4. Traduire. Un modèle bon marché la traduit en français. Porte : un détecteur de langue indique le français.
  5. Mettre en forme. Du code ordinaire place le texte dans le modèle de document juridique. Aucun appel LLM.

Chaque étape est assez petite pour être bien promptée, testée seule et déboguée. Quand une note est fausse, les résultats intermédiaires stockés montrent quelle étape a échoué.

Qui décide du déroulement : le développeur, à la conception. Le modèle écrit le contenu de chaque étape et produit au plus une valeur lue par une porte. Il ne choisit jamais l'étape suivante. C'est ce qui en fait un workflow et non un agent. Dans Plan-and-Execute, un LLM écrit la liste des étapes à l'exécution ; dans Orchestrator–Workers, un modèle principal invente les sous-tâches à chaque requête. Ici, la liste est dans votre code.

Analogie

Une rédaction de journal. Le reporter rend son article, le vérificateur contrôle les noms et les chiffres, le secrétaire de rédaction corrige le style, le traducteur produit l'édition étrangère, et la mise en page le place sur la page. L'ordre des postes est fixé par le rédacteur en chef, pas par les personnes à chaque poste. Le vérificateur joue le rôle de porte : un article avec un chiffre faux retourne au reporter au lieu de passer à la suite.

L'analogie s'arrête au jugement. Un secrétaire de rédaction humain qui remarque qu'un paragraphe manque le signale. Une étape LLM travaille en général avec ce qu'on lui donne et continue, d'où la nécessité de portes explicites dans une chaîne, et l'intérêt de montrer la source d'origine à chaque étape qui a besoin de la vérité de terrain.

Structure

L'entrée passe par l'étape 1, la porte 1, l'étape 2, la porte 2 et une étape de code jusqu'au résultat. Chaque porte peut renvoyer son étape pour un nouvel essai avec le message d'erreur ou, une fois la limite d'essais atteinte, envoyer l'exécution vers une sortie anticipée. Un état partagé conserve chaque résultat intermédiaire. réessai avec l'erreur (max k) réessai avec l'erreur (max k) échec échec Entrée Étape 1 LLM : extraire Porte 1 vérif. JSON Étape 2 LLM : risques Porte 2 vérif. ids Étape 3 code : format Sortie anticipée erreur, réponse de repli ou revue humaine Résultat État partagé {input, clauses, risks, ...} : écrit à chaque étape, plus un span de trace par étape 1 2 3 4 5 6
Les traits pleins représentent l'ordre fixe écrit dans le code ; les flèches d'accent quittent une porte quand sa vérification réussit. Les traits pointillés sont les nouveaux essais qui renvoient l'erreur de la porte à la même étape. Les traits rouges sont les échecs après la limite d'essais. La chaîne représentée est simplifiée : ses numéros d'étape diffèrent de l'exemple en cinq étapes.
  1. Étape. Une transformation ciblée : un modèle de prompt, un modèle de langage avec ses réglages, et un parseur qui transforme le texte brut en valeur typée. Une étape peut aussi être du code ordinaire ou un agent complet qui utilise des outils.
  2. Porte. Du code, ou un appel à un classifieur bon marché lu par du code, qui vérifie la valeur parsée : schéma, décomptes, expression régulière, règle métier. Elle renvoie validation, nouvel essai, réparation, sortie anticipée ou escalade.
  3. Contrat de passage. Exactement ce que reçoit l'étape suivante : la sortie précédente, et l'entrée d'origine ou des résultats antérieurs seulement si nécessaire. Trop peu fait perdre de l'information ; trop alourdit le prompt.
  4. Étape de code. Un travail déterministe comme la mise en forme, une requête en base de données ou l'exécution de tests. Moins cher et plus facile à tester qu'un appel LLM.
  5. Sortie anticipée. Un arrêt maîtrisé quand une porte échoue à répétition ou que l'entrée sort du périmètre : une erreur, une réponse de repli ou une personne.
  6. État et trace. Les résultats intermédiaires sont stockés par nom, pour que les exécutions puissent être inspectées, mises en cache et reprises, avec un span de trace par étape (prompt, sortie, tokens, latence, verdict de la porte). Le runner qui appelle les étapes dans l'ordre se résume souvent à une boucle for.

Générateur de prompt

Décrivez l'objectif et listez les étapes dans l'ordre. Pour chaque étape, indiquez sa tâche unique, son format de sortie et la vérification qui s'exécute après elle. Mettez code comme modèle pour les étapes qui n'ont pas besoin de LLM. Le résultat comporte deux parties : des règles pour le code du runner (nouveaux essais, sortie anticipée, budget, traces), puis un prompt par étape LLM avec ses balises d'entrée. Collez les prompts des étapes dans votre propre runner, un nœud LangGraph ou les étapes séquentielles de n'importe quel framework.

Étapes dans l'ordre d'exécution, une ligne par étape
Quand une porte échoue encore

Prompt généré

Le texte surligné vient du formulaire. Le texte [entre crochets] reste à remplir.

Les portes et les contrats comptent plus que les prompts

La plupart des défaillances d'une chaîne se produisent aux passages : un JSON mal formé, une clause perdue, un champ dont l'étape suivante avait besoin. Placez une vérification de code peu coûteuse juste après les étapes d'extraction et de planification, car leurs erreurs se propagent à tout ce qui suit. Gardez une référence en un seul prompt et ne conservez que les étapes qui font mieux qu'elle sur votre jeu d'évaluation.

Quand l'utiliser

À utiliser quand

À éviter quand

La frontière bouge dans les deux sens. Si vous ajoutez sans cesse des branches pour des cas imprévus, ou si les portes échouent souvent parce que les entrées varient plus que les étapes ne le supposent, une étape (ou toute la chaîne) devrait devenir un agent. Un compromis courant garde la chaîne extérieure et fait d'une étape un agent. Si les traces montrent qu'un agent suit presque toujours le même chemin, figez ce chemin dans le code : la documentation de l'OpenAI Agents SDK indique qu'orchestrer par le code est plus prévisible en vitesse, en coût et en performance.

Mise en œuvre

  1. Écrivez d'abord la référence en un seul prompt. La chaîne doit faire mieux qu'elle sur un jeu d'évaluation pour justifier son coût.
  2. Trouvez les points de découpe. Les bons endroits sont ceux où le type de sortie change (texte, puis données, puis prose), où une compétence différente est nécessaire (extraction, raisonnement, style, traduction), où la justesse est facile à vérifier, ou où un autre modèle convient mieux.
  3. Définissez un contrat de données pour chaque passage. Utilisez une sortie structurée (JSON schema, Pydantic) pour tout ce que lit du code. N'utilisez du texte libre que lorsque le consommateur suivant est un autre LLM, et entourez alors chaque résultat amont de sa propre balise XML (<outline>, <draft>) pour que le prompt suivant puisse y faire référence par son nom.
  4. Écrivez un prompt étroit par étape. Indiquez son objectif unique, son format d'entrée et de sortie, et ce qu'il ne faut pas faire (« ne traduis pas encore »).
  5. Ajoutez des portes là où les erreurs sont faciles à détecter et coûteuses à laisser passer. Juste après les étapes d'extraction et de planification. En cas d'échec, relancez en renvoyant le message d'erreur.
  6. Fixez des règles de nouvel essai et d'arrêt. Un nombre maximal d'essais par étape, un budget total en tokens ou en coût, et un timeout par appel et par chaîne. Séparez les nouveaux essais liés au transport (limites de débit) de ceux liés à une mauvaise sortie.
  7. Choisissez un modèle par étape. De petits modèles pour la classification, l'extraction et la mise en forme, des modèles puissants pour le raisonnement et la synthèse (recommandations de coût de l'Azure Architecture Center).
  8. Tracez et testez chaque étape séparément, puis de bout en bout. Persistez l'état après chaque étape pour qu'un plantage reprenne au lieu de tout recommencer.
  9. Mettez en cache les étapes déterministes ou répétées, par nom d'étape, version du prompt, modèle et hash de l'entrée.

Un framework est facultatif. Le cookbook d'Anthropic implémente tout le pattern comme une boucle qui ajoute le résultat précédent au prompt suivant (son exemple transforme en quatre étapes un rapport de performance désordonné en tableau markdown), et Anthropic prévient que les abstractions des frameworks peuvent masquer les prompts et les réponses. Les frameworks d'agents emballent la même idée sous le nom d'« orchestration séquentielle d'agents » ; si une étape n'a besoin ni d'outils ni de plusieurs tours, un simple appel LLM coûte moins cher et se teste plus facilement.

Prise en charge par les frameworks (vérifiez la documentation actuelle avant usage)
FrameworkForme que prend ce pattern
API bruteUne boucle for sur les prompts ; les portes sont vos propres instructions if.
LangChain (LCEL)prompt | model | parser construit une RunnableSequence ; .with_retry(), .with_fallbacks(), with_structured_output. Le streaming de bout en bout ne fonctionne que si chaque composant le prend en charge.
LangGraphStateGraph avec add_edge pour la ligne et add_conditional_edges pour une porte ; état partagé typé.
OpenAI Agents SDKPlusieurs appels Runner.run dans le code, un agent vérificateur avec output_type, un if pour la porte, le tout dans trace().
Google ADKSequentialAgent(sub_agents=[...]) avec output_key et le templating {key}. Désormais marqué comme obsolète au profit du graphe Workflow d'ADK 2.0.
CrewAIProcess.sequential ; context=[...] sélectionne des tâches antérieures ; guardrail avec guardrail_max_retries (3 par défaut).
Semantic KernelSequentialOrchestration(members=[...]) ; marqué expérimental, absent du SDK Java.
Microsoft Agent FrameworkSequentialBuilder ; transmet toute la conversation par défaut, chain_only_agent_responses=True ne transmet que la réponse précédente ; impossible de revenir à un agent antérieur.
DSPyUn module dont la méthode forward() appelle des sous-modules dans l'ordre ; un compilateur ajuste les prompts de chaque étape selon une métrique.
LlamaIndex WorkflowsDes méthodes @step reliées par des événements typés, de StartEvent à StopEvent.

Mise en garde. Ces API évoluent vite. La documentation de Google ADK marque SequentialAgent comme obsolète sans version ni date de retrait, l'orchestration d'agents de Semantic Kernel est expérimentale et Microsoft Agent Framework semble lui succéder, et l'API d'assertions de DSPy a changé d'une version à l'autre (noms actuels non vérifiés). Les frameworks de graphes sont la voie d'évolution habituelle : une chaîne est un graphe linéaire, une arête conditionnelle en fait du routage, et une arête de retour en fait une boucle.

Variantes

Chaîne linéaire

A, puis B, puis C, sans vérification. La boucle chain() du cookbook ou un pipe LCEL. Suffisant pour des prototypes et des transformations à faible enjeu.

Chaîne avec portes

Des vérifications en code entre les étapes décident de la validation, d'un nouvel essai ou d'une sortie anticipée. L'exemple de deterministic flow d'OpenAI s'arrête simplement quand le vérificateur de plan juge le plan médiocre ou hors genre. Une porte qui arrête l'exécution avec une raison claire fait son travail.

Chaîne hybride (étapes LLM et étapes de code)

Certaines étapes sont du parsing, de la recherche documentaire, des requêtes en base, l'exécution de tests ou de la mise en forme. Decomposed Prompting (Khot et al., 2023) permet qu'une sous-tâche soit un prompt, un modèle entraîné ou une fonction symbolique. L'étape de mise en forme de l'exemple du contrat en est une.

Extraire, transformer, générer

Une entrée non structurée devient des données structurées, puis des données traitées, puis de la prose. Les pipelines documentaires prennent cette forme. DocETL réécrit de tels pipelines en chaînes plus fines et annonce des sorties 25 à 80 % plus précises que des références bien conçues sur quatre tâches (Shankar et al., 2024, résultats déclarés par les auteurs).

Rédiger, critiquer, améliorer

Une chaîne fixe en trois étapes : générer, relire selon des critères, réécrire une fois. La documentation de Claude sur le prompting la désigne comme le pattern de chaînage le plus courant. Si l'étape d'amélioration boucle jusqu'à ce qu'un critère soit satisfait, elle devient un Evaluator–Optimizer.

Chaîne avec boucles intégrées (« flow engineering »)

Un pipeline essentiellement linéaire dont certaines étapes itèrent contre des tests. AlphaCodium exécute une chaîne de prétraitement linéaire (réfléchir au problème, raisonner sur les tests, proposer et classer des solutions, générer des tests supplémentaires), puis corrige le code contre les tests. La boucle de correction est elle-même une boucle évaluateur–optimiseur.

Chaîne par élément

La même chaîne s'exécute sur chaque document ou clause, souvent en parallèle, puis une étape de réduction fusionne les résultats. Le fan-out relève de Parallelization ; chaque voie est une chaîne.

Chaîne avec points de contrôle humains

Une pause après une étape pour approbation ou modification, par exemple avant l'envoi de la note. Microsoft Agent Framework propose with_request_info ; LangGraph propose des interrupts. Voir Human-in-the-Loop.

Chaîne d'agents

Chaque étape est un agent complet avec ses outils et sa propre boucle, et l'ordre entre les agents reste fixe. C'est ce que Semantic Kernel, ADK et CrewAI appellent l'orchestration séquentielle. À l'intérieur de chaque étape, voir ReAct.

Chaîne compilée

Les prompts et les exemples few-shot de chaque étape sont ajustés automatiquement selon une métrique. DSPy le fait avec un compilateur appliqué à des modules composés dans forward().

Chaîne générée

Un LLM écrit une fois la liste des étapes, puis du code l'exécute comme une chaîne fixe. C'est Plan-and-Execute.

Avantages et inconvénients

Avantages

  • En général plus précis, car chaque appel traite une tâche plus facile. AlphaCodium (un flux en plusieurs étapes, résultats déclarés par les auteurs) a fait passer le pass@5 de GPT-4 sur son jeu de validation CodeContests de 19 % à 44 %.
  • Chaque résultat intermédiaire peut être journalisé, testé unitairement et rejoué. Dans l'étude utilisateurs d'AI Chains (Wu et al., 2022, 20 participants), les participants déboguaient en testant des étapes isolées et ont jugé le chaînage meilleur en transparence et en contrôle.
  • Chaque étape peut avoir son propre modèle, sa température et ses outils, si bien que la plupart des étapes peuvent tourner sur un modèle bon marché.
  • Le même chemin s'exécute à chaque fois, ce qui rend le coût et la latence prévisibles et les audits possibles.
  • Les étapes peuvent être mises en cache, et les longs préfixes communs peuvent profiter du prompt caching.
  • Aucun framework nécessaire : le runner tient en quelques lignes de code.

Inconvénients

  • Latence plus élevée : la somme de toutes les étapes, plus le parsing et les nouveaux essais, sans parallélisme dans une chaîne stricte.
  • En général plus de tokens au total : consignes répétées, contexte répété, nouveaux essais. AlphaCodium utilise environ 15 à 20 appels LLM par solution.
  • Les erreurs s'accumulent si les portes ne les arrêtent pas. Simple calcul, pas une mesure : si chacune de 5 étapes indépendantes réussit 95 % du temps, la chaîne réussit environ 77 % du temps ; avec 10 étapes, environ 60 %.
  • Rigide : les entrées qui ne correspondent pas aux étapes prévues produisent des résultats absurdes.
  • Les étapes sont couplées : changer le format de sortie d'une étape peut casser le parseur de la suivante.

Ce calcul d'accumulation suppose des échecs indépendants, alors que les échecs réels sont corrélés. Il joue aussi dans l'autre sens : chaque étape plus petite est plus facile, donc son taux de réussite dépasse celui du prompt unique, et une porte avec nouveaux essais l'augmente encore. Le but est d'avoir des étapes faciles et vérifiables, pas le moins d'étapes possible.

L'essentiel des preuves vient de modèles sortis avant l'extended thinking intégré (LaMDA dans AI Chains, GPT-4 dans AlphaCodium et chez Sun et al.). Les sources ne contiennent aucune comparaison contrôlée récente entre une chaîne et un appel unique à un modèle de raisonnement : considérez l'ampleur des gains comme dépendante du modèle et mesurez-la sur votre propre tâche.

Modes de défaillance

Erreurs en cascade

Une extraction erronée au début empoisonne toutes les étapes suivantes. Dans la chaîne du contrat, une clause manquée à l'étape 1 n'atteint jamais la note, et la note reste pourtant agréable à lire.

Parade : des portes juste après les premières étapes ; des vérifications contre des données dont la justesse est connue (les « test anchors » d'AlphaCodium empêchent un test généré erroné d'annuler une correction qui passait les tests connus) ; laisser une personne corriger les sorties intermédiaires.

Perte d'information

Une étape ultérieure a besoin d'un détail qu'une étape précédente a supprimé ou résumé, comme au téléphone arabe. L'étape de rédaction connaît la note de risque mais pas la formulation exacte de la clause.

Parade : transmettre l'entrée d'origine ou le résultat antérieur quand une étape a besoin de la vérité de terrain ; stocker les gros artefacts et transmettre des références ; tester avec des entrées qui contiennent des détails rares.

Contexte qui gonfle

Transmettre tout l'historique à chaque étape rend les prompts longs, lents, coûteux et source de distraction.

Parade : des contrats de passage minimaux ; résumer ou élaguer entre les étapes. Les sources ne sont pas d'accord sur ce point : Cognition soutient que lorsque les étapes sont des agents de longue durée qui font des choix implicites, des passages étroits perdent ces choix. Pour des appels LLM courts et bien spécifiés, des contrats minimaux fonctionnent bien.

Dérive de format et erreurs de parsing

Le modèle entoure le JSON de prose ou oublie un champ, et l'étape suivante plante ou, pire, continue avec la moitié des données.

Parade : la sortie structurée native, une validation de schéma avec l'erreur renvoyée lors du nouvel essai (comme le fait Instructor), des parseurs stricts qui échouent bruyamment, du YAML au lieu du JSON quand la sortie contient du code (le choix d'AlphaCodium : pas d'échappement des guillemets, moins de tokens).

Portes mal calibrées

Trop strictes, elles provoquent des essais sans fin et de faux rejets. Trop laxistes, elles laissent passer les erreurs. Une porte confiée à un LLM juge a son propre taux d'erreur.

Parade : préférer les vérifications en code ; mesurer pour chaque porte les taux de fausses validations et de faux rejets sur des exemples étiquetés ; plafonner les essais ; journaliser chaque verdict et examiner les cas rejetés.

Sur-découpage

De nombreuses étapes minuscules ajoutent de la latence et du coût, et chaque passage est une occasion de perdre de l'information.

Parade : fusionner les étapes qui n'échouent jamais seules. Ne garder une étape que si elle améliore une métrique d'évaluation ou rend une vérification possible.

Processus simulé

Un seul prompt à qui l'on demande de « rédiger, puis critiquer, puis améliorer » se contente de faire semblant. Sun et al. (2024) ont constaté que trois prompts séparés faisaient mieux qu'un prompt combiné pour le résumé, même si le prompt combiné écrivait de meilleures critiques : la séparation semble surtout compter pour les étapes de génération.

Parade : faire de chaque phase un appel séparé.

Entrées qui ne correspondent pas aux étapes

Un document sans section de clauses, ou un contrat en allemand, traverse quand même la chaîne et produit un résultat absurde.

Parade : une porte de classification de l'entrée au début, avec sortie anticipée ou Routing vers une autre chaîne.

Régressions silencieuses

Modifier un prompt change la distribution de ses sorties et casse discrètement une étape ultérieure.

Parade : versionner les prompts et les contrats ; des tests d'assertion par étape sur des échantillons réels, relancés à chaque modification du pipeline ; une évaluation de bout en bout à chaque changement.

Tempêtes de nouveaux essais

Les nouveaux essais à chaque étape multiplient les appels, et les nouveaux essais liés au transport s'ajoutent à ceux de validation.

Parade : des budgets par étape et globaux en tokens, en temps et en argent ; une seule couche de nouveaux essais pour les erreurs de transport, pas deux (désactivez les retries du SDK si un wrapper relance déjà).

Erreurs masquées

Une étape renvoie une valeur vide ou fictive et les étapes suivantes continuent.

Parade : faire remonter les erreurs au lieu de les cacher ; prévoir un champ « unknown » explicite dans les contrats ; des portes qui rejettent les valeurs vides.

Instructions injectées qui descendent la chaîne

Le texte du contrat (ou un résultat d'outil) contient des instructions, et une étape ultérieure leur obéit.

Parade : entourer les sorties amont de balises et dire à chaque étape qu'il s'agit de données ; appliquer des contrôles de contenu à plusieurs endroits, pas seulement à la fin ; donner à chaque étape le moins d'outils possible.

Longues chaînes interrompues

Un plantage ou un déploiement en cours de chaîne fait perdre tout le travail déjà effectué.

Parade : persister l'état après chaque étape (checkpointers de LangGraph ou d'Agent Framework), rendre les étapes idempotentes, reprendre à la dernière étape terminée.

Liens avec les autres patterns

Pour aller plus loin

Toutes les sources ci-dessous sont en anglais.