Grundläggande tekniker inom Prompt Engineering

Prompt engineering omfattar en mängd olika tekniker och metoder som syftar till att optimera interaktionen med stora språkmodeller (LLM) för att uppnå önskade resultat. Dessa tekniker rör strukturering av förfrågningar, tillhandahållande av kontext, hantering av utdatastil och förbättring av modellens förmåga till resonemang. Eftersom LLM genererar svar genom att förutsäga nästa token baserat på den inmatade prompten, påverkar kvaliteten och strukturen hos denna prompt direkt resultatet. De grundläggande teknikerna inom prompt engineering gör det möjligt för utvecklare och användare att effektivt styra modellens beteende, minska fel och anpassa den till specifika uppgifter utan att behöva ändra modellens interna parametrar.

Grundläggande principer och promptstruktur

Även om specifika implementeringar varierar, byggs effektiva prompts ofta upp med hänsyn till gemensamma principer och strukturer:

• Empiriska riktlinjer: Som en praktisk struktur (men inte en branschstandard) föreslås följande principer: Ge Riktning, Ange Format, Ge Exempel, Bedöm Kvalitet och Dela upp Uppgiften.
• En effektiv prompt innehåller ofta följande komponenter:
  • Introduktion/Roll: Anger uppgiftens kontext eller modellens roll/persona.
  • Instruktioner: Tydliga anvisningar om vad som ska göras.
  • Kontext: Nödvändig information (statisk eller dynamiskt hämtad via RAG).
  • Exempel (Few-shot): Demonstration av önskat format/stil.
  • Svarsbegäran: Explicit angivelse av vad modellen ska generera.

