Tutoriel sur le chaînage de prompts : qu’est-ce que le prompt chaining et comment l’utiliser ?

Avez-vous déjà tenté de monter un meuble sans lire la notice ? Avec un peu de chance, vous parviendrez à assembler quelques pièces, mais sans un guidage pas à pas, le résultat risque d’être bancal. C’est un peu le même défi que rencontrent les grands modèles de langage (LLM) face à des problèmes complexes. Leur potentiel est immense, mais ils passent souvent à côté lorsqu’une tâche exige un raisonnement détaillé en plusieurs étapes.

Face à un prompt unique, les LLM peuvent fournir des réponses trop générales, peu approfondies ou qui omettent des éléments essentiels. Cette limite vient de la difficulté à capturer tout le contexte nécessaire et à fournir un guidage suffisant dans un seul prompt.

La solution : le chaînage de prompts.

Le prompt chaining consiste à décomposer une tâche complexe en une série de prompts plus petits et plus faciles à gérer. Chaque prompt traite une partie précise de la tâche, et la sortie de l’un sert d’entrée au suivant. Cette méthode impose une approche structurée et guide le LLM à travers une chaîne d’étapes de raisonnement menant à une réponse plus juste et plus complète. En suivant une séquence logique de prompts, on exploite pleinement les LLM pour résoudre efficacement des problèmes complexes.

Ce tutoriel fait partie de ma série « Prompt Engineering : from zero to hero » :

1. Prompt engineering pour toutes et tous
2. Zero-shot prompting
3. Few-shot prompting
4. Prompt chaining

Qu’est-ce que le prompt chaining ?

Le prompt chaining est une méthode où la sortie d’un prompt LLM devient l’entrée du prompt suivant dans une séquence. Cette technique consiste à créer une série de prompts reliés, chacun se concentrant sur un aspect spécifique du problème global. En suivant cette séquence, on guide le LLM dans un raisonnement structuré, ce qui l’aide à produire des réponses plus précises et détaillées.

L’objectif principal du prompt chaining est d’améliorer la performance, la fiabilité et la clarté des applications basées sur des LLM. Pour les tâches complexes, un prompt unique ne fournit souvent ni la profondeur ni le contexte nécessaires à une bonne réponse. Le chaînage résout ce problème en découpant la tâche en étapes plus petites et soignées. Cette approche améliore la qualité des sorties du LLM et facilite la compréhension du cheminement jusqu’au résultat final.

Voici quelques avantages du prompt chaining :

Comment mettre en œuvre le prompt chaining

Mettre en place un chaînage de prompts suppose une démarche systématique : décomposer une tâche complexe et guider un LLM à travers une série d’étapes bien définies. 

Voyons comment concevoir et exécuter efficacement une chaîne de prompts.

Identifier les sous-tâches

La première étape consiste à décomposer la tâche complexe en sous-tâches plus petites et gérables. Chaque sous-tâche doit représenter un aspect distinct du problème global afin que le LLM se concentre sur une partie à la fois.

Par exemple, si vous souhaitez que le LLM rédige un rapport complet sur le changement climatique, les sous-tâches pourraient être :

• Rechercher des données climatiques historiques
• Résumer les principaux résultats de la littérature scientifique
• Analyser l’impact du changement climatique sur différents écosystèmes
• Proposer des solutions et stratégies d’atténuation

Concevoir les prompts

Ensuite, concevez des prompts clairs et concis pour chaque sous-tâche. Chaque prompt doit être spécifique et direct pour que le LLM comprenne la demande et produise une sortie pertinente. Point clé : la sortie d’un prompt doit pouvoir servir d’entrée au suivant, afin de créer un flux d’information.

Pour nos sous-tâches ci-dessus, on peut créer les prompts suivants :

• Prompt de la sous-tâche 1 : « Résumez les principales tendances de l’évolution des températures mondiales au cours du dernier siècle. »
• Prompt de la sous-tâche 2 : « À partir des tendances identifiées, dressez la liste des principales études scientifiques qui traitent des causes de ces évolutions. »
• Prompt de la sous-tâche 3 : « Résumez les résultats des études listées, en vous concentrant sur l’impact du changement climatique sur les écosystèmes marins. »
• Prompt de la sous-tâche 4 : « Proposez trois stratégies pour atténuer l’impact du changement climatique sur les écosystèmes marins, à partir des résultats résumés. »

