Context engineering: cosa mettere nel contesto di un modello
Decidere cosa vede un modello o un agente, in quale momento, e cosa resta fuori
Un corso testuale completo sul context engineering, indipendente da qualunque fornitore: perché la qualità di un'applicazione basata su un modello dipende sempre più da ciò che il modello ha davanti e sempre meno dalla formulazione della richiesta. Si vede di cosa è fatto il contesto, quanto costa in spazio, tempo e qualità, come si scelgono i documenti da includere, come si riassume una sessione lunga senza perdere ciò che conta, quando separare il lavoro in contesti diversi, cosa salvare in memoria fra una sessione e l'altra, come progettare i risultati degli strumenti, come proteggere il contesto dai contenuti non fidati e come misurare l'effetto di ogni scelta. Al superamento della prova finale viene emesso un attestato di frequenza con Open Badge verificabile.
- Spiegare cosa si intende per context engineering e perché il problema si è spostato dalla formulazione del prompt al contenuto del contesto
- Scomporre il contesto di una chiamata nelle sue componenti e disporle in base a stabilità, autore e affidabilità
- Riconoscere i costi del contesto in spazio, latenza e qualità, e trattarlo come una risorsa scarsa anche quando la finestra è grande
- Scegliere fra precaricamento e recupero su richiesta, e riconoscere quando non recuperare affatto
- Progettare una compattazione che conserva obiettivo, vincoli, decisioni e identificativi esatti
- Usare contesti separati e memoria persistente senza perdere informazioni né propagare errori da una sessione all'altra
- Proteggere il contesto dai contenuti non fidati e misurare l'effetto delle scelte con confronti ed esperimenti di rimozione
Prerequisiti
- Il corso Prompt Engineering Operativo, o un'esperienza equivalente nello scrivere prompt per sistemi reali
- Il corso Agenti AI: come funzionano davvero, o una conoscenza di base di come un agente usa gli strumenti in un ciclo
- Saper leggere un JSON e un file di testo strutturato: non si scrive codice durante il corso
Capitolo 01
Dal prompt al contesto: perché il problema si è spostato
Per qualche anno la domanda pratica, con i modelli linguistici, è stata come scrivere la richiesta. Il prompt era quasi tutto ciò che il modello leggeva: un'istruzione, forse qualche esempio, il testo da elaborare. Migliorare il risultato voleva dire migliorare quelle righe. Oggi, in un'applicazione reale, il testo scritto a mano da qualcuno è spesso una parte minoritaria di ciò che il modello riceve. Il resto arriva da documenti recuperati, dalla cronologia della conversazione, dalle definizioni degli strumenti, dai risultati delle chiamate precedenti, da note salvate in sessioni passate. Il problema non è sparito: si è spostato da come si scrive a che cosa si mette dentro.
Context engineering è il nome che si è diffuso per questo lavoro: progettare, a ogni chiamata, l'insieme di informazioni che il modello ha davanti. È una definizione volutamente ampia. Comprende la scelta dei documenti, il modo in cui una conversazione lunga viene riassunta, quali strumenti sono disponibili e quanto restituiscono, cosa viene ricordato da una sessione all'altra e in che ordine tutto questo viene presentato. Non è una disciplina inventata dal nulla: molte delle sue pratiche esistevano già sotto altri nomi. Il termine è utile perché le riunisce sotto un'unica domanda — cosa deve vedere il modello, adesso, per fare bene questo passo — invece di trattarle come problemi separati.
La ragione per cui il problema è cresciuto è soprattutto agentica. Una singola chiamata ha un contesto che si progetta una volta e poi resta fermo. Un agente, invece, lavora in un ciclo: a ogni passo legge, decide, chiama uno strumento, e il risultato si aggiunge a ciò che leggerà al passo successivo. Il contesto non è più un testo che scrivi, ma uno stato che evolve, in parte per decisione del modello stesso. Dopo molti passi può contenere materiale che nessuno ha scelto consapevolmente: risultati ormai inutili, tentativi falliti, pagine lette una volta e mai più. Il corso Agenti AI introduce questo problema nel capitolo su memoria e contesto; qui lo si affronta come un lavoro di progetto a sé.
Conviene dire subito cosa il context engineering non è. Non è riempire la finestra il più possibile, nella speranza che il modello trovi da solo ciò che serve: più contesto non significa risultati migliori, e il capitolo 3 spiega perché. Non sostituisce il prompt engineering: le istruzioni restano una parte del contesto, e scriverle bene resta necessario — il corso Prompt Engineering Operativo ne è la base. E non è un trucco di formulazione per convincere il modello: è una decisione di architettura, che si prende più spesso nel codice che assembla la chiamata che nel testo delle istruzioni.
Il modo più utile di pensarci è come a un budget di attenzione. Ogni elemento nel contesto compete con gli altri per influenzare la risposta. Un elemento pertinente aiuta; uno irrilevante distrae; uno sbagliato o superato può portare fuori strada con la stessa forza di uno corretto. Il lavoro ha quindi due facce: far arrivare al modello ciò che gli serve, nel momento in cui gli serve, e tenere fuori tutto il resto. I prossimi capitoli seguono questo filo: di cosa è fatto il contesto, quanto costa, come si sceglie, come si riassume, come si separa, cosa si ricorda, come lo riempiono gli strumenti, quali rischi porta e come si misura l'effetto di ogni scelta.
Capitolo 02
Di cosa è fatto il contesto: istruzioni, cronologia, documenti, strumenti, memoria
Prima di decidere cosa includere bisogna sapere cosa c'è. Nel contesto di una chiamata a un modello si riconoscono di solito cinque famiglie di contenuto. Le istruzioni: regole, ruolo, formato, vincoli, scritte da chi costruisce l'applicazione. La cronologia: i turni precedenti della conversazione o i passi precedenti dell'agente, comprese le sue chiamate. I documenti: materiale di riferimento inserito per questa richiesta, recuperato da una base di conoscenza o allegato dall'utente. Gli strumenti: le definizioni di ciò che il modello può chiamare, e i risultati delle chiamate già fatte. La memoria: informazioni conservate in sessioni precedenti e reintrodotte all'inizio di questa.
Classificarle serve perché differiscono su tre assi che guidano ogni decisione successiva. Il primo è l'autore: le istruzioni le scrivi tu; documenti e risultati degli strumenti li scrive spesso qualcun altro; la memoria può averla scritta il modello stesso. L'autore determina quanto ci si può fidare di un contenuto, tema del capitolo 9. Il secondo è la stabilità: le istruzioni cambiano di rado, la cronologia cresce a ogni passo, i documenti cambiano a ogni richiesta. Il terzo è chi decide che un contenuto entri: alcune parti le inserisce il codice in modo deterministico, altre le sceglie il modello quando chiama uno strumento di ricerca o di lettura.
[ISTRUZIONI DI SISTEMA] stabile · scritte da te
ruolo, regole, formato, divieti
[DEFINIZIONI DEGLI STRUMENTI] stabile · scritte da te o da un server esterno
cerca_documenti, leggi_ordine, ...
[MEMORIA] cambia di rado · scritta in sessioni passate
convenzioni del progetto, preferenze dell'utente
[DOCUMENTI DI QUESTA RICHIESTA] cambia a ogni richiesta · autori esterni
<documento id="POL-07" fonte="intranet" data="2026-03-02"> ... </documento>
[CRONOLOGIA E RISULTATI] cresce a ogni passo · in parte non fidata
turni precedenti, chiamate agli strumenti, risultati
[RICHIESTA CORRENTE] cambia a ogni passoL'ordine non è un dettaglio estetico. Mettere in cima le parti stabili e in fondo quelle variabili ha un vantaggio pratico: molti fornitori offrono una forma di cache del prefisso, che riusa l'elaborazione della parte iniziale del contesto quando resta identica fra una chiamata e l'altra, con un risparmio di costo e di tempo. Un dato variabile inserito in cima — un orario, un identificativo di sessione — rende diverso tutto ciò che segue e annulla il vantaggio. C'è poi un effetto sulla qualità: nella pratica si osserva spesso che la richiesta posta dopo i documenti lunghi, vicino alla fine del contesto, viene seguita meglio di quella posta prima. Quanto conti nel tuo caso lo dice la valutazione del capitolo 10, non una regola generale. Lo stesso vale per i contenuti di affidabilità diversa: tenere le istruzioni separate dai contenuti esterni, mai mescolate, rende evidente al modello — e a chi rilegge i log — dove finiscono le regole e dove comincia il materiale da elaborare.
Un'ultima distinzione evita molti errori: quella fra ciò che il modello vede e ciò che il sistema sa. Il sistema può avere a disposizione l'intero storico di un cliente, tutti i file di un progetto, il risultato completo di ogni strumento. Il modello vede solo ciò che è nella finestra in quel momento. Tenere i dati completi fuori dal contesto e farne entrare soltanto una vista — un estratto, un riassunto, un riferimento da cui recuperare il resto — è la mossa fondamentale di tutto il corso. Ciò che non è nel contesto non è perso: semplicemente non è ancora stato caricato, e lo si può caricare quando serve.
Capitolo 03
Il contesto ha un costo: spazio, latenza e qualità che cala quando cresce
Ogni elemento nel contesto ha tre costi, e solo il primo si vede subito. Il primo è lo spazio: la finestra di contesto è finita, e tutto ciò che vi entra — istruzioni, definizioni degli strumenti, documenti, cronologia — toglie posto al resto. In un agente il conto cresce a ogni passo, perché ogni risultato si aggiunge e di norma resta. Le definizioni degli strumenti sono un costo che si dimentica spesso: occupano spazio in ogni chiamata, anche in quelle in cui nessuno strumento viene usato, e un agente collegato a molti strumenti può spendere una parte importante della finestra solo per sapere cosa potrebbe fare.
Il secondo costo è di denaro e di tempo. Nella maggior parte delle API si paga in proporzione al testo in ingresso, e un testo più lungo richiede più tempo di elaborazione prima che arrivi la prima parola della risposta. In un agente questi costi si moltiplicano: ogni passo rilegge l'intero contesto accumulato fino a quel momento, quindi un risultato voluminoso ottenuto all'inizio viene ripagato a ogni passo successivo. Il corso Prompt Engineering Operativo descrive le leve generali su costo e latenza; qui conta un punto specifico: nel ciclo di un agente il costo di un elemento non dipende solo da quanto è grande, ma da quanti passi resta nel contesto.
Il terzo costo è il meno intuitivo e il più importante: la qualità. Sarebbe naturale pensare che un modello con più informazioni risponda meglio, o al peggio uguale. Nella pratica si osserva spesso il contrario. Con contesti molto lunghi i modelli tendono a usare in modo meno affidabile ciò che contengono: un dettaglio presente nella finestra può essere trascurato, soprattutto se si trova in mezzo a molto materiale simile; istruzioni date all'inizio possono essere seguite con meno costanza dopo molti passi; un'informazione superata rimasta nel contesto può prevalere su quella aggiornata. Fra chi costruisce questi sistemi il fenomeno viene a volte chiamato context rot, degrado del contesto. Quanto sia marcato varia da modello a modello e da compito a compito, e i modelli migliorano; la tendenza, però, è abbastanza ricorrente da dover essere progettata, non ignorata.
Un modo intuitivo di capirlo è pensare all'attenzione del modello come a una risorsa distribuita su tutto ciò che legge. Il materiale irrilevante non è neutro: compete con quello rilevante, e quando gli somiglia compete con più forza. Per questo il danno maggiore non viene dal rumore evidente, che il modello scarta con facilità, ma dal materiale plausibile e sbagliato: la vecchia versione di un contratto, il risultato di una ricerca su un cliente omonimo, un'ipotesi scartata molti passi prima ma rimasta scritta nella cronologia, due procedure quasi uguali di cui una non vale più.
Da qui la regola che regge il resto del corso: lo spazio di contesto si tratta come una risorsa scarsa anche quando la finestra è grande. Una finestra più ampia alza il limite tecnico, non rende gratuito ciò che vi si mette. L'obiettivo non è il contesto più corto possibile, ma il più piccolo insieme di informazioni che rende probabile il risultato giusto. A volte quell'insieme è grande — l'analisi di un contratto lungo richiede il contratto intero — e allora va incluso senza esitare. Ciò che va evitato è l'inclusione per inerzia: il materiale che è lì soltanto perché nessuno ha deciso di toglierlo.
Capitolo 04
Scegliere cosa includere: recuperare i documenti giusti, e quando non farlo
Per il materiale di riferimento ci sono due strategie, e quasi tutti i sistemi reali le combinano. Il precaricamento inserisce le informazioni prima che il modello cominci: il codice sceglie i documenti — per esempio con una ricerca sulla domanda dell'utente — e li mette nel contesto. Il recupero su richiesta dà invece al modello strumenti per cercare e leggere, e lascia che sia lui a decidere cosa caricare e quando. Il primo è prevedibile, veloce e facile da controllare; il secondo è flessibile e carica solo ciò che serve, ma richiede più passi e dipende dalla capacità del modello di cercare bene. Il corso Agenti AI indica il recupero su richiesta come scelta di norma per gli agenti; qui si vede come scegliere caso per caso.
Il criterio pratico è quanto il fabbisogno sia prevedibile. Se per un certo tipo di richiesta si sa in anticipo cosa serve — il regolamento interno per una domanda sulle ferie, la scheda del cliente per un ticket — il precaricamento è la scelta più semplice e più affidabile. Se il fabbisogno si scopre solo lavorando — indagare un errore in una base di codice, rispondere a una domanda che attraversa più documenti — il recupero su richiesta evita di caricare tutto per paura di dimenticare qualcosa. Una via di mezzo che funziona bene è precaricare riferimenti leggeri invece dei contenuti: l'elenco dei documenti disponibili, i percorsi dei file, i titoli con una riga di descrizione. Il modello sa cosa esiste e decide cosa aprire.
Documenti disponibili (apri con leggi_documento(id)):
- POL-07 Politica rimborsi, revisione corrente rimborsi, resi, tempi
- POL-12 Condizioni del contratto Business livelli di servizio, penali
- FAQ-03 Domande frequenti sulla fatturazione IVA, note di credito
- ARC-01 Politica rimborsi, revisione precedente SUPERATA da POL-07Quando si recupera, conta la qualità di ciò che arriva più della quantità. Un buon risultato di ricerca ha tre proprietà. È pertinente: un passaggio che risponde alla domanda, non un documento intero in cui la risposta è da qualche parte. È contestualizzato: porta con sé fonte, data e posizione, così che il modello sappia da dove viene e possa citarlo, e così che un frammento tolto da una tabella o da un elenco resti comprensibile anche fuori dal suo documento. È non ridondante: dieci passaggi quasi identici occupano il posto di dieci informazioni diverse. Recuperare pochi risultati buoni e lasciare che il modello ne chieda altri, se servono, funziona di solito meglio che recuperarne molti mediocri.
La decisione più trascurata è quella di non recuperare affatto. Non ogni richiesta ha bisogno di documenti: una riformulazione, un calcolo, una domanda di chiarimento all'utente. Un sistema che lancia sempre una ricerca riempie il contesto di materiale vagamente collegato, che il modello si sente poi in dovere di usare. Conviene non recuperare anche quando l'informazione è già nel contesto, o quando l'unica fonte disponibile è superata e un «non lo so» è preferibile a una risposta basata su un dato vecchio. E va tenuto presente il limite già visto nel corso Prompt Engineering Operativo: se il recupero non ha trovato il passaggio giusto, nessuna istruzione lo compensa. Il recupero va quindi misurato a parte, come mostra il capitolo 10.
Capitolo 05
Riassumere senza perdere: la compattazione, e cosa non va mai tagliato
La compattazione è la risposta più diretta al contesto che cresce: a un certo punto la storia accumulata viene sostituita da una sua versione condensata, e il lavoro continua da lì. Il corso Agenti AI ne descrive il principio e l'ordine di priorità di ciò che va conservato. Qui interessa come progettarla, perché una compattazione fatta male è peggio di nessuna: un contesto lungo è lento e costoso, ma contiene ancora tutto; un riassunto che ha perso un vincolo contiene un errore che nessuno vedrà più, perché la versione completa non è più davanti al modello.
Esistono più forme, da usare in ordine di aggressività. La più leggera è la pulizia dei risultati: i risultati degli strumenti ormai consumati — una pagina letta, l'output di un comando — vengono sostituiti da un segnaposto che ricorda che la chiamata è avvenuta e come ripeterla. È sicura perché non riscrive niente: toglie materiale che si può recuperare. Più incisiva è la compattazione per riassunto, in cui un modello riscrive la cronologia in una nota strutturata. La più radicale è ripartire con un contesto nuovo che contiene solo quella nota e lo stato salvato fuori, nei file o nel sistema, come il file di avanzamento visto per i compiti lunghi. Le forme reversibili vanno usate prima di quelle che riscrivono.
Il punto critico è cosa non si taglia mai. L'obiettivo nelle parole dell'utente, non parafrasato: ogni parafrasi sposta di poco il significato, e dopo alcune compattazioni l'obiettivo è diventato un altro. I vincoli espliciti, con chi li ha posti. Le decisioni prese e il loro motivo, perché senza il motivo il modello le rimetterà in discussione. Gli identificativi esatti — nomi di file, numeri d'ordine, codici — che un riassunto tende ad approssimare. Le strade tentate e scartate, che altrimenti verranno ritentate. Le domande ancora aperte. Si può invece togliere il dettaglio dei passaggi riusciti, già riflesso nello stato del lavoro, e i contenuti grezzi che si possono rileggere dalla fonte.
## Obiettivo (parole dell'utente, non parafrasare)
"Allinea i prezzi del listino B2B al nuovo cambio, senza toccare
i clienti con contratto bloccato."
## Vincoli (con chi li ha posti)
- Non modificare i clienti con contratto bloccato (utente, inizio sessione)
- Arrotondamento come nel listino attuale (amministrazione, email inoltrata)
## Decisioni prese e perché
- Lavoriamo su una copia del listino: l'originale alimenta il sito
## Stato
- Fatto: prima metà delle righe aggiornata e verificata
- Prossimo: seconda metà, poi confronto dei totali con l'originale
## Tentato e scartato
- Import diretto via API: rifiuta file di queste dimensioni
## Domande aperte
- I prezzi in franchi seguono lo stesso cambio? (chiesto, nessuna risposta)
## Riferimenti esatti
listino_b2b_copia.xlsx · clienti_bloccati.csvDue accorgimenti rendono la compattazione verificabile. Il primo è dare al riassunto una struttura fissa, come quella qui sopra, invece di chiedere genericamente di «riassumere la conversazione». Il secondo è controllare la nota prima di sostituire la cronologia, almeno nei flussi importanti: verificare nel codice che gli identificativi presenti nella cronologia compaiano anche nella nota, e conservare la cronologia completa fuori dal contesto, nei log, così che una perdita si possa diagnosticare. Il momento conta quanto il contenuto: compattare a un punto di passaggio naturale — un sotto-compito concluso, una fase chiusa — perde meno che compattare a metà di un ragionamento soltanto perché la finestra si è riempita. Infine, anche le istruzioni che producono il riassunto sono un prompt: vanno provate su cronologie reali, confrontando ciò che il modello riesce a fare dopo la compattazione con ciò che faceva prima, con il metodo del capitolo 10.
Capitolo 06
Separare i contesti: sotto-agenti e compiti isolati
La compattazione riduce il contesto dopo che si è riempito. La separazione evita che si riempia: un compito che richiede molto materiale ma produce un risultato piccolo viene eseguito in un contesto a parte, e nel contesto principale entra solo il risultato. È la stessa idea di una funzione in un programma, che lavora con variabili locali e restituisce un valore. Il corso Agenti AI discute quando un sistema a più agenti conviene in generale; qui lo si guarda da un solo punto di vista: che cosa entra in ciascun contesto, e che cosa passa dall'uno all'altro.
I candidati naturali sono i compiti esplorativi in cui ciò che si legge è molto più di ciò che si restituisce. Cercare in una base di codice dove nasce un certo errore può richiedere di aprire molti file, quasi tutti irrilevanti; la risposta utile sta in poche righe. Esaminare un documento lungo per estrarne le clausole sulle penali segue lo stesso schema. Fatti nel contesto principale, questi compiti lo lasciano pieno di materiale letto una volta; fatti in un contesto separato, lasciano solo la risposta. Il criterio è semplice: se di ciò che un compito legge servirà dopo solo una piccola parte, quel compito è un buon candidato. Quando i sotto-compiti sono davvero indipendenti, i contesti separati possono anche lavorare in parallelo e ridurre il tempo complessivo; il costo totale, però, non scende.
Il contesto di un sotto-agente è esattamente ciò che gli viene scritto nel compito, più ciò che legge da sé. Non vede la conversazione principale, non sa cosa ha detto l'utente molti turni prima, non conosce i vincoli che non gli vengono passati. Per questo il testo della delega è context engineering a pieno titolo: deve bastare a chi non sa nient'altro. Altrettanto importante è il formato di ritorno, da chiedere esplicitamente: cosa ha trovato, con i riferimenti esatti per verificarlo, dove ha cercato senza trovare, e quanto è sicuro. Un sotto-agente lasciato libero tende a restituire il racconto del proprio lavoro, e quel racconto finisce nel contesto principale.
COMPITO
Trova dove l'applicazione genera l'errore «sessione scaduta»
subito dopo il login.
GIÀ NOTO, DA NON RIFARE
- Il timeout di sessione nel file di configurazione è corretto: verificato.
VINCOLI
- Solo lettura: non modificare nessun file.
RESTITUISCI, IN POCHE RIGHE
- Trovato: file e riga di ogni punto in cui l'errore nasce
- Perché pensi che sia la causa, in due frasi
- Cercato senza trovare: dove hai guardato
- Certezza: alta / media / bassaLa separazione ha costi che vanno messi in conto. Ogni passaggio perde informazione: ciò che il sotto-agente non riporta, per il contesto principale non esiste. Il lavoro totale aumenta, perché il sotto-agente ricostruisce da sé parte del contesto che il principale aveva già. E due contesti separati che lavorano sullo stesso oggetto prendono decisioni implicite diverse che nessuno dei due vede. Ne discende una regola pratica: separare i compiti che leggono molto e decidono poco, tenere insieme quelli che decidono molto. Quando più contesti devono condividere informazioni ampie, conviene farle passare da un file o da un archivio che ciascuno legge quando serve, invece di copiarle in ogni messaggio. Il risultato di un sotto-agente, infine, si tratta come quello di uno strumento: un input da verificare, soprattutto se ha letto contenuti non fidati.
Capitolo 07
Memoria fra le sessioni: cosa salvare, come rileggerlo, come fermare un errore
Ogni sessione di un modello comincia da zero: ciò che sembra memoria è sempre un contenuto che il sistema reintroduce nel contesto, che sia una nota salvata, un profilo o un file di progetto. La memoria è quindi un caso particolare del problema di tutto il corso, con una complicazione in più: chi decide cosa salvare lo fa in una sessione, e chi lo rilegge lo fa in un'altra, senza sapere in quali condizioni la nota è stata scritta. Il corso Agenti AI spiega perché la memoria persistente è utile e delicata; qui si vede come progettarla.
Vale la pena salvare ciò che è costoso da riscoprire, stabile nel tempo e utile in più sessioni. In pratica rientra in poche categorie: fatti sull'ambiente, come l'organizzazione di un progetto o il comando che esegue i test; preferenze e decisioni dell'utente, da non riproporre ogni volta; lezioni apprese, come un problema già diagnosticato o un approccio che non funziona. Non vale la pena salvare ciò che si ricava in un attimo dalla fonte, ciò che cambia spesso — lo stato di un ticket, un saldo — né i dati personali o riservati che non devono passare da un contesto all'altro. Lo stato di un compito in corso ha già lo strumento adatto, il file di avanzamento, che vive e muore con il compito.
Ogni voce dovrebbe portare con sé da dove viene e quando è stata scritta. Una nota senza fonte né data viene riletta come un fatto; la stessa nota con l'indicazione del file e del giorno in cui è stata osservata viene riletta come un'osservazione da ricontrollare se è passato del tempo. Conviene anche separare ciò che è stato osservato da ciò che è stato dedotto: «il test fallisce in modo intermittente» è un'osservazione; «il test fallisce per un problema di rete» è un'ipotesi, e salvarla come fatto la trasforma in una certezza per tutte le sessioni future.
# Memoria di progetto: portale clienti
<!-- Ogni voce ha fonte e data. Prima di agire su una voce vecchia,
rileggi la fonte. -->
## Ambiente
- I test si lanciano con "make test", non con il comando predefinito
(fonte: Makefile, 2026-10-14)
## Decisioni dell'utente
- Nessuna nuova dipendenza senza chiedere (utente, 2026-10-02)
## Lezioni verificate
- L'export CSV falliva con i nomi accentati: problema di codifica,
corretto in export.py (osservato e verificato, 2026-10-20)
## Ipotesi non verificate
- La lentezza del login potrebbe dipendere dalla cache
(dedotto, non verificato, 2026-10-21)Rileggere la memoria pone lo stesso problema del capitolo 4: caricarla tutta a ogni sessione riempie il contesto di note irrilevanti per il compito di oggi. Quando cresce, conviene caricare all'avvio solo un indice breve e le voci sempre valide, e lasciare il resto a una ricerca su richiesta. Serve anche manutenzione: unire i doppioni, correggere le voci superate, cancellare quelle inutili. Il rischio specifico, però, è la propagazione. Un errore nel contesto di una sessione muore con la sessione; un errore salvato in memoria viene riletto in ogni sessione successiva con l'autorità di qualcosa che il sistema sa, e può generare nuove note che lo confermano. Le difese sono di processo: salvare solo ciò che è verificato, o marcarlo come ipotesi; rileggere la fonte prima di agire su una voce importante o vecchia; rendere la memoria leggibile e modificabile da una persona; e non lasciare che contenuti non fidati vi entrino senza controllo, tema del capitolo 9.
Capitolo 08
Gli strumenti come contesto: descrizioni, risultati e quanto restituire
Uno strumento entra nel contesto due volte. La prima con la sua definizione — nome, descrizione, parametri — che il modello legge in ogni chiamata in cui lo strumento è disponibile. La seconda con i suoi risultati, che restano nel contesto per tutti i passi successivi. Chi progetta uno strumento sta quindi scrivendo contesto, anche se pensa di scrivere un'API. I corsi Agenti AI e Prompt Engineering Operativo spiegano come si scrive una buona descrizione e perché gli errori devono essere leggibili; qui ci si concentra sul volume e sulla forma di ciò che entra.
Sul lato delle definizioni il problema è la quantità. Ogni strumento disponibile occupa spazio anche quando non viene usato, e strumenti simili competono fra loro nella scelta. Collegare un agente a tutto ciò che potrebbe servirgli, per sicurezza, peggiora sia il costo sia la scelta. Le contromisure sono tre: offrire per ogni compito solo il sottoinsieme di strumenti pertinente; accorpare in uno strumento solo le operazioni che il modello userebbe sempre in sequenza; e, quando gli strumenti sono davvero molti, caricarne le definizioni su richiesta, dando al modello un modo per cercare lo strumento giusto invece di elencarli tutti. Alcune piattaforme offrono questa ricerca come funzione propria, ma la si può costruire anche nel codice che assembla la chiamata.
Sul lato dei risultati la domanda è: cosa servirà al modello nei prossimi passi? Quasi mai il risultato grezzo. Un'API restituisce decine di campi tecnici, identificativi interni illeggibili, metadati di paginazione, valori nulli; al modello servono i campi utili per decidere, nomi riconoscibili e un identificativo da riusare nelle chiamate successive. I due risultati qui sotto rispondono alla stessa chiamata: il secondo occupa una frazione dello spazio, si legge senza ambiguità e dice cosa fare per avere il resto. Gli identificativi leggibili contano più di quanto sembri: un codice breve e significativo si ricopia da un passo all'altro con meno rischi di una lunga stringa casuale, e un identificativo ricopiato male produce una chiamata sbagliata che ha tutta l'aria di essere corretta.
{
"data": [{
"id": "8f3a2c1e-77b0-4d2e-9a51-0c6e2b9f1d44",
"obj_type": "order",
"created_ts": 1760003421,
"updated_ts": 1760091877,
"cust_ref": "a91e0f52-3b7c-4c11-8e2d-5f0a9b6c7d18",
"status_cd": 4,
"lines": [ ...trentasette oggetti con dieci campi ciascuno... ],
"shipping": { "carrier_id": 12, "tracking": null, "addr_id": "c3d9e1f0" },
"internal_flags": { "legacy_import": false, "audit_rev": 17 },
"currency": "EUR",
"total_cents": 184500
}],
"page": { "cursor": "eyJvZmZzZXQiOjUwfQ==", "has_more": true }
}{
"ordini": [
{
"ordine": "ORD-2291",
"cliente": "Ferri Arredamenti (C-10482)",
"stato": "spedito, tracciamento non ancora disponibile",
"data": "2026-10-09",
"totale": "1.845,00 EUR",
"righe": 37
}
],
"completo": false,
"nota": "Ci sono altri ordini di questo cliente. Per vederli: cerca_ordini(cliente='C-10482', pagina=2). Per le righe di un ordine: leggi_ordine(ordine='ORD-2291')."
}Tre accorgimenti completano il quadro. Il primo è lasciare al modello la scelta del livello di dettaglio, con un parametro esplicito — una risposta sintetica di default e una dettagliata su richiesta — invece di decidere una volta per tutte. Il secondo riguarda i risultati inevitabilmente grandi, come un file di log o l'esito di una query ampia: invece di riversarli nel contesto, lo strumento può salvarli fuori, in un file o in un archivio, e restituire un riepilogo con un riferimento da cui leggerne una parte. Il terzo, già visto nel corso Agenti AI, è non troncare mai in silenzio: un elenco tagliato senza dirlo induce il modello a concludere che non esiste altro, ed è una causa frequente di risposte sbagliate date con sicurezza. Un risultato ben progettato dice sempre se è completo.
Capitolo 09
Contesto e sicurezza: contenuti non fidati dentro la finestra
Il capitolo 2 ha classificato il contesto per autore. Sul piano della sicurezza quella classificazione diventa decisiva, per una ragione che i corsi Agenti AI e Prompt Engineering Operativo hanno già introdotto: il modello non distingue in modo affidabile fra le istruzioni di chi lo usa e il testo che legge mentre lavora. Ogni contenuto nella finestra può influenzarne il comportamento, chiunque l'abbia scritto. Dal punto di vista del context engineering ne discende un principio semplice: ogni canale che porta contenuto nel contesto è una possibile porta d'ingresso, e va trattato in base a chi può scriverci.
Le porte sono più di quanto sembri. Ci sono quelle ovvie: pagine web, email, documenti caricati, risultati di ricerca. Ce ne sono di meno ovvie: le descrizioni degli strumenti forniti da server di terze parti, che il modello legge come istruzioni e che possono contenerne di malevole; i risultati di un sotto-agente che ha letto materiale non fidato; e soprattutto i testi che il sistema stesso produce rielaborando contenuti esterni, come una nota di compattazione o una voce di memoria. Questi ultimi sono i più insidiosi, perché cancellano la provenienza: un'istruzione nascosta in una pagina, una volta riassunta, diventa una frase del sistema; salvata in memoria, viene riletta nelle sessioni future come conoscenza propria.
La prima contromisura è conservare la provenienza lungo tutto il percorso. I contenuti esterni entrano delimitati ed etichettati con la loro fonte; le istruzioni di compattazione chiedono di riportare ciò che viene da fonti non fidate come contenuto attribuito a quella fonte, mai come fatto accertato o come compito da svolgere; le voci di memoria nate da contenuti esterni non vengono salvate senza un controllo. Nessuna di queste misure rende il modello immune: servono a non perdere un'informazione che le difese successive, e le persone che rileggono, devono poter usare.
La seconda contromisura, più robusta, è architetturale: limitare ciò che può fare un contesto esposto a contenuti non fidati. Lo schema più solido separa la lettura dall'azione. Un contesto di lettura, senza strumenti con effetti e senza accesso a dati riservati, elabora il contenuto esterno e restituisce solo dati strutturati, con campi chiusi e valori che il codice valida. Il contesto che agisce riceve quei campi, non il testo originale. Un'istruzione nascosta in un'email può forse alterare la classificazione, ma non arriva come testo libero al contesto che ha i permessi per agire, e un valore fuori dall'insieme ammesso viene scartato dal codice.
{
"mittente_cliente_noto": true,
"categoria": "richiesta_rimborso",
"numero_ordine": "ORD-2291",
"importo_richiesto_eur": 184.50,
"lingua": "it"
}Infine, il contesto va considerato anche come un luogo da cui le informazioni possono uscire. Tutto ciò che vi si trova può finire, per errore o per manipolazione, in una risposta, nel parametro di una chiamata, in un log. Ne seguono due regole. Non mettere nel contesto segreti che il modello non deve usare: chiavi, password e token restano nel codice che esegue gli strumenti, e il modello riceve al massimo un riferimento. E includere solo i dati personali necessari al compito, perché il principio di minimizzazione vale per il contesto come per qualunque altro trattamento. Le regole che contano, come ricordano i corsi precedenti, si applicano nel codice: il contesto informa il modello, non lo vincola.
Capitolo 10
Misurare l'effetto: valutare le scelte di contesto prima e dopo
Ogni scelta di questo corso — cosa recuperare, quando compattare, cosa delegare, quanto restituire — è un'ipotesi. Sembrano tutte ragionevoli, e proprio per questo vanno verificate: un riassunto più aggressivo può risparmiare spazio e perdere un vincolo proprio nel caso che conta; un documento in più può aiutare su una domanda e confondere su un'altra. I corsi Prompt Engineering Operativo e Agenti AI spiegano come costruire un insieme di casi di valutazione e cosa misurare. Qui si vede come usarlo per le decisioni sul contesto, che hanno alcune particolarità.
Il confronto si fa a parità di tutto il resto: stessi casi, stesso modello, stesse istruzioni, e cambia solo la scelta di contesto. Per ogni configurazione conviene misurare insieme quattro cose: la qualità del risultato, compresi i fallimenti gravi; la quantità di contesto usata; il costo e il tempo per compito; e, per gli agenti, il numero di passi. Vanno lette insieme perché le scelte di contesto spostano quasi sempre l'equilibrio fra loro: una configurazione può essere poco meno accurata e molto più economica, o più accurata ma troppo lenta. Quale compromesso sia accettabile si decide prima di guardare i risultati.
Confronto illustrativo, dati di fantasia
A: dieci passaggi precaricati
B: tre passaggi precaricati + ricerca su richiesta
Stessi 60 casi, stesso modello, stesse istruzioni, ogni caso eseguito 3 volte
A B
Casi risolti correttamente 51 53
Fallimenti gravi 3 1
Contesto medio per caso alto basso
Passi medi per caso 1,0 1,6
Costo medio per compito più alto più basso
Peggiorati passando da A a B: 2 casi (in entrambi il modello
non ha cercato il documento che gli mancava)Per il contesto la tecnica più istruttiva è l'esperimento di rimozione: togliere un componente alla volta — una sezione delle istruzioni, la memoria, un gruppo di strumenti, i documenti recuperati — e rieseguire i casi. Se i risultati non cambiano, quel componente non stava lavorando e si può togliere, con un risparmio a ogni chiamata. Se peggiorano, si sa a cosa serve. Una variante utile per gli agenti è far crescere di proposito il contesto, aggiungendo cronologia o documenti irrilevanti ma plausibili, per vedere da quale punto la qualità comincia a scendere: è il modo di passare dalla tendenza generale del capitolo 3 a una soglia misurata sul proprio sistema.
Il risultato finale non basta: per le scelte di contesto contano le tracce. Per ogni caso fallito la domanda utile è se l'informazione necessaria era nel contesto al momento della decisione. Se non c'era, il problema è di selezione: recupero, delega, compattazione o memoria l'hanno persa o non l'hanno portata. Se c'era ed è stata ignorata, il problema è di presentazione o di sovraccarico: troppo materiale concorrente, una posizione sfavorevole, un'informazione contraddetta da un'altra. Le due diagnosi portano a correzioni opposte — aggiungere nel primo caso, togliere o riordinare nel secondo — ed è per questo che conviene registrare, per ogni chiamata, il contesto esatto che il modello ha ricevuto.
Qualche abitudine completa il quadro: includere fra i casi quelli che mettono sotto pressione il contesto, come sessioni che richiedono una compattazione, ripartenze da memoria, documenti in versioni contraddittorie, contenuti con istruzioni nascoste; rieseguire ogni caso più volte, perché la variabilità fra esecuzioni può essere grande quanto l'effetto cercato; e rifare tutto quando cambia il modello, perché la scelta migliore per uno può non esserlo per il successivo.
Domande frequenti
Attestato, badge e accesso al corso
Il corso è gratuito? Ricevo un attestato?
Sì a entrambe. Il corso è gratuito per intero: i contenuti, la prova finale e l'attestato, senza moduli a pagamento e senza che ti venga mai chiesto un metodo di pagamento. Quando superi la prova finale con almeno l'80% di risposte corrette ricevi un Attestato di Frequenza intestato a te, con un codice di verifica, una pagina pubblica che chiunque può consultare per confermarne l'autenticità, il PDF da scaricare e un Open Badge da aggiungere al profilo LinkedIn. Nome ed email ti vengono chiesti solo alla fine, se decidi di sostenere la prova.
Chi rilascia il corso? È legato a un fornitore di modelli?
È un corso indipendente di Rinoova Academy, e l'attestato è emesso da Rinoova. Non è affiliato a nessun fornitore di intelligenza artificiale né approvato da uno di essi. I concetti sono scelti proprio perché valgono qualunque sia il modello o la piattaforma: dove il corso cita una funzione offerta da alcune piattaforme, come la cache del prefisso, la descrive in forma generica e ti rimanda alla documentazione del tuo fornitore per i dettagli.
Che differenza c'è fra context engineering e prompt engineering?
Il prompt engineering riguarda come si scrivono le istruzioni; il context engineering riguarda tutto ciò che il modello ha davanti a ogni chiamata: istruzioni, cronologia, documenti, strumenti e memoria, e come cambiano nel corso di un compito. Il secondo non sostituisce il primo, lo contiene. Il corso Prompt Engineering Operativo è la base consigliata; questo corso parte da lì e si concentra sui sistemi in cui il contesto viene assemblato dal codice o dall'agente stesso.
Quanto dura il corso e come sono calcolate le ore?
Circa due ore. Sono dieci capitoli per circa 5.000 parole di testo tecnico, che a una lettura attenta richiedono poco meno di un'ora, più nove esempi — disposizioni del contesto, note di compattazione, deleghe, file di memoria, risultati di strumenti e confronti — su cui vale la pena fermarsi, e la prova finale. Non è un corso video: puoi leggerlo alla tua velocità, interromperlo e riprenderlo quando vuoi.
Quali prerequisiti servono? Devo saper programmare?
Il corso è di livello intermedio: dà per scontato che tu sappia come si scrive un prompt per un sistema reale e come un agente usa gli strumenti in un ciclo, gli argomenti dei corsi Prompt Engineering Operativo e Agenti AI. Non si scrive codice durante il corso: gli esempi sono brevi file di testo e JSON, spiegati nel testo che li circonda. Per applicare molte delle tecniche, però, serve poter intervenire sul codice che assembla le chiamate al modello, da soli o con chi lo sviluppa.
Cosa succede se non supero la prova finale?
Puoi ripeterla. La soglia è l'80% e le domande coprono tutti i capitoli, quindi se una parte non è chiara conviene tornare al capitolo relativo e rileggerlo prima di riprovare. L'attestato viene emesso solo al superamento, e non viene emesso due volte per lo stesso corso alla stessa persona.
Il corso è aggiornato? Il settore cambia in fretta.
Sì, ed è scritto apposta per restarlo. Il corso si concentra su ciò che resta valido quando cambiano modelli e prodotti — cosa includere, come riassumere, come separare, cosa ricordare, come proteggere e misurare il contesto — ed è su questo che verte la prova. Nomi di modelli, versioni, prezzi, statistiche e dimensioni delle finestre di contesto sono lasciati fuori di proposito, perché invecchiano più in fretta del resto. La data dell'ultima revisione è indicata in cima alla pagina.
Continua da qui
Altri corsi Open
Model Context Protocol: Fondamenti
Collegare i modelli linguistici ai dati e agli strumenti aziendali
2 ore · attestato incluso
AI Automation per le PMI
Identificare e automatizzare i processi che costano di più
2 ore · attestato incluso
Prompt Engineering Operativo
Istruzioni che funzionano in produzione, non solo nelle demo
2 ore · attestato incluso