DeepSeek V4 lokaal uitvoeren

TR

De praktische manier om DeepSeek V4 lokaal te draaien is het gebruik van de officiële open-source-gewichten met een high-performance serving-stack zoals vLLM, en het model vervolgens blootstellen via een lokale, met OpenAI compatibele endpoint. DeepSeek’s huidige openbare materialen beschrijven twee modellen in de V4-familie: DeepSeek-V4-Pro met 1,6T totale parameters / 49B actief, en DeepSeek-V4-Flash met 284B totaal / 13B actief, beide met 1M-token context en drie redeneermodi. De huidige lokale deployment-voorbeelden van vLLM richten zich op 8× B200/B300 voor Pro en 4× B200/B300 voor Flash. Als je niet over dat soort hardware beschikt, is een gehoste fallback zoals CometAPI de praktischere route.

DeepSeek AI liet op 24 april 2026 een bom vallen met de preview-release van DeepSeek-V4, met twee krachtige Mixture-of-Experts (MoE) modellen: DeepSeek-V4-Pro (1,6T totale parameters, 49B actief) en DeepSeek-V4-Flash (284B totaal, 13B actief). Beide ondersteunen een native contextvenster van 1 miljoen tokens—een gamechanger voor lange-documentanalyse, agent-workflows, coderen over enorme codebases en retrieval-augmented generation (RAG) op schaal.

Getraind op meer dan 32 biljoen tokens en met architecturale innovaties zoals hybride Compressed Sparse Attention (CSA) + Heavily Compressed Attention (HCA), manifold-constrained hyper-connections (mHC) en efficiënt geheugengebruik, behaalt V4 tot 73% reductie in inference-FLOPs en 90% lagere KV-cache-voetafdruk voor 1M-contexten vergeleken met V3.2. De prestaties rivaliseren met top closed-source modellen terwijl het open-gewichten (MIT-licentie) blijven en via API extreem kosteneffectief zijn.

Deze modellen lokaal draaien biedt ongeëvenaarde privacy, geen terugkerende API-kosten (buiten hardware), offline-capaciteit en volledige aanpasbaarheid. Hun schaal brengt echter uitdagingen met zich mee: V4-Pro’s volledige gewichten overschrijden 800GB aan downloads, en inferentie vereist aanzienlijke hardware of agressieve kwantisering.

Kan DeepSeek V4 echt lokaal draaien?

Ja, maar “lokaal” betekent hier iets heel anders dan een 7B-model op een laptop draaien. DeepSeek’s eigen materialen en de vLLM-supportpost wijzen naar grote multi-GPU-systemen: V4-Pro is een 1,6T-parameter model met 49B actieve parameters, terwijl V4-Flash 284B totaal / 13B actief is. De officiële deployment-voorbeelden van vLLM zijn geschreven voor 8× B200/B300 op Pro en 4× B200/B300 op Flash. Dat is het duidelijkste praktische signaal dat DeepSeek V4 een enterprise-klasse lokale deployment is, geen vrijblijvende desktopproef.

Voor die schaal is een reden. DeepSeek zegt dat V4 een 1M-token contextvenster ondersteunt, en het technisch rapport claimt dat V4-Pro slechts 27% van de single-token inference FLOPs en 10% van de KV-cache gebruikt vergeleken met DeepSeek-V3.2 bij 1M context. vLLM legt verder uit dat DeepSeek V4, met bf16 KV-cache, 9,62 GiB KV-cache per sequence bij 1M context gebruikt, wat ongeveer 8,7× kleiner is dan de geschatte 83,9 GiB voor een vergelijkbare DeepSeek-V3.2-stapel. Met andere woorden, V4 is dramatisch efficiënter dan eerdere generaties, maar één miljoen tokens blijft een enorme systeemuitdaging.

Architectuurvergelijkingstabel: DeepSeek V4 vs V3 en concurrenten

Het MoE-ontwerp van V4 activeert slechts een fractie van de parameters per token, waardoor de compute dichter bij een dense 13B–49B-model blijft terwijl het profiteert van de kennis van een veel groter netwerk.

Welk DeepSeek V4-model moet je gebruiken?

Voor de meeste lokale deployments is DeepSeek-V4-Flash het betere startpunt. V4-Flash levert redeneren dat op eenvoudiger agenttaken dicht in de buurt komt van Pro, terwijl het sneller en economischer blijft.

Gebruik DeepSeek-V4-Pro wanneer absolute capaciteit belangrijker is dan efficiëntie. Pro is het sterkere model voor zwaardere redenering, coderen en agenttaken. De benchmarktabellen laten zien waarom: in de officiële vergelijking behaalt V4-Pro-Base 90,1 MMLU, 76,8 HumanEval en 51,5 LongBench-V2, terwijl V4-Flash-Base respectievelijk 88,7, 69,5 en 44,7 scoort. Beide zijn sterk; Pro gaat gewoon verder wanneer je het best mogelijke resultaat nodig hebt.