• Systemmeddelande (System Prompt): I API-chattgränssnitt (t.ex. hos modeller från OpenAI, Anthropic) möjliggör detta att globala instruktioner och roller ställs in för hela sessionen.
• Formatering: Användning av Markdown, JSON, XML eller YAML hjälper till att strukturera prompten och underlättar parsning av svaret. Avgränsare (```, `\"\"\"`, XML-taggar) är viktiga för att skilja instruktioner från data.

Grundläggande tekniker för instruktioner och exempel

• Tydliga och specifika instruktioner: Beskriv uppgiften, önskat resultat och begränsningar så exakt som möjligt. Undvik tvetydighet.
• Rollmodellering (Role Prompting): Tilldelning av en roll till modellen ("Du är en expert på...") för att styra ton, stil och kunskapsbas.
• Zero-shot Prompting: Förfrågan utan exempel. Effektivt för enkla uppgifter eller uppgifter som modellen känner väl till.
• Few-Shot Prompting: Tillhandahållande av några (vanligtvis 2 till 5) exempel på fråga-svar för att demonstrera uppgiften. Ett specialfall är One-shot Prompting med ett enda exempel. Särskilt användbart för komplexa format eller stilar. Kräver försiktighet för att undvika förankringseffekter (anchoring) eller att modellen fångar upp falska mönster från exemplen.

Tekniker för kontexthantering

• Retrieval-Augmented Generation (RAG): Dynamiskt tillägg av relevant information från externa kunskapsbaser till prompten innan den skickas till LLM. Metoden, som först föreslogs av Meta AI år 2020, är central för att bekämpa hallucinationer och säkerställa aktualitet hos data.
• Chunkning (Chunking): Uppdelning av stora texter i mindre delar (chunks) för att rymmas inom modellens kontextfönster. Strategier inkluderar uppdelning efter meningar, stycken eller tokens (med överlappning).
• Sammanfattning: Komprimering av långa texter eller dialoghistorik för att förmedla det väsentliga innehållet inom en begränsad kontext.

Tekniker för förbättrat resonemang (Reasoning)

Dessa tekniker syftar till att få modellen att \"tänka\" mer noggrant och strukturerat. Effektiviteten hos många av dem, särskilt CoT, visar sig i modeller av stor skala (vanligtvis mer än 100 miljarder parametrar).

• Chain-of-Thought (CoT): Instruktion till modellen att generera ett steg-för-steg-resonemang innan det slutliga svaret. Förbättrar avsevärt resultaten inom matematik, logik och flerstegsuppgifter.
  • Zero-shot CoT: Den enklaste formen, som inte kräver exempel. Att lägga till en fras som \"Låt oss tänka steg för steg\" (Let's think step by step) i prompten räcker för att starta en tankkedja.
• Varianter av CoT:
  • Auto-CoT: Automatisk generering av resonemangsexempel för few-shot prompting.
  • Self-Consistency: Generering av flera tankekedjor och val av det vanligast förekommande svaret genom \"röstning\", vilket ökar tillförlitligheten.
  • Tree-of-Thoughts (ToT): Utforskning av flera resonemangsvägar i form av ett träd, med möjlighet till backtracking och utvärdering av mellanliggande steg. Denna teknik visar hög effektivitet vid komplexa uppgifter, t.ex. genom att öka framgångsgraden för \"Game of 24\" från ~4% till ~74%.
  • Graph-of-Thought (GoT), LogiCoT och andra, inriktade på mer komplexa eller logiskt verifierade resonemang.
• ReAct (Reason and Act): En teknik som vidareutvecklar CoT. Den utgörs av en iterativ cykel där modellen växelvis utför steg av Resonemang (Thought) och Handling med hjälp av Verktyg (Act), och uppdaterar sin förståelse baserat på Observationer (Observation).
• Self-Refine: En iterativ process där modellen först genererar ett svar, sedan kritiserar det och slutligen förbättrar det baserat på sin egen kritik. Denna cykel av \"generering–kritik–förbättring\" kan upprepas flera gånger.
• Take a Step Back Prompting: Modellen formulerar först allmänna principer eller abstraktioner och tillämpar dem sedan på den specifika uppgiften.

Avancerade tekniker: agenter och verktyg

• Verktygsinvändning (Tool Usage) / Funktionsanrop (Function Calling): Möjliggör för LLM att anropa externa API:er (sökning, kalkylator, databas). Modellen genererar en strukturerad begäran om verktygsinvändning som utförs av applikationen, varefter resultatet returneras till modellen. Moderna LLM (GPT-4, Claude 3) har inbyggt stöd för denna funktion.
• Agenter (Agents): System baserade på LLM som autonomt kan planera, använda verktyg och agera för att uppnå ett mål. Använder ofta ReAct-liknande cykler. Ramverk (LangChain, AutoGen, CrewAI) förenklar skapandet av dem.
• Multiagentsystem: Samverkan mellan flera specialiserade agenter för att lösa komplexa uppgifter.

Tekniker för att minska fel och hallucinationer

• RAG: Förankrar svar i hämtade faktauppgifter.
• Instruktioner för att begränsa svar: Krav på att svara enbart utifrån tillhandahållen kontext eller att ange osäkerhet ("Om svaret är okänt, säg 'Jag vet inte'").
• Begäran om källhänvisning: Krav på att modellen anger källor eller citerar delar av kontexten som svaret grundas på.
• Verifiering och självkritik: Användning av tekniker som Chain-of-Verification (CoVe) (generering av svar följt av verifiering och korrigering), Self-Refine eller en direkt begäran till modellen att granska sitt svar efter fel.
• CoT: Steg-för-steg-resonemang kan i sig självt minska logiska fel.

Tekniker för utvärdering och iteration

Även om utvärdering är en separat process, utgör vissa aspekter av den en del av prompt engineering:

• A/B-testning av prompts: Jämförelse av effektiviteten hos olika versioner av prompts på samma uppgifter.
• Användning av LLM för utvärdering: Tillämpning av en kraftfull modell (t.ex. GPT-4) för att bedöma kvaliteten hos svar som genererats av en annan prompt eller modell (LLM-as-a-Judge).

Promptmönster

Vanliga återanvändbara strukturer:

• Personamönstret (Persona Pattern)
• Mönstret för anpassning av utdata (Output Customization Pattern)
• Mönstret för begäran om förtydliganden (Question Refinement Pattern)
• Mönstret för kognitiv verifiering/självkritik (Cognitive Verifier / Self-Critique Pattern)
• Mönstret för steg-för-steg-resonemang (Step-by-Step / Chain-of-Thought Pattern)
• Mallmönstret (Template Pattern)

Litteratur

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

Se även

• Stora språkmodeller
• Chain-of-Thought Prompting
• Hallucinationer och felaktiga svar från LLM