Come eseguire DeepSeek V4 in locale

TR

Il modo pratico per eseguire DeepSeek V4 in locale è usare i pesi open-source ufficiali con uno stack di serving ad alte prestazioni come vLLM, quindi esporre il modello tramite un endpoint locale compatibile con OpenAI. I materiali pubblici attuali di DeepSeek descrivono due modelli della famiglia V4: DeepSeek-V4-Pro con 1,6T di parametri totali / 49B attivi e DeepSeek-V4-Flash con 284B totali / 13B attivi, entrambi con contesto da 1M di token e tre modalità di ragionamento. Gli esempi di deployment locale di vLLM attualmente puntano a 8× B200/B300 per Pro e 4× B200/B300 per Flash. Se non disponi di quel tipo di hardware, un fallback hosted come CometAPI è la strada più pratica.

DeepSeek AI ha sganciato una bomba il 24 aprile 2026, con il rilascio in anteprima di DeepSeek-V4, che presenta due potenti modelli Mixture-of-Experts (MoE): DeepSeek-V4-Pro (1,6T di parametri totali, 49B attivi) e DeepSeek-V4-Flash (284B totali, 13B attivi). Entrambi supportano nativamente una finestra di contesto da 1 milione di token—un cambio di paradigma per l’analisi di documenti lunghi, i workflow agentici, il coding su codebase massive e la RAG su larga scala.

Addestrato su oltre 32 trilioni di token con innovazioni architetturali come Compressed Sparse Attention (CSA) ibrida + Heavily Compressed Attention (HCA), hyper-connessioni a varietà vincolata (mHC) e gestione efficiente della memoria, V4 raggiunge fino al 73% di riduzione dei FLOP di inferenza e al 90% in meno di impronta della cache KV per contesti da 1M rispetto a V3.2. Le prestazioni rivaleggiano con i migliori modelli closed-source restando open-weights (licenza MIT) ed estremamente convenienti via API.

Eseguire questi modelli in locale offre privacy impareggiabile, costi API ricorrenti pari a zero (al netto dell’hardware), capacità offline e piena personalizzazione. Tuttavia, la loro scala presenta sfide: i pesi completi di V4-Pro superano gli 800GB di download e l’inferenza richiede hardware significativo o quantizzazione aggressiva.

DeepSeek V4 può davvero girare in locale?

Sì, ma “in locale” qui significa qualcosa di molto diverso dall’eseguire un 7B su un laptop. I materiali di DeepSeek e il post di supporto vLLM indicano sistemi multi-GPU di grandi dimensioni: V4-Pro è un modello da 1,6T di parametri con 49B di parametri attivi, mentre V4-Flash è 284B totali / 13B attivi. Gli esempi di deployment ufficiali di vLLM sono scritti per 8× B200/B300 su Pro e 4× B200/B300 su Flash. È il segnale pratico più chiaro che DeepSeek V4 è un deployment locale di classe enterprise, non un esperimento da desktop.

C’è un motivo per tale scala. DeepSeek afferma che V4 supporta una finestra di contesto da 1M di token, e il report tecnico sostiene che V4-Pro utilizzi solo il 27% dei FLOP di inferenza per token singolo e il 10% della cache KV rispetto a DeepSeek-V3.2 a 1M di contesto. vLLM spiega inoltre che, con bf16 KV cache, DeepSeek V4 usa 9,62 GiB di cache KV per sequenza a 1M di contesto, circa 8,7× in meno rispetto ai 83,9 GiB stimati per uno stack simile a DeepSeek-V3.2. In altre parole, V4 è drasticamente più efficiente delle generazioni precedenti, ma un milione di token resta un problema di sistema enorme.

Tabella di confronto architetture: DeepSeek V4 vs V3 e concorrenti

Il design MoE di V4 attiva solo una frazione dei parametri per token, mantenendo il compute vicino a un modello denso da 13B-49B, beneficiando al contempo della conoscenza di una rete molto più grande.

Quale modello DeepSeek V4 dovresti usare?

Per la maggior parte dei deployment locali, DeepSeek-V4-Flash è il punto di partenza migliore. V4-Flash offre un ragionamento che si avvicina molto a Pro su task agent semplici, restando più veloce ed economico.

