DeepSeek in locale

C’è un momento preciso, durante l’installazione di un modello linguistico in locale, in cui ti rendi conto che il confine tra cloud e computer personale si è spostato. Non è quando vedi la barra di download che avanza. Non è quando il terminale stampa “success”. È quando scrivi la prima domanda, premi Invio, e la risposta arriva senza passare da nessun server esterno. Solo il tuo hardware, nella tua rete, sotto il tuo controllo.

DeepSeek in locale, ha reso questo momento accessibile a molti più sviluppatori di quanto fosse possibile fino a un anno fa. Modello open source, licenza MIT, pesi liberamente scaricabili. E prestazioni che, nelle benchmark, si avvicinano a GPT-4.

In questo articolo ti guido passo passo nell’installazione di DeepSeek in locale usando Ollama e Docker, con un’interfaccia chat pronta all’uso. Non serve un datacenter. Basta il computer che hai già, un po’ di pazienza, e la voglia di sporcarti le mani con il terminale.

Perché DeepSeek sta facendo rumore

Prima di aprire il terminale, vale la pena capire cosa stiamo per installare. Perché DeepSeek non è l’ennesimo LLM open source che promette miracoli e poi delude al primo prompt complesso.

DeepSeek V3 è un modello da 671 miliardi di parametri con architettura Mixture-of-Experts (MoE). Tradotto in termini pratici: ha la capacità rappresentativa di un modello enorme, ma per ogni token che genera ne attiva solo circa 37 miliardi. Il risultato è che ragiona come un gigante ma consuma risorse come un modello molto più piccolo.

Poi c’è DeepSeek R1, la variante specializzata nel ragionamento. Se V3 è il modello generalista — scrive codice, risponde a domande, traduce — R1 è quello che passa un minuto a pensare prima di rispondere. Emette una catena di ragionamento interna (spesso racchiusa tra tag <think>) e solo dopo produce la risposta finale. È più lento, consuma più token, ma su compiti di logica, matematica e debugging è nettamente superiore.

La famiglia DeepSeek in sintesi:

|—|—|—|—|—|

Ed è qui che bisogna fare chiarezza su un punto che genera molta confusione.

La verità sull’hardware: cosa puoi davvero eseguire

Quando qualcuno dice “giro DeepSeek sul mio portatile”, nel 95% dei casi sta eseguendo un modello distillato — un Qwen o Llama più piccolo, addestrato su tracce di ragionamento generate dal modello R1 completo. Non il mostro da 671 miliardi di parametri.

Il modello V3 completo, anche quantizzato a 4 bit, occupa circa 350-400 GB. Per eseguirlo servono più GPU di fascia server o un cluster di macchine. Non è roba da computer personale.

Ecco cosa puoi realisticamente eseguire in base alla tua GPU:

|—|—|—|—|

| 2× RTX 3090/4090 | 48 GB | R1 Distill 70B | ~18-25 tok/s |

La regola pratica: se hai una GPU con almeno 8 GB di VRAM, puoi eseguire DeepSeek in locale. Con 12 GB sei già nella zona di comfort. Con 24 GB hai un’esperienza paragonabile a un API cloud, ma senza latenza di rete e senza costi a token.

L’architettura che useremo: Ollama + Docker + Open WebUI

Il nostro stack è composto da tre pezzi:


┌──────────────┐     ┌─────────────────┐     ┌──────────────────┐

│   Browser    │────▶│   Open WebUI    │────▶│     Ollama       │

│  (chat UI)   │     │  (porta 3000)   │     │  (porta 11434)   │

└──────────────┘     └─────────────────┘     └────────┬─────────┘

                                                      │

                                          ┌───────────┴───────────┐

                                          │   DeepSeek Model     │

                                          │   (Q4_K_M GGUF)      │

                                          └───────────────────────┘

Ollama è il motore di inferenza. Gestisce il download del modello, la quantizzazione, il caricamento in GPU e l’API REST. È il pezzo che fa funzionare tutto senza dover compilare llama.cpp a mano.

Docker containerizza Ollama, isolandolo dal sistema host e rendendo l’installazione riproducibile. Con Docker Compose definiamo risorse, volumi, health check e restart policy in un file versionato.

Open WebUI è l’interfaccia chat. Un’app web che parla con l’API di Ollama e ti dà un’esperienza simile a ChatGPT, ma tutta in locale. Supporta cronologia conversazioni, upload di file, e gestione di più modelli.

