Modelli locali con Ollama: cosa ci fai davvero

Sul laptop con cui sto scrivendo, un modello linguistico da otto miliardi di parametri risponde in italiano, riassume documenti e scrive codice. Non manda un solo byte fuori dalla macchina, non costa nulla a chiamata e funziona anche in aereo. Tre anni fa sarebbe sembrato un trucco; oggi è un comando da terminale. Il merito è di due cose: la quantizzazione, che comprime i modelli fino a farli stare in memorie normali, e strumenti come Ollama, che nascondono tutta la complessità dietro un’interfaccia da manuale.

Questo tutorial fa due cose: ti porta da zero a interrogare un modello locale da Python, e ti dice — senza illusioni — cosa puoi aspettarti davvero dal tuo hardware.

Installazione e primo modello

Ollama è un runtime open source che scarica, gestisce ed esegue modelli open weights (Llama, Qwen, Gemma, Mistral e molti altri) esponendoli su un server locale. Su Linux si installa con uno script, su macOS e Windows con un installer dal sito ufficiale:

curl -fsSL https://ollama.com/install.sh | sh
ollama pull llama3.2      # scarica un modello da 3B, ~2 GB
ollama run llama3.2       # chat interattiva nel terminale

Il comando pull funziona come per le immagini Docker: scarica il modello una volta sola e lo tiene in una cache locale. Da quel momento Ollama espone una API REST su localhost:11434, ed è lì che entra in gioco Python.

Parlare col modello da Python

Il pacchetto ufficiale si installa con pip install ollama. La chiamata di base ricalca il formato a messaggi ormai standard:

import ollama

risposta = ollama.chat(
    model="llama3.2",
    messages=[
        {"role": "system",
         "content": "Rispondi in italiano, in modo conciso."},
        {"role": "user",
         "content": "Spiega la quantizzazione in due frasi."},
    ],
)
print(risposta["message"]["content"])

Per un uso interattivo conviene lo streaming, che mostra i token man mano che vengono generati invece di far attendere la risposta completa:

stream = ollama.chat(
    model="llama3.2",
    messages=[{"role": "user",
               "content": "Tre usi sensati di un LLM locale?"}],
    stream=True,
)
for pezzo in stream:
    print(pezzo["message"]["content"], end="", flush=True)

E siccome il server locale parla HTTP, puoi anche fare a meno del pacchetto e usare requests: utile per capire che sotto non c’è nessuna magia, solo una API sulla tua macchina:

import requests

r = requests.post(
    "http://localhost:11434/api/generate",
    json={"model": "llama3.2",
          "prompt": "Completa: il vantaggio di un modello locale è",
          "stream": False},
)
print(r.json()["response"])

Personalizzare il modello con un Modelfile

Ripetere lo stesso prompt di sistema a ogni chiamata è scomodo. Ollama risolve con il Modelfile, un file di configurazione che ricorda il Dockerfile: parti da un modello esistente, gli cuci addosso istruzioni e parametri, e ne ottieni una versione tua pronta all’uso. Salva queste righe in un file chiamato Modelfile:

FROM llama3.2

# istruzioni permanenti, valide per ogni conversazione
SYSTEM """Sei un assistente editoriale italiano.
Rispondi in modo conciso e non inventare fonti."""

# temperatura bassa = risposte piu' prevedibili
PARAMETER temperature 0.3

Poi lo si registra una volta e lo si usa come qualsiasi altro modello, anche da Python passando il nuovo nome a model=:

ollama create redattore -f Modelfile
ollama run redattore "Riscrivi in modo piu' chiaro: ..."

È l’equivalente locale di un «assistente configurato»: il comportamento è fissato nel modello, non ripetuto a ogni richiesta. Utile quando lo stesso profilo serve a più script.

La domanda vera: quanta memoria hai?

