Passa al contenuto principale

Eseguire modelli AI in locale con Ollama

Intermedio

I modelli di frontiera vivono nel cloud, ma un'intera classe di modelli open-weight — Llama, Mistral, Qwen, DeepSeek, Gemma — puoi scaricarla ed eseguirla sul tuo portatile o sul tuo server. Ollama è il modo più semplice per farlo: un'installazione, un comando e un modello gira in locale. Questa pagina ti porta da zero a un modello in esecuzione, a chiamarlo da codice e a conoscere i compromessi, così da non aspettarti che un modello locale da 7B si comporti come uno di frontiera.

What you'll learn
  • Sapere PERCHÉ eseguire un modello in locale — e gli onesti compromessi rispetto ai modelli cloud di frontiera
  • Installare Ollama ed eseguire il tuo primo modello con due comandi
  • Usare la CLI di base: pull, run, list, ps, rm, stop
  • Chiamare il tuo modello locale da codice tramite l'API di Ollama compatibile con OpenAI
  • Capire fabbisogno di RAM, dimensioni dei modelli e quantizzazione, per scegliere un modello che la tua macchina riesca davvero a eseguire
  • Sapere quando LM Studio (una GUI) è il punto di partenza migliore

Perché eseguire un modello in locale (e quando no)​

Eseguire un modello sul tuo hardware ti dà quattro cose:

  • Privacy — i tuoi prompt e i tuoi dati non lasciano mai la tua macchina. È il motivo per cui i team in ambiti regolamentati o sensibili scelgono i modelli locali. (Vedi il bivio privacy/self-host in Scegliere un modello.)
  • Offline — niente internet, niente API, nessuna dipendenza da interruzioni di servizio. Il modello è un file sul tuo disco.
  • Costo — nessuna fattura per token. Una volta scaricato, eseguirlo è "gratis" (paghi in elettricità e hardware, non in spesa API). Se la spesa in token è il tuo vincolo su larga scala, il locale può vincere.
  • Controllo — fissa una versione esatta, personalizza il comportamento e integra senza limiti di frequenza o sorprese nei termini di servizio.

I compromessi onesti:

  • Divario di capacità. Un modello che puoi eseguire su un portatile (1B–14B parametri) non è nella stessa lega di un modello cloud di frontiera su ragionamento difficile, contesto lungo o compiti agentici. Per molti compiti quotidiani il divario è piccolo; per i più difficili è grande.
  • Hardware. I modelli più grandi e capaci richiedono più RAM/VRAM di quella che ha una macchina tipica. Spesso scegli il modello più grande che il tuo hardware riesce a eseguire, non il migliore che esiste.
  • Lo gestisci tu. Nessuno scaling gestito, nessun aggiornamento automatico: è il prezzo del controllo.

Uno schema comune e duraturo: prototipa e scegli con una piccola valutazione (stesso metodo dei modelli cloud — vedi Scegliere un modello), usa il locale per lavori privati/offline/economici su larga scala e ricorri a un'API di frontiera quando il compito richiede davvero la capacità in più.

Installa Ollama ed esegui il tuo primo modello​

Guided walkthrough1 of 4
  1. macOS e Windows: scarica l'installer da ollama.com/download ed eseguilo. Linux: usa lo script di installazione ufficiale (qui sotto). Questo installa il comando ollama e un servizio locale in background.

Installazione su Linux (macOS/Windows usano invece l'installer scaricato):

curl -fsSL https://ollama.com/install.sh | sh

Scarica ed esegui un modello piccolo (buona prima scelta)

ollama run gemma4:e2b

Quest'unico comando scarica gemma4:e2b — il modello con cui parte la quickstart di Ollama stessa, una variante Gemma 4 di taglia edge con ~2,3B parametri effettivi e pochi GB su disco — e avvia una chat interattiva. Per scaricare senza ancora chattare, usa invece ollama pull.

La CLI di base​

Pochi comandi coprono quasi tutto. Esegui ollama --help per l'elenco completo.

# Download a model without starting a chat
ollama pull qwen3

# Start an interactive chat (downloads first if needed)
ollama run qwen3

# One-shot: pass the prompt inline, get the answer, exit
ollama run qwen3 "Summarize the CAP theorem in two sentences."

# List models you've downloaded
ollama list

# Show models currently loaded in memory
ollama ps

# Stop a running/loaded model (frees memory)
ollama stop qwen3

# Delete a downloaded model to reclaim disk
ollama rm qwen3

Dentro una sessione interattiva ollama run, scrivi /bye per uscire e /? per vedere i comandi di sessione. Il servizio in background che serve davvero i modelli viene avviato da ollama serve (l'app desktop lo avvia per te automaticamente).

Chiamalo da codice (API compatibile con OpenAI)​

È la parte che rende i modelli locali davvero utili nelle app. Il servizio in background di Ollama espone un'API HTTP locale su http://localhost:11434, sulla porta predefinita 11434. Ha endpoint nativi propri (/api/generate, /api/chat) e un livello compatibile con OpenAI su /v1 — così la maggior parte del codice scritto per l'SDK di OpenAI funziona con il tuo modello locale cambiando due righe.

HTTP puro con curl (endpoint nativo):

curl http://localhost:11434/api/chat -d '{
  "model": "gemma4:e2b",
  "messages": [
    { "role": "user", "content": "Why is the sky blue?" }
  ],
  "stream": false
}'

Da Python con l'SDK ufficiale di OpenAI — basta puntare base_url a Ollama e passare una api_key non vuota qualsiasi (Ollama richiede il campo ma ne ignora il valore):

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama",  # required by the SDK, ignored by Ollama
)

