Implementare un chatbot IA per il proprio team su intranet

#Perché un chatbot IA aziendale su intranet?

Tre ragioni concrete spingono a gestire il servizio internamente: la riservatezza (i tuoi prompt contengono spesso estratti di codice, dati dei clienti, informazioni finanziarie), il costo (un abbonamento ChatGPT Team a 25 €/mese per utente arriva rapidamente a 5.000 €/anno per 20 persone) e il controllo (scegli tu i modelli, i prompt di sistema e i log delle conversazioni).

Uno stack ben configurato per un chatbot IA sull’intranet aziendale può funzionare su una sola macchina per team fino a 30-50 persone. Oltre questa soglia, si separa il server di inferenza dal frontend, ma l’architettura rimane la stessa.

#Architettura dello stack

Quattro componenti sovrapposti, ciascuno con un ruolo preciso:

Ollama

Daemon di inferenza che ospita i modelli (Qwen 3.5, Granite 4.2, Gemma 4, Mistral Small). Ascolta per default su http://localhost:11434.

Open WebUI

Frontend ChatGPT-like multiutente in Docker. Gestisce account, conversazioni, RAG, ruoli admin/utente.

Nginx

Reverse proxy posto davanti al servizio. Termina le connessioni HTTPS, applica il rate limiting e rende il servizio accessibile tramite un nome di dominio interno ben definito.

Watchtower + cron

Aggiornamento automatico delle immagini Docker e backup quotidiano del volume Open WebUI (che contiene account + conversazioni).

#Requisiti hardware e sistema operativo

Il dimensionamento dipende dal modello scelto e dal carico simultaneo. Indicazioni pratiche per un team:

Piccola squadra (5-15 utenti, modello 8-9B)