Exécuter la chaîne

Il s’agit maintenant d’exécuter les prompts de manière séquentielle, en passant la sortie de l’un comme entrée au suivant. Cette exécution pas à pas permet au LLM de capitaliser sur ses sorties précédentes et de produire un résultat cohérent et complet.

Dans notre exemple, les sorties des sous-tâches pourraient ressembler à ceci :

• Sortie de la sous-tâche 1 : « La température moyenne mondiale a augmenté d’environ 1,2 °C au cours du dernier siècle, avec une hausse marquée ces 20 dernières années. »
• Entrée pour la sous-tâche 2 : « Sachant que les températures mondiales ont augmenté de 1,2 °C au cours du dernier siècle, dressez la liste des principales études scientifiques qui traitent des causes de ces évolutions. »
• Sortie de la sous-tâche 2 : « Parmi les études clés : ‘The Role of Greenhouse Gases in Global Warming’ de Dr Smith, ‘Deforestation and Climate Change’ de Dr Jones, et ‘Oceanic Changes and Climate Patterns’ de Dr Lee. »
• Entrée pour la sous-tâche 3 : « Résumez les conclusions de ‘The Role of Greenhouse Gases in Global Warming’ (Dr Smith), ‘Deforestation and Climate Change’ (Dr Jones) et ‘Oceanic Changes and Climate Patterns’ (Dr Lee), en vous concentrant sur l’impact du changement climatique sur les écosystèmes marins. »

Gestion des erreurs

Mettre en place des mécanismes de gestion des erreurs est essentiel. Prévoyez des contrôles de qualité et de pertinence avant de passer à l’étape suivante, ainsi que des prompts de repli pour remettre le LLM sur les rails en cas d’écart. Par exemple :

• Contrôle d’erreur 1 : après chaque sortie, vérifiez la pertinence et l’exhaustivité. Si le résumé des tendances de température est incomplet, demandez des précisions supplémentaires.
• Prompt de repli : si le LLM ne liste pas d’études pertinentes, utilisez un prompt plus précis : « Citez cinq études évaluées par des pairs publiées au cours de la dernière décennie sur les causes de la hausse des températures mondiales. »

Mise en œuvre

Voyons comment implémenter cela en Python !

Étape 1 : préparer l’environnement

Commencez par importer les bibliothèques nécessaires. Nous utiliserons la classe OpenAI du package openai et os pour gérer les variables d’environnement.

import openai
import os

Il est crucial de stocker en toute sécurité les informations sensibles comme les clés d’API. Une façon de faire est de définir la clé comme variable d’environnement. Vous pouvez le faire via une clé OpenAI API.

os.environ['OPENAI_API_KEY'] = 'your-api-key-here'

Remplacez 'your-api-key-here' par votre véritable clé OpenAI API.

Avec la clé définie, vous pouvez initialiser le client OpenAI, qui servira à effectuer les appels d’API vers les services d’OpenAI.

Client = OpenAI ()

Étape 2 : définir une fonction pour interagir avec l’API de chat completions d’OpenAI

Créons maintenant une fonction Python pour interagir avec l’API de chat completions d’OpenAI. Cette fonction enverra un prompt à l’API et retournera la réponse générée.

def get_completion(prompt, model="gpt-3.5-turbo"):
    try:
        response = client.chat.completions.create(
            model=model,
            messages=[
                {"role": "system", "content": "You are a helpful assistant."},
                {"role": "user", "content": prompt}
            ],
            temperature=0,
        )
        return response.choices[0].message.content
    except Exception as e:
        print(f"An error occurred: {e}")
        return None

Détaillons cette fonction :

