Chaînage de prompts et conception de pipelines Découper une tâche sans casser la chaîne

Réponse rapide

Le chaînage de prompts découpe une tâche complexe en une suite de sous-tâches plus simples, chacune confiée à un prompt dédié, où la sortie d'une étape devient l'entrée de la suivante. Le modèle ne voit jamais le problème entier — seulement le sous-problème dont il a la charge à cet instant.

  • Quatre architectures couvrent la plupart des pipelines réels : séquentielle, à branchement, en boucle, map-reduce.
  • Une chaîne n'est jamais plus fiable que sa frontière la plus faible — validez la sortie de chaque étape avant que la suivante ne la consomme.
  • Le chaînage n'est pas gratuit. Employez la chaîne minimale viable, pas la chaîne maximale imaginable.

Yous avez écrit un bon system prompt. Vous y avez ajouté la chaîne de pensée. Vous obtenez des sorties correctes sur des tâches simples. Puis un vrai besoin arrive : analyser un document de quarante pages, repérer les trois risques les plus critiques, les recouper avec une checklist de conformité, rédiger une synthèse de remédiation et mettre le tout en forme dans un rapport structuré. Vous tentez le coup en un seul prompt. Le modèle produit quelque chose de plausible — et de faux d'une manière facile à manquer.

Ce n'est pas un problème de capacité du modèle. C'est un problème de décomposition de la tâche. Le chaînage de prompts en est la réponse raisonnée.

1. Qu'est-ce que le chaînage de prompts ?

Le chaînage de prompts consiste à découper une tâche complexe en une suite de sous-tâches plus simples, chacune confiée à un prompt dédié, où la sortie d'une étape devient une partie de l'entrée de la suivante. Wu et al. (2022) définissent exactement ainsi une chaîne de prompts, et leur cadre AI Chains a rendu ces séquences transparentes et pilotables — un modèle mental juste, qui annonçait les frameworks d'agents à graphe orienté acyclique d'aujourd'hui, comme LangGraph.

Un modèle qui fait une chose de façon fiable vaut mieux qu'un modèle qui tente d'en faire dix à la fois. Le chaînage ne parle pas de la capacité du modèle — il consiste à contraindre chaque appel à un périmètre où le modèle peut être excellent plutôt que simplement acceptable.

Dohan et al. (2022) formalisent cela sous le terme de cascades de modèles de langage — des programmes probabilistes où chaque étape se conditionne aux sorties des précédentes et où chaque transition peut intégrer de la logique déterministe. Une chaîne n'est pas qu'une suite d'appels LLM ; c'est un programme dont les appels LLM sont les opérations et dont l'état, formaté en chaînes de caractères, est la mémoire.

Entrée

La sortie de l'étape précédente — ou la portion la plus étroite dont cette étape a réellement besoin. Jamais tout l'historique amont, sauf nécessité avérée.

System prompt

Une instruction serrée, à responsabilité unique, pour cette seule étape. Pas de prompt multi-rôles. Un travail par étape.

Sortie

Un artefact structuré et prévisible que l'étape suivante peut consommer sans réinterprétation. Définissez le contrat avant d'écrire le prompt.

Validation

Une couche d'assertions facultative qui confirme la conformité de la sortie à son schéma avant transmission en aval. Une assurance peu coûteuse contre la propagation des erreurs.

2. Pourquoi les prompts monolithiques cassent à l'échelle

Avant de se tourner vers une chaîne, il vaut la peine de comprendre précisément pourquoi un prompt unique échoue sur des tâches complexes. L'échec n'a rien d'aléatoire — il suit des schémas prévisibles.

La diffusion de l'attention

L'attention d'un transformeur se répartit sur tous les tokens de la fenêtre de contexte. Quand un prompt contient à la fois une description de tâche, un long document, plusieurs exemples, des règles de mise en forme et des contraintes de sortie, l'attention effective portée à chaque composant diminue — les instructions situées vers le milieu d'un long prompt sont systématiquement sous-pondérées par rapport à celles du début et de la fin. Une chaîne concentre l'attention de chaque étape sur les seuls tokens qui comptent pour elle.

Les conflits de contrat de format