response = client.chat.completions.create(
    model="gemma4:e2b",
    messages=[
        {"role": "system", "content": "You are a concise assistant."},
        {"role": "user", "content": "Explain gradient descent in two sentences."},
    ],
)

print(response.choices[0].message.content)

Essendo compatibile con OpenAI, gli stessi schemi che useresti con un'API ospitata valgono anche qui — compresi lo streaming e l'uso di strumenti / function calling, che in locale funzionano come nel cloud (a patto che il modello sia effettivamente bravo in questo). Il livello /v1 di Ollama copre /v1/chat/completions, /v1/completions, /v1/responses, /v1/models (e /v1/models/{model}) e /v1/embeddings.

Hardware, dimensioni dei modelli e quantizzazione​

Il numero che vedi associato a un modello — 1B, 7B, 8B, 70B — è il suo numero di parametri (in miliardi). Più parametri significa in genere più capace e più affamato di memoria. Il limite pratico a ciò che puoi eseguire è la RAM (e su una GPU, la VRAM).

La quantizzazione è il trucco chiave che lo rende fattibile su macchine normali. I pesi del modello sono originariamente memorizzati in alta precisione (es. 16 bit), ma possono essere compressi a ~4 bit con un costo in qualità ridotto e spesso appena percepibile. Ollama distribuisce la maggior parte dei modelli già quantizzati — ecco perché un modello con miliardi di parametri può starci in pochi GB. Una regola empirica approssimativa (verifica sulla pagina del modello specifico):

  • Modelli ~1B–3B: girano comodamente sulla maggior parte dei portatili moderni (pochi GB di RAM).
  • Modelli ~7B–8B: il punto ideale tra capacità ed eseguibilità; calcola diversi GB di RAM libera.
  • Modelli ~13B–14B: richiedono una macchina piuttosto ben dotata.
  • Modelli ~70B+: richiedono una workstation/server con molta RAM o una GPU potente — non è territorio da portatile tipico.

Una ricetta pratica: parti da un modello piccolo (gemma4:e2b), conferma il flusso end-to-end, poi sali al modello più grande che gira ancora fluido sul tuo hardware — non al più grande che esiste.

Vocabolario dei modelli locali
Premi Invio o Spazio per girare la carta. Usa le frecce sinistra e destra per spostarti tra le carte.Termine mostrato.
1 / 6

LM Studio: un'alternativa con interfaccia grafica​

Se la riga di comando non fa per te, LM Studio è un'app desktop (macOS, Windows, Linux) che fa lo stesso lavoro tramite un'interfaccia grafica: sfogli e scarichi modelli aperti, ci chatti in una UI integrata e — come Ollama — avvia un server locale compatibile con OpenAI così il tuo codice può parlargli. È la via d'ingresso più facile per chi non sviluppa o per chi preferisce il punta-e-clicca al terminale; Ollama tende a vincere quando vuoi una CLI scriptabile e un servizio leggero in background. Entrambi eseguono lo stesso tipo di modelli open-weight, quindi i concetti di questa pagina si trasferiscono direttamente.

Verifica te stesso

0/4
  1. Qual è il singolo compromesso onesto più grande dell'eseguire un modello in locale rispetto a un modello cloud di frontiera?
  2. Quale comando scarica un modello (se serve) E inizia a chattare con esso?
  3. Per chiamare il tuo modello locale da codice con l'SDK di OpenAI, cosa imposti?
  4. Perché un modello con miliardi di parametri può stare in pochi GB di RAM?
Key takeaways
  • Locale = privacy + offline + nessun costo per token + controllo; il compromesso è un reale divario di capacità e i limiti dell'hardware.
  • Bastano due comandi: installa Ollama, poi ollama run gemma4:e2b.
  • CLI di base: pull (scarica), run (chatta), list, ps, stop, rm — è quasi tutto.
  • Chiamalo da codice tramite l'endpoint compatibile con OpenAI: base_url http://localhost:11434/v1, qualsiasi api_key non vuota.
  • Numero di parametri + quantizzazione decidono se la tua macchina può eseguire un modello — parti piccolo, poi sali a ciò che gira fluido.
  • Preferisci una GUI? LM Studio fa lo stesso lavoro con il punta-e-clicca ed espone anch'esso un server locale compatibile con OpenAI.

Fonti e approfondimenti​

Prossimo passo​