• Elle prend un prompt et un paramètre de modèle optionnel.
• Elle effectue un appel à l’API OpenAI via l’endpoint chat completions.
• Elle initialise la conversation avec un message système et un message utilisateur (le prompt).
• Elle fixe la température à 0 pour des sorties plus déterministes (augmentez-la pour plus de créativité).
• Elle renvoie le contenu de la réponse ou None en cas d’erreur.

Étape 3 : chaîner plusieurs prompts

Créons maintenant une fonction Python qui enchaîne plusieurs prompts en alimentant chaque nouveau prompt avec la sortie du précédent.

def prompt_chain(initial_prompt, follow_up_prompts):
    result = get_completion(initial_prompt)
    if result is None:
        return "Initial prompt failed."
    print(f"Initial output: {result}\n")
    for i, prompt in enumerate(follow_up_prompts, 1):
        full_prompt = f"{prompt}\n\nPrevious output: {result}"
        result = get_completion(full_prompt)
        if result is None:
            return f"Prompt {i} failed."
        print(f"Step {i} output: {result}\n")
    return result

La fonction prompt_chain met en œuvre le chaînage :

• Elle démarre avec un prompt initial et récupère sa complétion.
• Elle itère sur une liste de prompts de suivi.
• Pour chaque prompt de suivi, elle combine le prompt avec la sortie précédente, obtient une complétion et met à jour le résultat.
• En cas d’échec à une étape, elle renvoie un message d’erreur.
• Chaque sortie intermédiaire est affichée pour le suivi.

Étape 4 : exemple d’utilisation

Voyons comment utiliser la fonction prompt_chain pour créer une séquence de prompts qui s’appuient les uns sur les autres. Cet exemple porte sur le résumé des tendances des températures mondiales et l’exploration des études et stratégies d’atténuation associées, mais adaptez-le à votre cas d’usage !

initial_prompt = "Summarize the key trends in global temperature changes over the past century."
follow_up_prompts = [
    "Based on the trends identified, list the major scientific studies that discuss the causes of these changes.",
    "Summarize the findings of the listed studies, focusing on the impact of climate change on marine ecosystems.",
    "Propose three strategies to mitigate the impact of climate change on marine ecosystems based on the summarized findings."
]
final_result = prompt_chain(initial_prompt, follow_up_prompts)
print("Final result:", final_result)

Nous définissons un prompt initial sur l’évolution des températures mondiales, puis une liste de prompts de suivi qui se nourrissent l’un l’autre. Nous appelons ensuite prompt_chain avec ces prompts et, enfin, nous affichons le résultat final.

Comment tout s’articule

Récapitulons :

1. Le prompt initial produit un résumé des tendances de température.
2. Le premier suivi exploite ce résumé pour trouver des études pertinentes.
3. Le deuxième suivi résume les résultats concernant les écosystèmes marins.
4. Le prompt final propose des stratégies d’atténuation à partir de l’ensemble des informations.

Ce chaînage permet une approche pas à pas des requêtes complexes, chaque étape se construisant sur la précédente.

Techniques de prompt chaining

Le chaînage de prompts peut s’implémenter de plusieurs façons selon la nature des tâches. Nous présentons ici trois techniques principales : le chaînage séquentiel, conditionnel et en boucle.

Chaînage séquentiel

Le chaînage séquentiel relie les prompts dans une suite linéaire. Chaque prompt dépend de la sortie du précédent, créant un flux d’informations pas à pas. Idéal lorsque la tâche suit une progression logique, par exemple :

• Résumé de texte : découper un long document en sections résumées, puis fusionner ces résumés en une synthèse cohérente.
• Génération de code : produire des extraits pas à pas : définir les fonctions, les implémenter, puis écrire les tests.

L’extrait de code de la section précédente illustre ce chaînage séquentiel.

Chaînage conditionnel

Le chaînage conditionnel introduit des embranchements selon la sortie du LLM. Cette technique rend les workflows plus souples et adaptatifs, le LLM empruntant des chemins différents selon ses réponses.

Voyons une implémentation pour l’analyse de sentiment.

def analyze_sentiment(text):
    prompt = f"Analyze the sentiment of the following text and respond with only one word - 'positive', 'negative', or 'neutral': {text}"
    sentiment = get_completion(prompt)
    return sentiment.strip().lower()