Passo 1: Preparare il terreno (Docker e driver GPU)

Prima di tutto, assicuriamoci che il sistema sia pronto.

Su Linux (Ubuntu/Debian)


# Verifica driver NVIDIA

nvidia-smi

# Dovresti vedere: Driver Version 550.x o superiore, CUDA 12.4+

  

# Installa Docker se non c'è

curl -fsSL https://get.docker.com | sh

sudo usermod -aG docker $USER

# Riavvia la sessione o fai newgrp docker

  

# Installa NVIDIA Container Toolkit

curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | \

  sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg

  

curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \

  sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \

  sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

  

sudo apt-get update

sudo apt-get install -y nvidia-container-toolkit

sudo systemctl restart docker

  

# Verifica che Docker veda la GPU

docker run --rm --gpus all nvidia/cuda:12.4.0-base nvidia-smi

Su Windows


# Installa Docker Desktop da https://www.docker.com/products/docker-desktop/

# Installa il driver NVIDIA Game Ready o Studio dal sito NVIDIA

# In Docker Desktop: Settings > General > seleziona "Use WSL 2 based engine"

  

# Verifica GPU in WSL2

wsl nvidia-smi

Passo 2: Docker Compose con Ollama e Open WebUI

Creiamo una cartella per il progetto e il file docker-compose.yml:


mkdir deepseek-local

cd deepseek-local

Ora crea il file docker-compose.yml:


version: "3.9"

  

services:

  ollama:

    image: ollama/ollama:0.6.2

    container_name: ollama-deepseek

    restart: unless-stopped

    ports:

      - "11434:11434"

    volumes:

      - ollama_data:/root/.ollama

    environment:

      - OLLAMA_KEEP_ALIVE=24h

      - OLLAMA_NUM_PARALLEL=1

      - OLLAMA_MAX_LOADED_MODELS=1

      - OLLAMA_CONTEXT_LENGTH=16384

    deploy:

      resources:

        reservations:

          devices:

            - driver: nvidia

              count: 1

              capabilities: [gpu]

        limits:

          memory: 14g

    healthcheck:

      test: ["CMD", "ollama", "list"]

      interval: 30s

      timeout: 10s

      retries: 3

      start_period: 60s

    logging:

      driver: "json-file"

      options:

        max-size: "10m"

        max-file: "3"

    ulimits:

      memlock: -1

      stack: 67108864

  

  open-webui:

    image: ghcr.io/open-webui/open-webui:main

    container_name: open-webui

    restart: unless-stopped

    ports:

      - "3000:8080"

    volumes:

      - openwebui_data:/app/backend/data

    environment:

      - OLLAMA_BASE_URL=http://ollama:11434

      - WEBUI_AUTH=false

    depends_on:

      ollama:

        condition: service_healthy

  

volumes:

  ollama_data:

    driver: local

  openwebui_data:

    driver: local

Analizziamo i parametri più importanti:

image: ollama/ollama:0.6.2: fissiamo la versione. Mai usare latest in produzione: un aggiornamento silenzioso può rompere la compatibilità con i modelli scaricati.
volumes: ollama_data:/root/.ollama: volume persistente. I modelli pesano diversi GB ciascuno; senza volume persistente li riscaricheresti a ogni riavvio del container.
OLLAMA_KEEP_ALIVE=24h: mantiene il modello caricato in VRAM per 24 ore dopo l’ultima richiesta. Evita il cold start di ~2 secondi a ogni nuova conversazione.
OLLAMA_CONTEXT_LENGTH=16384: imposta la finestra di contesto a 16K token. Il default di Ollama è 2048, che è troppo poco per conversazioni serie.
memory: 14g: limita il container a 14 GB di RAM, lasciando respiro al sistema host.
ulimits.memlock: -1: impedisce che la memoria venga swappata su disco. Cruciale per la latenza dell’inferenza GPU.
deploy.resources.reservations.devices: prenota la GPU via NVIDIA Container Toolkit. Senza questa sezione, Ollama gira in CPU.
Open WebUI: interfaccia chat web sulla porta 3000. WEBUI_AUTH=false disabilita l’autenticazione per uso locale.

Avvia lo stack


docker compose up -d

Dopo qualche secondo, verifica che tutto sia in salute:


docker compose ps