Usa DeepSeek-V4-Pro quando dai priorità alla capacità assoluta rispetto all’efficienza. Pro è il modello più forte per compiti di ragionamento, coding e agentici più difficili. Le tabelle di benchmark lo mostrano: nel confronto ufficiale, V4-Pro-Base raggiunge 90,1 su MMLU, 76,8 su HumanEval e 51,5 su LongBench-V2, mentre V4-Flash-Base segna 88,7, 69,5 e 44,7 rispettivamente. Entrambi sono forti; Pro spinge più in alto quando serve il miglior risultato possibile.

Una lettura semplice della tabella basta per la pianificazione di prodotto. Flash non è un modellino ridotto; è un assistente long-context serio a costo inferiore. Pro è il modello da testare per primo quando il problema è difficile, stateful o vicino a un workflow di conoscenza in produzione.

Stack locale consigliato

1) vLLM per serving in stile produzione

L’opzione ufficiale più solida oggi è vLLM. Il team vLLM afferma che ora supporta la famiglia DeepSeek V4 e fornisce comandi di lancio single-node concreti per entrambi i modelli. Il loro post inquadra V4 come una famiglia di modelli long-context progettata per task fino a un milione di token e descrive il lavoro di implementazione necessario per cache KV ibrida, fusioni di kernel e serving disaggregato.

Per V4-Pro, l’esempio di vLLM punta a 8× B200 o 8× B300. Per V4-Flash, l’esempio punta a 4× B200 o 4× B300. I comandi usano anche --kv-cache-dtype fp8, --block-size 256, --enable-expert-parallel e flag di parsing specifici di DeepSeek come --tokenizer-mode deepseek_v4, --tool-call-parser deepseek_v4 e --reasoning-parser deepseek_v4. Quella combinazione è un indizio molto forte su come DeepSeek si aspetta che venga fatto il self-hosting serio.

# DeepSeek-V4-Flash on a supported multi-GPU hostdocker run --gpus all \  --ipc=host -p 8000:8000 \  -v ~/.cache/huggingface:/root/.cache/huggingface \  vllm/vllm-openai:deepseekv4-cu130 deepseek-ai/DeepSeek-V4-Flash \  --trust-remote-code \  --kv-cache-dtype fp8 \  --block-size 256 \  --enable-expert-parallel \  --data-parallel-size 4 \  --compilation-config '{"cudagraph_mode":"FULL_AND_PIECEWISE", "custom_ops":["all"]}' \  --attention_config.use_fp4_indexer_cache=True \  --tokenizer-mode deepseek_v4 \  --tool-call-parser deepseek_v4 \  --enable-auto-tool-choice \  --reasoning-parser deepseek_v4

Per passare a V4-Pro, mantieni lo stesso schema e cambia il modello in deepseek-ai/DeepSeek-V4-Pro, con la dimensione di data-parallel spostata sull’esempio Pro nel post di vLLM. È il modo più semplice per iniziare a testare in locale senza reinventare lo stack di serving.

2) Helper di inferenza del repository DeepSeek

Deepseek V4 non include un template chat in formato Jinja. Al suo posto, fornisce una cartella encoding con script Python e test case per convertire messaggi in stile OpenAI in stringhe di input al modello e per il parsing dell’output. La stessa pagina indica di consultare la cartella inference per i dettagli del deployment locale, inclusi conversione pesi e demo di chat interattive. È utile se vuoi costruire un front-end personalizzato o controllare strettamente il formato dei prompt.

3) CometAPI come piano di backup pratico

Se non disponi di hardware classe B200/B300, una soluzione hosted è la scelta sensata. CometAPI afferma di offrire una sola API key per tutto, accesso a 500+ modelli di AI e prezzi più bassi del 20–40% rispetto alle tariffe ufficiali dei vendor. Pubblica anche pagine dedicate a DeepSeek V4, tra cui DeepSeek-V4-Pro e DeepSeek-V4-Flash, con esempi di integrazione compatibili con OpenAI.

Passo-passo: come eseguire DeepSeek V4 in locale

1. Prerequisiti

• OS: Linux consigliato (Ubuntu 22.04/24.04) per il miglior supporto CUDA/ROCm. Windows via WSL2 o nativo. macOS con Metal (limitato per i modelli più grandi).
• Driver: NVIDIA CUDA 12.4+ (o più recente). AMD ROCm per schede Radeon.
• Python 3.11+, Git e spazio su disco sufficiente.
• Account Hugging Face per modelli protetti (se applicabile): huggingface-cli login.