Les tâches complexes demandent souvent au modèle de raisonner, de rechercher, de classer et de formater en même temps. Un modèle à qui l'on demande d'analyser un contrat, de repérer les clauses de responsabilité, de les confronter à une grille et de produire un rapport JSON accompagné d'un récit explicatif doit écrire dans trois registres — prose analytique, données structurées, commentaire évaluatif — en une seule passe de génération. La fiabilité se dégrade parce que le modèle ne peut s'engager pleinement dans aucun format.

Le cumul des erreurs

Dans un prompt monolithique, une inférence fausse dans la première moitié de la réponse tend à se propager : la génération étant autorégressive, une affirmation erronée devient le contexte de tout ce qui suit. Dans une chaîne, les erreurs restent locales à l'étape où elles surviennent et peuvent être interceptées à la frontière avant de contaminer les étapes suivantes.

Chaque prompt a un plafond de fiabilité — un niveau de complexité au-delà duquel la qualité de sortie devient imprévisible. Le chaînage ne relève pas le plafond ; il fait en sorte que vous ne le touchiez jamais.
La métaphore du plafond

3. Les quatre architectures de chaîne

Quatre architectures couvrent la majorité des besoins réels de chaînage. Elles ne s'excluent pas — les pipelines de production les combinent souvent toutes les quatre — mais il est utile de comprendre d'abord chacune isolément.

Séquentielle

Les étapes s'exécutent dans un ordre fixe, la sortie de chacune alimentant la suivante. Le motif le plus simple et le plus courant, et le bon choix par défaut pour toute tâche exprimable comme une suite de transformations.

À branchement

Une étape de classification décide quelle sous-chaîne s'exécute ensuite. Le bon choix quand un même type d'entrée exige un traitement qualitativement différent selon son contenu.

En boucle / itérative

La sortie d'une étape lui est réinjectée jusqu'à ce qu'une condition d'arrêt soit remplie — le cycle canonique générer-critiquer-réviser.

Map-reduce

Une grande entrée est découpée en fragments traités indépendamment, puis fusionnés par une étape finale d'agrégation.

Les chaînes séquentielles

Un exemple concret : produire une analyse concurrentielle à partir de notes de recherche brutes. Le pipeline peut extraire des faits structurés de chaque source, normaliser les entités entre sources, repérer les contradictions, classer les constats par pertinence, puis rédiger l'analyse. Chaque étape est petite, vérifiable et déboguable indépendamment.

Sequential — Step 1 of 4 · Extraction System prompt
# Role: structured-extraction engine.
Extract every explicit claim from the source text below.
Return a JSON array of objects with fields: claim, subject,
source_sentence.

Rules:
- Extract only explicit claims. Do not infer.
- If the text contains no extractable claims, return
  an empty array: []
- Do not add commentary, preamble, or explanation
  outside the JSON.

Les chaînes à branchement

L'exigence critique est que l'étape de classification produise un ensemble fini et déterministe d'étiquettes qui correspondent proprement aux chaînes en aval. Si l'espace des étiquettes est flou, la logique de branchement devient peu fiable — contraignez le classifieur à un vocabulaire fixe et imposez-le par une sortie structurée.

Les chaînes en boucle

Madaan et al. (2023) formalisent cela sous le nom de Self-Refine — un modèle améliore itérativement sa propre sortie à partir d'un retour qu'il génère lui-même. Un modèle qui joue le critique puis le réviseur dans des prompts distincts et dédiés fait mieux qu'un modèle à qui l'on demande une réponse finale en une seule passe, à budget total de tokens constant.

Looped — Step 2 of 2 · Critique (termination check) System prompt
# Role: technical-editor critic.
Review the draft against this rubric:
1. Every claim is traceable to the source material.
2. No sentence exceeds 30 words.
3. Section headings match the outline.

Return JSON: {"pass": bool, "score": 1-10,
"issues": [...], "revised_draft": "..."}

# Orchestrator logic (not part of the prompt):
# if response.pass === true -> exit loop
# MAX_ITER=3 is a common starting point; tune per task.

