# Open WebUI con Docker e Ollama: Guida all'Installazione 2026

> Guida completa e aggiornata per installare e configurare Open WebUI con Docker e Ollama (anche su Windows con WSL), trasformando il tuo computer in una workstation IA privata: un'interfaccia stile ChatGPT, offline e gratuita.

- URL: https://mautoblog.com/posts/openwebui-installazione-locale-guida-completa-2025/
- Lingua: it
- Pubblicato: 2025-02-23
- Aggiornato: 2026-10-15
- Autore: Matteo
- Categorie: Intelligenza Artificiale, Tecnologia
- Tags: IA Locale, Ollama, Docker, Produttività, Privacy
- Guida: IA locale (parte 2)
- Traduzione (en): https://mautoblog.com/en/posts/openwebui-local-installation-complete-guide-2025/

---

> **Aggiornato a ottobre 2026** per Open WebUI v0.12: nuovi comandi con `WEBUI_SECRET_KEY`, immagine `:slim`, Docker Compose, installazione su Windows con WSL e il nuovo Watchtower per gli aggiornamenti.

Se sei qui dopo aver letto la mia [guida su DeepSeek in locale](/posts/installare-deepseek-in-locale-con-ollama-guida-2025/) oppure ti stai semplicemente chiedendo se esiste un modo più comodo, funzionale ed elegante per interagire con la tua IA locale invece di usare il terminale, la risposta è sì, e si chiama Open WebUI.

## Cos'è Open WebUI

Open WebUI rappresenta l'evoluzione naturale nell'utilizzo di modelli IA locali. È un'interfaccia web moderna ed elegante che trasforma l'esperienza da terminale in qualcosa di più simile a ChatGPT o Claude, ma con un vantaggio fondamentale: tutto rimane sul tuo computer. Non dovrai più preoccuparti della privacy dei tuoi dati o di costosi abbonamenti mensili. Puoi gestire multiple conversazioni, analizzare documenti e persino generare immagini, tutto localmente e gratuitamente.

E se un giorno ti serve un modello più grosso di quello che il tuo portatile riesce a reggere, Open WebUI si collega anche alle API di OpenAI, Anthropic o di qualunque servizio compatibile: stessa interfaccia, scegli tu modello per modello cosa resta in locale e cosa no.

## Prima di Iniziare

Open WebUI in sé è leggero: il peso vero lo fanno i modelli. Per far girare comodamente un modello locale servono almeno 16GB di RAM (anche se personalmente sono riuscito a farlo girare su un MacBook Air M2 con 8GB, con modelli piccoli), e una GPU NVIDIA o un Mac con Apple Silicon aiutano parecchio. Lato disco, l'immagine Docker standard pesa circa 1,6GB da scaricare, a cui vanno aggiunti i modelli.

Ti servono:

- **Docker** (Docker Desktop su Mac e Windows, oppure Docker Engine su Linux; su Mac va benissimo anche [OrbStack](/posts/docker-desktop-vs-orbstack-confronto/))
- **Ollama** con almeno un modello scaricato, se vuoi usare modelli locali

Se hai già installato Docker e Ollama seguendo la mia [guida](/posts/installare-deepseek-in-locale-con-ollama-guida-2025/) precedente, sei già a metà dell'opera.

### La chiave segreta (non saltare questo passaggio)

Rispetto alla prima versione di questa guida c'è una novità: tutti i comandi ufficiali ora passano la variabile `WEBUI_SECRET_KEY`, la chiave con cui Open WebUI firma le sessioni. Se non la imposti, ogni volta che il container viene ricreato (per esempio dopo un aggiornamento) vieni sbattuto fuori e devi rifare il login. Generane una e tienila da parte:

```bash
openssl rand -hex 32
```

Nei comandi qui sotto sostituisci `la-tua-chiave` con il risultato. E usa sempre la stessa.

## 6 Modi per Installare Open WebUI con Docker (e due senza)

L'installazione di Open WebUI cambia leggermente in base al tuo setup. Se hai Ollama in esecuzione sul tuo computer, usa questo comando:

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

Non serve dirgli dove si trova Ollama: l'immagine lo cerca da sola su `http://host.docker.internal:11434`, cioè sul tuo computer.

Se invece Ollama è su un altro server, modifica il comando specificando l'URL corretto:

```bash
docker run -d -p 3000:8080 \
    -e OLLAMA_BASE_URL=https://tuo-server.com \
    -v open-webui:/app/backend/data \
    -e WEBUI_SECRET_KEY=la-tua-chiave \
    --name open-webui \
    --restart always \
    ghcr.io/open-webui/open-webui:main
```