# Dovresti vedere entrambi i servizi con stato "Up" e ollama "(healthy)"

Passo 3: Scaricare il modello DeepSeek

Ora che Ollama è in esecuzione nel container, scarichiamo il modello. Scegli in base alla tua GPU dalla tabella che abbiamo visto sopra.


# Per GPU da 8-12 GB: modello 7B

docker exec -it ollama-deepseek ollama pull deepseek-r1:7b

  

# Per GPU da 16 GB: modello 14B (consigliato)

docker exec -it ollama-deepseek ollama pull deepseek-r1:14b

  

# Per GPU da 24 GB (RTX 3090/4090): modello 32B

docker exec -it ollama-deepseek ollama pull deepseek-r1:32b

  

# Per test veloci: modello 1.5B (scarica in 30 secondi)

docker exec -it ollama-deepseek ollama pull deepseek-r1:1.5b

Il download può richiedere da pochi minuti (1.5B, ~1 GB) a mezz’ora (32B, ~20 GB), a seconda della connessione.

Per chi ha un Mac Apple Silicon e ha installato Ollama nativo (non Docker):


# Su macOS, Ollama ha accesso diretto alla GPU via Metal

ollama pull deepseek-r1:14b

Verifica il modello


# Elenca i modelli installati

docker exec -it ollama-deepseek ollama list

  

# Test rapido di inferenza

curl -X POST http://localhost:11434/api/generate \

  -H "Content-Type: application/json" \

  -d '{

    "model": "deepseek-r1:14b",

    "prompt": "Scrivi una funzione Python per calcolare la sequenza di Fibonacci",

    "stream": false,

    "options": {

      "temperature": 0.6,

      "max_tokens": 256

    }

  }' | jq '.response'

Se vedi una risposta sensata, il modello funziona.

Passo 4: Personalizzare il modello con un Modelfile

I parametri di default di Ollama sono conservativi. Per un’esperienza migliore, creiamo una versione personalizzata con parametri ottimizzati. Nella cartella del progetto, crea un file Modelfile:


FROM deepseek-r1:14b

  

# Finestra di contesto: fondamentale per conversazioni lunghe

PARAMETER num_ctx 16384

  

# Temperatura: 0.6 è il valore raccomandato da DeepSeek per R1

# Più alta = risposte più creative ma meno coerenti

# Più bassa = risposte più deterministiche ma a volte ripetitive

PARAMETER temperature 0.6

  

# Top-p sampling: restringe la distribuzione di probabilità

PARAMETER top_p 0.9

  

# Penalità di ripetizione: riduce le sequenze ripetitive

PARAMETER repeat_penalty 1.1

  

# Prompt di sistema: definisce il comportamento predefinito

SYSTEM """Sei DeepSeek, un assistente tecnico preciso e affidabile.

Quando scrivi codice, includi commenti e gestione degli errori.

Rispondi in italiano a meno che non ti venga chiesto diversamente.

Se non conosci la risposta, dillo onestamente invece di inventare."""

Ora crea il modello personalizzato e caricalo:


docker exec -it ollama-deepseek ollama create deepseek-custom -f /root/.ollama/Modelfile

Prima però copia il Modelfile nel volume:


docker cp Modelfile ollama-deepseek:/root/.ollama/Modelfile

docker exec -it ollama-deepseek ollama create deepseek-custom -f /root/.ollama/Modelfile

Passo 5: Usare l’interfaccia chat

Apri il browser e vai a http://localhost:3000.

Open WebUI ti accoglie con un’interfaccia pulita, simile a ChatGPT. In alto a sinistra puoi selezionare il modello attivo tra quelli che hai scaricato. La cronologia delle conversazioni viene salvata automaticamente.

Qualche consiglio pratico:

Modelli R1 (ragionamento): vedrai un blocco <think> prima della risposta. È la catena di ragionamento interna. Puoi leggerla o ignorarla. Su compiti di logica e matematica, è lì che avviene la magia.
Temperatura 0.6: valore consigliato per R1. Valori più alti tendono a produrre catene di ragionamento divaganti; valori più bassi possono far collassare il ragionamento.
Contesto lungo: con num_ctx 16384 puoi sostenere conversazioni di decine di messaggi senza che il modello dimentichi l’inizio.

Passo 6: Usare l’API nei tuoi progetti

Ollama espone un’API compatibile con OpenAI su http://localhost:11434/v1. Qualsiasi client o SDK che supporti OpenAI funziona senza modifiche, basta cambiare l’URL base.

