La domanda più frequente che riceviamo dai neofiti dei modelli linguistici locali nel 2026 non è «Quale modello devo usare?», ma «Questo modello funzionerà sulla mia GPU?»
Questa guida è la risposta: i fabbisogni di VRAM di ogni importante LLM open a ogni quantizzazione comune, per hardware che spazia da una RTX 3060 da 12 GB a una H100 da 80 GB — il foglio di aiuto che avremmo voluto avesse esistito.
Un promemoria per gli impazienti: La VRAM è il vincolo determinante. Se il modello più la cache KV più il contesto non rientrano nella VRAM disponibile, le prestazioni di inferenza precipitano drasticamente. Tutto quanto segue presuppone che si desideri un’inferenza puramente su GPU; se invece si accetta l’offload sulla CPU, dividere le prestazioni di throughput per un fattore compreso tra 5 e 10.
Punti chiave
- VRAM da 12 GB: Modelli da 7–8 miliardi di parametri in Q5+ e da 13 miliardi in Q4. Llama 3 8B, Mistral 7B, Phi-4 Mini.
- 16 GB di VRAM: 13–14 miliardi di parametri a Q5+. Fascia scomoda: troppo per modelli da 8 miliardi, ma non abbastanza per quelli da 30 miliardi.
- 24 GB di VRAM: 30 B a Q4_K_M (Q5_K_M è un file di ~23,3 GB, troppo stretto una volta aggiunta la cache KV); 70 B solo a 2-bit (IQ2_XXS) o con CPU offload. Il sweet spot.
- 32 GB di VRAM: 30 B a Q5_K_M con spazio per contesto lungo; 70 B solo a Q3_K_S (~31 GB, stretto).
- 48 GB di VRAM: 70 B a Q4_K_M (~42,5 GB) comodamente; 104 B solo a Q3_K_S o inferiore (stretto).
- 128 GB unified (Apple Silicon): 123 B a Q4_K_M; 405 B solo a ~2-bit. Più lento per token rispetto a Nvidia.
Risposta rapida
Regola empirica: i pesi di un LLM richiedono circa 2 GB di VRAM per miliardo di parametri a FP16, poco più di 1 GB per miliardo a 8-bit (Q8_0) e circa 0,6 GB per miliardo a 4-bit (Q4_K_M), più spazio libero per la cache KV, che cresce con la lunghezza del contesto. Per un modello da 70 miliardi di parametri è circa 141 GB a FP16, 75 GB a Q8_0 e 42,5 GB a Q4_K_M (la dimensione del file Llama 3 70B Q4_K_M GGUF), quindi eseguire 70B alla quantizzazione consigliata a 4-bit richiede circa 48 GB di VRAM: due schede RTX 3090/4090 da 24 GB, una RTX A6000 o 6000 Ada da 48 GB, o un Mac con 64 GB o più di memoria unificata. Una singola scheda da 24 GB entra in 70B solo a 2-bit (IQ2_XXS, circa 19 GB, con una chiara perdita di qualità) o con lento CPU offload, e una RTX 5090 da 32 GB arriva al massimo a Q3_K_S (circa 31 GB). Per verificare un modello, una quantizzazione e una lunghezza di contesto specifici, utilizza il nostro Calcolatore VRAM per LLM.
Tabella di riferimento rapido
Ogni principale LLM open-source del 2026 e i relativi requisiti di VRAM ai comuni livelli di quantizzazione. I valori si riferiscono esclusivamente ai pesi del modello: le colonne quantizzate sono dimensioni di file GGUF da repo Hugging Face pubblici (principalmente bartowski; «—» dove nessun file del genere è pubblicato), e FP16 è circa 2 byte per parametro. Aggiungi la cache KV in cima: circa 0,5–4 GB per 8 K di contesto a FP16, a seconda del modello (vedi la tabella della cache KV qui sotto).
| Modello | FP16 | Q8_0 | Q5_K_M | Q4_K_M | Q3_K_M | IQ2_XXS |
|---|---|---|---|---|---|---|
| Phi-4 Mini (3,8 miliardi) | 7,7 GB | 4,1 GB | 2,8 GB | 2,5 GB | 2,1 GB | — |
| Gemma 2 2B | 5,2 GB | 2,8 GB | 1,9 GB | 1,7 GB | 1,5 GB | 0,9 GB |
| Llama 3 8B | 16,1 GB | 8,5 GB | 5,7 GB | 4,9 GB | 4,0 GB | 2,4 GB |
| Mistral 7B v0.3 | 14,5 GB | 7,7 GB | 5,1 GB | 4,4 GB | 3,5 GB | 2,0 GB |
| Qwen 2.5 7B | 15,2 GB | 8,1 GB | 5,4 GB | 4,7 GB | 3,8 GB | 2,3 GB |
| Phi-4 (14 B) | 29,3 GB | 15,6 GB | 10,6 GB | 9,1 GB | 7,4 GB | 4,1 GB |
| Qwen 2.5 14B | 29,5 GB | 15,7 GB | 10,5 GB | 9,0 GB | 7,4 GB | 4,3 GB |
| Mistral Nemo 12B | 24,5 GB | 13,0 GB | 8,7 GB | 7,5 GB | 6,1 GB | 3,6 GB |
| Qwen 2.5 32B | 65,5 GB | 34,8 GB | 23,3 GB | 19,8 GB | 15,9 GB | 9,0 GB |
| Yi-1.5 34B | 68,5 GB | 36,4 GB | 24,3 GB | 20,7 GB | 16,7 GB | 9,3 GB |
| Llama 3 70B | 141,0 GB | 74,9 GB | 49,9 GB | 42,5 GB | 34,3 GB | 19,1 GB |
| Qwen 2.5 72B | 145,0 GB | 77,3 GB | 54,4 GB | 47,4 GB | 37,7 GB | 25,5 GB |
| Command R+ 104B | 208,0 GB | 110,5 GB | 73,8 GB | 62,7 GB | 51,0 GB | 28,6 GB |
| Mistral Large 2 (123B) | 245,2 GB | 130,3 GB | 86,5 GB | 73,2 GB | 59,1 GB | 32,4 GB |
| Mixtral 8x22B (141 B) | 282,0 GB | 150,0 GB | 100,0 GB | 85,1 GB | 69,8 GB | 37,9 GB |
| DeepSeek V3 (671 B MoE) | ~1.342 GB | 713,3 GB | 475,4 GB | 404,4 GB | 319,2 GB | 174,4 GB |
| Llama 3.1 405B | 810,0 GB | 431,0 GB | 287,0 GB | 244,5 GB | 200,1 GB | 107,3 GB |
Una nota pratica: per un utilizzo quotidiano, Q4_K_M rappresenta il compromesso consigliato tra dimensione e qualità. La perdita di qualità rispetto all'FP16 è modesta (incremento tipico della perplessità < 2%) e i risparmi di memoria sono notevoli (~3,3× più piccolo). Q5_K_M offre una qualità marginalmente migliore con un aumento di circa il 17% della memoria occupata. Q3 e IQ2 vanno utilizzati solo in casi di emergenza — la qualità degrada in modo evidente.
Memoria della cache KV — quella che tutti dimenticano
I valori indicati sopra si riferiscono esclusivamente ai pesi del modello. La cache KV — la memoria attiva necessaria per memorizzare tutti i token della conversazione in corso — risiede anch’essa nella VRAM e cresce linearmente con la lunghezza del contesto.
Dimensione della cache KV per token con FP16 = 2 (chiavi e valori) × strati × teste KV × dimensione della testa × 2 byte. La tabella applica questa formula alla configurazione pubblicata di ogni modello; tutti questi modelli utilizzano grouped-query attention (GQA), quindi solo le teste KV contano (1 K = 1.024 token, 32 K = 32.768 token):
| Classe del modello | Cache KV per 1K token | Cache KV per contesto da 32K |
|---|---|---|
| Modelli 7–8 B (Llama 3 8B, Mistral 7B: 32 strati, 8 teste KV) | ~134 MB | ~4,3 GB |
| Qwen 2.5 7B (28 strati, 4 teste KV) | ~59 MB | ~1,9 GB |
| Modelli 12–14 B (Mistral Nemo 12B, Qwen 2.5 14B, Phi-4: 40–48 strati, 8–10 teste KV) | ~168–210 MB | ~5,4–6,7 GB |
| Modelli 32–34 B (Qwen 2.5 32B, Yi-1.5 34B: 60–64 strati, 8 teste KV) | ~252–268 MB | ~8,1–8,6 GB |
| Modelli 70–72 B (Llama 3 70B, Qwen 2.5 72B: 80 strati, 8 teste KV) | ~336 MB | ~10,7 GB |
| Modelli 104–123 B (Command R+ 104B: 64 strati; Mistral Large 2: 88 strati; entrambi 8 teste KV) | ~268–369 MB | ~8,6–11,8 GB |
| Llama 3.1 405B (126 strati, 8 teste KV) | ~528 MB | ~16,9 GB |
DeepSeek V3 è l'eccezione: utilizza multi-head latent attention (MLA), che memorizza una cache compressa, quindi la formula non si applica. La quantizzazione della cache KV (un'opzione in llama.cpp e vLLM nel 2026) la riduce di ~2–4× con un piccolo costo di qualità. La maggior parte dei setup di produzione ora utilizza cache KV Q8 — è quasi gratis dal punto di vista della qualità e risparmia una VRAM sostanziale con contesto lungo.
Se prevedi di utilizzare un contesto di 32 K o superiore, includi la cache KV nei tuoi calcoli di VRAM prima di scegliere la GPU.
Matrice di compatibilità GPU
Quali modelli trovano spazio comodamente su ciascuna GPU comune, ai quantizzatori raccomandati e con contesto da 8 K? Per «comodamente» si intende modello + cache KV + 1 GB di margine di sistema.
| GPU | VRAM | Miglior adattamento (Q4_K_M) | Miglior adattamento (Q5_K_M) | Massimo (qualsiasi quantizzazione) |
|---|---|---|---|---|
| RTX 3060 12 GB | 12 GB | 8 miliardi di parametri | 8 miliardi di parametri | 14 miliardi di parametri in Q3 |
| RTX 4060 Ti 16 GB | 16 GB | 13 miliardi di parametri | 13 miliardi di parametri | 30 miliardi di parametri in IQ2 |
| RTX 5080 / 5070 Ti | 16 GB | 13 miliardi di parametri | 13 miliardi di parametri | 30 miliardi di parametri in IQ2 |
| RTX 3090 / 4090 | 24 GB | 30 miliardi di parametri (Qwen 32B) | 14 B (30 B è troppo stretto) | 70 B a IQ2_XXS (2-bit) |
| RX 7900 XTX | 24 GB | 30 miliardi di parametri | 14 B (30 B è troppo stretto) | 70 B a IQ2_XXS (2-bit) |
| RTX 5090 | 32 GB | 30 miliardi di parametri | 30 miliardi di parametri | 70 B a Q3_K_S (stretto) |
| 2× RTX 3090 / 4090 | 48 GB | 70 miliardi di parametri | 34 B (70 B richiede ~50 GB) | 104 B a Q3_K_S |
| RTX A6000 / 6000 Ada | 48 GB | 70 miliardi di parametri | 34 B (70 B richiede ~50 GB) | 104 B a Q3_K_S |
| Mac Studio M5 Max 64 GB | 64 GB di memoria unificata | 70 miliardi di parametri | 70 miliardi di parametri | 123 B con IQ3_XXS (~47 GB) |
| H100 da 80 GB | 80 GB | 123 miliardi di parametri | 104 miliardi di parametri | 123 miliardi di parametri in Q4 |
| Mac Studio M5 Max 128 GB | 128 GB di memoria unificata | 123 miliardi di parametri | 123 miliardi di parametri | 405 miliardi di parametri in IQ2 (lento) |
| H200 / DGX Spark | 141 GB / 128 GB unificati | 123 miliardi di parametri | 123 miliardi di parametri | 405 B con IQ2_XXS (~107 GB, lento) |
| B200 | 192 GB | 123 miliardi di parametri | 123 miliardi di parametri | 405 B con Q3_K_S (~177 GB, stretto) |
I pattern da memorizzare:
1. 12 GB rappresenta la soglia minima di ingresso. Sotto questo limite, sei costretto a modelli molto piccoli che non giustificano l’uso di una GPU dedicata.
2. 24 GB rappresenta il punto di svolta. È il livello più economico in cui diventa possibile eseguire Llama 3 da 70B (con quantizzazioni compromesse).
3. 32 GB non è ancora una scheda da 70B. Llama 3 70B a Q4_K_M è circa 42,5 GB, quindi una RTX 5090 da 32 GB raggiunge solo Q3_K_S; il suo vantaggio rispetto alla 4090 è eseguire modelli della classe 30B a quantizzazioni più elevate con contesto lungo.
4. 48 GB rappresentano un margine confortevole. La maggior parte delle attività che desideri svolgere vi si adatta perfettamente.
5. 128 GB di memoria unificata costituiscono il tetto per i consumatori. Oltre questa soglia, stai acquistando hardware server.
Come scegliere la quantizzazione adatta al tuo hardware
La quantizzazione ottimale non è sempre «la più grande che entra nella tua VRAM». La qualità conta, e talvolta un modello più piccolo con una quantizzazione migliore supera un modello più grande con una quantizzazione peggiore.
Classifica approssimativa della qualità (basata sulla perplexity, valori più bassi sono migliori):
- FP16 / BF16 — originale. Riferimento di qualità di base.
- Q8_0 — aumento di circa lo 0,3% della perplexity. Praticamente indistinguibile.
- Q6_K — aumento di circa lo 0,5%. Indistinguibile nella pratica.
- Q5_K_M — aumento di circa l’1,0%. Leggero calo di qualità, ma comunque qualità molto elevata.
- Q4_K_M — aumento del 1,5–2,5%. Raccomandata per la maggior parte degli utenti.
- Q4_K_S — aumento di circa il 3%. Risultato sensibilmente peggiore rispetto a Q4_K_M per dimensioni simili.
- Q3_K_M — aumento del 5–8%. Output visibilmente compromesso.
- Q3_K_S — aumento di circa il 10%. Da usare solo se Q4 non entra nella VRAM disponibile.
- IQ2_XXS — aumento del 15–25%. Ultima risorsa.
Regola generale: preferisci un modello con meno parametri in Q5_K_M rispetto a un modello più grande in Q3_K_S per compiti quotidiani. Un Qwen da 32B in Q5 supera generalmente un Llama 3 da 70B in IQ2_XXS su benchmark reali, nonostante quest’ultimo sembri più impressionante sulla carta.
Eccezione: attività di programmazione e ragionamento dove il vantaggio intrinseco in termini di conoscenza del modello più grande spesso resiste anche a una quantizzazione aggressiva. Per la generazione di codice in particolare, persino una versione Q3_K_S di un modello da 70B può superare un modello da 30B in Q5_K_M.
Modelli MoE — la nota a piè di pagina
I modelli Mixture-of-Experts (MoE), come Mixtral 8x22B e DeepSeek V3 presentano un’asimmetria che confonde i principianti:
- VRAM necessaria = numero totale di parametri (poiché devi caricare tutti gli esperti)
- Calcolo richiesto = numero di parametri attivi per token (molto inferiore)
Mixtral 8x22B ha 141 miliardi di parametri totali / 39 miliardi attivi. Richiede oltre 80 GB di VRAM per essere eseguito, ma la velocità per token è simile a quella di un modello denso da 40 miliardi.
DeepSeek V3 è 671 B totali / 37 B attivi (236 B / 21 B era il suo predecessore, DeepSeek-V2). Anche il suo GGUF Q4_K_M è circa 404 GB (circa 174 GB con IQ2_XXS), ma il calcolo per token è più vicino a un modello denso ~37 B. Per questo DeepSeek V3 è definita «veloce per le sue dimensioni»: paghi il costo in termini di VRAM, ma ottieni uno sconto sul carico computazionale.
Se il tuo hardware riesce a ospitare un modello MoE, è spesso la scelta migliore. Se non ci riesce, allora il modello denso della stessa classe di parametri è ciò che ti serve.
Configurazioni pronte all’uso per diverse fasce di budget
Per chi vuole una risposta concreta, ecco alcuni setup di esempio a diversi livelli di budget nel 2026 (le dimensioni dei pesi sono i file GGUF su Hugging Face; aggiungi la cache KV in più):
| Budget | GPU | Modello migliore | Pesi (file GGUF) |
|---|---|---|---|
| $300 | RTX 3060 12 GB | Llama 3 8B Q5_K_M | 5,7 GB |
| $700 | RTX 3090 usata | Qwen 2.5 32B Q4_K_M | 19,8 GB |
| $1,300 | RTX 4090 usata | Qwen 2.5 32B Q4_K_M (70B solo a 2-bit) | 19,8 GB |
| $1,400 | 2× RTX 3090 usate + NVLink | Llama 3 70B Q4_K_M | 42,5 GB |
| $2,400 | RTX 5090 | Llama 3 70B Q3_K_S (stretto) | 30,9 GB |
| $3,799+ | Mac Studio M5 Max, 64–128 GB | Llama 3 70B Q4_K_M (64 GB); Mistral Large 2 Q4_K_M (128 GB) | 42,5 GB / 73,2 GB |
La «fascia di miglior rapporto qualità-prezzo» nel 2026 rimane ancora l’RTX 3090 o 4090 usata: sono le uniche GPU consumer per cui il rapporto prezzo/VRAM è favorevole, e entrambe rimarranno performanti almeno fino al 2028.
Per un’analisi approfondita sulla scelta della GPU più adatta, consulta migliore GPUs for local LLMs nel 2026.
Verificare questi dati alla fonte
Le specifiche e i prezzi possono cambiare senza preavviso. Si tratta delle pagine ufficiali dei produttori relative a quanto descritto sopra:
Domande frequenti
Quanta VRAM mi serve per eseguire Llama 3 da 70B in locale nel 2026?
Conta su 48 GB per Llama 3 70B a Q4_K_M, la quantizzazione consigliata: i soli pesi sono circa 42,5 GB, il che lascia spazio per una cache KV da 8 K. Q5_K_M (circa 50 GB) richiede più di 48 GB, e Q3_K_S (circa 31 GB) è il massimo che una RTX 5090 da 32 GB può contenere. Una singola scheda da 24 GB entra solo in quantizzazioni a 2-bit come IQ2_XXS (circa 19 GB, qualità approssimativa), e contesto più lungo su 24 GB richiede CPU offload.
Qual è la differenza tra Q4_K_M e Q4_K_S?
Entrambe sono quantizzazioni a 4 bit dello stesso modello. Q4_K_M («medium») utilizza 5 bit per alcuni gruppi critici di pesi, rendendola leggermente più grande ma di qualità sensibilmente migliore rispetto a Q4_K_S («small»). A parità quasi identica di utilizzo di VRAM, Q4_K_M è preferibile. Q4_K_S ha senso solo quando stai cercando di far entrare un modello in un budget di VRAM estremamente ristretto.
Posso eseguire un LLM più grande della mia VRAM?
Sì — utilizzando l’offload sulla CPUdove alcuni livelli del modello vengono eseguiti sulla CPU utilizzando la RAM di sistema anziché la VRAM della GPU. La penalità di prestazioni è severa (5–10× più lento), ma consente di eseguire modelli che altrimenti non entrerebbero. Pratico per un uso occasionale, doloroso come uso quotidiano. Sia llama.cpp che Ollama lo supportano out of the box via n_gpu_layers .
Il cache KV ha davvero un impatto sulla pianificazione della VRAM?
Sì, soprattutto con contesti lunghi. Per Llama 3 70B a 32 K di contesto, la sola KV cache è ~10,7 GB a FP16. Se sei già al limite della tua VRAM, andrai in OOM nel momento in cui la conversazione si allunga. Pianifica per la KV cache e considera la quantizzazione Q8 KV-cache (opzione nei motori di inferenza moderni) per dimezzarla approssimativamente.
Esiste un modo per eseguire Llama 3 da 405 miliardi di parametri a casa?
Sì, ma ti serve 200+ GB di memoria con quant utilizzabili. I percorsi realistici del 2026: un Mac Studio con M5 Ultra e 512 GB di memoria unificata (la pagina delle specifiche Mac Studio di Apple ora elenca la configurazione da 512 GB; lenta per token ma funziona), 8× RTX 4090 ($13K, setup complesso; 192 GB totali adattano 405B solo a Q3_K_S, circa 177 GB), due unità collegate NVIDIA DGX Spark unite (256 GB combinati, che NVIDIA valuta per modelli fino a circa 400B parametri), oppure CPU + 256 GB DDR5 RAM con GPU mid-range per offload parziale ($8K, lenta). Per confrontare questo costo hardware con il pagamento per token, usa il nostro Calcolatore del break-even self-hosting vs API.
Esistono formati di quantizzazione per il 2026, oltre a GGUF, di cui dovrei essere a conoscenza?
Sì — AWQ (Activation-aware Weight Quantization) e GPTQ sono ancora ampiamente utilizzati, soprattutto per le distribuzioni vLLM e TensorRT-LLM. Hanno una qualità leggermente migliore rispetto a GGUF con lo stesso bit count in alcuni casi. Per l'uso locale di LLM consumer con llama.cpp/Ollama/LM Studio, GGUF rimane dominante nel 2026 grazie alla sua semplicità e al supporto di strumenti ampio.
La quantizzazione Q4 influenzerà le capacità di scrittura del codice?
Meno di quanto si possa pensare, ma sì. Per il completamento diretto del codice, Q4_K_M è essenzialmente identico a FP16. Per ragionamenti complessi in più passaggi su un intero codebase, Q4 produce occasionalmente logiche meno accurate rispetto a Q5+. Se utilizzi modelli locali per attività di programmazione impegnative, preferisci Q5_K_M e scegli l’hardware in grado di supportarlo.
Conclusione
La pianificazione della VRAM per gli LLM locali nel 2026 non è complicata, ma premia la precisione. Scegli prima la classe di parametri (la dimensione del modello che offre le capacità di cui hai bisogno), quindi la quantizzazione più leggera che garantisca una qualità accettabile (Q4_K_M è generalmente la scelta giusta), aggiungi poi lo spazio richiesto dal cache KV in base alla lunghezza effettiva del contesto che prevedi di usare, e infine seleziona la GPU in base a tale stima.
Se dovessi ricordare solo tre numeri, questi sono:
- 12 GB gestisce agevolmente modelli da 8 miliardi di parametri.
- 24 GB esegue 30 B a quantizzazioni di qualità, 70 B solo a 2-bit.
- 48 GB esegue 70 B a quantizzazioni di qualità (Q4_K_M).
Tutto oltre 32 GB entra nel territorio multi-GPU, workstation o big-unified-memory, e tutto sotto 12 GB entra nel territorio phone/embedded. La maggior parte dell'attività locale-LLM nel 2026 avviene nella fascia 12–32 GB, che è esattamente la fascia GPU consumer — da design, non da coincidenza.