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 — la puoi scaricare ed eseguire sul tuo laptop o 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, chiamandolo da codice, e conoscendo i compromessi così da non aspettarti che un modello locale da 7B si comporti come uno di frontiera.

What you'll learn
  • Sapere PERCHÉ eseguiresti un modello in locale — e i compromessi onesti rispetto ai modelli di frontiera nel cloud
  • Installare Ollama ed eseguire il primo modello in due comandi
  • Usare la CLI di base: pull, run, list, ps, rm, stop
  • Chiamare il modello locale da codice tramite l'API OpenAI-compatibile di Ollama
  • Capire i requisiti di RAM, le dimensioni dei modelli e la quantizzazione — così scegli un modello che la tua macchina può davvero 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 compra quattro cose:

  • Privacy — i tuoi prompt e dati non lasciano mai la tua macchina. Il motivo per cui i team in domini 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 outage. Il modello è un file sul tuo disco.
  • Costo — nessun conto 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 rate limit o sorprese nei termini di servizio.

I compromessi onesti:

  • Gap di capacità. Un modello che puoi eseguire su un laptop (1B–14B parametri) non è nella stessa lega di un modello di frontiera nel cloud su ragionamento difficile, contesto lungo o compiti agentici. Per molti compiti quotidiani il gap è 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 stai scegliendo il modello più grande che il tuo hardware può eseguire, non il modello migliore che esiste.
  • Lo gestisci tu. Nessuno scaling gestito, nessun upgrade automatico — è il prezzo del controllo.

Un pattern comune e duraturo: prototipa e scegli con una piccola eval (stesso metodo dei modelli cloud — vedi Scegliere un modello), usa il locale per il lavoro privato/offline/economico su larga scala, e ricorri a un'API di frontiera quando il compito ha genuinamente bisogno della capacità extra.

Installa Ollama ed esegui il 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 (sotto). Questo installa il comando ollama e un servizio di background locale.

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

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

Scarica ed esegui un modello piccolo (buona prima scelta)

ollama run llama3.2

Quel singolo comando scarica sia llama3.2 (un piccolo modello classe 1B/3B che gira su hardware modesto) sia avvia una chat interattiva. Per scaricare senza ancora chattare, usa invece ollama pull.

La CLI di base​

Una manciata di comandi copre quasi tutto. Esegui ollama --help per la lista completa.

# 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

All'interno di una sessione interattiva ollama run, digita /bye per uscire e /? per vedere i comandi in-sessione. Il servizio di background che effettivamente serve i modelli è avviato da ollama serve (l'app desktop lo avvia automaticamente per te).

Chiamalo da codice (API OpenAI-compatibile)​

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

HTTP grezzo con curl (endpoint nativo):

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

Da Python usando l'SDK ufficiale di OpenAI — basta puntare base_url a Ollama e passare qualsiasi api_key non vuota (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="llama3.2",
    messages=[
        {"role": "system", "content": "You are a concise assistant."},
        {"role": "user", "content": "Explain gradient descent in two sentences."},
    ],
)

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

Poiché è OpenAI-compatibile, gli stessi pattern che useresti contro un'API hosted si trasferiscono — inclusi streaming e tool use / function calling, che funzionano in locale allo stesso modo che nel cloud (a condizione che il modello sia effettivamente bravo a farlo). Il layer /v1 di Ollama copre /v1/chat/completions, /v1/completions, /v1/models e /v1/embeddings, tra gli altri.

Hardware, dimensioni dei modelli e quantizzazione​

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

La quantizzazione è il trucco chiave che rende questo fattibile su macchine normali. I pesi del modello sono originariamente memorizzati ad alta precisione (es. 16-bit), ma possono essere compressi a ~4-bit con un piccolo costo di qualità, spesso appena percettibile. Ollama distribuisce la maggior parte dei modelli quantizzati per default — è per questo che un modello con miliardi di parametri può stare in pochi GB. Una regola pratica approssimativa (verifica sulla pagina del modello specifico):

  • Modelli ~1B–3B: girano comodamente sulla maggior parte dei laptop moderni (pochi GB di RAM).
  • Modelli ~7B–8B: il punto ottimale per capace-ma-eseguibile; metti in conto diversi GB di RAM libera.
  • Modelli ~13B–14B: richiedono una macchina abbastanza ben equipaggiata.
  • Modelli ~70B+: richiedono una workstation/server con molta RAM o una GPU potente — non territorio da laptop tipico.

Una ricetta pratica: parti con un modello piccolo (llama3.2), conferma il flusso end-to-end, poi sali verso l'alto fino al modello più grande che gira ancora fluido sul tuo hardware — non il 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 GUI​

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: sfoglia e scarica modelli aperti, chatta con loro in una UI integrata, e — come Ollama — esegui un server locale OpenAI-compatibile così il tuo codice può parlarci. È la rampa d'accesso più facile per non-sviluppatori o chiunque preferisca il punta-e-clicca a un terminale; Ollama tende a vincere quando vuoi una CLI scriptabile e un servizio di background leggero. Entrambi eseguono gli stessi tipi di modelli open-weight, quindi i concetti di questa pagina si trasferiscono direttamente.

Mettiti alla prova

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

Fonti e approfondimenti​

Prossimi passi​