Principales techniques du Prompt Engineering

Le Prompt Engineering (ou ingénierie de prompt) englobe diverses techniques et méthodes visant à optimiser l'interaction avec les grands modèles de langage (LLM) pour obtenir les résultats souhaités. Ces techniques concernent la structuration des requêtes, la fourniture de contexte, la gestion du style de sortie et l'amélioration de la capacité de raisonnement du modèle. Étant donné que les LLM génèrent une réponse en prédisant les tokens suivants sur la base du prompt d'entrée, la qualité et la structure de ce prompt influencent directement le résultat. Les principales techniques de prompt engineering permettent aux développeurs et aux utilisateurs de contrôler efficacement le comportement du modèle, de réduire les erreurs et de l'adapter à des tâches spécifiques sans avoir à modifier les paramètres internes du modèle.

Principes de base et structure d'un prompt

Bien que les implémentations spécifiques varient, les prompts efficaces sont souvent construits en tenant compte de principes et d'une structure communs :

• Repères empiriques : Une structure pratique (mais non une norme industrielle) suggère de suivre les principes suivants : Donner une Direction, Indiquer un Format, Fournir des Exemples, Évaluer la Qualité et Diviser la Tâche.
• Un prompt efficace inclut souvent les composants suivants :
  • Introduction/Rôle : Définit le contexte de la tâche ou le rôle/persona du modèle.
  • Instructions : Indications claires sur ce qui doit être fait.
  • Contexte : Informations nécessaires (statiques ou extraites dynamiquement via RAG).
  • Exemples (Few-shot) : Démonstration du format/style souhaité.
  • Demande de réponse : Indication explicite de ce que le modèle doit générer.

