Software per l'AI Locale

Guida: Intelligenza Artificiale Locale › Software e installazione

Uno stack di AI locale combina runtime del modello, interfaccia utente, eventuali documenti per il RAG e strumenti d’integrazione. Ollama e Open WebUI sono opzioni note, ma versioni, comandi Docker e requisiti vanno sempre confrontati con la documentazione ufficiale. Per trattare dati riservati è necessario verificare le funzioni cloud abilitate, i permessi, l’esposizione di rete e il ciclo di aggiornamento prima di mettere il servizio a disposizione degli utenti.

Il sistema operativo: dove vive l’assistente

Prima di installare scegli se l’obiettivo è una prova sul singolo computer o un servizio multiutente. Nel primo caso conta la semplicità del runtime; nel secondo servono autenticazione, backup, log governati, isolamento di rete e criteri di aggiornamento. Per la parte di sicurezza applicativa e le API consulta la guida alla messa in produzione; per controllare la compatibilità GPU parti dall’hardware effettivamente disponibile.

Linux è la casa naturale

Si può fare AI locale anche su Windows o macOS, ma Linux è l’ambiente più efficiente, leggero e controllabile, ed è ciò che useresti su una macchina dedicata in sala server. È più snello (nessun peso di un’interfaccia grafica che non ti serve), più trasparente, più automatizzabile, e tutti gli strumenti chiave nascono lì. Le distribuzioni più battute per questo scopo sono Ubuntu Server (la più documentata, con guide ovunque) e Debian (stabilissima, l’ossatura di mezzo mondo dei server). Ma — ed è importante dirlo — i due ingredienti chiave dello stack, Ollama e Docker, girano su qualunque distribuzione moderna. Non sei vincolato: scegli quella con cui ti trovi bene.

L’unico vero requisito: i driver della GPU

Qualunque distribuzione tu scelga, il punto delicato della configurazione è uno solo: far vedere e usare correttamente la GPU. È qui che si spende il tempo iniziale, ed è qui che nascono i problemi più comuni (“gira tutto su CPU”). Per NVIDIA servono i driver proprietari e il toolkit CUDA; verifica che il sistema veda la scheda con nvidia-smi, che è anche lo strumento per monitorare occupazione VRAM e temperatura. Per AMD serve lo stack ROCm, maturo nelle versioni recenti. Per Intel Arc servono i driver oneAPI. Una volta che il sistema vede la scheda e i driver funzionano, Ollama la usa automaticamente: non devi configurare nient’altro lato inferenza.

Gentoo: la via del controllo totale

Per chi vuole il massimo controllo e l’ottimizzazione spinta sull’hardware specifico, Gentoo è una scelta legittima e potente. La filosofia di Gentoo è compilare ogni cosa su misura per la tua macchina: l’overhead è minimo, niente gira che non serva, e con un’interfaccia a riga di comando — o un ambiente grafico leggerissimo come una semplice configurazione X minimale — vai velocissimo senza sprecare un grammo di risorse in fronzoli. È esattamente la mentalità giusta per una macchina dedicata all’inferenza, dove ogni gigabyte di VRAM e ogni ciclo di calcolo deve andare al modello, non al sistema.

Non è il percorso più semplice — Gentoo richiede esperienza e pazienza in fase di setup — ma se sei a tuo agio con la sua filosofia, ti regala una macchina cucita addosso al ferro. I punti di attenzione specifici per l’AI su Gentoo sono tre. Primo, i driver NVIDIA: vanno abilitati i pacchetti driver appropriati e configurato il kernel di conseguenza, assicurandosi che il modulo si carichi correttamente. Secondo, CUDA: il toolkit va installato e i relativi flag USE abilitati sui pacchetti che ne hanno bisogno, in modo che le librerie di calcolo trovino il supporto GPU. Terzo, Docker: si abilita il pacchetto e il servizio, e si configura il supporto al runtime container per la GPU (il NVIDIA Container Toolkit) se vuoi far girare l’inferenza dentro container con accesso alla scheda. Una volta sistemati questi tre tasselli, lo stack — Ollama, Open WebUI, il resto — gira come su qualunque altra distribuzione, ma su una base che hai ottimizzato tu. Per Ollama in particolare, su Gentoo conviene la via container o una compilazione controllata, piuttosto che lo script di installazione generico.

