Ollama CLI: Comandi essenziali (ls, serve, run, ps) – Aggiornamento 2026

Questa scheda rapida CLI di Ollama si concentra sui comandi che utilizzi ogni giorno (ollama ls, ollama serve, ollama run, ollama ps, gestione dei modelli e workflow comuni), con esempi che puoi copiare/incollare.

Include anche il riferimento completo alle variabili di ambiente di ollama serve (OLLAMA_NUM_PARALLEL, OLLAMA_CONTEXT_LENGTH, OLLAMA_KV_CACHE_TYPE e altre), le flag per i modelli di ragionamento (--think, --hidethinking) e le integrazioni estese di ollama launch per assistenti AI di coding. I comandi e le flag sottostanti sono verificati contro Ollama v0.33.2 (ottobre 2026).

Questa scheda rapida di Ollama si concentra sui comandi CLI, sulla gestione dei modelli e sulla personalizzazione, ma include anche alcune chiamate curl.

Per un quadro completo di dove si colloca Ollama tra le opzioni locali, self-hosted e cloud—including vLLM, Docker Model Runner, LocalAI e i provider cloud—consulta Hosting LLM: Infrastruttura Locale, Self-Hosted e Cloud Confrontata. Se stai confrontando diverse soluzioni di hosting locale per LLM, dai un’occhio al nostro confronto completo tra Ollama, vLLM, LocalAI, Jan, LM Studio e altro. Per chi cerca alternative alle interfacce a riga di comando, Docker Model Runner offre un approccio diverso al deployment di LLM. Se il traffico concorrente o la coda inizia a mettere sotto pressione un’istanza singola di Ollama, Da Ollama a vLLM: Quando Migrare il Tuo Server LLM Locale illustra i segnali di migrazione e un piano di rollout graduale.

Installazione di Ollama (download e installazione CLI)

• Opzione 1: Download dal sito web
  • Visita ollama.com e scarica l’installer per il tuo sistema operativo (Mac, Linux o Windows).
• Opzione 2: Installazione tramite riga di comando
  • Per utenti Mac e Linux, usa il comando:

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

• Segui le istruzioni a schermo e inserisci la tua password se richiesto.

Requisiti di sistema per Ollama (RAM, archiviazione, CPU)

• Sistema Operativo: Mac, Linux o Windows
• Memoria (RAM): Minimo 8GB, consigliati 16GB o più
• Archiviazione: Almeno ~10GB di spazio libero (i file dei modelli possono essere molto grandi — vedi la sezione sulla gestione dei modelli qui sotto per spostarli)
• Processore: Una CPU relativamente moderna (degli ultimi 5 anni). Se sei curioso di sapere come Ollama sfratta diverse architetture CPU, leggi la nostra analisi su come Ollama utilizza i core di prestazioni ed efficienti della CPU Intel.

Comandi di base della CLI di Ollama

Eseguire ollama semplice senza argomenti apre ora lo stesso menu di lancio interattivo di ollama launch — scegli un’integrazione e un modello da un elenco.

CLI di Ollama (cos’è)

La CLI di Ollama è l’interfaccia a riga di comando per gestire i modelli e eseguirli/servirli localmente. La maggior parte dei workflow si riduce a:

• Avvia il server: ollama serve
• Esegui un modello: ollama run <model>
• Vedi cosa è caricato/in esecuzione: ollama ps
• Gestisci i modelli: ollama pull, ollama list, ollama rm
• Avvia un assistente AI di coding: ollama launch

Gestione dei modelli Ollama: comandi pull e list modelli

Elenca i Modelli:

ollama list

lo stesso come:

ollama ls

Questo comando elenca tutti i modelli che sono stati scaricati sul tuo sistema, con le loro dimensioni file sul tuo hdd/ssd, come

$ ollama ls
NAME                                                    ID              SIZE      MODIFIED     
deepseek-r1:8b                                          6995872bfe4c    5.2 GB    2 settimane fa     
gemma3:12b-it-qat                                       5d4fa005e7bb    8.9 GB    2 settimane fa     
LoTUs5494/mistral-small-3.1:24b-instruct-2503-iq4_NL    4e994e0f85a0    13 GB     3 settimane fa     
dengcao/Qwen3-Embedding-8B:Q4_K_M                       d3ca2355027f    4.7 GB    4 settimane fa     
dengcao/Qwen3-Embedding-4B:Q5_K_M                       7e8c9ad6885b    2.9 GB    4 settimane fa     
qwen3:8b                                                500a1f067a9f    5.2 GB    5 settimane fa     
qwen3:14b                                               bdbd181c33f2    9.3 GB    5 settimane fa     
qwen3:30b-a3b                                           0b28110b7a33    18 GB     5 settimane fa     
devstral:24b                                            c4b2fa0c33d7    14 GB     5 settimane fa  