def conditional_prompt_chain(initial_prompt):
    result = get_completion(initial_prompt)
    if result is None:
        return "Initial prompt failed."
    print(f"Initial output: {result}\n")
    sentiment = analyze_sentiment(result)
    print(f"Sentiment: {sentiment}\n")
    if sentiment == 'positive':
        follow_up = "Given this positive outlook, what are three potential opportunities we can explore?"
    elif sentiment == 'negative':
        follow_up = "Considering these challenges, what are three possible solutions we can implement?"
    else:  # neutral
        follow_up = "Based on this balanced view, what are three key areas we should focus on for a comprehensive approach?"
    final_result = get_completion(f"{follow_up}\n\nContext: {result}")
    return final_result

# Example usage
initial_prompt = "Analyze the current state of renewable energy adoption globally."
final_result = conditional_prompt_chain(initial_prompt)
print("Final result:", final_result)

Nous définissons d’abord une fonction analyze_sentiment() qui utilise le modèle pour déterminer le sentiment d’un texte. Puis, dans conditional_prompt_chain(), nous partons d’un prompt sur l’adoption des énergies renouvelables. Après la première réponse, nous en analysons le sentiment et choisissons un prompt de suivi différent selon le cas :

• Pour un sentiment positif : interroger sur les opportunités.
• Pour un sentiment négatif : demander des solutions.
• Pour un sentiment neutre : cibler des axes de travail prioritaires.

Le prompt de suivi retenu est ensuite envoyé au modèle avec le contexte de la réponse initiale. Le résultat final est la réponse à ce prompt conditionnel.

Notez que le second prompt n’est pas prédéterminé : il dépend du contenu de la première réponse. Le flux s’adapte selon l’analyse de sentiment, illustrant comment la chaîne peut bifurquer. Cela permet des interactions plus dynamiques et sensibles au contexte.

À l’exécution, la question de suivi dépendra du caractère positif, négatif ou neutre de l’analyse initiale. Vous obtenez ainsi une chaîne de prompts plus réactive et adaptable.

Chaînage en boucle

Le chaînage en boucle introduit des itérations dans la chaîne pour parcourir des données ou répéter des étapes. Utile pour traiter des listes d’éléments avec des traitements similaires. Avantages et défis :

• Efficacité : automatiser les tâches répétitives pour gagner du temps.
• Traitement de données : adapté au traitement de multiples enregistrements, à la synthèse par lots ou aux améliorations itératives.
• Défis : éviter les boucles infinies et garantir un progrès significatif à chaque itération.

Voici une implémentation pour vérifier l’exhaustivité d’un texte :

def check_completeness(text):
    prompt = f"Analyze the following text and respond with only 'complete' if it covers all necessary aspects, or 'incomplete' if more information is needed:\n\n{text}"
    response = get_completion(prompt)
    return response.strip().lower() == 'complete'

def looping_prompt_chain(initial_prompt, max_iterations=5):
    current_response = get_completion(initial_prompt)
    if current_response is None:
        return "Initial prompt failed."
    print(f"Initial output: {current_response}\n")
    iteration = 0
    while iteration < max_iterations:
        if check_completeness(current_response):
            print(f"Complete response achieved after {iteration + 1} iterations.")
            return current_response
        print(f"Iteration {iteration + 1}: Response incomplete. Expanding...")
        expand_prompt = f"The following response is incomplete. Please expand on it to make it more comprehensive:\n\n{current_response}"
        new_response = get_completion(expand_prompt)
        if new_response is None:
            return f"Expansion failed at iteration {iteration + 1}."
        current_response = new_response
        print(f"Expanded response: {current_response}\n")
        iteration += 1
    print(f"Maximum iterations ({max_iterations}) reached without achieving completeness.")
    return current_response

# Example usage
initial_prompt = "Explain the process of photosynthesis."
final_result = looping_prompt_chain(initial_prompt)
print("Final result:", final_result)

Nous définissons d’abord check_completeness(), qui demande au modèle si une réponse est complète ou nécessite des compléments.