In sintesi sul sistema operativo: se vuoi semplicità e documentazione, Ubuntu Server o Debian; se vuoi controllo e ottimizzazione e te la cavi, Gentoo. In ogni caso, il lavoro vero è far funzionare i driver GPU; fatto quello, il resto è in discesa.

Ollama in profondità: il motore che rende tutto facile

Ollama è lo standard de facto per far girare modelli in locale. È open source (licenza MIT) e fa una cosa benissimo: scarica, gestisce ed esegue modelli, esponendoli attraverso un’interfaccia compatibile con le API di OpenAI. Scarichi, dai un comando, e hai un modello che gira con un endpoint a cui qualunque applicazione può parlare. Niente da assemblare a mano tra file dei modelli, runtime e livelli di servizio. La versione attuale a metà 2026 è la v0.30.8, con supporto hardware ampliato e un motore ottimizzato per Apple Silicon.

Installazione

Su Linux è una riga. Lo script ufficiale rileva l’hardware, installa i componenti e configura il servizio:

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

Su sistemi dove preferisci non eseguire script esterni (mentalità sana in ottica sicurezza), installa Ollama dentro un container Docker oppure dai pacchetti della distribuzione quando disponibili.

I comandi fondamentali

# scaricare ed eseguire un modello, aprendo una chat nel terminale
ollama run qwen3.6:27b

# solo scaricare, senza avviare la chat
ollama pull gpt-oss:20b

# elencare i modelli installati
ollama list

# vedere varianti, quantizzazioni e dettagli di un modello
ollama show qwen3.6:27b

# rimuovere un modello per liberare spazio
ollama rm gemma3:4b

# vedere quali modelli sono caricati in memoria adesso
ollama ps

Una volta avviato, Ollama espone il servizio sulla porta 11434. Questo endpoint è il cuore di tutto: a esso collegherai l’interfaccia web, il sito, le tue applicazioni.

Il Modelfile: creare modelli su misura

Qui Ollama mostra i muscoli. Un Modelfile è un file di testo che parte da un modello esistente e lo personalizza: gli dai un prompt di sistema fisso, regoli i parametri di campionamento, imposti la finestra di contesto. È il modo per trasformare un modello generico nel tuo assistente, con un’identità e un comportamento definiti, senza riaddestrare nulla. Esempio per un assistente di bottega informatica:

FROM qwen3.6:27b

# parametri di comportamento
PARAMETER temperature 0.4
PARAMETER num_ctx 8192
PARAMETER top_p 0.9

# il prompt di sistema che definisce l'assistente
SYSTEM """
Sei l'assistente virtuale di una bottega informatica.
Rispondi sempre in italiano, in modo chiaro, conciso e cordiale.
Sei competente su computer, riparazioni, assemblaggi e consigli d'acquisto.
Se non sai qualcosa, dillo con onestà invece di inventare.
Non fornire informazioni su argomenti non pertinenti all'informatica.
"""

Si costruisce e si usa così:

# crea il modello personalizzato a partire dal Modelfile
ollama create assistente-bottega -f ./Modelfile

# usalo come qualunque altro modello
ollama run assistente-bottega

Da questo momento assistente-bottega è un modello a sé, con la sua personalità, pronto da chiamare via API dal sito o da Open WebUI. Il prompt di sistema e i parametri sono cuciti dentro: non devi ripeterli a ogni richiesta.

Configurazione e parametri d’ambiente

