Prompt chaining : découper une tâche IA en étapes

Le prompt chaining (chaînage de prompts) consiste à découper une tâche complexe en une suite de prompts plus petits, où le résultat d'une étape devient l'entrée de la suivante. Au lieu de demander au modèle de lire, analyser et rédiger d'un seul coup, chaque prompt fait une seule chose : extraire des faits, les vérifier ou rédiger un texte. Le résultat est en général plus fiable et plus facile à corriger, car vous voyez et testez chaque résultat intermédiaire.

Cet article explique quand une chaîne fait mieux qu'un prompt unique, présente les schémas qui couvrent la plupart des tâches en entreprise, un exemple complet et la manière de concevoir les transmissions entre étapes. Il prolonge la méthode de notre guide pratique de l'ingénierie de prompt en entreprise.

Comment fonctionne une chaîne de prompts

Une chaîne est une suite d'étapes fixe. Exemple type :

1. Extraire : récupérer les faits utiles dans les documents sources.
2. Vérifier : contrôler les faits extraits, par du code, un second prompt ou une personne.
3. Rédiger : produire le texte uniquement à partir des faits vérifiés.
4. Contrôler : confronter le brouillon à des règles ou à une checklist.

Chaque étape a son propre prompt, avec ses propres instructions, et ne reçoit de l'étape précédente que ce dont elle a besoin. Certaines étapes se passent même de modèle : compter, trier, consulter une base de données ou valider un format se fait souvent mieux avec du code classique.

Prompt unique ou chaîne ?

	Prompt unique	Chaîne de prompts
Effort de mise en place	Faible	Plus élevé : plusieurs prompts et transmissions
Fiabilité sur les tâches complexes	Variable, des étapes sont sautées ou mélangées	Meilleure, chaque étape est simple
Transparence	Seul le résultat final est visible	Chaque résultat intermédiaire est consultable
Correction des erreurs	Difficile de savoir où ça a coincé	Vous voyez quelle étape a échoué
Rapidité	Un appel	Plusieurs appels, sauf étapes en parallèle
Coût	Un appel plus lourd	Plusieurs appels plus légers, en partie sur des modèles moins chers

Quand une chaîne est utile

Envisagez une chaîne si vous constatez l'un de ces signes :

• Le prompt contient plusieurs verbes. « Lis ces documents, repère les risques, évalue-les et rédige une note » : cela fait quatre tâches.
• La qualité varie d'une exécution à l'autre. Parfois le modèle couvre tout, parfois il oublie des parties.
• Les consignes se contredisent. L'extraction doit être exhaustive, le texte final court : un seul prompt peine à faire les deux.
• Les faits doivent être vérifiés avant usage. Une étape d'extraction séparée vous donne quelque chose à contrôler. C'est l'un des moyens les plus efficaces de réduire les hallucinations de l'IA.
• Les étapes demandent des réglages différents. L'une exige un JSON strict, l'autre un style rédactionnel naturel.
• L'entrée est trop longue. Un long document peut être traité section par section, puis synthétisé.

Pour un e-mail court, le résumé d'un seul document ou une classification simple, un prompt bien construit suffit. Une chaîne ajoute des pièces mobiles : réservez-la aux cas où elle règle un vrai problème.

Les schémas courants

Schéma	Fonctionnement	Exemple en entreprise
Extraire, puis rédiger	L'étape 1 range les faits dans une structure fixe, l'étape 2 rédige uniquement à partir de cette structure	Synthèse d'un contrat à partir des clauses extraites
Classer, puis orienter	L'étape 1 attribue une catégorie, l'étape suivante dépend de cette catégorie	E-mails clients envoyés vers des prompts de réponse différents
Rédiger, critiquer, réviser	L'étape 1 rédige, l'étape 2 vérifie selon des critères, l'étape 3 révise	Texte d'offre contrôlé selon la charte éditoriale
Découper, traiter, assembler	Une longue entrée est découpée, chaque partie traitée, puis les résultats fusionnés	Synthèse d'un long rapport chapitre par chapitre
Générer, puis valider	L'étape 1 produit un résultat, l'étape 2 (code ou prompt) vérifie format et contenu	Données produit en JSON, validées avant import

La plupart des chaînes réelles combinent deux ou trois de ces schémas.

Exemple concret : des avis clients à une note pour la direction

Une entreprise recueille chaque mois quelques centaines de commentaires libres via une enquête clients. Aujourd'hui, quelqu'un les lit tous et rédige une page pour la direction. Un prompt unique (« résume ces commentaires ») produit un texte fluide, mais difficile de savoir si les thèmes sont bien pondérés ou si une citation est authentique.

La chaîne :

Étape 1 : classer chaque commentaire. Par lots, avec une liste de thèmes fixe.

Classe chacun des commentaires clients ci-dessous.
Thèmes (utilise uniquement ceux-ci) : livraison, qualité produit, prix, service client, site web, autre.
Tonalité : positive, neutre ou négative.

Renvoie un objet JSON par ligne :
{"id": "...", "theme": "...", "tonalite": "..."}

Commentaires :
"""
[ID 101] La livraison a pris neuf jours, personne ne m'a expliqué pourquoi.
[ID 102] ...
"""

Étape 2 : compter. Un tableur ou quelques lignes de code comptent les commentaires par thème et par tonalité. Pas besoin de modèle, et les chiffres sont exacts.

Étape 3 : extraire le détail des thèmes principaux. Pour les trois thèmes qui réunissent le plus de commentaires négatifs, le prompt suivant ne reçoit que ces commentaires.