2. Metodo più semplice: Ollama o LM Studio (per principianti)

Ollama offre l’esperienza CLI e WebUI più semplice. A fine aprile 2026, il supporto completo per V4 può richiedere Modelfile personalizzati o tag della community, ma le versioni quantizzate di V4-Flash stanno emergendo rapidamente.

Installa Ollama (Linux/macOS):

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

Esegui un modello compatibile (inizia con più piccolo o verifica i tag V4):

ollama pull deepseek-v4-flash:q4_0   # Example quantized tag; check ollama.com/library or community
ollama run deepseek-v4-flash:q4_0

Per personalizzare: crea un Modelfile (testo):

FROM ./DeepSeek-V4-Flash-GGUF-Q4.gguf
TEMPLATE """{{ .Prompt }}"""
PARAMETER num_ctx 32768  # Start conservative; increase as hardware allows up to 1M with sufficient RAM/VRAM

Poi ollama create my-v4-flash -f Modelfile.

LM Studio: alternativa GUI. Scarica da lmstudio.ai, cerca/sfoglia su HF le quantizzazioni GGUF di DeepSeek-V4 (stile TheBloke o ufficiali), carica e chatta. Eccellente per sperimentare con slider del contesto e offloading su GPU.

Open WebUI: layer sopra Ollama per un’interfaccia tipo ChatGPT (Bash):

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

Accedi su http://localhost:8080.

3. Avanzato: Hugging Face + vLLM o SGLang (alte prestazioni)

Per la massima velocità e supporto al contesto da 1M, usa vLLM (ottimo supporto MoE e PagedAttention):

Step 1: Prepara l’ambiente

Inizia installando lo stack vLLM attuale e assicurandoti che CUDA, driver e topologia GPU corrispondano al modello che vuoi eseguire. recommending temperature = 1.0 and top_p = 1.0 for local deployment, and for Think Max it recommends a context window of at least 384K tokens. That is a useful starting point whether you are building a chat app, a coding assistant, or an agent workflow.

Installazione:

Bash
pip install -U "vllm>=0.9.0"  # Check latest for V4 compatibility

Scarica il modello (usa la CLI per file di grandi dimensioni):

Bash
pip install -U "huggingface_hub[cli]"
huggingface-cli download deepseek-ai/DeepSeek-V4-Flash --local-dir ./DeepSeek-V4-Flash

Servi con vLLM (esempio per Flash su 2 GPU):

Step 2: Avvia il server del modello

Una volta che il container è attivo, esponi il modello come endpoint locale compatibile con OpenAI. Questo semplifica il riuso del tuo codice applicativo esistente e lo swap dei backend senza cambiare l’architettura dell’app.

Servi con vLLM (esempio per Flash su 2 GPU):

Python
from vllm import LLM, SamplingParams

llm = LLM(
    model="deepseek-ai/DeepSeek-V4-Flash",
    tensor_parallel_size=2,      # Adjust to your GPU count
    max_model_len=1048576,       # 1M context (hardware permitting)
    dtype="auto",                # or "fp8" / "bfloat16"
    quantization="gptq" if using quantized weights else None,
    gpu_memory_utilization=0.9
)

sampling_params = SamplingParams(temperature=0.7, top_p=0.95, max_tokens=4096)

outputs = llm.generate(["Explain the architecture of DeepSeek V4 in detail."], sampling_params)
for output in outputs:
    print(output.outputs[0].text)

Per la modalità server (API compatibile con OpenAI):

Bash
vllm serve deepseek-ai/DeepSeek-V4-Flash \
  --tensor-parallel-size 2 \
  --max-model-len 1048576 \
  --port 8000

Quindi interroga tramite il client OpenAI impostando base_url="http://localhost:8000/v1".

Alternativa SGLang per prestazioni potenzialmente migliori su contesti lunghi:

Bash
pip install "sglang[all]>=0.4.0"
python -m sglang.launch_server --model-path deepseek-ai/DeepSeek-V4-Flash --port 30000

Step 3: Interroga l’endpoint locale da Python

from openai import OpenAI
# Adjust the base URL if your vLLM server is bound differently.