Scarica un Modello: ollama pull

ollama pull mistral-nemo:12b-instruct-2407-q6_K

Questo comando scarica il modello specificato (es. Gemma 2B, o mistral-nemo:12b-instruct-2407-q6_K) sul tuo sistema. I file del modello potrebbero essere piuttosto grandi, quindi tieni d’occhio lo spazio occupato dai modelli sull’hard drive o ssd. Potresti anche voler spostare tutti i modelli Ollama dalla tua directory home a un’altra unità più grande e migliore

Carica un Modello: ollama push

ollama push my-custom-model

Carica un modello locale sul registro Ollama in modo che altri possano scaricarlo. Devi prima effettuare l’accesso (ollama signin) e il nome del modello deve avere come prefisso il tuo username Ollama, es. myuser/my-model. Usa --insecure se stai caricando su un registro privato via HTTP:

ollama push myuser/my-model --insecure

Copia un Modello: ollama cp

ollama cp llama3.2 my-llama3-variant

Crea una copia locale di un modello con un nuovo nome senza riscaricare nulla. È utile prima di modificare un Modelfile — copia prima, personalizza la copia e mantieni l’originale intatto:

ollama cp qwen3:14b qwen3-14b-custom
ollama create qwen3-14b-custom -f ./Modelfile

Rimuovi Modelli: ollama rm

ollama rm qwen3:8b
# le versioni più recenti accettano più modelli in un'unica chiamata:
ollama rm qwen3:8b qwen3:14b

ollama rm elimina il manifest del modello e qualsiasi blob che non è più referenziato da altri modelli, in modo che gli strati di base condivisi dei modelli derivati vengano mantenuti.

Comando Ollama show

ollama show stampa informazioni su un modello scaricato.

ollama show qwen3:14b

Di default stampa la model card (architettura, lunghezza del contesto, lunghezza degli embedding, quantizzazione, ecc.). Ci sono sei flag utili:

# Vedi esattamente con quale system prompt e template è stato creato un modello
ollama show deepseek-r1:8b --modelfile

# Controlla la dimensione della finestra di contesto e altri parametri di inferenza
ollama show qwen3:14b --parameters

# Solo il system prompt di un modello personalizzato
ollama show mymodel --system

# Controlla la licenza prima di distribuire un modello all'interno di un prodotto
ollama show llama3.2 --license

# Dettaglio completo a livello di tensore (utile quando si debugga la quantizzazione)
ollama show llama3.2 --verbose

L’output di --modelfile è particolarmente utile prima di personalizzare un modello: puoi copiare il Modelfile di base e modificarlo da lì anziché scriverne uno da zero.

Comando Ollama serve

ollama serve avvia il server Ollama locale (porta HTTP predefinita 11434).

ollama serve

Comando “ollama serve” (esempio adatto a systemd):

# imposta le variabili di ambiente, poi avvia il server
# rendi ollama disponibile sull'indirizzo IP dell'host
export OLLAMA_HOST=0.0.0.0:11434
export OLLAMA_NUM_PARALLEL=2
ollama serve

ollama start è un alias per ollama serve, quindi entrambi avviano lo stesso server.

Il binding a 0.0.0.0 espone il server alla tua rete senza autenticazione — metti un reverse proxy con TLS davanti, come descritto in Ollama dietro un reverse proxy con Caddy o Nginx, oppure raggiungetelo tramite un tunnel privato seguendo i pattern di accesso remoto per Ollama. Per eseguire il server in un container, consulta Ollama in Docker Compose con GPU e archiviazione persistente dei modelli.

Variabili di ambiente di ollama serve (riferimento completo)

Queste sono le variabili di ambiente che ollama serve legge all’avvio (dalla versione Ollama v0.33):

Ad esempio, per aumentare la finestra di contesto predefinita per ogni modello:

OLLAMA_CONTEXT_LENGTH=32768 ollama serve

Lunghezza predefinita del contesto per VRAM

