# Migliori LLM di piccole dimensioni da eseguire in locale: guida completa

> I migliori LLM di piccole dimensioni da eseguire in locale nel 2026: Qwen3, Gemma 3, Llama 3.2 e Phi-4-mini, oltre alla RAM necessaria e a come eseguirli con Ollama.

Source: https://ailoot.ai/blog/it/best-small-llms-to-run-locally/
Canonical: https://ailoot.ai/blog/it/best-small-llms-to-run-locally/
Language: it
Publisher: Ailoot (https://ailoot.ai/)
Translation: guide-100014
Revision: sha256-902e457465d2ff3e91f70bb17e8ff9a5c554a618e546c8a5d1f94ae35a662ac1


I modelli linguistici di piccole dimensioni sono diventati discretamente uno degli strumenti più utili che uno sviluppatore possa tenere sul proprio computer. Non serve più un rack di GPU né una bolletta cloud per avere un modello capace che risponde alle domande, scrive codice e riassume documenti, tutto completamente offline.

Lo scenario è cambiato molto dai primi tempi dei pesi aperti di LLaMA originale, Alpaca e GPT-J. Nel 2026, un modello da 4 miliardi di parametri su un portatile può svolgere attività che prima richiedevano qualcosa dieci volte più grande. Questa guida presenta i migliori LLM di piccole dimensioni da eseguire in locale oggi, l'hardware necessario e i modi più semplici per metterli in funzione.

**Risposta rapida.** I migliori LLM di piccole dimensioni da eseguire in locale nel 2026 sono Qwen3 (1.7B–14B), Google Gemma 3 (1B–12B), Meta Llama 3.2 (1B/3B) e Microsoft Phi-4-mini (3.8B). Qwen3 è la scelta predefinita più sicura a tutto tondo. Eseguili con Ollama o LM Studio; per la maggior parte bastano 8–16 GB di RAM.

## Che cosa si intende per LLM di piccole dimensioni nel 2026?

Un **LLM di piccole dimensioni** (talvolta chiamato modello linguistico di piccole dimensioni, o SLM) è un modello compatto che puoi eseguire su hardware consumer invece che su un cluster di GPU nel cloud. Non esiste una soglia ufficiale, ma in pratica i modelli piccoli di oggi condividono tre caratteristiche:

- Circa **0.5B–14B parametri** — abbastanza pochi da consentire a una versione quantizzata di entrare nella memoria di un normale portatile o di una singola GPU di fascia media.
- Funzionano bene dopo la **quantizzazione a 4 bit**, che riduce l'uso della memoria di circa 4x con un piccolo compromesso sulla qualità.
- Sono distribuiti con **pesi aperti**, così puoi scaricarli, eseguirli e spesso perfezionarli senza una chiave API.

Il cambiamento fondamentale dal 2023 è la qualità per parametro. Un moderno modello da 3–4B è ottimizzato per seguire istruzioni, è multilingue e spesso ragiona meglio di un modello da 13B di due anni fa. Ecco perché i vecchi modelli preferiti — LLaMA 7B vanilla, Alpaca, Vicuna, GPT-J, GPT-Neo, Falcon 7B — sono stati sostituiti dalle famiglie qui sotto.

## Perché eseguire un LLM di piccole dimensioni in locale?

Eseguire un modello sul tuo computer ti offre diversi vantaggi che un'API ospitata non può dare:

- **Privacy.** Prompt e dati non lasciano mai il tuo dispositivo: un aspetto importante per codice proprietario e attività legali o mediche.
- **Costo.** Nessuna tariffazione per token. Una volta scaricato il modello, l'inferenza è gratuita.
- **Uso offline.** Funziona in aereo, su una rete protetta o ovunque non ci sia una connessione Internet affidabile.
- **Latenza e controllo.** Nessun viaggio di andata e ritorno sulla rete, nessun limite di frequenza; puoi fissare una versione specifica così il comportamento non cambia senza che tu te ne accorga.
- **Personalizzazione.** Puoi perfezionare il modello o collegargli un sistema di recupero per adattarlo al tuo dominio.

## Quali sono i migliori LLM di piccole dimensioni da eseguire in locale nel 2026?

Queste sono le famiglie di modelli che vale la pena scaricare nel 2026, raggruppate in base a chi le produce e ai loro punti di forza.

### Qwen3 — il tuttofare predefinito

La famiglia Qwen3 di Alibaba è diventata discretamente la risposta alla domanda «che cosa dovrei eseguire in locale?» per la maggior parte degli sviluppatori. Offre un'ampia gamma di dimensioni — 0.6B, 1.7B, 4B, 8B e 14B nella versione densa — tutte con licenza permissiva Apache 2.0 e senza restrizioni commerciali.

- **Ideale per:** chat generica, assistenza alla programmazione, refactoring e attività multilingue.
- **La scelta giusta:** Qwen3 8B è ampiamente considerato la migliore scelta complessiva su una GPU da 8 GB; Qwen3 4B è un'ottima opzione per portatili che usano solo la CPU.
- **Perché si distingue:** ottima qualità per parametro, licenza chiara e supporto eccellente negli strumenti.

### Google Gemma 3 — potente e multimodale

Google Gemma 3 è disponibile nelle dimensioni 1B, 4B, 12B e 27B. Le varianti da 4B in su sono multimodali (possono leggere immagini) e supportano più di 140 lingue, il che rende Gemma la scelta giusta quando servono capacità visive o un'ampia copertura linguistica sul dispositivo.

- **Ideale per:** input multimodali, attività multilingue e uso generico su una macchina da 16 GB (Gemma 3 12B).
- **Nota:** Gemma è distribuito con una licenza specifica di Google: verifica le condizioni per l'uso commerciale.

### Meta Llama 3.2 — il punto di partenza più semplice

I piccoli modelli Llama di Meta — Llama 3.2 1B e 3B — sono il modo più semplice per iniziare. Sono compatti, ben documentati, supportati ovunque e adatti ad attività sul dispositivo come riassunti e chat semplici.

- **Ideale per:** un primo modello locale, riassunti e assistenti sul dispositivo.
- **Compromesso:** le dimensioni 1B/3B sono inferiori a Qwen3 e Phi-4 nel ragionamento difficile, ma sono difficili da battere per velocità e semplicità.

### Microsoft Phi-4 e Phi-4-mini — capacità di ragionamento superiori alla loro dimensione

I modelli Phi di Microsoft sono addestrati in larga misura su dati selezionati e sintetici, il che consente loro di superare le aspettative rispetto alle dimensioni nei calcoli, nella logica e nella risoluzione strutturata dei problemi. Phi-4 è un modello da 14B che compete regolarmente con modelli molto più grandi nelle attività di ragionamento, mentre **Phi-4-mini (3.8B)** è probabilmente il miglior modello di ragionamento piccolo eseguibile su hardware minimo: richiede circa 3 GB di VRAM a 4 bit. Entrambi sono distribuiti con una licenza MIT permissiva.

- **Ideale per:** calcoli, logica e ragionamento passo dopo passo su hardware modesto.

### Mistral 7B — l'opzione matura, pensata prima di tutto per il codice

Mistral 7B è ancora un affidabile cavallo da tiro, con uno dei più grandi ecosistemi di versioni perfezionate e integrazioni. È distribuito con licenza Apache 2.0, funziona comodamente su una GPU da 8 GB e resta uno dei preferiti per configurazioni locali orientate al codice. I modelli Ministral più piccoli di Mistral (3B e 8B) ampliano la famiglia verso l'uso su dispositivi edge.

- **Ideale per:** programmazione, un modello generico ben supportato e perfezionamento semplice.

### Modelli distillati DeepSeek-R1 — per attività che richiedono molta logica

DeepSeek ha rilasciato modelli di ragionamento distillati basati sui modelli Qwen e Llama (comunemente 7B, 8B e 14B). Portano il ragionamento in stile chain-of-thought a dimensioni eseguibili in locale e sono efficaci nella risoluzione dei problemi passo dopo passo. Hanno licenza MIT e sono disponibili in Ollama.

- **Ideale per:** ragionamento, calcoli e problemi che traggono vantaggio da passaggi di ragionamento visibili.

### SmolLM2 — quando serve il modello più piccolo in assoluto

SmolLM2 di Hugging Face è disponibile nelle dimensioni 135M, 360M e 1.7B. Sono i modelli da scegliere con hardware molto limitato, nei browser o sui dispositivi edge. Gestiscono riassunti e istruzioni semplici, ma non sono progettati per il ragionamento complesso.

- **Ideale per:** RAM estremamente ridotta, uso embedded ed edge e sperimentazione.

## Tabella comparativa degli LLM di piccole dimensioni

Valori approssimativi per le versioni quantizzate a 4 bit (Q4). L'uso effettivo della memoria varia in base alla lunghezza del contesto e all'ambiente di esecuzione.

| Modello | Parametri | RAM/VRAM approssimativa (Q4) | Ideale per | Licenza |
|----|----|----|----|----|
| Qwen3 1.7B | 1.7B | ~2 GB | Chat veloce su qualsiasi portatile | Apache 2.0 |
| Qwen3 4B | 4B | ~3–4 GB | Chat equilibrata e programmazione leggera | Apache 2.0 |
| Qwen3 8B | 8B | ~6–8 GB | Miglior scelta complessiva su una GPU da 8 GB | Apache 2.0 |
| Qwen3 14B | 14B | ~10–12 GB | Programmazione, refactoring e ragionamento | Apache 2.0 |
| Gemma 3 4B | 4B | ~3–4 GB | Multimodalità / più di 140 lingue | Gemma |
| Gemma 3 12B | 12B | ~9–10 GB | Uso generico efficace su 16 GB | Gemma |
| Llama 3.2 3B | 3B | ~3 GB | Punto di partenza semplice | Llama |
| Phi-4-mini | 3.8B | ~3 GB | Ragionamento e calcoli su hardware ridotto | MIT |
| Phi-4 | 14B | ~10–12 GB | Matematica e logica superiori alle aspettative | MIT |
| Mistral 7B | 7B | ~5–6 GB | Orientato al codice, ecosistema maturo | Apache 2.0 |
| Distillato DeepSeek-R1 8B | 8B | ~6–8 GB | Logica impegnativa e ragionamento passo dopo passo | MIT |
| SmolLM2 1.7B | 1.7B | ~1.5 GB | Edge / RAM estremamente ridotta | Apache 2.0 |

## Quanta RAM e quale hardware servono?

Una regola pratica utile: un modello quantizzato a 4 bit richiede circa **0.6–0.75 GB di memoria per ogni miliardo di parametri**, più un po' di margine per il contesto. Quindi un modello 7B richiede circa 5–6 GB e uno 14B circa 10–12 GB. Le opzioni dipendono dalla memoria disponibile:

| Disponibilità | Dimensioni del modello gestibili comodamente | Scelte consigliate |
|----|----|----|
| 8 GB di RAM, senza GPU | 1–4B | Qwen3 4B, Phi-4-mini, Gemma 3 1B, Llama 3.2 3B |
| GPU da 8 GB (VRAM) | 7–8B | Qwen3 8B, Mistral 7B, distillato DeepSeek-R1 8B |
| 16 GB di RAM / VRAM | 12–14B | Gemma 3 12B, Qwen3 14B, Phi-4 |
| GPU da 24 GB o più | 14–32B | Qwen3 32B, varianti DeepSeek più grandi |

I Mac con Apple Silicon sono un caso particolare: la loro memoria unificata consente alla GPU di usare gran parte della RAM di sistema, quindi un MacBook della serie M con 16–32 GB può eseguire modelli che su un PC richiederebbero una GPU dedicata.

**Regola d'oro:** non iniziare dal modello più grande. Inizia dal miglior modello che il tuo hardware può eseguire comodamente. Un modello 4B veloce è meglio di un modello 14B che usa la memoria virtuale e risponde a un token al secondo.

## Come si esegue localmente un LLM di piccole dimensioni?

Per iniziare non serve usare Python. Tre strumenti coprono quasi tutti i casi d'uso:

- **Ollama** — il percorso più semplice. Installalo, poi scarica ed esegui un modello con un solo comando. Gestisce download, quantizzazione e un'API compatibile con OpenAI su `localhost:11434`.
- **LM Studio** — un'app desktop rifinita, con interfaccia di chat, catalogo dei modelli e download con un clic. Ideale se preferisci un'interfaccia grafica.
- **llama.cpp** — il motore C/C++ sottostante che alimenta gran parte dell'ecosistema. Sceglilo quando vuoi il massimo controllo o eseguire direttamente file GGUF su CPU o Apple Silicon.

Un primo avvio con Ollama si presenta così:

```
# Pull and chat with Qwen3 8B (best all-rounder on an 8 GB GPU)
ollama pull qwen3:8b
ollama run qwen3:8b

# Lighter options for CPU-only laptops
ollama pull qwen3:4b
ollama pull llama3.2:3b
ollama pull phi4-mini
ollama pull gemma3:4b
```

Una volta avviato un modello, sia Ollama sia LM Studio espongono un endpoint compatibile con OpenAI, così puoi indirizzare strumenti e script esistenti al modello locale semplicemente cambiando l'URL di base.

## Come si sceglie l'LLM di piccole dimensioni giusto?

Abbina il modello al lavoro da svolgere, invece di inseguire una classifica:

- **Chat generica e attività quotidiane:** Qwen3 (4B o 8B) — la scelta predefinita più sicura.
- **Programmazione e refactoring:** Qwen3 14B, Mistral o un distillato DeepSeek-R1 su una GPU da 12–16 GB.
- **Calcoli, logica e ragionamento su hardware ridotto:** Phi-4-mini, poi Phi-4 se hai 16 GB.
- **Immagini o molte lingue:** Gemma 3 4B o 12B.
- **Ingombro minimo assoluto:** Llama 3.2 1B, Gemma 3 1B o SmolLM2.

## Quali sono i limiti dei piccoli LLM locali?

I modelli piccoli sono davvero utili, ma è bene sapere dove si fermano:

- **Meno conoscenze sul mondo.** Ne sanno meno dei modelli cloud di frontiera e possono sbagliare con sicurezza: verifica i fatti quando sono importanti.
- **Più deboli nel ragionamento molto difficile.** Un modello 3B non eguaglierà un grande modello ospitato su problemi complessi e articolati in più passaggi.
- **Compromessi tra contesto e velocità.** Contesti lunghi usano più memoria; su CPU, i modelli grandi possono essere lenti.
- **La qualità varia a seconda dell'attività.** Un modello eccellente nella chat può essere mediocre nella programmazione. Prova un paio di modelli prima di decidere.

Per molti flussi di lavoro, la soluzione è il recupero delle informazioni (RAG) o un rapido perfezionamento per fornire al modello i tuoi dati: entrambi sono molto meno costosi in locale di quanto sembri.

## Domande frequenti

### Qual è il miglior LLM di piccole dimensioni da eseguire in locale nel 2026?

Per la maggior parte delle persone, Qwen3 8B è la migliore scelta complessiva su una GPU da 8 GB, mentre Qwen3 4B o Llama 3.2 3B funzionano bene sui portatili che usano solo la CPU. Scegli il modello più grande che il tuo hardware esegue comodamente, invece del più grande disponibile.

### Qual è l'LLM più piccolo che si può eseguire in locale?

Modelli come SmolLM2 (135M–1.7B), Llama 3.2 1B, Gemma 3 1B e Qwen3 0.6B funzionano su quasi tutti i portatili moderni, spesso con meno di 2 GB di RAM se quantizzati a 4 bit. Gestiscono riassunti e chat semplici, ma sono deboli nel ragionamento complesso.

### Quanta RAM serve per eseguire localmente un LLM di piccole dimensioni?

Un modello 3–4B quantizzato a 4 bit richiede circa 3–4 GB di RAM o VRAM libera; un modello 7–8B ne richiede circa 6–8 GB e uno 12–14B ne richiede 10–16 GB. 16 GB di RAM di sistema sono una base comoda per la maggior parte dei modelli piccoli.

### Qual è il modo più semplice per eseguire localmente un LLM di piccole dimensioni?

Installa Ollama o LM Studio, poi scarica un modello con un solo comando (per esempio `ollama pull qwen3:8b`). Entrambi gestiscono download, quantizzazione e un'interfaccia di chat locale, oltre a esporre un'API compatibile con OpenAI per le tue applicazioni.

### Posso eseguire un LLM di piccole dimensioni senza una GPU?

Sì. Con la quantizzazione a 4 bit, i modelli fino a circa 7–8B funzionano su una CPU moderna e sono sensibilmente più veloci sui Mac con Apple Silicon grazie alla memoria unificata. La velocità dei token sarà inferiore rispetto a una GPU dedicata, ma è sufficiente per chat e stesura di testi.

### I piccoli LLM locali sono adatti alla programmazione?

Possono esserlo. Qwen3 e i modelli distillati DeepSeek-R1 sono efficaci nella programmazione tra i modelli piccoli, e Mistral ha un ecosistema maturo orientato prima di tutto al codice. Per refactoring più impegnativi, un modello 14B su una GPU da 12–16 GB offre la migliore qualità ottenibile in locale.

## In conclusione

I piccoli LLM locali sono passati da esperimento per appassionati a strumento pratico per tutti i giorni. Inizia con Qwen3 per una scelta equilibrata, scegli Phi-4-mini quando ti serve ragionare su hardware leggero e Gemma 3 quando ti servono capacità visive o molte lingue: tutto tramite Ollama o LM Studio in pochi minuti. Per assistenza sull'uso della documentazione Ailoot, consulta la [documentazione Ailoot](https://ailoot.ai/docs/).


## Ailoot · L’azienda e il suo portafoglio di progetti

Ailoot si basa su un’esperienza operativa consolidata, un’ampia base di clienti, un servizio stabile e un controllo costante dei KPI.

L’azienda e il suo portafoglio di progetti: milioni di clienti; vendite nell’ordine dei miliardi ogni mese.

Ailoot mette questa esperienza operativa al servizio dell’accesso API alle funzioni AI nei prodotti dei clienti, negli agenti, nelle applicazioni e nelle automazioni.