Ensuite, dans looping_prompt_chain(), nous partons d’un prompt sur la photosynthèse. Après une première réponse, nous entrons dans une boucle :

• Nous vérifions si la réponse courante est complète via check_completeness().
• Si elle est complète, on quitte la boucle et on renvoie le résultat.
• Sinon, on génère un prompt demandant d’étoffer la réponse précédente.
• On récupère alors une nouvelle réponse basée sur ce prompt d’expansion.

Le processus se poursuit jusqu’à obtenir une réponse jugée complète ou jusqu’à atteindre le nombre maximal d’itérations (5 par défaut).

La boucle garantit un affinage progressif de la réponse jusqu’à exhaustivité ou atteinte de la limite d’itérations.

À l’exécution, le code cherchera à fournir une explication complète de la photosynthèse, avec plusieurs itérations si nécessaire, pour aboutir à un résultat final plus solide.

Cas d’usage concrets du prompt chaining

Le prompt chaining peut considérablement renforcer les capacités des LLM dans de nombreux contextes. Voici quelques applications pratiques illustrant son utilité sur des tâches réelles.

Questions-réponses sur documents

Le chaînage peut servir à résumer de longs documents puis à répondre à des questions précises. On découpe d’abord le document, on résume chaque section, puis on s’appuie sur ces résumés pour répondre aux questions détaillées.

Voici une implémentation :

def split_document(document, max_length=1000):
    """Split the document into sections of approximately max_length characters."""
    words = document.split()
    sections = []
    current_section = []
    current_length = 0
    for word in words:
        if current_length + len(word) + 1 > max_length and current_section:
            sections.append(' '.join(current_section))
            current_section = []
            current_length = 0
        current_section.append(word)
        current_length += len(word) + 1
    if current_section:
        sections.append(' '.join(current_section))
    return sections

def summarize_section(section):
    prompt = f"Summarize the following text in a concise manner:\n\n{section}"
    return get_completion(prompt)

def answer_question(summaries, question):
    context = "\n\n".join(summaries)
    prompt = f"Given the following context, answer the question:\n\nContext:\n{context}\n\nQuestion: {question}"
    return get_completion(prompt)

def document_qa(document, questions):
    # Step 1: Split the document
    sections = split_document(document)
    print(f"Document split into {len(sections)} sections.")
    # Step 2: Summarize each section
    summaries = []
    for i, section in enumerate(sections):
        summary = summarize_section(section)
        summaries.append(summary)
        print(f"Section {i+1} summarized.")
    # Step 3: Answer questions
    answers = []
    for question in questions:
        answer = answer_question(summaries, question)
        answers.append((question, answer))
    return answers

# Example usage
long_document = """
[Insert a long document here. For brevity, we are using a placeholder. 
In a real scenario, this would be a much longer text, maybe several 
paragraphs or pages about a specific topic.]
This is a long document about climate change. It discusses various aspects 
including causes, effects, and potential solutions. The document covers 
topics such as greenhouse gas emissions, rising global temperatures, 
melting ice caps, sea level rise, extreme weather events, impact on 
biodiversity, and strategies for mitigation and adaptation.
The document also explores the economic implications of climate change, 
international agreements like the Paris Agreement, renewable energy 
technologies, and the role of individual actions in combating climate change.
[Continue with more detailed information about climate change...]
"""
questions = [
    "What are the main causes of climate change mentioned in the document?",
    "What are some of the effects of climate change discussed?",
    "What solutions or strategies are proposed to address climate change?"
]
results = document_qa(long_document, questions)
for question, answer in results:
    print(f"\nQ: {question}")
    print(f"A: {answer}")

Cet extrait montre comment le chaînage permet d’aborder des tâches complexes comme l’analyse de documents et le question-réponse. Il décompose la compréhension d’un long texte en étapes gérables (résumés de sections), puis exploite ces sorties pour répondre aux questions. Pratique pour traiter des documents trop longs pour un prompt unique.

Avec un vrai document, le code le découpera, résumera chaque partie, puis utilisera ces résumés pour répondre aux questions sur les causes, effets et solutions liés au changement climatique.

Génération de texte avec vérification des faits