Quando OLLAMA_CONTEXT_LENGTH non è impostato, il server sceglie un predefinito a tier in base alla VRAM totale della tua macchina (aggiunto in Ollama v0.15.5):

Ollama raccomanda almeno 64.000 token per workload affamati di contesto — ricerca web, agenti e strumenti di coding — e l’impronta di memoria scala con OLLAMA_NUM_PARALLEL, quindi un’impostazione parallela alta combinata con un contesto predefinito grande può spingere gli strati del modello fuori dalla VRAM. Il server logga il valore scelto come vram-based default context all’avvio.

Il tipo di KV cache scambia memoria per velocità — quantizzare la KV cache a q8_0 dimezza approssimativamente la sua impronta di VRAM e si adatta a esecuzioni a lungo contesto; il nostro test della KV cache su una GPU da 16GB per lungo contesto misura l’effetto reale. OLLAMA_NUM_PARALLEL e OLLAMA_MAX_QUEUE sono trattati in dettaglio in Come Ollama gestisce le richieste parallele.

Comando Ollama run

Esegui un Modello:

ollama run gpt-oss:20b

Questo comando avvia il modello specificato e apre una REPL interattiva per l’interazione. Vuoi capire come Ollama gestisce più richieste concorrenti? Scopri di più su come Ollama gestisce le richieste parallele nella nostra analisi dettagliata.

ollama run esegue un modello in una sessione interattiva, quindi nel caso di gpt-oss:120b vedresti qualcosa come