Een eenvoudige lezing van de tabel is voldoende voor productplanning. Flash is geen uitgekleed speeltje; het is een serieuze long-contextassistent met lagere kosten. Pro is het model om als eerste te testen wanneer het probleem moeilijk, stateful of dicht bij een productieworkflow voor kennis zit.

Aanbevolen lokale stack

1) vLLM voor serving op productieniveau

De sterkste officiële optie vandaag is vLLM. Het vLLM-team zegt dat het nu de DeepSeek V4-familie ondersteunt en geeft concrete single-node startcommando’s voor beide modellen. Hun post framet V4 als een long-context modellenfamilie ontworpen voor taken tot een miljoen tokens en beschrijft het implementatiewerk dat nodig is voor hybride KV-cache, kernelfusie en gedisaggregeerde serving.

Voor V4-Pro richt het vLLM-voorbeeld zich op 8× B200 of 8× B300. Voor V4-Flash richt het voorbeeld zich op 4× B200 of 4× B300. De commando’s gebruiken ook --kv-cache-dtype fp8, --block-size 256, --enable-expert-parallel en DeepSeek-specifieke parse-flags zoals --tokenizer-mode deepseek_v4, --tool-call-parser deepseek_v4 en --reasoning-parser deepseek_v4. Die combinatie is een zeer sterke hint over hoe DeepSeek verwacht dat serieuze self-hosting wordt gedaan.

# 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

Om over te schakelen naar V4-Pro behoud je hetzelfde patroon en wijzig je het model naar deepseek-ai/DeepSeek-V4-Pro, met de data-parallel-waarde zoals in het Pro-voorbeeld in de vLLM-post. Dat is de eenvoudigste manier om lokaal te beginnen testen zonder de serving-stack opnieuw uit te vinden.

2) DeepSeek’s repository inference-helpers

DeepSeek V4 bevat geen Jinja-achtige chatt-template. In plaats daarvan levert het een dedicated encoding-map met Python-scripts en testcases om OpenAI-stijlberichten om te zetten in modelinvoerstrings en de output te parsen. Op dezelfde pagina staat dat je de inference-map moet raadplegen voor details over lokale deployment, inclusief gewichtsconversie en interactieve chatdemo’s. Dat is nuttig als je een aangepaste front-end wilt bouwen of promptopmaak strak wilt controleren.

3) CometAPI als het praktische back-upplan

Als je geen hardware van B200/B300-klasse hebt, is een gehoste route de verstandige keuze. CometAPI zegt dat het één API-sleutel voor alles biedt, toegang tot 500+ AI-modellen en prijzen die 20–40% goedkoper zijn dan officiële leveranciers. Het publiceert ook speciale DeepSeek V4-pagina’s, inclusief DeepSeek-V4-Pro en DeepSeek-V4-Flash, met OpenAI-compatibele integratievoorbeelden.

Stapsgewijs: DeepSeek V4 lokaal draaien

1. Vereisten

• OS: Linux aanbevolen (Ubuntu 22.04/24.04) voor de beste CUDA/ROCm-ondersteuning. Windows via WSL2 of native. macOS met Metal (beperkt voor de grootste modellen).
• Drivers: NVIDIA CUDA 12.4+ (of recenter). AMD ROCm voor Radeon-kaarten.
• Python 3.11+, Git en voldoende schijfruimte.
• Hugging Face-account voor afgeschermde modellen (indien van toepassing): huggingface-cli login.

2. De makkelijkste manier: Ollama of LM Studio (beginnersvriendelijk)

Ollama biedt de eenvoudigste CLI- en WebUI-ervaring. Eind april 2026 kan volledige V4-ondersteuning aangepaste Modelfiles of community-tags vereisen, maar gequantiseerde V4-Flash-versies verschijnen snel.

Installeer Ollama (Linux/macOS):

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

Draai een compatibel model (begin klein of check op V4-tags):

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

Voor custom: maak een Modelfile (tekst):

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

Vervolgens: ollama create my-v4-flash -f Modelfile.

LM Studio: GUI-alternatief. Download van lmstudio.ai, zoek/browse op HF naar DeepSeek-V4 GGUF-kwantisaties (TheBloke-stijl of officieel), laad en chat. Uitstekend voor experimenten met context-sliders en GPU-offloading.

