Core prompt engineering techniques (IT)

Il Prompt Engineering comprende una varietà di tecniche e metodologie volte a ottimizzare l'interazione con i grandi modelli linguistici (LLM) per ottenere i risultati desiderati. Queste tecniche riguardano la strutturazione delle richieste, la fornitura di contesto, la gestione dello stile di output e il miglioramento della capacità di ragionamento del modello. Poiché gli LLM generano risposte predicendo i token successivi sulla base del prompt in ingresso, la qualità e la struttura di tale prompt influenzano direttamente il risultato. Le tecniche principali di Prompt Engineering consentono a sviluppatori e utenti di gestire efficacemente il comportamento del modello, ridurre gli errori e adattarlo a compiti specifici senza necessità di modificarne i parametri interni.

Principi di base e struttura del prompt

Sebbene le implementazioni specifiche varino, i prompt efficaci sono spesso costruiti tenendo conto di principi e strutture comuni:

• Linee guida empiriche: Come struttura pratica (ma non standard di settore) si suggerisce di attenersi ai seguenti principi: Fornire una Direzione, Specificare il Formato, Fornire Esempi, Valutare la Qualità e Suddividere il Compito.
• Un prompt efficace include spesso i seguenti componenti:
  • Introduzione/Ruolo: Stabilisce il contesto del compito o il ruolo/persona del modello.
  • Istruzioni: Indicazioni chiare su cosa deve essere fatto.
  • Contesto: Informazioni necessarie (statiche o recuperate dinamicamente tramite RAG).
  • Esempi (Few-shot): Dimostrazione del formato/stile desiderato.
  • Richiesta di risposta: Indicazione esplicita di ciò che il modello deve generare.

• Messaggio di sistema (System Prompt): Nelle interfacce chat API (ad esempio nei modelli OpenAI, Anthropic) consente di definire istruzioni globali e il ruolo per l'intera sessione.
• Formattazione: L'uso di Markdown, JSON, XML o YAML aiuta a strutturare il prompt e facilita il parsing della risposta. I delimitatori (```, `"""`, tag XML) sono importanti per separare le istruzioni dai dati.

Tecniche principali di istruzioni ed esempi

• Istruzioni chiare e specifiche: Descrivere il compito, il risultato desiderato e i vincoli nel modo più preciso possibile. Evitare ambiguità.
• Role Prompting: Assegnare al modello un ruolo ("Sei un esperto di...") per gestire tono, stile e base di conoscenza.
• Zero-shot Prompting: Richiesta senza esempi. Efficace per compiti semplici o ben noti al modello.
• Few-Shot Prompting: Fornitura di alcuni esempi (di solito da 2 a 5) nel formato "domanda-risposta" per dimostrare il compito. Un caso particolare è il One-shot Prompting con un singolo esempio. Particolarmente utile per formati o stili complessi. Richiede attenzione per evitare distorsioni (anchoring) o l'apprendimento di pattern errati dagli esempi.

Tecniche di gestione del contesto

• Retrieval-Augmented Generation (RAG): Aggiunta dinamica di informazioni rilevanti provenienti da basi di conoscenza esterne al prompt prima dell'invio all'LLM. Proposto per la prima volta da Meta AI nel 2020, questo metodo è fondamentale per contrastare le allucinazioni e garantire l'aggiornamento dei dati.
• Chunking: Suddivisione di testi lunghi in parti più piccole (chunk) per rientrare nella finestra di contesto del modello. Le strategie includono la suddivisione per frasi, paragrafi, token (con sovrapposizione).
• Riassunto (Summarization): Compressione di testi lunghi o della cronologia del dialogo per trasmettere il significato essenziale in un contesto limitato.

Tecniche per il miglioramento del ragionamento (Reasoning)

Queste tecniche mirano a fare in modo che il modello "pensi" in modo più accurato e strutturato. L'efficacia di molte di esse, in particolare del CoT, si manifesta su modelli di grande scala (generalmente con più di 100 miliardi di parametri).

• Chain-of-Thought (CoT): Istruzione al modello di generare un ragionamento passo dopo passo prima della risposta finale. Migliora significativamente i risultati in matematica, logica e compiti a più fasi.
  • Zero-shot CoT: La forma più semplice, che non richiede esempi. L'aggiunta al prompt di una frase come «Ragioniamo passo dopo passo» (Let's think step by step) è già in grado di avviare la catena di ragionamento.