client = OpenAI(
base_url="http://localhost:8000/v1",
api_key="EMPTY",
)

response = client.chat.completions.create(
model="deepseek-ai/DeepSeek-V4-Flash",
messages=[
{"role": "system", "content": "You are a precise, technical assistant."},
{"role": "user", "content": "Explain the difference between V4-Pro and V4-Flash."},
],
temperature=1.0,
top_p=1.0,
)

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

Aspettative di prestazioni e suggerimenti di ottimizzazione

• Token/sec: Su RTX 4090 con Q4 Flash: 15-40+ t/s a 8K-32K di contesto (varia in base all’implementazione). Cala a 128K+ per attenzione/cache KV, ma le efficienze di V4 aiutano. Il multi-GPU scala bene con parallelismo tensor/pipeline.
• Ottimizzazioni:
• Usa FlashAttention-3 o PagedAttention di vLLM.
• Decoding speculativo per speedup 1,5-2×.
• Tecniche di pruning o compressione del contesto.
• Monitora con nvidia-smi; utilizza gpu_memory_utilization.
• Per CPU: llama.cpp con --n-gpu-layers -1 (offload totale se possibile) o solo CPU con molta RAM.

Esegui benchmark del tuo setup con strumenti come llama-bench o semplici script di timing. La velocità reale dipende dalla lunghezza del prompt, dalla lunghezza della generazione e dall’hardware.

Sfide e limitazioni del deployment locale di V4

• Intensità di risorse: Anche Flash richiede hardware adeguato per velocità confortevoli su contesti lunghi.
• Trade-off della quantizzazione: Bit più bassi possono ridurre la qualità del ragionamento, soprattutto su task complessi—valida con benchmark come SWE-Bench, MMLU o valutazioni specifiche del tuo dominio.
• Maturità del software: Essendo una preview nuova (aprile 2026), il supporto pienamente ottimizzato in tutti i backend è in rollout. Controlla le issue su GitHub per vLLM, llama.cpp e HF.
• Download/Storage: Modelli scala terabyte richiedono internet e storage veloci.
• Energia & calore: Setup di fascia alta consumano molta elettricità.

Per molti utenti, funzionano meglio approcci ibridi: esegui localmente i task più piccoli, scarica su cloud il ragionamento a contesto 1M quando necessario.

Quando il locale non basta: integrazione senza attriti con CometAPI

Per molti team, la scelta più intelligente è non forzare affatto un deployment locale. Sebbene il deployment locale eccella per privacy e controllo, scalare in produzione, gestire i picchi o accedere a prestazioni non quantizzate complete senza un enorme investimento hardware spesso favorisce una API affidabile.

CometAPI fornisce un gateway unificato e compatibile con OpenAI ai modelli DeepSeek—including gli ultimi della serie Deeppseek V4—insieme a dozzine di altri LLM top (Claude, GPT, Llama, Qwen, Grok, ecc.).

Dove la API batte il deployment locale

Gli attuali modelli Deepseek V4 sono disponibili tramite endpoint in stile OpenAI e Anthropic, con base URL stabili mentre il nome del modello cambia. I documenti dicono anche che i nomi modello deepseek-chat e deepseek-reasoner verranno infine deprecati e mappati al comportamento V4-Flash durante la transizione.

Questo conta perché il deployment locale comporta costi operativi. Se il carico non è sensibile alla residenza dei dati o se il tuo team vuole time-to-value più rapido, la via API è solitamente la scelta razionale. V4-Flash a $0,14 per 1M token in input su cache miss, $0,0028 per 1M token in input su cache hit, e $0,28 per 1M token in output. La stessa pagina indica che V4-Pro è attualmente scontato del 75% fino al 31 maggio 2026, a $0,435 per 1M token in input su cache miss e $0,87 per 1M token in output.

La migliore alternativa a Deepseek: dove si inserisce CometAPI

CometAPI è utile quando l’obiettivo non è solo chiamare DeepSeek V4 una volta, ma costruire uno stack che possa cambiare modello rapidamente. CometAPI afferma di fornire una singola API key per 500+ modelli, una API compatibile con OpenAI, analytics d’uso e prezzi inferiori alle tariffe dei vendor ufficiali. Si propone anche come mezzo per evitare il lock-in del fornitore e gestire la spesa su più provider.