Per chi ha una GPU NVIDIA e vuole sfruttarne la potenza (l'immagine `:cuda` ora è compilata per CUDA 12.8; se i tuoi driver sono più vecchi esiste `:cuda126`):

```bash
docker run -d -p 3000:8080 --gpus all \
    --add-host=host.docker.internal:host-gateway \
    -v open-webui:/app/backend/data \
    -e WEBUI_SECRET_KEY=la-tua-chiave \
    --name open-webui \
    --restart always \
    ghcr.io/open-webui/open-webui:cuda
```

C'è anche un'immagine all-in-one che include sia Open WebUI che Ollama. Con GPU:

```bash
docker run -d -p 3000:8080 --gpus=all \
    -v ollama:/root/.ollama \
    -v open-webui:/app/backend/data \
    -e WEBUI_SECRET_KEY=la-tua-chiave \
    --name open-webui \
    --restart always \
    ghcr.io/open-webui/open-webui:ollama
```

O senza GPU:

```bash
docker run -d -p 3000:8080 \
    -v ollama:/root/.ollama \
    -v open-webui:/app/backend/data \
    -e WEBUI_SECRET_KEY=la-tua-chiave \
    --name open-webui \
    --restart always \
    ghcr.io/open-webui/open-webui:ollama
```

Infine la novità più interessante per chi usa solo modelli via API (OpenAI, Anthropic, OpenRouter e simili): l'immagine `:slim`. Pesa circa 196MB invece di 1,6GB, perché non include i modelli locali per embedding, trascrizione vocale ed estrazione dei documenti. La chat funziona uguale; basta cambiare `:main` in `:slim` nel primo comando. Se invece vuoi caricare documenti e farli analizzare in locale, resta su `:main`.

### Con Docker Compose

Se preferisci avere la configurazione in un file (io ormai faccio così per tutto), crea un `docker-compose.yml`:

```yaml
services:
  open-webui:
    image: ghcr.io/open-webui/open-webui:main
    ports:
      - "3000:8080"
    volumes:
      - open-webui:/app/backend/data
    extra_hosts:
      - host.docker.internal:host-gateway
    environment:
      - WEBUI_SECRET_KEY=la-tua-chiave
    restart: unless-stopped

volumes:
  open-webui:
```

E avvialo con:

```bash
docker compose up -d
```

### Su Windows con WSL

Su Windows la strada più semplice è Docker dentro WSL 2:

1. Installa WSL seguendo la [guida ufficiale Microsoft](https://learn.microsoft.com/it-it/windows/wsl/install).
2. Installa Docker Desktop scegliendo il backend **WSL 2** durante il setup.
3. In Docker Desktop vai su **Settings > Resources > WSL Integration** e abilita la tua distribuzione.
4. Apri il terminale della distribuzione WSL (non PowerShell, non il Prompt dei comandi) e lancia lo stesso comando standard visto sopra.

L'errore più comune è proprio lanciare i comandi `docker` da PowerShell: vanno eseguiti dentro WSL. Se poi Docker proprio non lo vuoi, su Windows puoi usare l'installazione con `uv` qui sotto o l'[app desktop di Open WebUI](https://github.com/open-webui/desktop).

### Senza Docker: pip o uv

Per chi preferisce Python, c'è l'installazione via pip. Attenzione alla versione: Open WebUI supporta **Python 3.11 e 3.12**, la 3.13 non è ancora supportata.

```bash
pip install open-webui
open-webui serve
```

Ancora più comodo, se usi [uv](https://docs.astral.sh/uv/), che si scarica da solo la versione di Python giusta:

```bash
DATA_DIR=~/.open-webui uvx --python 3.11 open-webui@latest serve
```

In entrambi i casi Open WebUI risponde su `http://localhost:8080`. Su Linux senza GPU NVIDIA conviene installare prima la versione CPU di PyTorch, per evitare di scaricare gigabyte di librerie CUDA inutili:

```bash
pip install torch --index-url https://download.pytorch.org/whl/cpu
```

## Primo Avvio e Configurazione

Una volta completata l'installazione, apri il tuo browser preferito e vai su `http://localhost:3000` (oppure `http://localhost:8080` se non utilizzi Docker). La prima cosa che dovrai fare è creare un account amministratore. Non preoccuparti, tutto rimane sul tuo computer: puoi anche usare un'email finta se vuoi. Dopo aver creato l'account ti troverai di fronte a questa schermata (gli screenshot sono della prima versione della guida: l'interfaccia nel frattempo è cambiata un po', ma la sostanza è quella):

![Screenshot della pagina di login di Open WebUI](/img/screen/openwebui-1.png)

Dopo il login, potrai selezionare quali modelli usare. Se hai seguito la mia guida su DeepSeek, dovresti già vedere il modello disponibile nella lista.

![Screenshot della pagina successiva al login di Open WebUI](/img/screen/openwebui-2.png)

Se usi Open WebUI da solo e il login ti sembra superfluo, esiste la modalità single-user: aggiungi `-e WEBUI_AUTH=False` al comando `docker run`. Pensaci bene prima, però: una volta attivata non si torna indietro alla modalità multi-utente.

## Le Funzionalità Che Ti Faranno Innamorare

Una delle cose più interessanti di Open WebUI è la sua capacità di analizzare documenti. Immagina di avere una documentazione tecnica di 100 pagine e dover trovare una risposta specifica. Invece di leggerla tutta, puoi caricarla in Open WebUI e lasciare che l'IA faccia il lavoro pesante per te.

![Screenshot della sezione Knowledge Base](/img/screen/openwebui-3.png)

Puoi anche creare modelli personalizzati che combinano diversi modelli base con le tue knowledge base. È come avere un assistente specializzato per ogni tipo di compito. E la cosa migliore? Puoi gestire multiple conversazioni contemporaneamente, organizzarle in cartelle e persino condividerle con i tuoi colleghi (sempre localmente, ovviamente).

## Resta Aggiornato

Open WebUI rilascia aggiornamenti spesso, quindi vale la pena tenerlo al passo. Il modo più semplice resta Watchtower, ma occhio: il vecchio `containrrr/watchtower` non è più mantenuto, la documentazione ufficiale ora usa il fork `nickfedor/watchtower`:

```bash
docker run --rm --volume /var/run/docker.sock:/var/run/docker.sock nickfedor/watchtower --run-once open-webui
```

Se preferisci farlo a mano, i dati stanno nel volume `open-webui` e sopravvivono alla ricreazione del container:

```bash
docker rm -f open-webui
docker pull ghcr.io/open-webui/open-webui:main
# poi rilancia lo stesso comando docker run di prima, con la stessa WEBUI_SECRET_KEY
```

Con Docker Compose bastano `docker compose pull` e `docker compose up -d`; con pip, `pip install -U open-webui`.

Una precisazione che molti ignorano: `:main` (e il suo alias `:latest`) è un'immagine "mobile", ricostruita a ogni modifica del branch principale, non per forza l'ultima release stabile. Se vuoi qualcosa di riproducibile, usa un tag di versione come `:v0.12.0` e aggiornalo tu quando decidi.

## Quando Le Cose Non Vanno Come Previsto

Se dovessi incontrare problemi di connessione, la prima cosa da fare è verificare che Ollama sia in esecuzione (usa `ollama list` nel terminale). Se tutto sembra a posto ma Open WebUI continua a non funzionare, controlla i log con `docker logs open-webui`.

Due classici:

- **Open WebUI non vede i modelli di Ollama.** Verifica di aver lanciato il container con `--add-host=host.docker.internal:host-gateway`. Su Linux, inoltre, Ollama di default ascolta solo su `127.0.0.1`: per raggiungerlo dal container fallo partire con `OLLAMA_HOST=0.0.0.0`.
- **Vieni disconnesso dopo ogni aggiornamento o riavvio.** Manca `WEBUI_SECRET_KEY`, oppure la stai cambiando a ogni avvio. Impostala una volta e non toccarla più.

Nel caso peggiore, puoi sempre fare un reset completo: rimuovi il container (`docker rm -f open-webui`), elimina il volume con i dati (`docker volume rm open-webui`) e reinstalla. È come formattare il telefono: risolve molti problemi, ma perdi tutte le chat e le impostazioni.

## Il Futuro è Locale (E Open Source)

Open WebUI dimostra che non dobbiamo più scegliere tra funzionalità avanzate e privacy. Con i modelli IA che diventano sempre più efficienti e le interfacce sempre più sofisticate, soluzioni come questa non sono più solo un'alternativa interessante ma una scelta pratica e sensata.

La comunità continua a sviluppare nuove funzionalità a ritmo serrato: generazione di immagini integrata, analisi del codice, chat vocali, connessioni a provider e agenti esterni. E il ritmo dei rilasci non accenna a rallentare.

## Vale la Pena Provarlo?

Assolutamente sì. Open WebUI trasforma completamente l'esperienza di utilizzo dei modelli IA locali. Non è più una questione di smanettare col terminale (anche se quello ha il suo fascino), ma di avere uno strumento professionale e intuitivo che chiunque può usare.

Se stai ancora leggendo e non hai ancora provato a installarlo, ti suggerisco di farlo ora. Nel tempo che hai impiegato a leggere questo articolo, avresti già potuto configurarlo e iniziare a usarlo. E se incontri problemi, beh, sai dove trovarmi!

P.S. Se pensi che questo sia interessante, aspetta di vedere cosa ho in serbo per il prossimo articolo della serie. Spoiler: coinvolge l'intelligenza artificiale, un po' di magia con Docker, e forse qualche bestemmia in aramaico antico quando le cose non funzionano come dovrebbero!

---

**Risorse Utili:**
- [Repository ufficiale di Open WebUI](https://github.com/open-webui/open-webui)
- [Documentazione completa](https://docs.openwebui.com/)
- [Guida rapida ufficiale](https://docs.openwebui.com/getting-started/quick-start/)

