Come Eseguire un LLM in Locale con Ollama

Ogni chiamata a un’API LLM ospitata manda il tuo prompt sul server di qualcun altro e ti fattura per token. Se perdi la connessione di rete, smette di rispondere. Ollama toglie di mezzo entrambi i problemi: scarica un modello open-weight sulla tua macchina e lo serve tramite un’API REST su localhost:11434. Un solo binario fa da gestore dei modelli, client di chat e server.

Cosa fa davvero Ollama

Ollama avvolge llama.cpp e motori di inferenza simili, così non devi mai toccare un flag del compilatore o un percorso di libreria CUDA. ollama pull llama3.2 scarica un file di modello quantizzato (formato GGUF) dal registro di Ollama invece che da Hugging Face, anche se può importare file GGUF anche da lì. Quando esegui il modello, quei pesi passano a un server in background: li carica in RAM (o in VRAM, se trova una GPU compatibile), li tiene residenti per qualche minuto dopo l’ultima richiesta così la successiva è veloce, e li scarica non appena smetti di fare domande.

La CLI, l’API e il sistema dei Modelfile poggiano tutti sullo stesso compito: portare i pesi in memoria, instradare le richieste verso quel server.

Come installare Ollama ed eseguire il primo modello

Su Linux o macOS:

1

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

Su Windows, esegui l’installer da ollama.com, oppure usa:

1

irm https://ollama.com/install.ps1 | iex

In entrambi i casi ottieni la CLI ollama e un server in background in ascolto sulla porta 11434. Scarica un modello piccolo e parlaci:

1
2

ollama pull llama3.2
ollama run llama3.2

ollama run ti porta in un prompt interattivo. Fai una domanda, leggi la risposta, /bye per uscire. Altri tre comandi che userai di continuo:

1
2
3

ollama list   # i modelli che hai scaricato, con la dimensione su disco
ollama ps     # i modelli attualmente caricati in memoria
ollama rm llama3.2   # libera lo spazio su disco

llama3.2 è un buon primo modello da scaricare: circa 2 GB, abbastanza veloce da girare sulla CPU di un laptop. Non è il modello più forte della sua fascia di dimensione. gemma4 guida la fascia piccola in questo momento e gestisce anche le immagini, mentre qwen3-coder è la scelta migliore se stai testando assistenza alla scrittura di codice. Parti comunque da llama3.2, perché dimostra che la tua configurazione funziona prima di impegnarti in un download da 20 GB.

Come comunicare con Ollama tramite la sua API REST

Il prompt interattivo serve a verificare che tutto funzioni. Qualunque cosa tu costruisca, chiama l’API. Il formato nativo di Ollama è questo:

1
2
3
4
5

curl http://localhost:11434/api/generate -d '{
  "model": "llama3.2",
  "prompt": "Write a one-line commit message for a typo fix in README.md",
  "stream": false
}'

Con "stream": false ricevi un solo oggetto JSON, che include eval_count e eval_duration, sufficienti per misurare i token al secondo sul tuo hardware. Impostalo su true e ottieni invece una serie di oggetti di risposta parziale, quello che serve a un’interfaccia di chat.

Per le conversazioni multi-turno, /api/chat accetta un array messages nello stesso formato usato dall’API di OpenAI:

1
2
3
4
5
6
7

curl http://localhost:11434/api/chat -d '{
  "model": "llama3.2",
  "messages": [
    {"role": "user", "content": "What port does Ollama listen on by default?"}
  ],
  "stream": false
}'

Ollama parla anche il formato dell’API OpenAI in modo nativo su /v1, quindi gli SDK ufficiali di OpenAI ci funzionano senza modifiche:

1
2
3
4
5
6
7
8
9

from openai import OpenAI

client = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")

response = client.chat.completions.create(
    model="llama3.2",
    messages=[{"role": "user", "content": "Summarize this changelog in two sentences."}],
)
print(response.choices[0].message.content)

Ollama ignora api_key, ma il costruttore dell’SDK ne pretende uno, quindi va bene qualsiasi stringa non vuota. Questo lo rende il modo più rapido per puntare uno strumento già basato su OpenAI verso un modello locale: cambi base_url e lasci il resto del codice com’è.

Un altro endpoint conta se stai assemblando una pipeline di retrieval-augmented generation in locale. POST /api/embed trasforma il testo in vettori usando un modello di embedding (nomic-embed-text è la scelta più comune), cosa che un modello di chat da solo non ti dà.

Come eseguire Ollama in Docker