La génération de texte avec vérification des faits consiste à produire un texte puis à intégrer des étapes de fact-checking dans la chaîne de prompts, afin d’assurer la cohérence mais aussi l’exactitude.

def generate_text(topic):
    prompt = f"Write a short paragraph about {topic}."
    return get_completion(prompt)

def extract_facts(text):
    prompt = f"Extract the key factual claims from the following text, listing each claim on a new line:\n\n{text}"
    return get_completion(prompt)

def verify_facts(facts):
    verified_facts = []
    for fact in facts.split('\n'):
        if fact.strip():
            prompt = f"Verify the following statement and respond with 'True' if it's factually correct, 'False' if it's incorrect, or 'Uncertain' if it can't be verified without additional research: '{fact}'"
            verification = get_completion(prompt)
            verified_facts.append((fact, verification.strip()))
    return verified_facts

def revise_text(original_text, verified_facts):
    context = "Original text:\n" + original_text + "\n\nVerified facts:\n"
    for fact, verification in verified_facts:
        context += f"- {fact}: {verification}\n"
    
    prompt = f"{context}\n\nRewrite the original text, keeping the verified facts, removing or correcting any false information, and indicating any uncertain claims as 'It is claimed that...' or similar phrasing."
    return get_completion(prompt)

def text_generation_with_verification(topic):
    print(f"Generating text about: {topic}")
    # Step 1: Generate initial text
    initial_text = generate_text(topic)
    print("\nInitial Text:")
    print(initial_text)
    # Step 2: Extract facts
    extracted_facts = extract_facts(initial_text)
    print("\nExtracted Facts:")
    print(extracted_facts)
    # Step 3: Verify facts
    verified_facts = verify_facts(extracted_facts)
    print("\nVerified Facts:")
    for fact, verification in verified_facts:
        print(f"- {fact}: {verification}")
    # Step 4: Revise text
    revised_text = revise_text(initial_text, verified_facts)
    print("\nRevised Text:")
    print(revised_text)
    return revised_text

# Example usage
topic = "the effects of climate change on polar bears"
final_text = text_generation_with_verification(topic)

La fonction text_generation_with_verification() orchestre l’ensemble : generate_text() crée un paragraphe initial ; extract_facts() en extrait les affirmations factuelles ; verify_facts() vérifie chaque affirmation (True/False/Uncertain) ; enfin revise_text() réécrit le texte en corrigeant les erreurs et en signalant les points incertains. Vous obtenez ainsi un résultat plus informatif et fiable.

Le chaînage intervient à plusieurs niveaux : génération initiale, extraction des faits, vérification, puis révision fondée sur ces vérifications.

Avec un sujet comme « the effects of climate change on polar bears », le code génère un texte, en extrait les faits, les vérifie et réécrit le texte final sur la base des faits validés. Vous pouvez évidemment choisir votre propre sujet.

Génération de code avec débogage

Utiliser le prompt chaining pour écrire puis tester du code accélère le développement. Cette méthode aide à s’assurer que le code fonctionne correctement et répond au besoin, au-delà d’une simple exécution sans erreur.

def generate_code(task):
    prompt = f"Write a Python function to {task}. Include comments explaining the code."
    return get_completion(prompt)

def generate_test_cases(code):
    prompt = f"Given the following Python code, generate 3 test cases to verify its functionality. Include both input and expected output for each test case:\n\n{code}"
    return get_completion(prompt)

def run_tests(code, test_cases):
    prompt = f"""
    Given the following Python code and test cases, run the tests and report the results. 
    If any tests fail, explain why and suggest fixes.
    Code:
    {code}
    Test Cases:
    {test_cases}
    For each test case, respond with:
    1. "PASS" if the test passes
    2. "FAIL" if the test fails, along with an explanation of why it failed and a suggested fix
    """
    return get_completion(prompt)

def debug_code(code, test_results):
    prompt = f"""
    Given the following Python code and test results, debug the code to fix any issues.
    Provide the corrected code along with explanations of the changes made.
    Original Code:
    {code}
    Test Results:
    {test_results}
    """
    return get_completion(prompt)