Voici des commentaires clients sur un seul thème : [thème].
Liste les problèmes précis mentionnés, le nombre de commentaires qui citent chacun,
et pour chaque problème une courte citation mot pour mot avec l'ID du commentaire.
N'utilise que le contenu des commentaires. Ne fusionne pas de citations.

"""
[commentaires sur ce thème]
"""

Étape 4 : rédiger la note. Le prompt de rédaction reçoit uniquement les chiffres de l'étape 2 et le détail de l'étape 3, pas les commentaires bruts.

Rédige une note d'une page pour l'équipe de direction.
Public : dirigeant et responsables de service. Ton : factuel, sans langage marketing.
Structure : trois constats clés, puis une section par thème principal avec les problèmes
majeurs et une citation chacun, puis deux ou trois prochaines étapes proposées.
Utilise uniquement les chiffres et citations fournis. N'ajoute aucun chiffre.

Chiffres : """[résultat de l'étape 2]"""
Détail : """[résultat de l'étape 3]"""

Étape 5 : vérifier. Avant diffusion, une personne ou un dernier prompt vérifie, grâce aux ID, que chaque chiffre et chaque citation de la note figurent bien dans les résultats des étapes 2 et 3.

Chaque étape est assez simple pour être testée isolément. Si un thème manque dans la note finale, vous voyez s'il a été mal classé à l'étape 1, perdu à l'étape 3 ou omis à l'étape 4. Le prompt de chaque étape peut être construit avec le générateur de prompt IA, qui sépare tâche, contexte, format et règles.

Concevoir les transmissions entre étapes

C'est aux transmissions entre étapes que les chaînes cassent le plus souvent. Quelques règles aident :

• Une structure fixe entre les étapes. JSON, tableau ou titres imposés rendent la sortie d'une étape prévisible pour la suivante. Du texte libre entre deux étapes favorise les dérives.
• Ne transmettre que l'utile. Tout envoyer annule l'intérêt de la chaîne et alourdit la facture.
• Garder la source accessible pour les contrôles. Une étape de vérification a besoin à la fois de l'affirmation et du texte d'origine.
• Bien signaler les entrées. Placez les éléments issus des étapes précédentes entre délimiteurs et étiquetez-les, pour que le modèle ne les prenne pas pour des instructions.
• Prévoir le cas d'échec. Si une étape renvoie une sortie invalide, relancez une fois, puis arrêtez et signalez le cas plutôt que de propager l'erreur.

Pour les étapes structurées, les exemples aident beaucoup. Quelques exemples étiquetés dans le prompt de classification rendent les catégories nettement plus cohérentes ; voir le few-shot prompting.

Une chaîne dans un outil de chat ou dans une automatisation

Pas besoin de logiciel pour chaîner des prompts. Dans un assistant conversationnel, vous pouvez enchaîner les étapes à la main : demander l'extraction, la vérifier, puis coller le résultat vérifié dans un nouveau prompt pour la rédaction. C'est une bonne façon de concevoir et tester une chaîne avant de l'automatiser.

Dans une plateforme d'automatisation ou dans du code, chaque étape devient un nœud ou un appel de fonction, les résultats intermédiaires sont stockés et la validation s'exécute automatiquement. La chaîne est alors un workflow avec des étapes d'IA, l'approche comparée dans agents IA ou automatisation de workflows.

Tester une chaîne

1. Testez chaque étape séparément avec un petit jeu d'entrées réalistes, y compris des cas difficiles.
2. Testez la chaîne complète de bout en bout sur les mêmes cas.
3. Journalisez les résultats intermédiaires pour remonter tout mauvais résultat jusqu'à l'étape fautive.
4. Ne modifiez qu'une étape à la fois et relancez les tests, car améliorer une étape peut dérégler la suivante.

Coût et rapidité

Une chaîne appelle le modèle plus souvent qu'un prompt unique, d'où la tentation de la croire bien plus chère. Ce n'est souvent pas le cas : chaque appel est plus léger, les étapes simples comme la classification peuvent tourner sur un modèle plus petit et moins cher, et les étapes sans modèle ne coûtent presque rien. La rapidité peut en pâtir si les étapes s'enchaînent strictement ; les étapes indépendantes, comme le traitement de plusieurs chapitres, peuvent tourner en parallèle. Pour comparer des variantes, estimez les tokens par étape et saisissez-les dans le calculateur de coût d'API LLM.

Les erreurs fréquentes

• Chaîner pour chaîner. Si un prompt unique fonctionne de façon fiable, gardez-le.
• Du texte libre entre les étapes. Imposez une structure fixe à chaque transmission.
• Laisser l'étape de rédaction voir les données brutes. Elle peut alors contourner les faits vérifiés.
• Confier au modèle le comptage ou les recherches. Le code est exact et moins cher.
• Aucune gestion des échecs. Une étape défaillante gâche en silence tout ce qui suit.
• Ne tester que le résultat final. Vous perdez l'avantage principal d'une chaîne : savoir où ça coince.

En résumé

Le prompt chaining transforme un prompt surchargé en une série d'étapes simples et vérifiables. Utilisez-le quand une tâche mélange plusieurs métiers, quand la qualité varie ou quand des faits doivent être vérifiés avant d'être utilisés. Soignez les transmissions, laissez au code ce que le code fait mieux et testez chaque étape. Commencez par noter les étapes d'une tâche que vous faites aujourd'hui à la main, puis construisez un prompt par étape avec le générateur de prompt IA.