Définissez la condition d'arrêt avant d'écrire la boucle : une porte réussite/échec, un plafond fixe d'itérations, ou un seuil de rendement décroissant. En production, combinez toujours une porte de qualité et un plafond strict — une boucle infinie est un incident en attente de se produire.

Les chaînes map-reduce

L'étape de réduction est la plus difficile à réussir. Un prompt de réduction naïf du type « résume tous les résumés » produit une sortie aplatie et générique. Une meilleure approche confie à l'étape de réduction une opération d'agrégation précise — classement, détection de contradictions, extraction de thèmes — plutôt qu'une fusion libre.

Architecture → idéale pour → risque principal

  • Séquentielle. Pipelines de transformation fixes, traitement documentaire. Risque : propagation d'erreurs sans validation aux frontières. Fin : fixe — la dernière étape s'achève.
  • À branchement. Routage de requêtes, tri de contenu, tâches multi-domaines. Risque : ambiguïté des étiquettes entraînant un mauvais routage. Fin : fixe — la branche se termine normalement.
  • En boucle. Rédaction, génération de code, sortie soumise à une porte de qualité. Risque : boucles infinies ; rendements décroissants après deux ou trois passes. Fin : conditionnelle — porte ou plafond.
  • Map-reduce. Longs documents, résumé par lots, extraction parallèle. Risque : l'étape de réduction perd la nuance ; artefacts aux frontières de fragments. Fin : fixe — la réduction s'achève.

4. Le motif routeur et répartiteur

Le motif du routeur mérite sa propre section, car il apparaît au point d'entrée de presque tout système multi-chaînes non trivial, et sa qualité détermine la fiabilité de tout ce qui suit. Un routeur est un prompt (ou une fonction légère qui l'enveloppe) qui prend une entrée et décide quelle chaîne doit la traiter.

La tentation est d'écrire un routeur qui cherche à comprendre l'entrée en profondeur. Résistez-y. Le seul travail d'un routeur est de classer dans un ensemble fini de catégories — mutuellement exclusives, aussi exhaustives que possible, avec une catégorie fourre-tout explicite pour les entrées hors périmètre. Ce motif « décider puis agir » annonce l'architecture ReAct (Yao et al., 2023), traitée dans la leçon sur la conception d'agents.

Prompt de routeur — sortie structurée imposée System prompt
# Role: request classifier.
Classify the user request into exactly one category:

- "data_extraction" — user wants structured data pulled
  from a document
- "summarisation" — user wants a shorter version of
  provided content
- "question_answer" — user is asking a factual question
- "code_generation" — user wants code written or modified
- "unknown" — the request does not fit any category above

Return JSON only: {"type": "<one of the five values above>",
"confidence": <0.0-1.0>}

# Orchestrator logic (not part of the prompt):
# if confidence < 0.6 -> fallback to a clarification step
# if type === "unknown" -> route to a human escalation queue

Deux décisions d'ingénierie comptent davantage que le texte du prompt lui-même. Sortie structurée : forcez le routeur à produire un objet JSON au schéma fixe — {"type": "summarisation", "confidence": 0.91} s'analyse en un seul appel, là où de la prose exige une correspondance de chaînes fragile. Un seuil de confiance : tout appel de routeur en dessous d'un seuil configurable ne doit pas router — il doit déclencher une demande de clarification ou une voie de repli. Un mauvais routage coûte nettement plus cher qu'un routage retardé.

Un routeur classe. Un répartiteur agit sur cette classification. Gardez ces deux responsabilités séparées : le routeur est une fonction pure, entrée d'un côté, étiquette de l'autre ; le répartiteur détient la correspondance étiquette → chaîne, les règles de repli et les seuils de confiance. Mélanger les deux produit des prompts difficiles à tester et à faire évoluer.

5. L'état et le contexte entre les étapes

Chaque étape d'une chaîne reçoit un état et en produit un. Gérer cet état avec soin est ce qui sépare un pipeline de production d'une preuve de concept qui s'effondre sur les cas limites.

Ce qu'il faut transmettre