Ollama si regola con variabili d’ambiente, utili per ottimizzare il comportamento su una macchina dedicata. Le più importanti: OLLAMA_HOST per decidere su quale indirizzo e porta ascoltare (per esempio per renderlo raggiungibile dalla rete locale, con le dovute cautele di sicurezza); OLLAMA_MODELS per cambiare la cartella dove salvare i modelli (utile se vuoi metterli su un disco capiente dedicato); OLLAMA_KEEP_ALIVE per decidere quanto a lungo un modello resta caricato in memoria dopo l’ultimo uso (tenerlo caricato elimina il tempo di caricamento alle richieste successive, al costo di occupare VRAM); OLLAMA_NUM_PARALLEL e OLLAMA_MAX_LOADED_MODELS per gestire quante richieste e quanti modelli servire contemporaneamente, cruciali se l’assistente deve rispondere a più utenti insieme. Su una macchina sempre accesa che serve un chatbot, una configurazione tipica tiene il modello caricato in permanenza (keep-alive lungo o infinito) per risposte immediate.

Servire più utenti contemporaneamente

Se il tuo assistente deve rispondere a più persone insieme — un chatbot di sito con traffico — Ollama gestisce richieste in parallelo, ma per carichi seri e molti utenti simultanei il riferimento di produzione è un altro motore, vLLM (sezione successiva), pensato apposta per il throughput. Per un’azienda piccola o media con traffico moderato, Ollama configurato bene basta e avanza; per servire decine o centinaia di utenti in tempo reale, si passa a vLLM.

Le alternative a Ollama: quando e perché

Ollama è la scelta giusta per la maggior parte dei casi, ma conoscere le alternative ti aiuta a scegliere lo strumento adatto al compito.

llama.cpp è il motore di basso livello su cui molte cose (incluso, in larga parte, l’ecosistema GGUF) si appoggiano. Scritto in C/C++, leggerissimo, controllo fine su ogni parametro, ottimo per deployment minimali, ambienti senza Python, o quando vuoi spremere ogni goccia di prestazione e personalizzazione. Più ostico di Ollama, ma imbattibile per controllo. Include un server compatibile con le API di OpenAI (llama-server). Se Ollama è l’automatica, llama.cpp è la manuale.

vLLM è il motore di produzione per l’alto throughput. Pensato per servire molti utenti in parallelo con tecniche avanzate (batching continuo) che massimizzano l’uso della GPU. È la scelta quando devi servire un’applicazione vera con tanti utenti simultanei, su hardware serio. Richiede più configurazione di Ollama e gira tipicamente con modelli in formati ottimizzati per GPU (AWQ, GPTQ, FP8). Per un’azienda che passa da “assistente interno” a “servizio per molti clienti”, vLLM è il salto naturale. Esistono anche alternative simili come SGLang e, per il massimo throughput su hardware NVIDIA, TensorRT-LLM.

LocalAI è un’alternativa open source completa, compatibile con le API di OpenAI, che oltre ai modelli linguistici gestisce anche immagini e audio, con un piglio “tutto in uno”. Buona per chi vuole un solo sistema che copra più modalità.

LM Studio è un’applicazione desktop con interfaccia grafica, per chi preferisce il mouse al terminale. Catalogo di modelli integrato (pesca da Hugging Face), scarichi e avvii con un clic, ed espone anch’essa un’API compatibile con OpenAI. Ottima per esplorare, provare modelli, lavorare da una singola macchina. Esiste anche una versione “motore senza interfaccia” per il deployment su server.

Jan è simile a LM Studio nello spirito — desktop, grafico, semplice — ma più essenziale e con il codice sorgente aperto e verificabile, apprezzato da chi tiene alla trasparenza totale.

text-generation-webui (spesso chiamata “oobabooga”) è un’interfaccia web ricca di funzioni per chi vuole sperimentare a fondo, con supporto a molti formati e tante opzioni avanzate. Più da appassionato smaliziato che da deployment pulito.