• Prompt système (System Prompt) : Dans les interfaces de chat via API (par exemple, pour les modèles d'OpenAI, Anthropic), il permet de définir des instructions globales et un rôle pour toute la session.
• Formatage : L'utilisation de Markdown, JSON, XML ou YAML aide à structurer le prompt et facilite l'analyse (parsing) de la réponse. Les délimiteurs (```, `"""`, balises XML) sont importants pour séparer les instructions des données.

Techniques de base pour les instructions et les exemples

• Instructions claires et spécifiques : Décrire la tâche, le résultat souhaité et les contraintes de la manière la plus précise possible. Éviter l'ambiguïté.
• Prompting de rôle (Role Prompting) : Attribuer un rôle au modèle ("Tu es un expert en...") pour gérer le ton, le style et la base de connaissances.
• Zero-shot Prompting : Une requête sans exemples. Efficace pour les tâches simples ou celles que le modèle connaît bien.
• Few-Shot Prompting : Fournir quelques exemples (généralement de 2 à 5) de paires "question-réponse" pour démontrer la tâche. Un cas particulier est le One-shot Prompting avec un seul exemple. Particulièrement utile pour les formats ou styles complexes. Nécessite de la prudence pour éviter les biais (anchoring) ou la détection de faux motifs à partir des exemples.

Techniques de gestion du contexte

• Retrieval-Augmented Generation (RAG) : Ajout dynamique d'informations pertinentes provenant de bases de connaissances externes dans le prompt avant de l'envoyer au LLM. Initialement proposée par Meta AI en 2020, cette méthode est essentielle pour lutter contre les hallucinations et garantir l'actualité des données.
• Chunking (Segmentation) : Diviser de longs textes en parties plus petites (chunks) pour respecter la fenêtre de contexte du modèle. Les stratégies incluent la division par phrases, paragraphes ou tokens (avec chevauchement).
• Summarisation (Synthèse) : Compresser de longs textes ou l'historique d'un dialogue pour transmettre l'essentiel dans un contexte limité.

Techniques pour améliorer le raisonnement (Reasoning)

Ces techniques visent à inciter le modèle à "penser" de manière plus approfondie et structurée. L'efficacité de beaucoup d'entre elles, en particulier le CoT, se manifeste sur des modèles à grande échelle (généralement plus de 100 milliards de paramètres).

• Chain-of-Thought (CoT) : Instruire le modèle de générer un raisonnement étape par étape avant de donner la réponse finale. Améliore considérablement les résultats en mathématiques, en logique et pour les tâches multi-étapes.
  • Zero-shot CoT : La forme la plus simple, ne nécessitant aucun exemple. L'ajout au prompt d'une phrase comme « Réfléchissons étape par étape » (Let's think step by step) peut suffire à déclencher une chaîne de raisonnement.
• Variations du CoT :
  • Auto-CoT : Génération automatique d'exemples de raisonnement pour le few-shot prompting.
  • Self-Consistency : Génération de plusieurs chaînes de raisonnement et sélection de la réponse la plus fréquente par un système de "vote", ce qui augmente la fiabilité.
  • Tree-of-Thoughts (ToT) : Exploration de plusieurs chemins de raisonnement sous forme d'arbre, avec la possibilité de revenir en arrière et d'évaluer les étapes intermédiaires. Cette technique démontre une grande efficacité dans les tâches complexes, par exemple en augmentant le taux de réussite pour la résolution du "Jeu des 24" d'environ 4 % à environ 74 %.
  • Graph-of-Thought (GoT), LogiCoT et d'autres, visant des raisonnements plus complexes ou logiquement vérifiés.
• ReAct (Reason and Act) : Une technique qui étend le CoT. Elle représente un cycle itératif où le modèle alterne entre des étapes de Raisonnement (Thought) et d'Action à l'aide d'Outils (Act), en mettant à jour sa compréhension sur la base d'Observations (Observation).
• Self-Refine : Un processus itératif dans lequel le modèle génère d'abord une réponse, puis la critique et, enfin, l'améliore sur la base de sa propre critique. Ce cycle "génération-critique-amélioration" peut être répété plusieurs fois.
• Take a Step Back Prompting : Le modèle formule d'abord des principes généraux ou des abstractions, puis les applique à la tâche spécifique.

Techniques avancées : agents et outils

• Utilisation d'outils (Tool Usage) / Appel de fonction (Function Calling) : Donner au LLM la capacité d'appeler des API externes (recherche, calculatrice, base de données). Le modèle génère une requête structurée pour appeler l'outil, qui est exécutée par l'application, et le résultat est renvoyé au modèle. Les LLM modernes (GPT-4, Claude 3) ont un support intégré pour cette fonctionnalité.
• Agents (Agents) : Systèmes basés sur les LLM qui peuvent planifier, utiliser des outils et agir de manière autonome pour atteindre un objectif. Ils utilisent souvent des cycles de type ReAct. Des frameworks (LangChain, AutoGen, CrewAI) simplifient leur création.
• Systèmes multi-agents : Interaction de plusieurs agents spécialisés pour résoudre des tâches complexes.

Techniques de réduction des erreurs et des hallucinations

• RAG : Lier les réponses à des données factuelles extraites.
• Instructions pour limiter la réponse : Exiger de répondre uniquement sur la base du contexte fourni ou d'indiquer une incertitude ("Si la réponse est inconnue, dis 'Je ne sais pas'").
• Demande de citation : Exiger que le modèle cite ses sources ou des parties du contexte sur lesquelles sa réponse est basée.
• Vérification et auto-critique : Utilisation de techniques telles que la Chain-of-Verification (CoVe) (génération d'une réponse suivie de sa vérification et de sa correction), Self-Refine, ou demander directement au modèle de vérifier ses propres erreurs.
• CoT : Le raisonnement étape par étape peut en soi réduire les erreurs logiques.

Techniques d'évaluation et d'itération

Bien que l'évaluation soit un processus distinct, certains de ses aspects font partie du prompt engineering :

• Test A/B de prompts : Comparaison de l'efficacité de différentes versions de prompts sur les mêmes tâches.
• Utilisation d'un LLM pour l'évaluation : Appliquer un modèle puissant (par exemple, GPT-4) pour évaluer la qualité des réponses générées par un autre prompt ou modèle (LLM-as-a-Judge).

Patrons de prompts (Prompt Patterns)

Structures réutilisables courantes :

• Patron Persona (Persona Pattern).
• Patron de Personnalisation de la Sortie (Output Customization Pattern).
• Patron de Demande de Clarification (Question Refinement Pattern).
• Patron de Vérification Cognitive / Auto-critique (Cognitive Verifier / Self-Critique Pattern).
• Patron de Raisonnement Étape par Étape (Step-by-Step / Chain-of-Thought Pattern).
• Patron de Modèle (Template Pattern).

Voir aussi

• Grands modèles de langage
• Chain-of-Thought Prompting
• Hallucinations et réponses incorrectes des LLM

Bibliographie

• Radford, A. et al. (2019). Language Models are Unsupervised Multitask Learners. PDF.
• Brown, T. B. et al. (2020). Language Models are Few-Shot Learners. arXiv:2005.14165.
• Lewis, P. et al. (2020). Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks. arXiv:2005.11401.
• Li, X. L.; Liang, P. (2021). Prefix-Tuning: Optimizing Continuous Prompts for Generation. arXiv:2101.00190.
• Liu, Y. et al. (2021). Fantastically Ordered Prompts and Where to Find Them: Overcoming Few-Shot Prompt Order Sensitivity. arXiv:2104.08786.
• Bai, Y. et al. (2022). Constitutional AI: Harmlessness from AI Feedback. arXiv:2212.08073.
• Wei, J. et al. (2022). Chain-of-Thought Prompting Elicits Reasoning in Large Language Models. arXiv:2201.11903.
• Wang, X. et al. (2022). Self-Consistency Improves Chain of Thought Reasoning in Language Models. arXiv:2203.11171.
• Kojima, T. et al. (2022). Large Language Models are Zero-Shot Reasoners. arXiv:2205.11916.
• Zhang, Z. et al. (2022). Automatic Chain of Thought Prompting in Large Language Models. arXiv:2210.03493.
• Zhou, D. et al. (2022). Least-to-Most Prompting Enables Complex Reasoning in Large Language Models. arXiv:2205.10625.
• Yao, S. et al. (2022). ReAct: Synergizing Reasoning and Acting in Language Models. arXiv:2210.03629.
• Besta, M. et al. (2023). Graph of Thoughts: Solving Elaborate Problems with Large Language Models. arXiv:2308.09687.
• Madaan, A. et al. (2023). Self-Refine: Iterative Refinement with Self-Feedback. arXiv:2303.17651.
• Schick, T. et al. (2023). Toolformer: Language Models Can Teach Themselves to Use Tools. arXiv:2302.04761.
• Rafailov, R. et al. (2023). Direct Preference Optimization: Your Language Model is Secretly a Reward Model. arXiv:2305.18290.
• Wang, Y. et al. (2023). Self-Instruct: Aligning Language Models with Self-Generated Instructions. arXiv:2212.10560.
• Yao, S. et al. (2023). Tree of Thoughts: Deliberate Problem Solving with Large Language Models. arXiv:2305.10601.
• Chen, S. Y. et al. (2023). Extending Context Window of Large Language Models via Positional Interpolation. arXiv:2306.15595.
• Chang, K. et al. (2024). Efficient Prompting Methods for Large Language Models: A Survey. arXiv:2404.01077.
• Genkina, D. (2024). AI Prompt Engineering Is Dead. IEEE Spectrum. [1].
• Li, Z. et al. (2024). Prompt Compression for Large Language Models: A Survey. arXiv:2410.12388.
• Liang, X. et al. (2024). Internal Consistency and Self-Feedback in Large Language Models: A Survey. arXiv:2407.14507.
• Han, H. et al. (2025). Retrieval-Augmented Generation with Graphs (GraphRAG). arXiv:2501.00309.
• Li, W. et al. (2025). A Survey of Automatic Prompt Engineering: An Optimization Perspective. arXiv:2502.11560.
• Wu, Z. et al. (2025). The Dark Side of Function Calling: Pathways to Jailbreaking Large Language Models. EMNLP 2025. PDF.
• Yang, B. et al. (2025). Hallucination Detection in Large Language Models with Metamorphic Relations. arXiv:2502.15844.