Qui il tutorial diventa una questione di fisica. Un modello quantizzato a 4 bit occupa all’incirca mezzo gigabyte per miliardo di parametri, più un margine per il contesto: un 8B chiede circa 5-6 GB, un 70B oltre 40. La memoria che conta è quella accessibile alla GPU — la VRAM su PC con scheda dedicata, la memoria unificata sui Mac Apple Silicon. Se il modello non ci sta, Ollama lo fa girare (in tutto o in parte) su CPU: funziona, ma la velocità crolla da «conversazione» a «attesa».

L’analogia giusta è la cilindrata: non esiste il modello «migliore» in assoluto, esiste il più grande che il tuo motore muove a velocità accettabile.

Cosa puoi far girare in base alla memoria GPU (o unificata, sui Mac). Le soglie sono indicative e valgono per la quantizzazione a 4 bit, quella usata di default da Ollama.

Un esempio concreto: estrarre dati da testo, gratis e offline

Dove un modello locale rende di più non è la chat, ma l’elaborazione ripetitiva: classificare, estrarre, riformattare centinaia di testi senza pagare una API a chiamata e senza mandare dati fuori. Ecco un estrattore di informazioni strutturate che forza l’output in JSON:

import json
import ollama

recensioni = [
    "Consegna rapidissima ma il prodotto è arrivato graffiato.",
    "Ottimo rapporto qualità-prezzo, lo ricomprerei.",
    "Assistenza clienti inesistente, esperienza pessima.",
]

schema = {
    "type": "object",
    "properties": {
        "sentimento": {"type": "string",
                       "enum": ["positivo", "negativo", "misto"]},
        "tema": {"type": "string"},
    },
    "required": ["sentimento", "tema"],
}

for testo in recensioni:
    r = ollama.chat(
        model="llama3.2",
        messages=[{"role": "user",
                   "content": f"Analizza questa recensione: {testo}"}],
        format=schema,   # output vincolato allo schema JSON
    )
    print(json.loads(r["message"]["content"]))

Il parametro format vincola la generazione allo schema: niente parsing fragile di testo libero. Su un laptop con 8 GB questo giro processa qualche recensione al secondo — lento per un servizio pubblico, perfetto per un batch notturno sui tuoi dati.

Cosa ci fai davvero (e cosa no)

Dopo qualche settimana di uso reale, il bilancio onesto è questo. Un modello locale nella fascia 8-14B è genuinamente utile per: riassunti e bozze, estrazione e classificazione di testi, ricerca semantica sui propri documenti (gli embedding locali, via ollama.embed, sono ottimi), completamento di codice, e qualsiasi cosa coinvolga dati che non vuoi o non puoi mandare a terzi.

Dove invece i modelli piccoli deludono: ragionamento a più passaggi, domande di cultura generale molto specifiche (meno parametri significa letteralmente meno cose memorizzate), lingue diverse dall’inglese su modelli piccoli — l’italiano migliora sensibilmente salendo di taglia — e tutto ciò che richiede affidabilità da produzione. Un 8B locale non è un modello di frontiera compresso: è un altro strumento, con un altro punto di equilibrio.

Il modello locale non sostituisce l’API di frontiera: la complementa. Uno gestisce il volume e i dati sensibili, l’altra i casi difficili.

Perché ti riguarda

Provare Ollama costa mezz’ora e zero euro, e ti dà tre cose. La prima è un laboratorio personale: puoi sperimentare prompt, embedding e fine-tuning senza contatori che girano. La seconda è un’opzione strategica: sapere cosa gira in casa ti dice quanto sei davvero dipendente dai fornitori cloud, ed è la stessa domanda che si fanno le aziende quando valutano i costi dell’AI su larga scala. La terza è la comprensione: quando il modello gira sulla tua macchina, con la tua memoria e i tuoi limiti, smette di essere un oracolo remoto e diventa quello che è — un file di pesi, un runtime, e una quantità sorprendente di cose utili che puoi già fare oggi.