L'instinct par défaut — transmettre la sortie complète de chaque étape précédente à toutes les suivantes — est mauvais. Il gonfle la fenêtre de contexte à chaque étape, augmente le coût en tokens et dégrade la qualité en obligeant le modèle à analyser du contenu antérieur non pertinent. Le bon principe est celui du contexte strictement nécessaire : chaque étape ne reçoit que la sortie de son prédécesseur direct, plus le contexte global réellement indispensable. Si une étape tardive a besoin d'une information remontant à trois étapes, c'est le signe que les étapes intermédiaires auraient dû la conserver explicitement dans leur sortie structurée.

Le motif du schéma d'état

Définissez un schéma d'état partagé dès le début de la conception du pipeline, avant d'écrire le moindre prompt d'étape. Ce schéma est un objet JSON qui accumule des données au fil de la chaîne — chaque étape y lit, apporte sa contribution et y réécrit. Les étapes ne communiquent pas par de la prose : elles communiquent par des champs.

L'état qui s'accumule le long d'un pipeline JSON
// Initial state
{"user_request": "...", "source_document": "..."}

// After step 1
{...initial, "extracted_facts": [...]}

// After step 2
{...prev, "ranked_facts": [...], "contradictions": [...]}

// After step 3
{...prev, "draft": "...", "draft_score": 8}

// Final state
{"final_report": "...", "metadata": {"steps": 3, "iterations": 2}}

La compression du contexte

Sur de longs pipelines appliqués à de longs documents, même la transmission du contexte strictement nécessaire peut approcher les limites de tokens. La solution est une étape de compression — un prompt dédié dont le seul travail est de résumer l'état accumulé sous une forme compacte qui préserve tout ce dont les étapes suivantes ont besoin. Khattab et al. (2023) traitent cela systématiquement dans DSPy, qui compile des pipelines de modèles de langage déclaratifs en optimisant automatiquement les prompts et les exemples few-shot d'une étape à l'autre.

6. Modes de défaillance et propagation des erreurs

Une chaîne n'est jamais plus fiable que sa frontière la plus faible. Les modes de défaillance des systèmes chaînés sont généralement silencieux, différés et difficiles à imputer.

Trois défaillances de frontière

  • Violations du contrat de format. L'étape N promet du JSON ; l'étape N+1 l'analyse. Une clôture Markdown ou un préambule d'excuse fait tomber la chaîne — non pas à l'étape N où l'erreur est née, mais à l'étape N+1 où elle est consommée. Validez toujours le schéma de sortie à chaque frontière avant transmission en aval. Des bibliothèques comme Zod (TypeScript) ou Pydantic (Python) rendent cela trivial, et redirigent les échecs vers un prompt de réparation.
  • L'héritage d'hallucination. Une erreur factuelle à l'étape 2 n'est pas corrigée à l'étape 3, sauf si celle-ci valide explicitement contre une source de vérité. Insérez des contrôles d'ancrage à toute étape produisant des affirmations factuelles — faites-lui citer la phrase source de chaque affirmation.
  • L'amplification des erreurs en boucle. Si le critique d'une boucle générer-critiquer-réviser est mal calibré, l'étape de révision agit sur un retour défectueux et peut produire une sortie pire que celle qu'elle remplace. Évaluez le prompt du critique séparément, sur des brouillons connus comme bons et comme mauvais, avant de lui confier le rôle de porte d'arrêt.
Étape de réparation — récupération d'un JSON malformé System prompt
# Role: JSON repair.
The following text was supposed to be valid JSON matching
this schema: {schema}

It is not valid JSON. Extract and repair it, returning only
the corrected JSON — no commentary. If the content cannot be
recovered, return {"error": "unrecoverable"}.

Malformed input:
{malformed_output}

# This step runs only when JSON.parse throws.
# Log all repair invocations — a high repair rate signals
# a failing step prompt.

Journalisez l'entrée et la sortie complètes de chaque étape de chaîne en production. Un pipeline qui échoue à l'étape 5 n'est déboguable que si vous pouvez inspecter ce qu'ont produit les étapes 1 à 4. Journaliser les appels LLM n'est pas une surcharge facultative — c'est l'outil de débogage principal des systèmes agentiques.

7. Quand ne pas chaîner