def code_generation_with_debugging(task):
    print(f"Generating code for task: {task}")
    # Step 1: Generate initial code
    initial_code = generate_code(task)
    print("\nInitial Code:")
    print(initial_code)
    # Step 2: Generate test cases
    test_cases = generate_test_cases(initial_code)
    print("\nGenerated Test Cases:")
    print(test_cases)
    # Step 3: Run tests
    test_results = run_tests(initial_code, test_cases)
    print("\nTest Results:")
    print(test_results)
    # Step 4: Debug code if necessary
    if "FAIL" in test_results:
        print("\nDebugging code...")
        debugged_code = debug_code(initial_code, test_results)
        print("\nDebugged Code:")
        print(debugged_code)    
        # Optionally, you can run tests again on the debugged code
        print("\nRe-running tests on debugged code...")
        final_test_results = run_tests(debugged_code, test_cases)
        print("\nFinal Test Results:")
        print(final_test_results)    
        return debugged_code
    else:
        print("\nAll tests passed. No debugging necessary.")
        return initial_code

# Example usage
task = "calculate the factorial of a number"
final_code = code_generation_with_debugging(task)
La fonction code_generation_with_debugging() pilote l’ensemble : generate_code() écrit le code Python, generate_test_cases() crée des tests, run_tests() évalue le code, et debug_code() corrige si nécessaire.
Chaque étape s’appuie sur la précédente : écrire, tester, corriger. On décompose ainsi le développement en sous-étapes plus simples. Le prompt chaining se montre apte à gérer des tâches sophistiquées comme la programmation, en reproduisant le cycle réel des développeurs.
Avec un objectif comme « calculate the factorial of a number », le code génère une première version, crée des tests, simule leur exécution, signale les résultats et tente de corriger puis de re-tester en cas d’échec.
Tâches de raisonnement multi‑étapes
Le prompt chaining permet de résoudre des problèmes nécessitant plusieurs étapes de raisonnement, comme des problèmes mathématiques rédigés ou des casse-têtes logiques. Chaque étape s’appuie sur la précédente pour une approche structurée et rigoureuse.
def solve_step_by_step(problem):
    steps = []
    current_problem = problem
    while True:
        prompt = f"Solve the following problem step by step. Provide the next step only and explain it clearly:\n\n{current_problem}"
        step = get_completion(prompt)
        if step is None or "solution" in step.lower():
            break
        steps.append(step)
        current_problem = f"{current_problem}\n\n{step}"
        print(f"Step {len(steps)}: {step}\n")
    return steps

def combine_steps(steps):
    combined_steps = "\n".join(steps)
    prompt = f"Combine the following steps into a coherent solution for the problem:\n\n{combined_steps}"
    return get_completion(prompt)

def multi_step_reasoning(problem):
    print(f"Solving problem: {problem}")    
    # Step 1: Solve step by step
    steps = solve_step_by_step(problem)    
    # Step 2: Combine steps into a final solution
    final_solution = combine_steps(steps)
    print("\nFinal Solution:")
    print(final_solution)
    return final_solution

# Example usage
problem = "A car travels 60 miles per hour for 2 hours, then 40 miles per hour for 3 hours. What is the total distance traveled by the car?"
final_solution = multi_step_reasoning(problem)
D’abord, solve_step_by_step() décompose le problème en étapes, en sollicitant le modèle une étape à la fois jusqu’à la fin. Chaque étape est conservée. Ensuite, combine_steps() assemble ces étapes en une solution claire. La fonction get_completion() gère les échanges avec l’API OpenAI tout du long.
Dans cet exemple : « Une voiture roule à 60 miles/h pendant 2 heures, puis à 40 miles/h pendant 3 heures. Quelle est la distance totale parcourue ? »
À l’exécution, le problème est décomposé en étapes de raisonnement, affiché à chaque étape, puis regroupé en une solution finale.
Bonnes pratiques pour le prompt chaining
Pour maximiser l’efficacité du chaînage, suivez quelques bonnes pratiques. Elles rendent vos chaînes plus robustes, précises et efficientes, et améliorent la fiabilité de vos applications LLM.
Conception des prompts
Des prompts clairs et concis sont essentiels pour de bons résultats. Des demandes directes facilitent la compréhension par le modèle, réduisent l’ambiguïté et améliorent la qualité des réponses.
Quelques conseils :

