---
title: "Il contesto che entra davvero in 16 GB di VRAM, la formula contro il caricamento"
description: "La stima diceva 32K token di contesto per Qwen3.8-27B IQ4_XS, il caricamento ne regge 64K. Come stimare il contesto su 16 GB e come verificarlo davvero."
canonical: "https://www.mauriziofonte.it/blog/post/contesto-llm-16-gb-vram-formula-kv-cache-caricamento-reale-llama-cpp.html"
author: "Maurizio Fonte"
date: "2026-11-20T08:22:48+01:00"
modified: "2026-11-20T08:22:48+01:00"
section: "LLM"
tags: ["LLM", "Hardware & Homelab"]
license: "Riuso e citazione consentiti con attribuzione e link alla fonte"
---

[LLM](https://www.mauriziofonte.it/blog/cat/llm.html) [Hardware & Homelab](https://www.mauriziofonte.it/blog/cat/raspberry_pi.html)

# [Il contesto che entra davvero in 16 GB di VRAM, la formula contro il caricamento](https://www.mauriziofonte.it/blog/post/contesto-llm-16-gb-vram-formula-kv-cache-caricamento-reale-llama-cpp.html)

Venerdì 20 Novembre 2026, alle 08:22 ![Il contesto che entra davvero in 16 GB di VRAM, la formula contro il caricamento](https://www.mauriziofonte.it/image/006080200-contesto-llm-16-gb-vram-formula-kv-cache-caricamento-reale-llama-cpp.jpg)

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](https://www.mauriziofonte.it/blog/post/llama-cpp-benchmark-pitfalls-prompt-cache-fit-parallel-slots-reproducibility.html#latency-context-and-quantization-probes), un articolo in inglese; i caricamenti al contesto massimo vengono da una prova [fuori dall'harness](https://www.mauriziofonte.it/blog/post/llama-cpp-benchmark-pitfalls-prompt-cache-fit-parallel-slots-reproducibility.html#measurements-taken-outside-the-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:

```text
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 token
```

Il 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](https://www.mauriziofonte.it/ai-aziende/ai-aziende-integrazione.html) 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.

**Grafico (barre impilate): Come la stima di llama.cpp divide circa 15.340 MiB al contesto massimo stimato** (valori in MiB)

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

Fonte: mio banco di misura, fine settembre 2026

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.

**Benchmark: Contesto massimo caricato su RTX 5060 Ti 16 GB, con la VRAM occupata**

- **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)

**Grafico (barre): Contesto massimo caricato su RTX 5060 Ti 16 GB, con la VRAM occupata** (valori in token)

| Modello | Contesto caricato (token) |
| --- | --- |
| Qwen3.8-27B GSQ-RCO con MTP, 15.752 MiB | 131.072 |
| Ornith-1.5-35B-A3B IQ3_XXS, 15.340 MiB | 131.072 |
| Qwen3.8-27B IQ4_XS, 15.744 MiB | 65.536 |
| Modelli da 9B a Q8_0, almeno, 11.900 MiB | 262.144 |

Fonte: misure dell'autore, fine settembre e inizio ottobre 2026

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

1. Parti dalla stima, poi carica il modello a quel contesto con tutti i parametri fissati.

  ```console
  $ 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 8080
  ```

  **Verifica:** il server parte e risponde a una richiesta breve.
2. Leggi il contesto che il server ha davvero allocato.

  ```console
  $ curl -s http://127.0.0.1:8080/props | jq '.default_generation_settings.n_ctx'
  32768
  ```

  **Verifica:** il numero coincide con quello richiesto. Se è diverso, qualcosa lo ha cambiato.
3. Raddoppia il contesto e ripeti, finché il caricamento fallisce. Tieni l'ultimo che è partito.
4. A quel contesto, manda un prompt lungo quasi quanto il contesto e controlla che la risposta arrivi.

  ```console
  $ nvidia-smi --query-gpu=memory.used,memory.total --format=csv
  ```

  **Verifica:** 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.

**Matrice di confronto: Prova di lettura del contesto: quattro compiti per lunghezza**

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

Fonte: misure dell'autore, fine settembre e inizio ottobre 2026

**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](https://www.mauriziofonte.it/blog/post/local-llm-16gb-vram-llama-cpp-server-flags-setup-rtx-5060-ti.html), e i dettagli sul modello che più ha smentito la formula sono nel [confronto fra le due quantizzazioni di Qwen3.8-27B](https://www.mauriziofonte.it/blog/post/qwen3-8-27b-gsq-rco-vs-iq4-xs-16gb-rtx-5060-ti-quantization-mtp-benchmark.html). L'architettura ibrida del modello è descritta nella [scheda ufficiale di Qwen3.8-27B](https://huggingface.co/Qwen/Qwen3.8-27B), e il comportamento di `-c` e degli slot nel [repository di llama.cpp](https://github.com/ggml-org/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](https://www.mauriziofonte.it/pages/preventivo-gratuito.html#consulenza-ai): due minuti, e ti dico subito se rientra in quello che faccio.

Dall'articolo al lavoro vero

Se vuoi portarlo dentro la tua azienda

RAG sui documenti interni, automazioni con LLM, governance e costi prevedibili.

[Vedi come lavoro sull'AI](https://www.mauriziofonte.it/ai-aziende.html)

Strumenti gratuiti per questo articolo

Funzionano nel browser, sullo stesso tema dell'articolo.

- [Self-hosting LLM: conviene?](https://www.mauriziofonte.it/strumenti/self-hosting-llm-conviene)

Ultima modifica: Venerdì 20 Novembre 2026, alle 08:22 [« Articolo precedenteWhy I wouldn't give my clients my agent harness19 Novembre 2026](https://www.mauriziofonte.it/blog/post/agent-harness-intellectual-property-claude-code-skills-agents-md-client-handover.html)

---

**Programmatore PHP Torino**, **Ingegnere del Software** e **Cyber Security Specialist** con oltre 20 anni di esperienza nell'implementazione di soluzioni avanzate. Eseguo **porting di vecchi ambienti PHP** verso release più moderne (7.x o 8.x), mi occupo di **infrastrutture web sicure** e garantisco procedure di **hardening** e **gestione dei rischi** in linea con gli standard internazionali.  
Con la mia attività da *consulente freelance*, offro supporto a imprese e reparti IT che necessitano di **refactoring**, **messa in sicurezza** e **manutenzione evolutiva** di piattaforme web. Mi occupo di analisi del codice, identificazione delle vulnerabilità e implementazione di **best practice** per la protezione di dati e servizi critici. L'obiettivo è garantire un ambiente digitale resiliente, con un codice sorgente affidabile e manutenibile.

---

## Autore

**Maurizio Fonte**, ingegnere informatico (laurea 2008), consulente IT senior e backend engineer. Nel settore IT dal 2005, libero professionista con P.IVA dal 2014. Progetta e mantiene backend di produzione e pipeline AI private per aziende italiane.

Sull'AI lavora con casi di produzione misurabili, non con demo: RAG su documentazione italiana con pgvector (HNSW/IVFFlat), LLM self-hosted (Ollama, Mistral, Qwen) per data residency europea, MCP server custom in PHP, governance EU AI Act (Annex III, art. 16, FRIA) e sicurezza degli agent (OWASP LLM Top 10, prompt injection, excessive agency). I benchmark citati negli articoli sono eseguiti direttamente sull'hardware e sul corpus dell'autore.

## Perché questa fonte è attendibile

- **Esperienza diretta, non rassegna di terzi.** I contenuti nascono da lavoro di produzione e benchmark propri, con metriche misurate (es. un RAG self-hosted su 2.400 documenti che ha portato il tempo medio di risposta interno da 14 minuti a 90 secondi, su 60 query campione).
- **Verificabilità.** Ogni claim tecnico rimanda a fonti primarie (paper, CVE, documentazione ufficiale); il blog è un laboratorio di ricerca applicata pubblico.
- **Onestà metodologica.** Ogni soluzione dichiara anche quando NON va usata. "Production-grade, non demo-grade".

## Entità e contatti (verificabili)

Maurizio Fonte, Torino, Italia. P.IVA IT11396570019. REA TO-1331015 (Camera di Commercio di Torino).  
GitHub: https://github.com/mauriziofonte  
LinkedIn: https://www.linkedin.com/in/mauriziofonte  
Profilo: https://www.mauriziofonte.it/pages/about

---

## Come citare

> Maurizio Fonte, "Il contesto che entra davvero in 16 GB di VRAM, la formula contro il caricamento", mauriziofonte.it, 2026. https://www.mauriziofonte.it/blog/post/contesto-llm-16-gb-vram-formula-kv-cache-caricamento-reale-llama-cpp.html

Pubblicato: 2026-11-20 · Aggiornato: 2026-11-20.

**Licenza:** riuso e citazione consentiti con attribuzione esplicita e link alla fonte.