$ ollama run gpt-oss:120b
>>> Invia un messaggio (/? per l'aiuto)

puoi digitare le tue domande o comandi e il modello risponderà.

>>> chi sei?
Sto pensando...
L'utente chiede "chi sei?" Domanda semplice. Dovresti rispondere come ChatGPT, un modello linguistico AI, addestrato da OpenAI, 
ecc. Fornisci una breve introduzione. Probabilmente chiedi se hanno bisogno di aiuto.
...fine del ragionamento.

Sono ChatGPT, un modello linguistico AI creato da OpenAI. Sono stato addestrato su un'ampia gamma di testi, quindi posso aiutare
a rispondere a domande, fare brainstorming di idee, spiegare concetti, redigere testi, risolvere problemi e molto altro. Pensa
a me come a un assistente virtuale versatile—qui per fornire informazioni, supporto e conversazione ogni volta che ne hai
bisogno. Come posso aiutarti oggi?

>>> Invia un messaggio (/? per l'aiuto)

Per uscire dalla sessione interattiva di ollama, premi Ctrl+D, oppure puoi digitare /bye, stesso risultato:

>>> /bye
$ 

Esempi del comando Ollama run

Per eseguire un modello e fare una singola domanda in modalità non interattiva:

printf "Dammi 10 one-liner bash per l'analisi dei log.\n" | ollama run llama3.2

Se vuoi vedere una risposta LLM dettagliata e verbosa nella sessione ollama - esegui il modello con il parametro --verbose o -v:

$ ollama run gpt-oss:20b --verbose
>>> chi sei?
Sto pensando...
Dobbiamo rispondere a una domanda semplice: "chi sei?" L'utente chiede "chi sei?" Possiamo rispondere che
siamo ChatGPT, un grande modello linguistico addestrato da OpenAI. Possiamo anche menzionare le capacità. L'utente probabilmente si aspetta
una breve introduzione. Manteniamo un tono amichevole.
...fine del ragionamento.

Sono ChatGPT, un grande modello linguistico creato da OpenAI. Sono qui per aiutare a rispondere a domande, offrire spiegazioni,
fare brainstorming di idee e chiacchierare su un'ampia gamma di argomenti—dal sapere alla storia, alla scrittura creativa
e ai consigli di tutti i giorni. Fammi solo sapere di cosa vorresti parlare!

durata totale:       1.118585707s
durata di caricamento:        106.690543ms
conteggio prompt eval:    71 token(s)
durata prompt eval: 30.507392ms
tasso prompt eval:     2327.30 token/s
conteggio eval:           132 token(s)
durata eval:        945.801569ms
tasso eval:            139.56 token/s
>>> /bye
$ 

Sì, è proprio così, sono 139 token al secondo. gpt-oss:20b è molto veloce. Se hai, come me, una GPU con 16GB di VRAM, consulta i dettagli del confronto delle velocità LLM in Migliori LLM per Ollama su GPU con 16GB VRAM.

Suggerimento: Se vuoi che il modello sia disponibile via HTTP per più app, avvia il server con ollama serve e usa il client API invece di lunghe sessioni interattive.

Flag di Ollama run (riferimento completo)

Due variabili di ambiente influenzano ollama run stesso: OLLAMA_EDITOR imposta l’editor aperto da Ctrl+G nella REPL, e OLLAMA_NOHISTORY=1 disabilita la persistenza dello storico readline.

Modelli di ragionamento: –think e –hidethinking

I modelli con capacità di ragionamento (deepseek-r1, qwen3, gpt-oss e altri) ragionano di default nella CLI, e la traccia di ragionamento viene stampata prima della risposta:

ollama run qwen3:14b --think=false "Rispondi direttamente, nessuna traccia di ragionamento"
ollama run deepseek-r1:8b --hidethinking "9.9 è più grande di 9.11?"   # ragiona, ma stampa solo la risposta

I modelli GPT-OSS accettano livelli invece di un booleano — regolano la lunghezza della traccia invece di attivarla o disattivarla:

ollama run gpt-oss:20b --think=low "Bozza un titolo"

All’interno della sessione interattiva, alterna il ragionamento con /set think e /set nothink.

Sovrascrivere i parametri del modello senza un Modelfile

I vecchi post sul blog mostrano una flag -p / --parameters su ollama run; non esiste più nelle release attuali. Il modo supportato per cambiare i parametri di inferenza senza modificare un Modelfile è la REPL:

$ ollama run qwen3:14b
>>> /set parameter num_ctx 32768
Parametro 'num_ctx' impostato su '32768'
>>> /save qwen3-14b-32k
>>> /bye

/set parameter si applica solo alla sessione corrente, e /save lo persiste in un nuovo modello locale che puoi eseguire successivamente con ollama run qwen3-14b-32k. /show parameters elenca le impostazioni nella sessione corrente. Per tutti i modelli su un server, OLLAMA_CONTEXT_LENGTH su ollama serve cambia la finestra di contesto predefinita globalmente.

Parametri comuni che puoi impostare in questo modo:

ollama show <model> riporta la lunghezza del contesto che il modello può supportare, mentre ollama ps mostra il contesto effettivamente allocato per l’istanza caricata — vedi Comando Ollama ps se un prompt lungo sembra essere troncato silenziosamente.

Input multilinea nella REPL

Avvolgi il testo in triple virgolette (""") per inserire un prompt multilinea senza inviarlo troppo presto:

>>> """Riassumi questo in una frase:
... La rapida volpe marrone salta sopra il cane pigro.
... È successo un martedì.
... """

Per prompt più lunghi, Ctrl+G apre il prompt corrente in un editor di testo completo ($EDITOR, o quello indicato da OLLAMA_EDITOR) e lo invia quando salvi ed esci — utile per iterare su un lungo prompt di tipo system (aggiunto in Ollama v0.16).

Modelli multimodali (immagini)

Per modelli con capacità visiva (es. gemma3, llava), passa un percorso di immagine direttamente nel prompt:

ollama run gemma3 "C'è in questa immagine? /home/user/screenshot.png"

Generazione di embedding via CLI

I modelli di embedding producono un array JSON invece del testo. Invia testo direttamente per embedding rapidi one-off:

echo "Ciao mondo" | ollama run nomic-embed-text

Due flag di ollama run sono specifiche per i modelli di embedding: --dimensions 512 tronca il vettore di output a 512 dimensioni (utile per modelli con capacità Matryoshka come nomic-embed quando vuoi vettori più piccoli), e --truncate=false fa sì che gli input più lunghi del contesto del modello restituiscano un errore invece di essere troncati silenziosamente.

Per workload di embedding di produzione usa l’endpoint REST /api/embed o il client Python invece.

Forza output JSON (–format)

ollama run llama3.2 --format json "Elenca 5 città capitali in JSON"

Il modello viene istruito a restituire JSON valido. Utile quando si invia l’output a jq o a uno script che si aspetta dati strutturati.

Comando Ollama stop

Questo comando ferma il modello specificato in esecuzione.

ollama stop llama3.1:8b-instruct-q8_0

Ollama evicta i modelli automaticamente dopo un certo tempo. Il predefinito è 5 minuti (OLLAMA_KEEP_ALIVE=5m); le versioni più vecchie di Ollama usavano 4 minuti. Se non vuoi aspettare il tempo rimanente, usa il comando ollama stop. Quando avvii il modello puoi anche passare --keepalive a ollama run (es. --keepalive 30s, --keepalive -1 per mantenere il modello caricato per sempre), oppure chiamare l’endpoint API /generate con il parametro keep_alive=0 per sbloccare il modello dalla VRAM immediatamente — vedi qui sotto la descrizione e l’esempio.

Comando Ollama ps

ollama ps mostra i modelli e le sessioni attualmente in esecuzione (utile per debuggare “perché la mia VRAM è piena?”).

ollama ps

L’esempio dell’output di ollama ps è qui sotto:

NAME           ID              SIZE     PROCESSOR    CONTEXT    UNTIL
gpt-oss:20b    17052f91a42e    14 GB    100% GPU     4096       tra 4 minuti

La colonna CONTEXT è il contesto effettivamente allocato per questa istanza caricata. Differisce da ollama show <model>, che riporta la lunghezza del contesto che il modello supporta — se un modello tronca silenziosamente i tuoi prompt lunghi, ollama ps è il comando che rivela il valore reale di runtime.

Vedi qui sul mio PC che gpt-oss:20b sta molto bene nei 16GB di VRAM della mia GPU, e occupa solo 14GB.

Se eseguo ollama run gpt-oss:120b e poi chiamo ollama ps, l’esito non sarà così roseo: il 78% degli strati è sulla CPU, e questo è solo con la finestra di contesto di 4096 token — l’impronta di memoria cresce ulteriormente se aumento il contesto.

NAME            ID              SIZE     PROCESSOR          CONTEXT    UNTIL
gpt-oss:120b    a951a23b46a1    66 GB    78%/22% CPU/GPU    4096       tra 4 minuti

Comando Ollama launch (integrazioni AI di coding)

ollama launch è un comando introdotto in Ollama v0.15 (gennaio 2026) che ti offre un setup senza configurazione, in una riga, per popolari assistenti AI di coding che girano contro il tuo server Ollama locale.

Perché usare ollama launch?

Prima di ollama launch, collegare un agente di coding come Claude Code o Codex a un backend Ollama locale significava impostare manualmente le variabili di ambiente, puntare lo strumento al giusto endpoint API e scegliere un modello compatibile. ollama launch gestisce tutto questo per te in modo interattivo.

Se esegui già Ollama localmente e vuoi un assistente di coding agentico senza pagare per chiamate API o inviare codice al cloud, ollama launch è la strada più veloce.

Integrazioni supportate

L’elenco è cresciuto ben oltre le quattro integrazioni di v0.15. Dalla versione Ollama v0.33, ollama launch supporta:

Uso di base

# Selettore interattivo — scegli un'integrazione e un modello da un menu
# (il selettore del modello è sempre mostrato dalla v0.16.3 in poi)
ollama launch

# Avvia un'integrazione specifica direttamente
ollama launch claude

# Avvia con un modello specifico
ollama launch claude --model qwen3-coder

# Configura l'integrazione senza avviarla (utile per ispezionare le impostazioni)
ollama launch droid --config

# Resetta un'integrazione al suo profilo predefinito
ollama launch codex --restore

# Passa argomenti aggiuntivi all'integrazione dopo --
ollama launch codex -- --sandbox workspace-write

--yes (-y) risponde automaticamente ai prompt di conferma, utile negli script e nei flussi di onboarding.

Modelli consigliati

Gli agenti di coding hanno bisogno di una finestra di contesto lunga per contenere il contesto di interi file e la storia delle conversazioni multi-turno. Ollama raccomanda modelli con almeno 64.000 token di contesto:

Se la tua GPU non riesce a contenere il modello, Ollama offre anche varianti cloud-hosted (es. qwen3-coder:480b-cloud) che si integrano allo stesso modo ma instradano l’inferenza al tier cloud di Ollama — richiedendo ollama signin.

Esempio: esecuzione di Claude Code localmente con Ollama

# 1. Assicurati che il modello sia disponibile
ollama pull qwen3-coder

# 2. Avvia Claude Code contro di esso
ollama launch claude --model qwen3-coder

Ollama imposta le variabili di ambiente necessarie e avvia Claude Code puntando a http://localhost:11434 automaticamente. Puoi quindi usare Claude Code esattamente come faresti normalmente — l’unica differenza è che l’inferenza avviene sul tuo hardware.

Manopole di prestazione (OLLAMA_NUM_PARALLEL)

Se noti code o timeout sotto carico, la prima manopola da imparare è OLLAMA_NUM_PARALLEL.

• OLLAMA_NUM_PARALLEL = quante richieste Ollama esegue in parallelo.
• Un valore più alto può aumentare il throughput, ma può aumentare la pressione sulla VRAM e i picchi di latenza.
• Le richieste che arrivano mentre tutti i slot paralleli sono occupati finiscono in coda; la sua profondità è limitata da OLLAMA_MAX_QUEUE.

Esempio rapido:

OLLAMA_NUM_PARALLEL=2 ollama serve

Per una spiegazione completa (incluse strategie di tuning e modalità di fallimento), consulta:

• Come Ollama gestisce le richieste parallele

Rilascio del modello Ollama dalla VRAM (keep_alive)

Quando un modello è caricato nella VRAM (memoria GPU), rimane lì anche dopo che hai finito di usarlo. Per rilasciare esplicitamente un modello dalla VRAM e liberare la memoria GPU, puoi inviare una richiesta all’API di Ollama con keep_alive: 0.

• Rilascia il modello dalla VRAM usando curl:

curl http://localhost:11434/api/generate -d '{"model": "MODELNAME", "keep_alive": 0}'

Sostituisci MODELNAME con il nome reale del tuo modello, per esempio:

curl http://localhost:11434/api/generate -d '{"model": "qwen3:14b", "keep_alive": 0}'

• Rilascia il modello dalla VRAM usando Python:

import requests

response = requests.post(
    'http://localhost:11434/api/generate',
    json={'model': 'qwen3:14b', 'keep_alive': 0}
)

Questo è particolarmente utile quando:

• Hai bisogno di liberare la memoria GPU per altre applicazioni
• Stai eseguendo più modelli e vuoi gestire l’uso della VRAM
• Hai finito di usare un modello grande e vuoi rilasciare le risorse immediatamente

Nota: Il parametro keep_alive controlla quanto tempo (in secondi) un modello rimane caricato in memoria dopo l’ultima richiesta. Impostandolo a 0 scarica immediatamente il modello dalla VRAM, un valore negativo (es. -1) mantiene il modello caricato per sempre, e una stringa di durata (es. 10m, 24h) è anche accettata. Il predefinito globale del server è OLLAMA_KEEP_ALIVE=5m, e un keep_alive per richiesta lo sovrascrive sempre.

Se preferisci evitare del tutto il livello di astrazione di Ollama e vuoi il controllo diretto su quale modello GGUF è residente in un dato momento, modalità router di llama-server copre l’approccio nativo di llama.cpp per lo switching dinamico dei modelli.

Personalizzazione dei modelli Ollama (system prompt, Modelfile)

• Imposta il System Prompt: All’interno della REPL di Ollama, puoi impostare un system prompt per personalizzare il comportamento del modello:

  >>> /set system Per tutte le domande, rispondi in inglese semplice evitando il gergo tecnico il più possibile
  >>> /save ipe
  >>> /bye
  

  Poi, esegui il modello personalizzato:

  ollama run ipe
  

  Questo imposta un system prompt e salva il modello per uso futuro.

• Crea un File di Modello Personalizzato: Crea un file di testo (es. custom_model.txt) con la seguente struttura:

  FROM llama3.1
  PARAMETER num_ctx 32768
  SYSTEM [Le tue istruzioni personalizzate qui]
  

  Poi, esegui:

  ollama create mymodel -f custom_model.txt
  ollama run mymodel
  

  Questo crea un modello personalizzato basato sulle istruzioni nel file. ollama create può anche quantizzare durante la costruzione — -q q4_K_M produce un GGUF Q4_K_M da una sorgente non quantizzata (safetensors), --draft-quantize imposta la quantizzazione per un modello di draft (decodifica speculativa), e --experimental abilita le funzionalità di creazione di modelli safetensors ancora marcate come sperimentali.

Ollama signin e signout (autenticazione registro)

ollama signin
ollama signout

ollama signin autentica la tua installazione locale di Ollama con il registro Ollama su ollama.com. Una volta effettuato l’accesso, il client salva le credenziali localmente e le riutilizza automaticamente per i comandi successivi.

Cosa sblocca signin:

• Scaricare e caricare modelli privati dal tuo account o organizzazione.
• Usare modelli cloud-hosted (es. qwen3-coder:480b-cloud) che sono troppo grandi per girare localmente.
• Pubblicare modelli sul registro con ollama push.

Alternativa: Autenticazione con chiave API

Se stai eseguendo Ollama in una pipeline CI o su un server headless dove l’ollama signin interattivo non è pratico, crea una chiave API nelle impostazioni del tuo account Ollama ed esponila come variabile di ambiente:

export OLLAMA_API_KEY=ollama_...
ollama pull myorg/private-model

La variabile OLLAMA_API_KEY viene raccolta automaticamente da ogni comando Ollama e richiesta API — non è necessario eseguire ollama signin su ogni macchina.

Uso del comando Ollama run con file (riassunti, redirect)

• Riassumi Testo da un File:

  ollama run llama3.2 "Riassumi il contenuto di questo file in 50 parole." < input.txt
  

  Questo comando riassume il contenuto di input.txt usando il modello specificato.

• Registra le Risposte del Modello in un File:

  ollama run llama3.2 "Parlami dell'energia rinnovabile." > output.txt
  

  Questo comando salva la risposta del modello in output.txt.

Casi d’uso della CLI di Ollama (generazione di testo, analisi)

• Generazione di Testo:

  • Riassumere un grande file di testo:

    ollama run llama3.2 "Riassumi il seguente testo:" < long-document.txt
    

  • Generare contenuti:

    ollama run llama3.2 "Scrivi un breve articolo sui benefici dell'uso dell'AI in ambito sanitario." > article.txt
    

  • Rispondere a domande specifiche:

    ollama run llama3.2 "Quali sono le ultime tendenze nell'AI e come influenzeranno l'ambito sanitario?"
    

  • Risposte one-shot senza la traccia di ragionamento (su modelli di ragionamento):

    ollama run qwen3:14b --think=false --hidethinking "Quali sono le ultime tendenze nell'AI e come influenzeranno l'ambito sanitario?"
    

• Elaborazione e Analisi dei Dati:

  • Classificazione del testo in sentiment positivo, negativo o neutro:

    ollama run llama3.2 "Analizza il sentiment di questa recensione del cliente: 'Il prodotto è fantastico, ma la consegna era lenta.'"
    

  • Categorizzazione del testo in categorie predefinite: Usa comandi simili per classificare o categorizzare il testo in base a criteri predefiniti.

Uso di Ollama con Python (client e API)

• Installa la Libreria Python di Ollama:

  pip install ollama
  

• Genera Testo Usando Python:

  import ollama
  
  response = ollama.generate(model='gemma:2b', prompt='cos'è un qubit?')
  print(response['response'])
  

  Questo frammento di codice genera testo usando il modello e il prompt specificati.

Per integrazioni Python avanzate, esplora uso dell’API di Web Search di Ollama in Python, che copre le capacità di ricerca web, il tool calling e l’integrazione dei server MCP.

Cerchi un’interfaccia basata sul web? Open WebUI fornisce un’interfaccia self-hosted con capacità RAG e supporto multi-utente.

Link utili

Configurazione e Gestione

• Sposta i Modelli Ollama su Un’Altra Unità o Cartella
• Ollama in Docker Compose con GPU e Archiviazione Persistente dei Modelli

Alternative e Confronti

• Hosting LLM Locale: Guida Completa 2026 - Ollama, vLLM, LocalAI, Jan, LM Studio & Altro
• llama.cpp vs Ollama nel 2026: Quale Runtime Eseguire?
• vLLM Quickstart: Servizio LLM ad Alta Prestazione
• Docker Model Runner vs Ollama: Quale Scegliere?
• Primi Segnali di Enshittification di Ollama
• Da Ollama a vLLM: Quando Migrare il Tuo Server LLM Locale

Prestazioni e Hardware

• Come Ollama Gestisce le Richieste Parallele
• Come Ollama Utilizza i Core di Prestazioni ed Efficienti della CPU Intel
• NVIDIA DGX Spark vs Mac Studio vs RTX-4080: Confronto Prestazioni Ollama

Integrazione e Sviluppo

• Uso dell’API di Web Search di Ollama in Python
• Uso dell’API di Web Search di Ollama in Go
• Confronto degli Assistenti di Coding AI
• Interfacce Chat Open-Source per LLM su Istanze Locali di Ollama
• Vincolare LLM con Output Strutturato: Ollama, Qwen3 & Python o Go
• Integrazione di Ollama con Python: Esempi di REST API e Client Python
• SDK Go per Ollama - confronto con esempi