Questo rende CometAPI una raccomandazione forte per team che stanno valutando V4-Pro rispetto a V4-Flash, o confrontando DeepSeek con altri modelli frontier nella stessa applicazione. Invece di cablare una nuova integrazione ogni volta che il modello cambia, l’app può mantenere un client in stile OpenAI stabile e cambiare solo il valore model e la base URL. Guida V4 di CometAPI mostra esattamente quel pattern.

Quick Start con CometAPI per DeepSeek V4:

• Usa l’SDK OpenAI:
• Registrati/accedi su CometAPI.com.
• Genera una API key nella console.

Ecco la versione hosted dello stesso pattern di integrazione:

from openai import OpenAIclient = OpenAI(    base_url="https://api.cometapi.com",    api_key="YOUR_COMETAPI_KEY",)response = client.chat.completions.create(    model="deepseek-v4-pro",    messages=[        {"role": "system", "content": "You are a senior coding assistant."},        {"role": "user", "content": "Review this architecture for bottlenecks."}    ],    stream=False,    extra_body={        "thinking": {"type": "enabled"},        "reasoning_effort": "high"    })print(response.choices[0].message.content)

Il valore di questa strada è operativo, non retorico. Rimuove il lavoro d’infrastruttura, mantiene il codice client portabile e offre al team un unico luogo per testare costo, latenza e qualità su più modelli. CometAPI afferma anche di tracciare spesa, latenza e volume di chiamate, utile quando il prototipo diventa un carico di lavoro in produzione.

Quando scegliere locale, API o CometAPI

La via locale è giustificata quando il controllo conta più della comodità. La via API è giustificata quando velocità e semplicità contano più della proprietà. CometAPI è il layer intermedio quando il team vuole portabilità e controllo dei costi senza ricostruire l’integrazione ogni volta che il modello cambia.

FAQ

DeepSeek V4 può girare su un laptop?

Non nel senso pratico implicato dai tutorial di inferenza locale. I materiali ufficiali puntano a deployment multi-GPU e multi-nodo, e le dimensioni dei modelli vanno ben oltre i budget di memoria consumer. Un laptop va bene per l’accesso via API, ma non per un self-hosting significativo di V4-Pro o anche per un setup comodo di V4-Flash.

Qual è migliore: V4-Pro o V4-Flash?

V4-Pro è il modello più forte per ragionamento, coding e ricerca. V4-Flash è la scelta predefinita migliore per velocità, throughput e costo inferiore. Il rilascio ufficiale e la tabella dei benchmark portano alla stessa conclusione.

CometAPI è obbligatorio nel deployment locale?

No. È un layer di produzione opzionale. L’API di DeepSeek funziona direttamente e il self-hosting locale è possibile tramite il percorso di inferenza ufficiale. CometAPI diventa interessante quando vuoi un’unica code path tra più provider di modelli, il tracciamento dei costi e uno switch più semplice tra famiglie di modelli.

Conclusione

DeepSeek V4 non è solo un altro rilascio di modello. È un sistema long-context, orientato agli agenti, con pesi open, accesso API ufficiale e una chiara divisione tra un modello di ragionamento di fascia alta e un modello di throughput a costo inferiore. Le ultime novità ufficiali contano perché cambiano l’albero decisionale: il deployment locale è possibile, ma solo per team con infrastruttura GPU seria; l’accesso via API è disponibile immediatamente; e CometAPI è una raccomandazione sensata quando portabilità e disciplina dei costi contano più del possesso dello stack di inferenza.

Se il carico di lavoro è complesso e l’hardware c’è, inizia con V4-Pro. Se il carico è guidato dal volume, inizia con V4-Flash. Se l’obiettivo è spedire rapidamente e mantenere aperte le opzioni di modello, usa lo strato API e mantieni il codice portabile. È la strategia di produzione più difendibile in questo momento.

Prossimi passi operativi:

1. Valuta il tuo hardware e inizia con V4-Flash quantizzato via Ollama o LM Studio.
2. Sperimenta con gli esempi di codice sopra e fai benchmark sui tuoi workload.
3. Esplora quantizzazioni GGUF e ottimizzazioni della community man mano che maturano post-release.
4. Per produzione o carichi pesanti, integra CometAPI per accesso affidabile e conveniente a V4-Pro/Flash completi senza gestire hardware.