Le chaînage n'est pas universellement supérieur à un prompt unique bien conçu. Il a des coûts réels — latence, dépense en tokens, complexité d'ingénierie, davantage de surfaces de défaillance — et ces coûts ne valent pas d'être payés pour des tâches qu'un seul prompt traite de façon fiable.

Chaînez quand

  • La tâche comporte plusieurs sous-tâches qualitativement différentes.
  • La sortie d'une étape est vérifiable indépendamment.
  • La fiabilité du monolithe est en dessous de votre seuil de qualité.
  • La localisation des erreurs compte.

Restez monolithique quand

  • La tâche est une transformation unique.
  • La latence est critique.
  • Le modèle est déjà régulier.
  • L'équipe ne peut pas assumer la complexité supplémentaire d'un système multi-étapes.

Ne construisez pas de chaîne quand

  • La tâche tient proprement dans un seul prompt — résumer cet e-mail, traduire cette phrase, classer ce ticket. Ajouter une chaîne ajoute de la complexité sans ajouter de fiabilité.
  • La latence est la contrainte principale. Chaque étape représente au minimum un aller-retour supplémentaire ; sous un budget de deux secondes, une chaîne à deux étapes est souvent irréalisable.
  • La structure de sortie est simple et le modèle est déjà régulier sur 99 % des entrées — une étape de correction de format est une optimisation prématurée.
  • L'équipe ne peut pas maintenir le pipeline. Une chaîne de cinq étapes sans journalisation, sans validation de schéma et sans contrats d'étape documentés est plus difficile à réparer qu'un prompt monolithique unique.

La règle de décision pratique : tentez d'abord la tâche avec un prompt unique, soigneusement conçu. Mesurez sa fiabilité sur un échantillon représentatif. S'il atteint votre niveau de qualité, livrez-le. Sinon, identifiez précisément quelle sous-tâche échoue — puis n'externalisez que celle-là dans une étape à part. Le chaînage est un outil de gestion de la complexité à l'échelle, pas une architecture par défaut. La meilleure chaîne est la plus courte qui satisfait votre exigence de fiabilité.

Cette leçon vous a-t-elle été utile ?

FAQ

Questions fréquentes

Le chaînage de prompts découpe une tâche complexe en une suite de sous-tâches plus simples, chacune confiée à un prompt dédié, où la sortie d'une étape devient une partie de l'entrée de la suivante. Le modèle ne voit jamais le problème entier d'un coup — chaque appel est contraint à un périmètre où il peut être excellent plutôt que simplement acceptable.

Références

  1. Wu, T., Terry, M., & Cai, C. J. (2022). AI Chains: Transparent and Controllable Human-AI Interaction by Chaining Large Language Model Prompts. CHI 2022. arXiv:2110.01691.
  2. Dohan, D., et al. (2022). Language Model Cascades. arXiv:2207.10342.
  3. Liu, N. F., et al. (2023). Lost in the Middle: How Language Models Use Long Contexts. TACL 12. arXiv:2307.03172.
  4. Madaan, A., et al. (2023). Self-Refine: Iterative Refinement with Self-Feedback. NeurIPS 2023.
  5. Khattab, O., et al. (2023). DSPy: Compiling Declarative Language Model Calls into Self-Improving Pipelines. arXiv:2310.03714.
  6. Yao, S., et al. (2023). ReAct: Synergizing Reasoning and Acting in Language Models. ICLR 2023.
  7. Wei, J., et al. (2022). Chain-of-Thought Prompting Elicits Reasoning in Large Language Models. NeurIPS 2022.
  8. Chase, H. (2022). LangChain [software]. github.com/langchain-ai/langchain.

Envie de vous tester ?

10 questions tirées au hasard des six leçons de la Partie I. Sans limite de temps. Partagez votre score.

Faire le quiz

Contact

Un système à construire ?

Si vous montez un pipeline RAG, un workflow d'agents IA ou une intégration MCP et que vous voulez comparer vos notes, échanger des idées, ou simplement éviter les erreurs que j'ai déjà faites — écrivez-moi.

Ou recevez le Playbook par e-mail — un message quand une nouvelle leçon sort, et rien d'autre.

Pas de bruit, pas de spam. Désinscription à tout moment.