Python


from openai import OpenAI

  

client = OpenAI(

    base_url="http://localhost:11434/v1",

    api_key="ollama"  # qualsiasi stringa va bene

)

  

response = client.chat.completions.create(

    model="deepseek-custom",

    messages=[

        {"role": "system", "content": "Sei un esperto di Python."},

        {"role": "user", "content": "Spiega i decoratori in una frase."}

    ],

    temperature=0.6,

    max_tokens=200

)

  

print(response.choices[0].message.content)

JavaScript / Node.js


import { Ollama } from 'ollama';

  

const ollama = new Ollama({ host: 'http://localhost:11434' });

  

const response = await ollama.chat({

  model: 'deepseek-custom',

  messages: [

    { role: 'user', content: 'Qual è la differenza tra let e var in JavaScript?' }

  ],

  stream: true

});

  

for await (const chunk of response) {

  process.stdout.write(chunk.message.content);

}

cURL (per test rapidi)


curl http://localhost:11434/v1/chat/completions \

  -H "Content-Type: application/json" \

  -d '{

    "model": "deepseek-custom",

    "messages": [

      {"role": "user", "content": "Dimmi tre librerie Python per data science e spiegale in una frase ciascuna."}

    ],

    "temperature": 0.6

  }'

Ottimizzare le prestazioni

Una volta che il sistema funziona, puoi metterlo a punto con qualche accorgimento.

Scegliere la quantizzazione giusta

La quantizzazione comprime i pesi del modello riducendo la precisione numerica. Meno bit = meno VRAM = più velocità, ma anche meno qualità.

|—|—|—|—|

| Q2_K | 2 bit | ~5 GB | Degradazione evidente su ragionamenti complessi |

| Q3_K_M | 3 bit | ~7 GB | Accettabile per chat semplici |

| Q4_K_M | 4 bit | ~9 GB | Miglior compromesso qualità/velocità |

| Q5_K_M | 5 bit | ~12 GB | Leggero miglioramento rispetto a Q4 |

| Q8_0 | 8 bit | ~16 GB | Quasi indistinguibile dalla piena precisione |

Ollama scarica di default la versione Q4_K_M. Se hai VRAM in abbondanza, puoi provare una quantizzazione più alta:


docker exec -it ollama-deepseek ollama pull deepseek-r1:14b-q5_K_M

Monitorare l’uso della GPU


# In tempo reale

watch -n 1 nvidia-smi

  

# Oppure, dentro il container

docker exec -it ollama-deepseek nvidia-smi

Se la VRAM arriva al 100% e vedi rallentamenti, il sistema sta swappando tra GPU e RAM di sistema. Riduci il modello o la quantizzazione.

Mantenere il modello in VRAM

Con OLLAMA_KEEP_ALIVE=24h il modello resta in memoria. Il primo messaggio dopo un periodo di inattività è istantaneo invece di richiedere 2-3 secondi di caricamento.

Aumentare la finestra di contesto

Se fai conversazioni molto lunghe o vuoi processare documenti estesi:


environment:

  - OLLAMA_CONTEXT_LENGTH=32768  # 32K token

Attenzione: più contesto = più VRAM consumata per la KV cache. Su GPU con VRAM limitata, meglio restare su 8192-16384.

Risoluzione dei problemi comuni

Ecco cosa fare quando qualcosa non va.

Il container non vede la GPU


# Errore: "no such device" o "CUDA not available"

docker run --rm --gpus all nvidia/cuda:12.4.0-base nvidia-smi

Se fallisce, reinstalla NVIDIA Container Toolkit e riavvia Docker.

Il modello dà risposte senza senso o troncate

Probabilmente stai superando la finestra di contesto. Il default di Ollama è 2048 token — troppo poco per conversation serie. Verifica OLLAMA_CONTEXT_LENGTH nella configurazione.

Lentezza eccessiva


# Controlla che la GPU sia effettivamente usata

docker exec -it ollama-deepseek nvidia-smi

  

# Se vedi poca attività GPU e molta CPU, verifica la sezione deploy.resources

# nel docker-compose.yml

Spazio disco finito


# Controlla quanto occupano i modelli

docker exec -it ollama-deepseek ollama list

  

# Rimuovi modelli non usati

docker exec -it ollama-deepseek ollama rm deepseek-r1:1.5b

  