Open WebUI: Leg er bovenop voor een ChatGPT-achtige interface (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

Toegang via http://localhost:8080.

3. Geavanceerd: Hugging Face + vLLM of SGLang (hoge prestaties)

Voor maximale snelheid en 1M-contextondersteuning gebruik je vLLM (uitstekende MoE- en PagedAttention-ondersteuning):

Stap 1: Bereid de omgeving voor

Begin met het installeren van de huidige vLLM-stack en zorg dat je CUDA, drivers en GPU-topologie overeenkomen met het model dat je wilt draaien. 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. Dat is een nuttig startpunt of je nu een chatapp, code-assistent of agent-workflow bouwt.

Installatie:

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

Model downloaden (gebruik CLI voor grote bestanden):

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

Serveren met vLLM (voorbeeld voor Flash op 2 GPU’s):

Stap 2: Start de modelserver

Zodra de container draait, stel je het model bloot als een lokale, met OpenAI compatibele endpoint. Zo kun je je bestaande applicatiecode hergebruiken en backends wisselen zonder je app-architectuur te wijzigen.

Serveren met vLLM (voorbeeld voor Flash op 2 GPU’s):

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)

Voor servermodus (OpenAI-compatibele API):

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

Vervolgens kun je via de OpenAI-client query’en door base_url="http://localhost:8000/v1" te zetten.

SGLang-alternatief voor mogelijk betere long-context-prestaties:

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

Stap 3: Query de lokale endpoint vanuit 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)

Verwachtingen qua prestaties en optimalisatietips

• Tokens/sec: Op een RTX 4090 met Q4 Flash: 15–40+ t/s bij 8K–32K context (verschilt per implementatie). Zakt bij 128K+ door attention/KV, maar V4’s efficiënties helpen. Multi-GPU schaalt goed met tensor-/pipeline-parallelisme.
• Optimalisaties:
• Gebruik FlashAttention-3 of vLLM’s PagedAttention.
• Speculatieve decodering voor 1,5–2× versnelling.
• Contextpruning of compressietechnieken.
• Monitor met nvidia-smi; gebruik gpu_memory_utilization.
• Voor CPU: llama.cpp met --n-gpu-layers -1 (alles offloaden indien mogelijk) of pure CPU met veel RAM.

Benchmark je setup met tools zoals llama-bench of eenvoudige timingscripts. De werkelijke throughput hangt af van promptlengte, generatielengte en hardware.

Uitdagingen en beperkingen van lokale V4-deployment

• Resource-intensiteit: Zelfs Flash vereist degelijke hardware voor comfortabele snelheden bij lange contexten.
• Kwantisatie-afwegingen: Lagere bits kunnen redeneerkwaliteit verminderen, vooral bij complexe taken—valideer met benchmarks zoals SWE-Bench, MMLU of je domeinspecifieke evaluaties.
• Softwarevolwassenheid: Als nieuwe preview (april 2026) rolt volledige geoptimaliseerde ondersteuning in alle backends nog uit. Check GitHub-issues voor vLLM, llama.cpp en HF.
• Download/opslag: Modellen op terabyteschaal vereisen snel internet en opslag.
• Stroom & warmte: High-end setups verbruiken aanzienlijke elektriciteit.

Voor veel gebruikers werken hybride benaderingen het best: draai kleinere taken lokaal, offload zware 1M-contextredenering naar de cloud wanneer nodig.

Wanneer lokaal niet genoeg is: naadloze integratie met CometAPI

Voor veel teams is de slimste zet om lokale deployment helemaal niet te forceren. Hoewel lokaal uitblinkt in privacy en controle, zijn opschalen naar productie, piekbelasting afhandelen of toegang tot volledige ongekwantiseerde prestaties zonder massale hardware-investeringen vaak een argument voor een betrouwbare API.

CometAPI biedt een verenigd, met OpenAI compatibel toegangspunt tot DeepSeek-modellen—waaronder de nieuwste Deeppseek V4-serie—samen met tientallen andere top-LLM’s (Claude, GPT, Llama, Qwen, Grok, enz.).

Waar de API lokale deployment verslaat

De huidige DeepSeek V4-modellen zijn beschikbaar via OpenAI- en Anthropic-achtige endpoints, met base-URL’s die stabiel blijven terwijl de modelnaam wijzigt. De docs zeggen ook dat de modelnamen deepseek-chat en deepseek-reasoner uiteindelijk worden uitgefaseerd en tijdens de overgang naar V4-Flash-gedrag worden gemapt.

Dat is relevant omdat lokale deployment operationele kosten met zich meebrengt. Als de workload niet gevoelig is voor dataresidentie of als je team sneller waarde wil leveren, is de API-route meestal de rationele keuze. V4-Flash kost $0,14 per 1M inputtokens bij cache-miss, $0,0028 per 1M inputtokens bij cache-hit, en $0,28 per 1M outputtokens. Op dezelfde pagina staat dat V4-Pro momenteel tot 31 mei 2026 met 75% korting wordt aangeboden, voor $0,435 per 1M inputtokens bij cache-miss en $0,87 per 1M outputtokens.

