Il contesto che entra davvero in 16 GB di VRAM, la formula contro il caricamento
La domanda "quanto contesto mi entra?" è quella che decide se un modello locale serve davvero a un lavoro su codice. Con 8.000 token ci stanno un paio di file, con 32.000 un modulo, con 128.000 un piccolo repository. Su una scheda da 16 GB la risposta dipende da quanta memoria resta dopo aver caricato i pesi, e la si calcola di solito con una formula che circola in ogni guida. Io la uso come tutti, come punto di partenza. Sul mio banco di misura, una RTX 5060 Ti da 16 GB, l'ho messa a confronto con la realtà: ho caricato i modelli a contesti crescenti fino al primo che non entrava, li ho fatti rispondere a un prompt lungo, e ho confrontato il risultato con la stima. Le due cose non coincidono quasi mai, e non sbagliano sempre nella stessa direzione. In questo articolo spiego come funziona la stima, perché sbaglia, come si verifica il numero vero con llama.cpp in pochi minuti, e perché anche il numero vero non basta: un modello può caricare 128.000 token e non usarli. È una regola che seguo per ogni pezzo che scrivo: una stima della VRAM non è una garanzia di avvio, e un avvio non è una garanzia di lettura.
Nota
Il banco: RTX 5060 Ti 16 GB (Blackwell, limite di 180 W) su PCIe Gen3 x8, Ryzen 5 4500 a 6 core, 32 GB di DDR4 (a 2.133 MT/s per le stime e i caricamenti di settembre, a 3.600 MT/s per le prove di ottobre), Debian 13, driver NVIDIA 615.71.09 con CUDA 13.4, llama.cpp al commit 391fac1 con --fit off, cache KV q4_0 e un solo slot. Tutti i numeri che vedi qui derivano dalla procedura di benchmark descritta nel dettaglio in come il mio harness misura il contesto, un articolo in inglese; i caricamenti al contesto massimo vengono da una prova fuori dall'harness.
Come si stima il contesto che entra?
Si sottrae dalla VRAM disponibile lo spazio dei pesi e dei buffer di calcolo, e si divide il resto per il costo in memoria di un token di contesto. Il costo di un token è la cache KV: per ogni layer che usa l'attenzione, il modello conserva una chiave e un valore per ogni testa KV, ciascuno grande quanto la dimensione della testa, nel tipo di dato scelto per la cache. In formula semplificata:
byte per token = 2 × layer con attenzione × teste KV × dimensione della testa × byte per elemento
contesto massimo ≈ (VRAM libera − pesi − buffer di calcolo) / byte per tokenIl tipo della cache pesa moltissimo: con q4_0 ogni elemento occupa circa mezzo byte più una piccola quota di scale, con f16 due byte. Passare da f16 a q4_0 moltiplica il contesto per quasi quattro, ed è per questo che su 16 GB uso q4_0 su entrambe le metà della cache, che tiene anche attivo il kernel veloce di flash attention.
Nella pratica la stima ha due incognite che la formula semplificata non vede: quanti layer usano davvero l'attenzione con una cache KV completa, e quanto crescono i buffer di calcolo con il contesto. Sono proprio le due cose su cui sbaglia.
Se stai dimensionando un setup di inferenza per un team e vuoi sapere quanto contesto avrai davvero prima di comprare la scheda, nel mio hub sull'AI per le aziende trovi il metodo con cui affronto il dimensionamento.
Dove va la memoria, modello per modello
Lo strumento di stima di llama.cpp scompone la memoria in pesi, cache KV e buffer di calcolo. Sui modelli che ho misurato la scomposizione cambia moltissimo da un modello all'altro, ed è il modo più rapido per capire dove sta il margine.
| Modello e contesto stimato | Pesi (MiB) | Cache KV (MiB) | Buffer di calcolo (MiB) |
|---|---|---|---|
| Ornith 35B IQ3_XXS, 163.840 token | 13.956 | 962 | 426 |
| Qwen3.6 35B IQ3_XXS, 322.560 token | 12.697 | 1.834 | 813 |
| Ornith 9B Q8_0, 547.840 token | 8.045 | 4.865 | 2.435 |
| Ornith 9B Q4_K_M, 792.576 token | 4.812 | 7.016 | 3.511 |
Su un mixture of experts da 35B a 3 bit i pesi occupano quasi tutto e la cache KV resta sotto il gigabyte anche a 160.000 token: questi modelli hanno poche teste KV e una cache molto compatta. Su un 9B i pesi lasciano spazio, e la stima riempie quello spazio di cache, arrivando a numeri di contesto enormi. Quei numeri sono il primo segnale che la stima va presa con cautela: che un 9B "entri con 800.000 token" non dice nulla su quanti ne sappia leggere, e nessuna mia prova è arrivata fin lì.
La stima contro il caricamento
Il confronto che conta è fra la stima e il caricamento vero. Ho caricato ogni modello con tutti i parametri fissati, l'adattamento automatico spento, cache KV q4_0, un solo slot e nessun offload, a contesti crescenti, e ho tenuto il più grande che caricava e rispondeva.
- Hardware
- RTX 5060 Ti 16 GB, 15.749 MiB utilizzabili, 180 W, PCIe Gen3 x8; Ryzen 5 4500; 32 GB DDR4 a 2133 MT/s
- Sistema
- Debian 13, driver NVIDIA 615.71.09, CUDA 13.4
- Software
- llama.cpp 391fac1, --fit off, ogni parametro fissato, cache KV q4_0, flash attention attiva, un solo slot, nessun offload, prova sul campo fuori dall'harness
Metodo: Caricamento a contesti crescenti; si tiene il più grande che carica e risponde a un prompt lungo. VRAM letta a modello caricato. Per i 9B 262.144 è la misura più grande tentata, con 3.849 MiB ancora liberi.
Risultati (token, più alto è meglio)
Il caso più istruttivo è Qwen3.8-27B in IQ4_XS: la stima del mio strumento di pianificazione si fermava a 32.768 token, il caricamento ne ha retti 65.536 in 15.744 MiB. Il contesto caricato è il doppio di quello stimato. Per i modelli da 9B il caricamento a 262.144 token ha lasciato 3.849 MiB liberi: il limite viene dal modello, la memoria avanza. Per il 35B di Ornith lo strumento di llama.cpp stimava 163.840 token; in produzione lo uso a 131.072, il valore a cui l'ho caricato e verificato.
La formula ti dice da dove partire. Il caricamento ti dice dove arrivi. Fra le due, sulla mia scheda, c'è stato anche un fattore due.
Perché la stima si è fermata a metà
La ragione, in questo caso, è banale e istruttiva. Il mio strumento di pianificazione tiene un margine di sicurezza di 400 MiB, e con quel margine il contesto successivo non entrava nel suo conto. Il caricamento vero, a 65.536 token, occupava 15.744 MiB dei 15.749 utilizzabili: entrava con 5 MiB liberi. La stima era prudente, giusta nella sostanza, e su una scheda da 16 GB la prudenza di qualche centinaio di MiB vale un raddoppio del contesto.
C'è poi un motivo per cui la formula semplificata delle guide sbaglia su questo modello in particolare, e si vede nella configurazione pubblicata: dei 64 layer di Qwen3.8-27B, solo 16 usano l'attenzione completa con una cache KV che cresce con il contesto, mentre gli altri 48 usano un'attenzione lineare con uno stato di dimensione fissa. Una formula che conta tutti i layer come se avessero una cache KV piena sovrastima il costo per token di un fattore vicino a quattro. Lo stimatore di llama.cpp legge la struttura vera dal file, la formula a mano no.
La lezione generale è che la formula semplificata è scritta per i transformer classici, e i modelli recenti lo sono sempre meno: attenzione ibrida, finestre scorrevoli, cache condivise fra layer. Su ognuna di queste architetture il conto fatto a mano può sbagliare in un verso o nell'altro.
Come si verifica il numero vero in pochi minuti
Il procedimento che uso è semplice e vale per qualunque modello.
Parti dalla stima, poi carica il modello a quel contesto con tutti i parametri fissati.
llama-server -m Qwen3.8-27B-IQ4_XS.gguf -ngl 99 -c 32768 -fa on --cache-type-k q4_0 --cache-type-v q4_0 -b 512 -ub 256 -np 1 --fit off --port 8080Verifica: il server parte e risponde a una richiesta breve.
Leggi il contesto che il server ha davvero allocato.
curl -s http://127.0.0.1:8080/props | jq '.default_generation_settings.n_ctx' 32768Verifica: il numero coincide con quello richiesto. Se è diverso, qualcosa lo ha cambiato.
Raddoppia il contesto e ripeti, finché il caricamento fallisce. Tieni l'ultimo che è partito.
A quel contesto, manda un prompt lungo quasi quanto il contesto e controlla che la risposta arrivi.
nvidia-smi --query-gpu=memory.used,memory.total --format=csvVerifica: la VRAM occupata resta sotto il totale con un margine di qualche centinaio di MiB.
Due cose rendono questa verifica affidabile. La prima è --fit off: senza, llama.cpp adatta da solo i parametri che non hai fissato per far entrare il modello, e il contesto che leggi non è quello che hai chiesto. La seconda è il prompt lungo: un modello che carica ma va in errore alla prima richiesta lunga non ha davvero quel contesto, perché i buffer di calcolo crescono durante l'elaborazione.
Occhio anche agli slot: in llama.cpp -c è il budget totale, diviso fra gli slot paralleli. Con -c 65536 -np 4, ogni richiesta ha 16.384 token, e /props riporta quel valore per slot.
Caricare non vuol dire leggere
Un modello che carica 128.000 token di contesto non è detto che li usi. Per verificarlo ho fatto una prova di lettura del contesto con quattro compiti: estrarre le parole più frequenti da un testo lunghissimo, trovare più "aghi" in un pagliaio, recuperare più valori associati a una chiave, seguire una variabile attraverso una catena di assegnazioni. Ogni compito a 8.000, 32.000 e 128.000 token nominali; a 128.000 il server ne contava in mediana 117.903.
| Modello | 8K | 32K | 128K |
|---|---|---|---|
| Qwen3.8-27B GSQ-RCO | Sì, 4 su 4 | Sì, 4 su 4 | Sì, 4 su 4 |
| Ornith-1.5-35B-A3B | Parziale, 3 su 4 | Sì, 4 su 4 | Sì, 4 su 4 |
| Ornith-1.5-9B | Parziale, 3 su 4 | Sì, 4 su 4 | Sì, 4 su 4 |
| Ornith-1.0-9B | Sì, 4 su 4 | Sì, 4 su 4 | Sì, 4 su 4 |
Fino a 128.000 token nessuno dei quattro modelli è caduto. I due errori a 8.000 token sono sullo stesso compito, l'estrazione delle parole frequenti, e non si ripetono alle lunghezze maggiori: con quattro prove per lunghezza, un errore isolato dice poco. Quello che queste prove dicono con chiarezza è dove un modello non cade, e su questa scheda nessuno è caduto entro il contesto che carica.
Il prezzo di leggere tanto contesto è il tempo. A 128.000 token, il 27B ha letto il prompt a 540 token al secondo e ha impiegato in mediana 219 secondi per prova; il 35B mixture of experts ha letto a 1.513 token al secondo e ha impiegato 78 secondi. Un contesto pieno si paga a ogni richiesta, e su un assistente di coding che riceve tutto il repository a ogni domanda quell'attesa è il vero limite, più della memoria.
| A 128.000 token nominali | Qwen3.8-27B GSQ-RCO | Ornith-1.5-35B-A3B |
|---|---|---|
| Token contati dal server, mediana | 117.903 | 117.903 |
| Velocità di lettura del prompt | 540 token/s | 1.513 token/s |
| Secondi per prova, mediana | 219 | 78 |
| Prove superate | 4 su 4 | 4 su 4 |
Importante
Prima di affidare a un modello un contesto lungo, verifica tre cose separate: che il contesto entri nella VRAM, che il server lo allochi davvero e che il modello lo legga. Sono tre misure diverse, e la formula ne copre solo la prima, a volte male.
Gli slot paralleli consumano lo stesso contesto
Un errore frequente, quando il contesto non basta, è cercare la colpa nella formula mentre il problema è la configurazione del server. In llama.cpp il valore di -c indica il budget complessivo della cache KV, diviso in parti uguali fra gli slot dichiarati con -np. Chi alza gli slot per servire più utenti insieme divide lo stesso budget, e ogni utente vede un contesto più corto senza che la VRAM occupata cambi di un byte.
Sul mio banco uso un solo slot per una ragione in più: la riproducibilità. Con quattro slot attivi, a parità di seed e di prompt, fra due passate identiche cambiava il 3,7% delle risposte, contro lo 0% a slot singolo, perché il batching fra richieste modifica l'ordine delle operazioni in virgola mobile. Per misurare serve uno slot; per servire un team piccolo, gli slot si possono aggiungere, ma il contesto per richiesta va ricalcolato dividendo.
C'è un secondo dettaglio che incide sul margine: le due metà della cache, chiavi e valori, conviene tenerle dello stesso tipo. Con q4_0 su entrambe resta attivo il kernel fuso di flash attention; mescolare i tipi lo disattiva senza avvisare, e l'attenzione passa a un percorso più lento.
Cosa resta fuori
Sopra i 131.072 token non ho misurato nulla per i modelli grandi, e sotto gli 8.192 nemmeno: la prova di lettura copre tre lunghezze. Le misure di caricamento più grandi sui modelli da 9B si sono fermate a 262.144 token con memoria libera, quindi sono un limite inferiore. E la prova di lettura misura compiti sintetici di recupero, non la comprensione di un codebase vero: un modello che trova un ago a 128.000 token può comunque ragionare peggio su un modulo intero che su un file.
La configurazione completa che uso, dai parametri fissati al tipo di cache, è nelle strategie consigliate per gli LLM locali su 16 GB, e i dettagli sul modello che più ha smentito la formula sono nel confronto fra le due quantizzazioni di Qwen3.8-27B. L'architettura ibrida del modello è descritta nella scheda ufficiale di Qwen3.8-27B, e il comportamento di -c e degli slot nel repository di llama.cpp.
Il margine da lasciare
Un'ultima indicazione pratica. Il contesto massimo che carica non è quello da usare in produzione, perché lascia la scheda senza margine: un aggiornamento del driver, un processo che occupa qualche centinaio di MB, un buffer che cresce più del previsto, e il server non riparte. Sui miei modelli di produzione resto a 131.072 token per entrambi: per il 35B è sotto il massimo stimato, per il 27B con la testa MTP è il massimo che ho caricato, e lascia circa 860 MiB liberi. Verifico il valore a ogni aggiornamento del motore.
La formula della VRAM è utile e va usata, ma come ipotesi, non come promessa. Sulla mia scheda la stima prudente si è fermata alla metà del contesto vero di un 27B, e ha promesso a modelli piccoli contesti che nessuno ha verificato. Il numero vero si ottiene caricando, e il contesto utile si ottiene leggendo. Se stai pianificando un setup locale che deve lavorare su codebase o documenti lunghi e vuoi sapere quanto contesto avrai davvero, puoi descrivermi il caso nel modulo di preventivo gratuito: due minuti, e ti dico subito se rientra in quello che faccio.
