Core prompt engineering techniques (NL)

Prompt engineering omvat een verscheidenheid aan technieken en methoden die gericht zijn op het optimaliseren van de interactie met grote taalmodellen (LLM) om gewenste resultaten te behalen. Deze technieken hebben betrekking op het structureren van verzoeken, het verstrekken van context, het beheren van de uitvoerstijl en het verbeteren van het redeneertalent van het model. Omdat LLM's een antwoord genereren door de volgende tokens te voorspellen op basis van de invoerprompt, beïnvloeden de kwaliteit en structuur van deze prompt het resultaat direct. De belangrijkste technieken van prompt engineering stellen ontwikkelaars en gebruikers in staat om het gedrag van het model effectief te sturen, fouten te verminderen en het aan te passen aan specifieke taken zonder dat de interne parameters van het model hoeven te worden gewijzigd.

Basisprincipes en structuur van een prompt

Hoewel concrete implementaties variëren, worden effectieve prompts vaak opgebouwd aan de hand van gemeenschappelijke principes en structuren:

• Empirische richtlijnen: Als een van de praktische structuren (maar geen industriestandaard) wordt voorgesteld de volgende principes te hanteren: Geef Richting, Specificeer Formaat, Geef Voorbeelden, Beoordeel Kwaliteit en Splits de Taak.
• Een effectieve prompt bevat vaak de volgende componenten:
  • Inleiding/Rol: Stelt de context van de taak of de rol/persona van het model in.
  • Instructies: Duidelijke aanwijzingen wat er gedaan moet worden.
  • Context: Benodigde informatie (statisch of dynamisch opgehaald via RAG).
  • Voorbeelden (Few-shot): Demonstratie van het gewenste formaat/stijl.
  • Antwoordverzoek: Een expliciete aanwijzing wat het model moet genereren.