# Pulisci immagini Docker non usate

docker system prune -a

Usare DeepSeek senza Docker (su macOS e Linux)

Se preferisci evitare Docker, puoi installare Ollama direttamente sul sistema. Su macOS è anzi la scelta migliore, perché Ollama nativo ha accesso diretto all’accelerazione Metal mentre la versione Docker ne è sprovvista.


# macOS

brew install ollama

  

# Linux

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

  

# Avvia il servizio

ollama serve

  

# In un altro terminale, scarica il modello

ollama pull deepseek-r1:14b

  

# Avvia la chat interattiva

ollama run deepseek-r1:14b

In questo caso puoi comunque usare Open WebUI, installandolo separatamente o eseguendolo con Docker collegandolo all’Ollama nativo:


docker run -d \

  --name open-webui \

  -p 3000:8080 \

  -v openwebui_data:/app/backend/data \

  -e OLLAMA_BASE_URL=http://host.docker.internal:11434 \

  -e WEBUI_AUTH=false \

  ghcr.io/open-webui/open-webui:main

Nota: host.docker.internal è l’indirizzo speciale che da dentro un container Docker punta all’host. Su Linux potresti dover usare --network host o l’IP della tua macchina.

Quando DeepSeek locale ha senso (e quando no)

DeepSeek in locale non è la soluzione giusta per tutti. Ecco un confronto onesto:

| Scenario | DeepSeek locale | API cloud (OpenAI/Anthropic) |

|—|—|—|

| Privacy dati | ✅ I dati non escono dal tuo computer | ❌ Ogni prompt va a server esterni |

| Costo per uso intensivo | ✅ Paghi solo l’elettricità (~0.003€/1M token) | ❌ Da 0.15€ a 15€ per 1M token |

| Latenza | ✅ Tempo di primo token < 200ms | ❌ 500-800ms di rete |

| Disponibilità | ❌ Il computer deve essere acceso | ✅ Always-on |

| Manutenzione | ❌ Devi aggiornare modelli e Docker | ✅ Zero manutenzione |

| Qualità massima | ❌ Modelli distillati o quantizzati | ✅ Modelli full-precision sempre aggiornati |

| Setup iniziale | ❌ 30-60 minuti la prima volta | ✅ 2 minuti per una API key |

| Scalabilità multi-utente | ❌ Un utente alla volta, code se in molti | ✅ Infrastruttura cloud elastica |

La regola pratica: se il tuo caso d’uso coinvolge dati sensibili, uso intensivo e continuativo, o latenza critica, DeepSeek locale è probabilmente la scelta giusta. Se invece hai bisogno della massima qualità possibile, fai poche richieste al giorno, o non vuoi gestire infrastruttura, l’API cloud resta la via più semplice.

Conclusioni

Installare DeepSeek in locale con Ollama e Docker richiede circa mezz’ora la prima volta e pochi minuti le volte successive. Il risultato è un assistente AI che gira interamente sul tuo hardware, senza costi a token, senza inviare dati a server esterni, e con una latenza che nessuna API cloud può eguagliare.

La scelta del modello è il punto più delicato. Non farti ingannare dai numeri: il V3 completo da 671B non gira su hardware consumer. Ma i modelli distillati — 7B, 14B, 32B — sono più che all’altezza per la stragrande maggioranza dei compiti reali. Un R1 Distill 32B su RTX 4090 produce risposte che in molti casi sono indistinguibili da quelle di un modello cloud, e lo fa a costo zero dopo l’investimento iniziale in hardware.

Il punto non è se DeepSeek sostituirà del tutto i modelli cloud. Non lo farà, e non deve farlo. Il punto è che oggi puoi scegliere: cloud quando ti serve la massima qualità e zero pensieri, locale quando ti servono privacy, controllo e costi prevedibili. Non è più una scelta tra “modello scarso gratis” e “modello buono a pagamento”. È una scelta tra due opzioni entrambe valide, con trade-off diversi.

E questa è una novità notevole.

AI Disclaimer

Questo articolo è stato sviluppato a partire dalla documentazione ufficiale di DeepSeek, Ollama, Docker e Open WebUI, ed una serie incredibile di miei appunti sull’argomento, con test pratici su configurazioni reali. L’intelligenza artificiale è stata utilizzata per organizzare i contenuti, strutturare la guida.

DiR. Andrea Belvedere