16 GB di RAM, GPU con 8-12 GB di VRAM (RTX 3060 12GB, 4060 Ti 16GB). Qwen 3.5 9B Q4 (6,6 GB, 256k ctx) o Granite 4.2 8B (5,3 GB, molto parsimonioso nell'uso dei token).

Team di medie dimensioni (15-30 utenti, modello 20-24B)

32 GB RAM, GPU 16 GB VRAM (RTX 4070 Ti Super, 5080). Mistral Small 24B Q4 (14 GB, buono in francese) o gpt-oss 20B (14 GB, molto veloce in MXFP4).

Grande squadra (30-50 utenti, modello 27-30B)

64 GB di RAM, GPU con 24 GB di VRAM (RTX 3090/4090) o Mac Studio M5 Max 64 GB. Qwen 3.8 27B Q4 (18 GB, 262k ctx, visione) o Granite 4.2 30B Q4 (18 GB, orientato alle aziende).

Al di sopra di 50 utenti contemporanei

Passa a vLLM o a più istanze Ollama dietro un load balancer. Esci dall'ambito di questa guida.

Per il sistema operativo: Ubuntu Server 22.04 o 24.04 LTS rimane la scelta più semplice. Docker Engine e i driver NVIDIA (con nvidia-container-toolkit se si usa una GPU) devono essere installati in precedenza.

#1. Installare Ollama sul server

L'installazione su Linux avviene tramite lo script ufficiale. Rileva la GPU NVIDIA e configura automaticamente il servizio systemd.

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

Per impostazione predefinita, il daemon ascolta soltanto su localhost. Per permettere a Docker (Open WebUI) di chiamarlo dal suo container, esponilo su tutte le interfacce locali del server. Modifica l'override systemd:

sudo systemctl edit ollama

[Service]
Environment="OLLAMA_HOST=0.0.0.0:11434"
Environment="OLLAMA_KEEP_ALIVE=30m"
Environment="OLLAMA_NUM_PARALLEL=4"

OLLAMA_HOST=0.0.0.0:11434

Ascolta su tutte le interfacce. Il firewall del sistema operativo continua a bloccare l'accesso dall'esterno alla porta 11434: solo Open WebUI sulla stessa macchina potrà accedervi.

OLLAMA_KEEP_ALIVE=30m

Mantiene il modello caricato in VRAM per 30 minuti dopo l'ultimo prompt. Evita ricaricamenti costosi tra due richieste degli utenti.

OLLAMA_NUM_PARALLEL=4

Numero di richieste parallele. 4 è un buon punto di partenza per un modello da 8-9B (come Qwen 3.5 9B) con 12 GB di VRAM; riduci il numero a 2 su una GPU più piccola.

sudo systemctl daemon-reload
sudo systemctl restart ollama
ollama pull qwen3.5:9b

#2. Open WebUI in modalità multiutente con Docker

Open WebUI si distribuisce con un solo comando Docker. Il volume open-webui:/app/backend/data contiene l'intero database: account, conversazioni, prompt. È di questo volume che dovrai fare il backup.

docker run -d \
  --name open-webui \
  --restart always \
  -p 127.0.0.1:3000:8080 \
  -v open-webui:/app/backend/data \
  -e OLLAMA_BASE_URL=http://host.docker.internal:11434 \
  -e WEBUI_AUTH=true \
  -e ENABLE_SIGNUP=false \
  -e DEFAULT_USER_ROLE=pending \
  --add-host=host.docker.internal:host-gateway \
  ghcr.io/open-webui/open-webui:main

-p 127.0.0.1:3000:8080

Open WebUI è accessibile soltanto dal server stesso. Nginx fa da ponte verso la rete interna. Cruciale per la sicurezza.

ENABLE_SIGNUP=false

Nessuno può creare un account dalla pagina di login. Crei gli utenti dal pannello di amministrazione.

DEFAULT_USER_ROLE=pending

Ogni nuovo account è in attesa di approvazione da parte dell'amministratore. Evita che un dipendente inviti una persona esterna per errore.

OLLAMA_BASE_URL

Punta a Ollama in esecuzione sull'host. host.docker.internal viene risolto nell'indirizzo del gateway Docker grazie a --add-host.

Il primo account creato tramite l'interfaccia http://serveur:3000 (tramite port forwarding SSH o direttamente) diventa automaticamente amministratore. Crealo immediatamente dopo l'avvio del container, prima di esporre il servizio.

#3. Reverse proxy Nginx con SSL interno

Per esporre correttamente chat.entreprise.local, Nginx termina la connessione HTTPS e inoltra le richieste a Open WebUI su 127.0.0.1:3000. Su una intranet, puoi usare un certificato emesso dalla tua PKI interna oppure un certificato autofirmato distribuito alle postazioni tramite GPO.

sudo apt install nginx

server {
    listen 80;
    server_name chat.entreprise.local;
    return 301 https://$host$request_uri;
}

server {
    listen 443 ssl http2;
    server_name chat.entreprise.local;

    ssl_certificate     /etc/ssl/certs/chat-intranet.crt;
    ssl_certificate_key /etc/ssl/private/chat-intranet.key;
    ssl_protocols TLSv1.2 TLSv1.3;

    client_max_body_size 100M;

    location / {
        proxy_pass http://127.0.0.1:3000;
        proxy_http_version 1.1;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;

        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";

        proxy_read_timeout 600s;
        proxy_send_timeout 600s;
    }
}

client_max_body_size 100M

Indispensabile per il RAG: permette ai tuoi utenti di caricare PDF o documenti fino a 100 MB.

Upgrade / Connection

Attiva il WebSocket. Senza queste due righe, lo streaming token per token smette di funzionare e l'interfaccia sembra bloccata.

proxy_read_timeout 600s

Una richiesta di generazione lunga (riassunto di un grande documento) può durare diversi minuti. Il timeout predefinito di Nginx (60s) interrompe la risposta proprio nel mezzo.

sudo ln -s /etc/nginx/sites-available/chat-intranet /etc/nginx/sites-enabled/
sudo nginx -t && sudo systemctl reload nginx

#4. Autenticazione, ruoli e onboarding

Open WebUI gestisce nativamente tre ruoli: admin (configura tutto), user (usa la chat), pending (account creato ma non attivato). Per una PMI, l'autenticazione locale basta. Oltre le 30-40 persone o per un rigoroso allineamento con l'IT, collega OIDC al tuo IdP (Keycloak, Authentik, Microsoft Entra).

1. 01
   Creare gli utenti

   Pannello Admin → Users → Add User. Inserisci email, nome e password iniziale. L'utente la cambierà al primo accesso.
2. 02
   Limitare i modelli per ruolo

   In Admin → Models, puoi nascondere alcuni modelli agli utenti standard. Ad esempio: riservare Qwen 3.8 27B (quello che richiede più VRAM) agli amministratori, se l'hai caricato.
3. 03
   Imporre un system prompt predefinito

   Admin → Settings → Interface → Default Prompt Suggestions. Ideale per definire l'uso ('Tu rispondi in francese, rifiuti i temi sensibili, ecc.').
4. 04
   Disattiva le funzionalità esterne

   Admin → Settings → disattiva Web Search (altrimenti Open WebUI contatta DuckDuckGo) e Image Generation se non vuoi alcuna connessione di rete in uscita.

#5. Monitoraggio e salvataggio delle conversazioni

Tre cose da monitorare: lo stato del server (CPU/GPU/RAM), lo stato dell'API Ollama e l'integrità del database di Open WebUI. E una cosa di cui fare il backup: il volume Docker open-webui.

#Monitoraggio rapido

curl -s http://localhost:11434/api/tags | jq '.models | length'

Se usi Prometheus + Grafana, nvidia_smi_exporter per la GPU e node_exporter per il sistema bastano nel 95% dei casi. Open WebUI stesso espone /health tramite GET, da inserire nel tuo controllo di uptime.

#Backup quotidiano del volume Open WebUI

Il volume Docker open-webui contiene un database SQLite con tutti gli account, le conversazioni, i prompt personalizzati e i documenti indicizzati per il RAG. La sua perdita equivale alla perdita completa della cronologia del team.

#!/bin/bash
set -e
BACKUP_DIR=/var/backups/open-webui
TIMESTAMP=$(date +%Y%m%d-%H%M)
mkdir -p "$BACKUP_DIR"

docker run --rm \
  -v open-webui:/data \
  -v "$BACKUP_DIR":/backup \
  alpine tar czf "/backup/openwebui-$TIMESTAMP.tar.gz" -C /data .

find "$BACKUP_DIR" -name 'openwebui-*.tar.gz' -mtime +14 -delete

sudo chmod +x /usr/local/bin/backup-openwebui.sh
echo "0 2 * * * root /usr/local/bin/backup-openwebui.sh" | sudo tee /etc/cron.d/openwebui-backup

Lo script conserva 14 giorni di storico. Per un piano di ripristino d'emergenza degno di questo nome, replica /var/backups/open-webui su un NAS o un bucket S3 cifrato ogni notte tramite rsync o rclone.

#Risoluzione dei problemi

Open WebUI non vede nessun modello

Il contenitore non raggiunge Ollama. Verifica con docker exec open-webui curl http://host.docker.internal:11434/api/tags. In caso di timeout, il tuo Ollama ascolta su 127.0.0.1 — reimposta OLLAMA_HOST=0.0.0.0:11434.

Streaming a scatti o bloccato

Mancano gli header WebSocket in Nginx. Verifica la presenza di proxy_set_header Upgrade e Connection "upgrade" nella configurazione del vhost.

504 Gateway Timeout su richieste lunghe

proxy_read_timeout è troppo basso. Portalo ad almeno 600 s. Per i riassunti di documenti di grandi dimensioni, aumentalo a 1200 s.

GPU saturo, latenza che esplode

Troppe richieste parallele. Riduci OLLAMA_NUM_PARALLEL a 2 e aumenta OLLAMA_KEEP_ALIVE per evitare i ricaricamenti.

Errore 'no space left' su /var/lib/docker

I modelli Ollama non sono in Docker — è il volume open-webui che cresce. Esegui docker system prune e tieni sotto controllo il RAG (i documenti indicizzati arrivano rapidamente a occupare diversi GB).

#Per approfondire

Hai un’istanza in funzione per il tuo team. Tre modi naturali per renderla più professionale:

Documentare la conformità al GDPR

La guida su LLM locali e RGPD tratta l'audit, il registro dei trattamenti e le raccomandazioni della CNIL — indispensabile se il tuo team tratta dati personali.

Estendere lo strumento con il RAG

La guida RAG con ChromaDB e Mistral mostra come collegare la tua base documentale interna (wiki, SharePoint esportato, contratti) a Open WebUI.

Automatizzare i workflow

La guida per automatizzare con n8n e Ollama spiega come collegare il tuo chatbot al tuo stack aziendale (email in arrivo, ticket, RSS) senza alcuna fuga di dati verso il cloud.