Le chaînage découpe une tâche en prompts reliés
📍 In One Sentence
Le chaînage de prompts découpe une grande tâche en prompts plus petits et transmet la sortie de chaque étape à la suivante, de sorte que chaque appel a une mission vérifiable.
💬 In Plain Terms
Il fonctionne comme une chaîne de montage plutôt qu'une requête géante : chaque poste fait une chose et passe son travail, donc en cas de problème vous voyez quel poste est en cause.
Le chaînage de prompts décompose une tâche en une suite d'étapes, où chaque appel au LLM traite la sortie du précédent. Au lieu de tout demander d'un coup, vous exécutez des étapes comme analyser, planifier, rédiger et relire, chacune avec une responsabilité précise.
Chaque étape a une entrée définie, un format de sortie défini et une seule mission. Entre deux étapes, votre code peut valider ou corriger la sortie : la chaîne se comporte comme un pipeline testable, pas comme une conversation dont on espère l'issue.
Chaîner rend chaque appel plus facile à vérifier
Le chaînage aide quand une tâche comporte trop de couches pour qu'un seul prompt la traite de façon fiable. Séparer compréhension, planification, génération et contrôle vous donne la maîtrise à chaque étape.
- Chaque appel est une tâche plus simple ; Anthropic décrit cela comme un échange de latence contre plus de précision.
- Vous pouvez inspecter et valider les sorties intermédiaires, l'une des deux raisons données par le guide de prompting de Claude pour chaîner explicitement.
- Les étapes sont réutilisables : « résumer », « extraire des entités » ou « traduire » peuvent servir à plusieurs workflows.
- Vous pouvez affecter un modèle différent à chaque étape, par exemple un petit modèle rapide pour l'extraction et un modèle plus puissant pour la rédaction.
Quatre schémas courants pour les chaînes de prompts
La plupart des chaînes reprennent quelques formes récurrentes. Choisissez celle qui correspond à votre tâche et adaptez les étapes.
- Analyser → Planifier → Rédiger → Affiner : articles, rapports, stratégies.
- Extraire → Transformer → Résumer : documents bruts, journaux, tickets de support.
- Classer → Aiguiller → Générer : trier les entrées puis les envoyer vers un prompt spécialisé.
- Brouillon → Relecture → Affinage : autocorrection itérative de textes, de code ou de maquettes.
Une chaîne de trois étapes est plus facile à vérifier qu'un long prompt
Le gain se voit mieux quand un long prompt et une courte chaîne traitent la même tâche. La tâche : transformer des notes de version brutes en journal des modifications destiné aux clients.
Prompt unique
« Lis ces notes de version et rédige un journal des modifications sympathique pour nos utilisateurs. »
Chaîne de prompts
Étape 1, extraire : « Extrais toutes les modifications visibles par l'utilisateur dans les notes de version et liste-les sous forme de puces groupées par domaine fonctionnel. »
Étape 2, classer : « Étiquette chaque puce comme correction de bug, amélioration ou nouvelle fonctionnalité et ajoute une ligne expliquant pourquoi elle compte. »
Étape 3, rédiger : « À partir de la liste étiquetée, rédige un court e-mail avec une introduction et 3 à 6 puces. Mets en avant les bénéfices, pas les détails internes. »
Chaque prompt est désormais plus simple, testable seul et réutilisable dans d'autres workflows.
Exemples de chaînage de prompts pour des tâches courantes
Ces exemples montrent où une chaîne remplace un prompt surchargé. Les deux premiers viennent de la description du schéma par Anthropic ; la chaîne de relecture est le schéma d'autocorrection du guide de prompting de Claude.
Cas d'usage | Étapes de la chaîne | Pourquoi chaîner |
|---|---|---|
| Texte marketing | Rédiger → traduire | Vérifier le texte avant traduction |
| Rédaction de document | Plan → vérifier → rédiger | Valider le plan avant le brouillon |
| Tri du support | Classer → aiguiller → répondre | Chaque catégorie a son propre prompt |
| Relecture de code ou texte | Brouillon → relecture → affiner | Appels séparés pour écrire et critiquer |
| Analyse de journaux | Extraire → grouper → résumer | Garde chaque appel court et vérifiable |
Exemple de chaînage de prompts avec LangChain en Python
Pour chaîner des prompts dans LangChain, chargez un modèle de chat avec `init_chat_model`, appelez `invoke` à chaque étape et transmettez le texte de chaque étape au prompt suivant. L'exemple exécute la chaîne du journal des modifications ci-dessus ; il suppose que `langchain`, le paquet d'intégration de votre fournisseur et sa clé d'API sont en place.
Pour les besoins avancés, LangChain renvoie vers LangGraph, son framework d'orchestration bas niveau pour combiner workflows déterministes et agentiques (par exemple branches ou boucles). Les agents se créent avec `create_agent`.
from langchain.chat_models import init_chat_model
model = init_chat_model("claude-sonnet-4-6") # any supported chat model
def run(prompt: str) -> str:
return model.invoke(prompt).text
notes = "..." # raw release notes
changes = run(f"List every user-visible change as bullets:\n{notes}")
labeled = run(f"Label each bullet as bug fix, improvement or new feature:\n{changes}")
email = run(f"Write a short user-facing changelog email from this list:\n{labeled}")
print(email)Une chaîne pour des étapes fixes, un seul prompt pour les petites tâches
Utilisez le chaînage quand une tâche se divise en étapes fixes qui peuvent échouer ou évoluer indépendamment. Un prompt très long rempli de conditions « si » signale souvent le besoin d'une chaîne.
- Utilisez une chaîne : pipelines de contenu (recherche → plan → brouillon → relecture), de données (ingestion → nettoyage → extraction → synthèse) et d'aide à la décision (faits → options → arbitrages → recommandation).
- Utilisez un seul prompt : petites tâches ponctuelles pour lesquelles vous n'avez pas besoin d'inspecter les résultats intermédiaires.
- Envisagez un agent : problèmes ouverts dont les étapes ne peuvent pas être fixées à l'avance (Anthropic distingue workflows fixes et agents).
Chaîne de prompts, prompt unique et chain-of-thought
Les trois approches diffèrent par l'endroit où le travail se fait. Une chaîne le répartit entre plusieurs appels ; le chain-of-thought le garde dans une seule réponse.
Dimension | Prompt unique | Chaîne de prompts | Chain-of-thought |
|---|---|---|---|
| Appels au modèle | Un | Un par étape | Un |
| Où se fait le raisonnement | Dans une réponse | Entre étapes, dans votre code | Écrit dans une réponse |
| Inspection intermédiaire | Non | Oui, après chaque étape | Seulement en lisant le texte |
| Coût et latence | Les plus bas | Plus élevés : un appel par étape | Un peu plus élevés : sortie plus longue |
| Idéal pour | Tâches simples | Tâches à étapes fixes | Questions riches en logique |
Les frameworks automatisent les chaînes, l'idée reste la même
Vous pouvez chaîner à la main avec de simples appels d'API ou utiliser un framework d'orchestration. Le principe est identique ; les frameworks ajoutent traçage, nouvelles tentatives et structure.
- LangChain : `init_chat_model` pour les modèles, `create_agent` pour les agents, LangGraph pour l'orchestration bas niveau.
- DSPy (Khattab et al.) : compile des appels déclaratifs à des modèles de langage en pipelines qui s'améliorent seuls.
- Anthropic, Building effective agents : chaînage de prompts et autres schémas de workflow, avec des conseils sur le choix de chacun.
- Guide de prompting de Claude, « Chain complex prompts » : le chaînage explicite « is still useful when you need to inspect intermediate outputs or enforce a specific pipeline structure ».
Comment construire une chaîne de prompts en cinq étapes
- 1Découpez la tâche en étapes ayant chacune une seule mission. Pour un article de blog : plan, rédaction des sections, vérification des faits, mise en forme.
- 2Définissez le format de sortie de chaque étape. Si l'étape 2 attend du JSON, faites produire exactement ce JSON à l'étape 1.
- 3Testez chaque étape seule avant de les relier. Exécutez l'étape 1 sur dix entrées réelles et corrigez-la avant de construire l'étape 2.
- 4Ajoutez des contrôles entre les étapes. Une validation programmatique ou une relecture humaine après les étapes critiques évite la propagation des erreurs.
- 5Journalisez les sorties intermédiaires et itérez. Quand le résultat est faux, les journaux indiquent l'étape à corriger.
Quatre erreurs de chaînage de prompts à éviter
❌ Trop d'étapes
Why it hurts: Chaque étape ajoute de la latence et une nouvelle occasion d'erreur.
Fix: Commencez avec le moins d'étapes possible qui simplifie chaque appel ; fusionnez celles qui ne changent pas le résultat.
❌ Format de transmission flou
Why it hurts: L'étape 2 ne peut pas se fier à « une liste d'idées » venant de l'étape 1.
Fix: Précisez le format exact, comme des clés JSON, et montrez un exemple de sortie.
❌ Aucun contrôle entre étapes
Why it hurts: Un mauvais plan donne un mauvais brouillon, puis un texte final pire.
Fix: Validez ou relisez la sortie des étapes où une erreur coûterait cher.
❌ Tester seulement la chaîne entière
Why it hurts: Quand la sortie finale est fausse, vous ne savez pas quelle étape a échoué.
Fix: Testez d'abord chaque étape isolément, puis la chaîne de bout en bout.
Les erreurs s'accumulent d'une étape à l'autre
Chaque étape est un point de plus où le modèle peut se tromper. À titre d'illustration arithmétique, et non de mesure : si cinq étapes sont justes à 95 % chacune et que les erreurs sont indépendantes, la chaîne entière est juste environ 77 % du temps (0,95 puissance 5).
C'est pourquoi les chaînes courtes, les tests par étape et les contrôles intermédiaires comptent plus que l'ajout d'étapes.
Comparer les modèles sur une étape de chaîne avec PromptQuorum
PromptQuorum envoie un prompt à plusieurs modèles et affiche les réponses côte à côte. Pour une chaîne, exécutez une étape sur plusieurs modèles afin de voir lequel la traite le mieux avant de lui attribuer cette étape.
Questions fréquentes
Qu'est-ce que le chaînage de prompts ?
Le chaînage de prompts est une technique qui décompose une tâche en une suite d'étapes, où chaque appel au LLM traite la sortie du précédent. Chaque étape a une mission précise, et vous pouvez vérifier ou modifier le résultat entre deux étapes.
En quoi consiste une chaîne de prompts ?
Elle consiste à diviser une grande tâche en prompts plus petits et reliés. Le premier prompt produit une sortie dans un format convenu, cette sortie entre dans le deuxième prompt, et ainsi de suite jusqu'à ce que la dernière étape livre le résultat voulu.
Quelle est la différence entre chaînage de prompts et chain-of-thought ?
Le chain-of-thought demande au modèle d'écrire son raisonnement dans un seul prompt et une seule réponse. Le chaînage utilise plusieurs appels distincts, entre lesquels votre code transmet les résultats. Vous pouvez combiner les deux : du chain-of-thought dans une étape de la chaîne.
Comment faire du chaînage de prompts avec LangChain ?
Chargez un modèle avec `init_chat_model`, appelez `invoke` pour le premier prompt, lisez le texte de la réponse, insérez-le dans le deuxième prompt et recommencez. Pour les besoins avancés, LangChain renvoie vers LangGraph, son framework d'orchestration bas niveau pour combiner workflows déterministes et agentiques (par exemple branches ou boucles).
Quand ne faut-il pas utiliser le chaînage de prompts ?
Évitez-le pour les petites tâches ponctuelles qu'un prompt résout et quand vous n'avez pas besoin d'inspecter les résultats intermédiaires. Pour les problèmes ouverts dont les étapes ne peuvent pas être fixées à l'avance, Anthropic suggère un agent plutôt qu'un workflow fixe.
Combien d'étapes une chaîne de prompts doit-elle avoir ?
Il n'y a pas de nombre fixe. Utilisez le moins d'étapes possible qui simplifie chaque appel, car chaque étape ajoute latence, coût et une source d'erreur. Fusionnez toute étape dont la suppression ne change pas la sortie.
Le chaînage de prompts est-il la même chose que le fine-tuning ?
Non. Le chaînage change la manière d'appeler un modèle, avec plusieurs prompts à la suite. Le fine-tuning modifie le modèle lui-même en l'entraînant sur des exemples. On peut les combiner, et la comparaison entre prompt engineering et fine-tuning explique quand choisir chacun.
Quel est un exemple simple de chaînage de prompts ?
L'exemple d'Anthropic : générer un texte marketing dans un premier appel, puis le traduire dans une autre langue dans un second appel. Entre les deux, vous pouvez vérifier le texte avant sa traduction.
Sources et lectures complémentaires
- Anthropic, « Building effective agents » — définition du chaînage de prompts, cas d'usage et exemples.
- Guide de prompting de Claude, « Chain complex prompts » — quand le chaînage explicite reste utile et schéma brouillon, relecture, affinage.
- Wu, Terry et Cai (2022). « AI Chains: Transparent and Controllable Human-AI Interaction by Chaining Large Language Model Prompts. » CHI 2022. arXiv:2110.01691 — étude utilisateurs avec 20 participants sur le chaînage.
- Documentation LangChain — `init_chat_model`, `create_agent` et LangGraph.
- Khattab et al. (2023). « DSPy: Compiling Declarative Language Model Calls into Self-Improving Pipelines. » arXiv:2310.03714 — pipelines de prompts programmatiques.