Se tutto il resto sulla macchina è già un container, Ollama fornisce un’immagine ufficiale invece di chiederti di installare qualcosa sull’host:

1
2
3
4
5

docker run -d \
  -v ollama:/root/.ollama \
  -p 11434:11434 \
  --name ollama \
  ollama/ollama

In pratica il volume nominato non è opzionale: senza, ogni modello che hai scaricato sparisce nel momento in cui il container viene rimosso. Per scaricare ed eseguire un modello dentro il container in esecuzione:

1

docker exec -it ollama ollama run llama3.2

Su una macchina con GPU NVIDIA, installa prima l’NVIDIA Container Toolkit sull’host, poi aggiungi un solo flag:

1
2
3
4
5

docker run -d --gpus=all \
  -v ollama:/root/.ollama \
  -p 11434:11434 \
  --name ollama \
  ollama/ollama

Le GPU AMD usano un tag di immagine separato e il mount dei device al posto di --gpus:

1
2
3
4
5

docker run -d --device /dev/kfd --device /dev/dri \
  -v ollama:/root/.ollama \
  -p 11434:11434 \
  --name ollama \
  ollama/ollama:rocm

La stessa cosa come servizio Docker Compose mantiene la porta e il volume, niente di più:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

services:
  ollama:
    image: ollama/ollama
    ports:
      - "11434:11434"
    volumes:
      - ollama:/root/.ollama

volumes:
  ollama:

Esporre quel container oltre localhost è un compito per un reverse proxy con TLS davanti. Ollama non ha un’autenticazione propria, quindi una porta 11434 raggiungibile dalla rete è un server di modelli che chiunque può usare.

Come personalizzare un modello con un Modelfile

Un Modelfile fissa un system prompt, una temperatura e una sequenza di stop su un modello esistente senza doverlo riaddestrare. Crea un file chiamato Modelfile:

1
2
3
4
5
6
7
8

FROM llama3.2

PARAMETER temperature 0.3

SYSTEM """
You are a terse code reviewer. Reply with the diff and one sentence of
rationale. Never restate the code you were not asked to change.
"""

Poi costruiscilo ed eseguilo:

1
2

ollama create code-reviewer -f Modelfile
ollama run code-reviewer

code-reviewer compare ora come voce a sé stante in ollama list, anche se i pesi sono esattamente quelli usati da llama3.2. Solo il system prompt e i parametri di sampling sono incorporati. Il vantaggio è che ogni client che chiama quel nome eredita la configurazione senza doverla inviare.

Quale dimensione di modello si adatta alla tua RAM

Il numero nel nome di un modello è il suo numero di parametri, e predice abbastanza bene di quanta RAM (o VRAM, per l’inferenza su GPU) hai bisogno:

Questi numeri presuppongono la quantizzazione a 4 bit che Ollama scarica di default: scambia un po’ di qualità dell’output per un download e un ingombro in memoria circa quattro volte più piccoli rispetto ai pesi a piena precisione. Per riassumere testo o scrivere bozze di commit message, la quantizzazione non è ciò che noterai. Finire la RAM, sì. Una volta che il modello finisce nello swap su disco, passa da lento a inutilizzabile, una differenza molto più grande di un punto di accuratezza.

Quando Ollama non è lo strumento giusto

Ollama è pensato per un utente che parla con un modello su una macchina. Non fa batching delle richieste né alcuno scheduling che permetta a una GPU di servire decine di utenti in parallelo in modo efficiente, compito che spetta a vLLM, TGI o un’API ospitata. Se stai per mettere un modello locale davanti a traffico reale, misura il throughput di Ollama sotto carico concorrente prima di impegnarti: una singola istanza si pianta molto prima di quanto farebbe un server con batching vero.

Non è nemmeno uno strumento di fine-tuning. Un Modelfile cambia un system prompt e i parametri di sampling, mai i pesi. Far imparare al modello un comportamento nuovo dai tuoi esempi è una pipeline a parte.

Nessuno dei due limiti riguarda uno sviluppatore su un laptop. Scarica un modello che stia comodamente sotto il tuo tetto di RAM, eseguilo una volta dalla CLI, poi interrogalo con curl su /api/generate. Se la risposta torna in un paio di secondi e ha il contenuto che ti aspettavi, hai un server di inferenza locale che qualsiasi strumento compatibile con OpenAI può usare.

Articoli correlati

• Cos’è il RAG: la Retrieval-Augmented Generation Spiegata
• Cos’è Docker Compose e Come si Usa
• Cos’è un Reverse Proxy e Come Funziona