• Systeembericht (System Prompt): In API-chatinterfaces (zoals die van de modellen van OpenAI en Anthropic) maakt dit het mogelijk om globale instructies en een rol voor de gehele sessie in te stellen.
• Opmaak: Het gebruik van Markdown, JSON, XML of YAML helpt de prompt te structureren en vergemakkelijkt het verwerken van het antwoord. Scheidingstekens (```, `\"\"\"`, XML-tags) zijn belangrijk om instructies van gegevens te scheiden.

Basistechnieken voor instructies en voorbeelden

• Duidelijke en specifieke instructies: Beschrijf de taak, het gewenste resultaat en de beperkingen zo nauwkeurig mogelijk. Vermijd dubbelzinnigheid.
• Rolmodellering (Role Prompting): Het toewijzen van een rol aan het model ("Jij bent een expert in...") om de toon, stijl en kennisbasis te sturen.
• Zero-shot Prompting: Een verzoek zonder voorbeelden. Effectief voor eenvoudige of het model goed bekende taken.
• Few-Shot Prompting: Het verstrekken van enkele (doorgaans 2 tot 5) vraag-en-antwoord-voorbeelden om de taak te demonstreren. Een bijzonder geval is One-shot Prompting met één voorbeeld. Bijzonder nuttig voor complexe formaten of stijlen. Vereist voorzichtigheid om vertekening (anchoring) of het oppikken van valse patronen uit de voorbeelden te vermijden.

Technieken voor contextbeheer

• Retrieval-Augmented Generation (RAG): Het dynamisch toevoegen van relevante informatie uit externe kennisbanken aan de prompt vóór verzending naar het LLM. Deze methode, voor het eerst voorgesteld door Meta AI in 2020, is een sleutelmethode in de strijd tegen hallucinaties en het waarborgen van de actualiteit van gegevens.
• Chunking: Het opsplitsen van grote teksten in kleinere delen (chunks) om binnen het contextvenster van het model te blijven. Strategieën omvatten opsplitsing per zin, alinea of token (met overlapping).
• Samenvatting: Het comprimeren van lange teksten of de gespreksgeschiedenis om de kernbetekenis over te brengen binnen een beperkte context.

Technieken ter verbetering van redeneren (Reasoning)

Deze technieken zijn erop gericht het model "dieper" en meer gestructureerd te laten nadenken. De effectiviteit van veel van deze technieken, met name CoT, komt tot uiting bij grootschalige modellen (doorgaans meer dan 100 miljard parameters).

• Chain-of-Thought (CoT): Een instructie aan het model om stapsgewijze redenering te genereren vóór het uiteindelijke antwoord. Verbetert de resultaten aanzienlijk bij wiskunde, logica en meerstapstaken.
  • Zero-shot CoT: De eenvoudigste vorm, waarvoor geen voorbeelden nodig zijn. Het toevoegen van een zin als «Laten we stap voor stap redeneren» (Let's think step by step) aan de prompt kan al een redeneerketen in gang zetten.
• Variaties op CoT:
  • Auto-CoT: Automatische generatie van redeneervoorbeelden voor few-shot prompting.
  • Self-Consistency: Het genereren van meerdere redeneersketens en het selecteren van het meest voorkomende antwoord via \"stemming\", wat de betrouwbaarheid verhoogt.
  • Tree-of-Thoughts (ToT): Het verkennen van meerdere redeneerroutes in de vorm van een boom, met de mogelijkheid om terug te keren en tussenliggende stappen te evalueren. Deze techniek toont hoge effectiviteit bij complexe taken, bijvoorbeeld door de slagingskans voor het oplossen van \"Game of 24\" te verhogen van ~4% tot ~74%.
  • Graph-of-Thought (GoT), LogiCoT en andere, gericht op complexere of logisch geverifieerde redenering.
• ReAct (Reason and Act): Een techniek die voortbouwt op CoT. Het betreft een iteratieve cyclus waarbij het model afwisselend stappen van Redeneren (Thought) en Handelen met behulp van Gereedschappen (Act) uitvoert, waarbij het begrip wordt bijgewerkt op basis van Observaties (Observation).
• Self-Refine: Een iteratief proces waarbij het model eerst een antwoord genereert, dit vervolgens bekritiseert en ten slotte verbetert op basis van zijn eigen kritiek. Deze cyclus van \"genereren-bekritiseren-verbeteren\" kan meerdere malen worden herhaald.
• Take a Step Back Prompting: Het model formuleert eerst algemene principes of abstracties en past deze vervolgens toe op de specifieke taak.

Geavanceerde technieken: agenten en gereedschappen

• Gebruik van gereedschappen (Tool Usage) / Functieaanroep (Function Calling): Het bieden van de mogelijkheid aan het LLM om externe API's aan te roepen (zoeken, rekenmachine, databanken). Het model genereert een gestructureerd verzoek tot het aanroepen van een gereedschap, dat door de applicatie wordt uitgevoerd, waarna het resultaat wordt teruggegeven aan het model. Moderne LLM's (GPT-4, Claude 3) hebben ingebouwde ondersteuning voor deze functie.
• Agenten (Agents): Systemen gebaseerd op LLM's die autonoom kunnen plannen, gereedschappen gebruiken en handelen om een doel te bereiken. Maken vaak gebruik van ReAct-achtige cycli. Frameworks (LangChain, AutoGen, CrewAI) vereenvoudigen hun ontwikkeling.
• Multiagentsystemen: De interactie van meerdere gespecialiseerde agenten voor het oplossen van complexe taken.

Technieken voor het verminderen van fouten en hallucinaties

• RAG: Het verankeren van antwoorden aan opgehaalde feitelijke gegevens.
• Instructies voor het beperken van antwoorden: De eis om alleen te antwoorden op basis van de verstrekte context of om onzekerheid aan te geven (\"Als het antwoord onbekend is, zeg dan 'Ik weet het niet'\").
• Verzoek om bronvermelding: De eis aan het model om bronnen te vermelden of delen van de context te citeren waarop het antwoord is gebaseerd.
• Verificatie en zelfkritiek: Het gebruik van technieken zoals Chain-of-Verification (CoVe) (het genereren van een antwoord gevolgd door verificatie en correctie daarvan), Self-Refine of een direct verzoek aan het model om zijn antwoord op fouten te controleren.
• CoT: Stapsgewijze redenering kan op zichzelf logische fouten verminderen.

Technieken voor evaluatie en iteratie

Hoewel evaluatie een afzonderlijk proces is, maken sommige aspecten ervan deel uit van prompt engineering:

• A/B-testen van prompts: Het vergelijken van de effectiviteit van verschillende versies van prompts op dezelfde taken.
• Gebruik van LLM voor evaluatie: Het inzetten van een krachtig model (zoals GPT-4) om de kwaliteit te beoordelen van antwoorden die gegenereerd zijn door een andere prompt of een ander model (LLM-as-a-Judge).

Promptpatronen

Veelgebruikte herbruikbare structuren:

• Persona-patroon (Persona Pattern).
• Uitvoerkwalisatiepatroon (Output Customization Pattern).
• Verduidelijkingsverzoekpatroon (Question Refinement Pattern).
• Cognitief verificatie-/zelfkritiekpatroon (Cognitive Verifier / Self-Critique Pattern).
• Stapsgewijs redeneerpatroon (Step-by-Step / Chain-of-Thought Pattern).
• Sjabloonpatroon (Template Pattern).

Literatuur

• 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.

Zie ook

• Grote taalmodellen
• Chain-of-Thought Prompting
• Hallucinaties en onjuiste antwoorden van LLM's