• Varianti del CoT:
  • Auto-CoT: Generazione automatica di esempi di ragionamento per il prompting few-shot.
  • Self-Consistency: Generazione di più catene di ragionamento e selezione della risposta più frequente tramite "votazione", il che aumenta l'affidabilità.
  • Tree-of-Thoughts (ToT): Esplorazione di più percorsi di ragionamento sotto forma di albero, con possibilità di backtracking e valutazione dei passi intermedi. Questa tecnica dimostra un'elevata efficacia in compiti complessi, ad esempio aumentando il tasso di successo nel "Game of 24" da circa il 4% a circa il 74%.
  • Graph-of-Thought (GoT), LogiCoT e altri, orientati a ragionamenti più complessi o verificati logicamente.
• ReAct (Reason and Act): Tecnica che sviluppa il CoT. Rappresenta un ciclo iterativo in cui il modello alterna passi di Ragionamento (Thought) e Azioni con l'uso di Strumenti (Act), aggiornando la propria comprensione sulla base delle Osservazioni (Observation).
• Self-Refine: Processo iterativo in cui il modello prima genera una risposta, poi la critica e infine la migliora sulla base della propria critica. Questo ciclo "generazione-critica-miglioramento" può ripetersi più volte.
• Take a Step Back Prompting: Il modello formula prima principi generali o astrazioni, per poi applicarli al compito specifico.

Tecniche avanzate: agenti e strumenti

• Utilizzo di strumenti (Tool Usage) / Chiamata di funzioni (Function Calling): Possibilità per l'LLM di richiamare API esterne (ricerca, calcolatrice, database). Il modello genera una richiesta strutturata di chiamata allo strumento, che viene eseguita dall'applicazione, e il risultato viene restituito al modello. I moderni LLM (GPT-4, Claude 3) dispongono di supporto nativo per questa funzionalità.
• Agenti (Agents): Sistemi basati su LLM che possono pianificare autonomamente, utilizzare strumenti e agire per raggiungere un obiettivo. Spesso utilizzano cicli simili a ReAct. I framework (LangChain, AutoGen, CrewAI) ne semplificano la creazione.
• Sistemi multi-agente: Interazione di più agenti specializzati per la risoluzione di compiti complessi.

Tecniche per la riduzione di errori e allucinazioni

• RAG: Ancoraggio delle risposte a dati fattuali recuperati da fonti esterne.
• Istruzioni per la limitazione della risposta: Richiedere di rispondere solo sulla base del contesto fornito o di segnalare l'incertezza ("Se la risposta non è nota, di' 'Non lo so'").
• Richiesta di citazioni: Richiedere al modello di indicare le fonti o citare le parti del contesto su cui si basa la risposta.
• Verifica e autocritica: Utilizzo di tecniche come la Chain-of-Verification (CoVe) (generazione di una risposta seguita dalla sua verifica e correzione), Self-Refine o richiesta diretta al modello di controllare la propria risposta alla ricerca di errori.
• CoT: Il ragionamento passo dopo passo di per sé può ridurre gli errori logici.

Tecniche di valutazione e iterazione

Sebbene la valutazione sia un processo separato, alcuni suoi aspetti fanno parte del Prompt Engineering:

• A/B Testing dei prompt: Confronto dell'efficacia di diverse versioni di prompt sugli stessi compiti.
• Utilizzo di LLM per la valutazione: Impiego di un modello potente (ad esempio GPT-4) per valutare la qualità delle risposte generate da un altro prompt o modello (LLM-as-a-Judge).

Pattern di prompt

Strutture riutilizzabili comuni:

• Pattern Persona (Persona Pattern).
• Pattern di Personalizzazione dell'Output (Output Customization Pattern).
• Pattern di Richiesta di Chiarimenti (Question Refinement Pattern).
• Pattern di Verifica Cognitiva / Autocritica (Cognitive Verifier / Self-Critique Pattern).
• Pattern di Ragionamento Passo dopo Passo (Step-by-Step / Chain-of-Thought Pattern).
• Pattern Modello (Template Pattern).

Vedi anche

• Grandi modelli linguistici
• Chain-of-Thought Prompting
• Allucinazioni e risposte errate degli LLM

Letteratura

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