DeepSeek’s beste alternatief: waar CometAPI past

CometAPI is nuttig wanneer het doel niet is om DeepSeek V4 één keer aan te roepen, maar om een stack te bouwen die snel van model kan wisselen. CometAPI zegt één API-sleutel voor 500+ modellen te bieden, een OpenAI-compatibele API, gebruiksanalytics en lagere prijzen dan officiële leveranciers. Het positioneert zich ook als een manier om vendor lock-in te vermijden en uitgaven over meerdere providers te beheren.

Dat maakt CometAPI een sterke aanbeveling voor teams die V4-Pro tegen V4-Flash evalueren, of DeepSeek vergelijken met andere frontiermodellen in dezelfde applicatie. In plaats van elke keer een nieuwe integratie te bedraden, kan de applicatie een stabiele OpenAI-achtige client behouden en alleen de model-waarde en base-URL wijzigen. CometAPI’s V4-gids laat precies dat patroon zien.

Snelstart met CometAPI voor DeepSeek V4:

• Gebruik de OpenAI-SDK:
• Registreer/log in op CometAPI.com.
• Genereer een API-sleutel in de console.

Hier is de gehoste versie van hetzelfde integratiepatroon:

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)

De waarde van deze route is operationeel, niet retorisch. Het verwijdert infrastructuurwerk, houdt de clientcode draagbaar en geeft het team één plek om kosten, latency en kwaliteit over meerdere modellen te testen. CometAPI zegt ook uitgaven, latency en callvolume te tracken, wat nuttig is zodra het prototype een productieworkload wordt.

Wanneer kiezen voor lokaal, API of CometAPI

Het lokale pad is gerechtvaardigd wanneer controle belangrijker is dan gemak. Het API-pad is gerechtvaardigd wanneer snelheid en eenvoud belangrijker zijn dan eigenaarschap. CometAPI is de middelste laag wanneer het team portabiliteit en kostenbeheersing wil zonder bij elke modelwijziging de integratie opnieuw te bouwen.

FAQ

Kan DeepSeek V4 op een laptop draaien?

Niet in de praktische zin die lokale inferentietutorials impliceren. De officiële materialen wijzen op multi-GPU- en multi-node-deployment, en de modelgroottes liggen ver buiten de geheugenbudgetten van gewone consumenten. Een laptop is prima voor API-toegang, maar niet voor zinvolle self-hosting van V4-Pro of zelfs een comfortabele V4-Flash-setup.

Welke is beter: V4-Pro of V4-Flash?

V4-Pro is het sterkere model voor redeneren, coderen en onderzoek. V4-Flash is de betere standaard voor snelheid, throughput en lagere kosten. De officiële release en de benchmarktabel wijzen op dezelfde conclusie.

Is CometAPI vereist bij lokale implementatie?

Nee. Het is een optionele productielaag. DeepSeek’s eigen API werkt direct, en lokale self-hosting is mogelijk via het officiële inferentiepad. CometAPI wordt aantrekkelijk wanneer je één codepad wilt over veel modelproviders, kostenbewaking en makkelijker wisselen tussen modelfamilies.

Conclusie

DeepSeek V4 is niet zomaar weer een modelrelease. Het is een long-context, agent-gecentreerd systeem met open gewichten, officiële API-toegang en een duidelijke splitsing tussen een high-end redeneermodel en een lager-geprijsd throughputmodel. Het laatste officiële nieuws is belangrijk omdat het de beslisboom verandert: lokale deployment is mogelijk, maar alleen voor teams met serieuze GPU-infrastructuur; API-toegang is onmiddellijk beschikbaar; en CometAPI is een verstandige aanbeveling wanneer portabiliteit en kostendiscipline belangrijker zijn dan het bezitten van de inferentiestack.

Als de workload complex is en de hardware aanwezig, begin dan met V4-Pro. Als de workload volumegedreven is, begin dan met V4-Flash. Als het doel is om snel te leveren en modelopties open te houden, gebruik dan de API-laag en houd je code draagbaar. Dat is op dit moment de meest verdedigbare productiestrategie.

Concreet te nemen stappen:

1. Beoordeel je hardware en begin met gequantiseerde V4-Flash via Ollama of LM Studio.
2. Experimenteer met de bovenstaande codevoorbeelden en benchmark tegen je workloads.
3. Verken GGUF-kwantisaties en community-optimalisaties naarmate ze na release volwassen worden.
4. Integreer voor productie of zwaar werk CometAPI voor betrouwbare, kosteneffectieve toegang tot volledige V4-Pro/Flash zonder hardwarebeheer.