Privilégier un langage simple : éviter le jargon inutile.
Aller droit au but : formuler clairement la demande, sans détour.
Se concentrer sur une seule tâche : chaque prompt doit traiter une question ou une tâche unique. 

Par exemple :

Au lieu de : « Pouvez-vous résumer les points clés des tendances historiques des températures mondiales sur le siècle écoulé, en mettant l’accent sur les changements significatifs et leurs causes potentielles, ainsi que les événements notables susceptibles de les avoir influencées ? »
Préférez : « Résumez les points clés des tendances historiques des températures mondiales au cours du dernier siècle. »

Des prompts bien structurés aident aussi le LLM à suivre le fil logique de la tâche. Une organisation claire favorise des réponses adaptées.
Conseils :

Décomposer les tâches complexes : en étapes successives gérables.
Assurer un enchaînement logique : chaque prompt s’appuie sur le précédent et mène naturellement au suivant.

Structurer vos prompts de cette manière guide le LLM étape par étape pour des réponses plus justes. Par exemple :

Étape 1 : « Dressez les principaux changements de température mondiale au cours du dernier siècle. »
Étape 2 : « Identifiez les causes potentielles de chacun de ces changements. »

Expérimentation
Chaque tâche requiert un enchaînement différent. Tester plusieurs approches et comparer les résultats vous aide à choisir la plus adaptée et à obtenir de meilleures performances.
Évaluez régulièrement l’efficacité de vos chaînes de prompts : précision, complétude, pertinence des sorties. Cette démarche vous permet d’identifier les axes d’amélioration et d’ajuster vos prompts en continu.
Affinage itératif
L’affinage itératif basé sur les retours et les résultats conduit à des prompts plus efficaces. En collectant les retours, en repérant les lacunes et en ajustant vos formulations, vous améliorez progressivement les performances du LLM. Par exemple :

Prompt initial : « Décrivez l’impact du changement climatique. »
Prompt affiné : « Décrivez l’impact du changement climatique sur les écosystèmes côtiers au cours de la dernière décennie. »

Optimiser la structure de la chaîne
La façon d’ordonner vos prompts influe fortement sur le résultat. Ajustez l’ordre et la logique selon vos observations pour que chaque étape s’enchaîne de manière naturelle et augmente la qualité des réponses.
Gestion des erreurs
Une gestion robuste des erreurs permet à la chaîne de continuer même si un prompt individuel échoue. En définissant des contrôles de validité et des prompts de repli, vous maintenez le cap et la fiabilité globale.
Suivi et journalisation
Surveillez les performances de vos chaînes de prompts pour comprendre ce qui fonctionne et identifier les problèmes. Journalisez les entrées, les sorties, les temps de réponse, les erreurs. En documentant chaque étape et en stockant ces informations proprement, vous pouvez analyser, diagnostiquer et optimiser vos chaînes dans la durée.
Des traces détaillées facilitent le débogage et l’amélioration continue. Vous affinez ainsi vos chaînes pour de meilleures performances et des réponses plus fiables.
En appliquant ces bonnes pratiques, vous concevrez des chaînes de prompts efficaces et fiables qui renforcent les capacités des LLM et améliorent la qualité des résultats sur de nombreux cas d’usage.
Conclusion
Dans cet article, nous avons exploré le prompt chaining, une technique qui améliore les performances des LLM sur des tâches complexes en les décomposant en prompts plus simples. Nous avons vu différentes méthodes de chaînage, leurs applications et les bonnes pratiques pour exploiter les LLM dans un large éventail de cas.
Pour aller plus loin en prompt engineering, nous vous recommandons ces articles :

Prompt compression : guide avec exemples en Python
Buffer of Thoughts (BoT)
Qu’est-ce que DSPy ? Fonctionnement, cas d’usage et ressources
Comprendre le prompt tuning