La regola pratica: comincia con Ollama per semplicità e copertura. Passa a vLLM se devi servire molti utenti in produzione. Usa llama.cpp se vuoi controllo di basso livello o un deployment minimale. Le interfacce desktop (LM Studio, Jan) sono comode per esplorare da una singola macchina.

Open WebUI e le interfacce di chat

Ollama da solo ti dà il motore e una chat da terminale. Per un’interfaccia grafica vera — quella che assomiglia a ChatGPT, accessibile dal browser di qualunque dispositivo in rete — lo strumento di riferimento è Open WebUI. È un’applicazione web open source che si collega a Ollama e regala chat con cronologia, gestione di più modelli, caricamento di documenti (con RAG integrato), gestione utenti e permessi, ricerca web opzionale, e molto altro. È, di fatto, il “ChatGPT privato” che metti a disposizione di te stesso e dei tuoi collaboratori.

Si installa come container Docker, il modo pulito e gestibile di tenere insieme i pezzi. Lo schema mentale: Ollama gira ed espone la porta 11434; Open WebUI gira in un container e si collega a Ollama; tu apri il browser e usi l’interfaccia. Un avvio tipico, con Ollama sulla stessa macchina:

docker run -d \
  --name open-webui \
  -p 3000:8080 \
  --add-host=host.docker.internal:host-gateway \
  -v open-webui:/app/backend/data \
  --restart always \
  ghcr.io/open-webui/open-webui:main

Dopo questo comando apri il browser su http://indirizzo-della-macchina:3000, crei il primo account (che diventa amministratore), e hai la tua interfaccia AI privata, accessibile da ogni dispositivo della rete locale. Il volume montato (-v open-webui:...) fa sopravvivere cronologia e impostazioni a riavvii e aggiornamenti. Da qui puoi scegliere il modello, caricare documenti per interrogarli, creare più utenti per i collaboratori, e configurare il comportamento dell’assistente. Per la maggior parte delle aziende, Ollama più Open WebUI sono già una soluzione completa per l’uso interno.

Lo stack completo con Docker Compose

Per mettere tutto insieme in modo ordinato e ripetibile, Docker Compose è lo strumento giusto: un singolo file descrive l’intero stack, e un comando lo avvia tutto. Ecco un esempio di stack completo che mette insieme Ollama e Open WebUI, pronto da adattare. Salvalo come docker-compose.yml:

services:
  ollama:
    image: ollama/ollama:latest
    container_name: ollama
    ports:
      - "11434:11434"
    volumes:
      - ollama-data:/root/.ollama
    restart: always
    # per usare la GPU NVIDIA (richiede NVIDIA Container Toolkit installato)
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]

  open-webui:
    image: ghcr.io/open-webui/open-webui:main
    container_name: open-webui
    ports:
      - "3000:8080"
    environment:
      - OLLAMA_BASE_URL=http://ollama:11434
    volumes:
      - open-webui-data:/app/backend/data
    depends_on:
      - ollama
    restart: always

volumes:
  ollama-data:
  open-webui-data:

Si avvia tutto con un comando, e si ferma con un altro:

# avvia l'intero stack in background
docker compose up -d

# scarica un modello dentro il container Ollama appena avviato
docker compose exec ollama ollama pull qwen3.6:27b

# guarda i log
docker compose logs -f

# ferma tutto
docker compose down

Questo è il modello mentale di un deployment pulito: tutto descritto in un file, versionabile, ripetibile, facile da spostare su un’altra macchina o da ricostruire. Da qui, nella Parte VI, aggiungeremo i pezzi per esporre l’assistente sul sito in sicurezza, e nella Parte V vedremo come collegargli i tuoi documenti e dargli la voce.

← Costi e fasceModelli →

Vuoi la tua AI privata, accesa e funzionante?

In Terabyte Lab progettiamo, assembliamo e configuriamo la macchina su misura: hardware, modello, RAG, voce e sicurezza, pronti all'uso.

Contatta Terabyte Lab