Sådan kører du DeepSeek V4 lokalt

TR

Den praktiske måde at køre DeepSeek V4 lokalt på er at bruge de officielle open-source-vægte med en højtydende serving-stack som vLLM og derefter udstille modellen via et lokalt OpenAI-kompatibelt endepunkt. DeepSeek’s nuværende offentlige materialer beskriver to modeller i V4-familien: DeepSeek-V4-Pro med 1,6T samlede parametre / 49B aktive og DeepSeek-V4-Flash med 284B samlede / 13B aktive, begge med 1M-token kontekst og tre ræsonneringstilstande. vLLM’s nuværende lokale udrulningseksempler retter sig mod 8× B200/B300 for Pro og 4× B200/B300 for Flash. Hvis du ikke har den type hardware, er en hostet fallback som CometAPI den mere praktiske vej.

DeepSeek AI kom med en stor nyhed den 24. april 2026 med forhåndsudgivelsen af DeepSeek-V4, der indeholder to kraftige Mixture-of-Experts (MoE)-modeller: DeepSeek-V4-Pro (1,6T samlede parametre, 49B aktive) og DeepSeek-V4-Flash (284B samlet, 13B aktive). Begge understøtter et native kontekstvindue på 1 million tokens—en gamechanger for langdokumentanalyse, agent-baserede arbejdsgange, kodning over massive kodebaser og retrieval-augmented generation (RAG) i skala.

Trænet på over 32 billioner tokens med arkitekturinnovationer som hybrid Compressed Sparse Attention (CSA) + Heavily Compressed Attention (HCA), manifold-constrained hyper-connections (mHC) og effektiv hukommelseshåndtering opnår V4 op til 73% reduktion i inferens-FLOPs og 90% lavere KV-cache-fodaftryk for 1M-kontekster sammenlignet med V3.2. Ydelsen matcher topmodeller med lukket kildekode, samtidig med at vægtene er åbne (MIT-licens) og ekstremt omkostningseffektive via API.

At køre disse modeller lokalt giver uovertruffen privatliv, nul løbende API-omkostninger (ud over hardware), offline-kapabilitet og fuld tilpasning. Men deres skala giver udfordringer: V4-Pro’s fulde vægte overstiger 800GB i download, og inferens kræver betydelig hardware eller aggressiv kvantisering.

Kan DeepSeek V4 virkelig køre lokalt?

Ja, men “lokalt” her betyder noget helt andet end at køre en 7B-model på en laptop. DeepSeek’s egne materialer og vLLM’s supportopslag peger på store multi-GPU-systemer: V4-Pro er en 1,6T-parameter model med 49B aktive parametre, mens V4-Flash er 284B samlet / 13B aktive. De officielle udrulningseksempler fra vLLM er skrevet til 8× B200/B300 for Pro og 4× B200/B300 for Flash. Det er det klareste praktiske signal om, at DeepSeek V4 er en virksomhedsorienteret lokal udrulning, ikke et afslappet desktop-eksperiment.

Der er en grund til denne skala. DeepSeek siger, at V4 understøtter et kontekstvindue på 1M tokens, og den tekniske rapport hævder, at V4-Pro kun bruger 27% af enkelt-token-inferens-FLOPs og 10% af KV-cachen sammenlignet med DeepSeek-V3.2 ved 1M kontekst. vLLM forklarer derudover, at med bf16 KV-cache bruger DeepSeek V4 9,62 GiB KV-cache pr. sekvens ved 1M kontekst, hvilket er cirka 8,7× mindre end de estimerede 83,9 GiB for en sammenlignelig DeepSeek-V3.2-lignende stack. Med andre ord er V4 dramatisk mere effektiv end tidligere generationer, men en million tokens er stadig et enormt systemproblem.

Arkitektur-sammenligningstabel: DeepSeek V4 vs. V3 og konkurrenter

V4’s MoE-design aktiverer kun en brøkdel af parametrene pr. token, hvilket holder compute tættere på en 13B-49B tæt model, samtidig med at man drager fordel af viden i et meget større netværk.

Hvilken DeepSeek V4-model skal du bruge?

For de fleste lokale udrulninger er DeepSeek-V4-Flash det bedste udgangspunkt. V4-Flash leverer ræsonnering, der ligger tæt på Pro ved enklere agent-opgaver, samtidig med at den er hurtigere og mere økonomisk.

Brug DeepSeek-V4-Pro, når du vægter absolut kapabilitet over effektivitet. Pro er den stærkere model til sværere ræsonnering, kodning og agentiske opgaver. Benchmark-tabellerne viser hvorfor: på den officielle sammenligning når V4-Pro-Base 90,1 MMLU, 76,8 HumanEval og 51,5 LongBench-V2, mens V4-Flash-Base scorer hhv. 88,7, 69,5 og 44,7. Begge er stærke; Pro presser bare højere, når du har brug for det bedst mulige resultat.

En enkel læsning af tabellen er nok til produktplanlægning. Flash er ikke en nedskåret legetøjsmodel; det er en seriøs langt-kontekst-assistent med lavere omkostninger. Pro er modellen, der bør testes først, når problemet er svært, tilstandsfuldt eller tæt på en produktionsvidensarbejdsgang.

Anbefalet lokal stak

1) vLLM til produktionslignende serving

Den stærkeste officielle mulighed i dag er vLLM. vLLM-teamet siger, at det nu understøtter DeepSeek V4-familien og giver konkrete single-node startkommandoer for begge modeller. Deres opslag indrammer V4 som en langt-kontekst-modelfamilie designet til opgaver op til en million tokens og beskriver implementeringsarbejdet, der krævedes for hybrid KV-cache, kernesammensmeltning og disaggregeret serving.

For V4-Pro retter vLLM’s eksempel sig mod 8× B200 eller 8× B300. For V4-Flash retter eksemplet sig mod 4× B200 eller 4× B300. Kommandoerne bruger også --kv-cache-dtype fp8, --block-size 256, --enable-expert-parallel og DeepSeek-specifikke parser-flag som --tokenizer-mode deepseek_v4, --tool-call-parser deepseek_v4 og --reasoning-parser deepseek_v4. Den kombination er en meget stærk indikation af, hvordan DeepSeek forventer, at seriøs self-hosting udføres.

# 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

For at skifte til V4-Pro bevar samme mønster og ændr modellen til deepseek-ai/DeepSeek-V4-Pro, med data-parallel-størrelsen flyttet til Pro-eksemplet i vLLM’s opslag. Det er den enkleste måde at starte lokale tests uden at genopfinde serving-stakken.

2) DeepSeek’s repository-inferenshjælpere

DeepSeek V4 indeholder ikke en chat-skabelon i Jinja-format. I stedet leverer den en dedikeret encoding-mappe med Python-scripts og testcases til at konvertere OpenAI-lignende beskeder til modelinputstrenge og parse output. Den samme side siger, at man skal konsultere inference-mappen for detaljer om lokal udrulning, inklusive vægtkonvertering og interaktive chat-demoer. Det er nyttigt, hvis du vil bygge en brugerdefineret frontend eller have stram kontrol over promptformatering.

3) CometAPI som den praktiske backup-plan

Hvis du ikke har hardware i B200/B300-klassen, er en hostet rute det fornuftige valg. CometAPI siger, at de tilbyder én API-nøgle til alting, adgang til 500+ AI-modeller og priser, der er 20–40% billigere end officielle leverandørrater. De udgiver også dedikerede DeepSeek V4-sider, inklusive DeepSeek-V4-Pro og DeepSeek-V4-Flash, med OpenAI-kompatible integrations-eksempler.

Trin for trin: Sådan kører du DeepSeek V4 lokalt

1. Forudsætninger

• OS: Linux foretrækkes (Ubuntu 22.04/24.04) for bedst CUDA/ROCm-understøttelse. Windows via WSL2 eller native. macOS med Metal (begrænset for de største modeller).
• Drivere: NVIDIA CUDA 12.4+ (eller nyeste). AMD ROCm til Radeon-kort.
• Python 3.11+, Git og tilstrækkelig diskplads.
• Hugging Face-konto til gated modeller (hvis relevant): huggingface-cli login.

2. Nem­meste vej: Ollama eller LM Studio (begynder-venlig)

Ollama giver den enkleste CLI- og WebUI-oplevelse. Pr. slut april 2026 kan fuld V4-understøttelse kræve brugerdefinerede Modelfiles eller community-tags, men kvantiserede V4-Flash-versioner dukker hurtigt op.

Installér Ollama (Linux/macOS):

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

Kør en kompatibel model (start med mindre eller tjek for 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

Til brugerdefineret: Opret en 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

Kør derefter: ollama create my-v4-flash -f Modelfile.

LM Studio: GUI-alternativ. Download fra lmstudio.ai, søg/gennemse HF for DeepSeek-V4 GGUF-kvantiseringer (TheBloke-stil eller officielle), indlæs og chat. Fremragende til eksperimenter med kontekst-slidere og GPU-offloading.

Open WebUI: Læg ovenpå Ollama for en ChatGPT-lignende grænseflade (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

Adgang på http://localhost:8080.

3. Avanceret: Hugging Face + vLLM eller SGLang (høj ydelse)

For maksimal hastighed og 1M-kontekst-understøttelse, brug vLLM (fremragende MoE- og PagedAttention-understøttelse):

Step 1: Forbered miljøet

Start med at installere den aktuelle vLLM-stack og sikre, at din CUDA, drivere og GPU-topologi matcher den model, du vil køre. 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. Det er et nyttigt udgangspunkt, uanset om du bygger en chat-app, en kodeassistent eller en agent-arbejdsgang.

Installation:

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

Download model (brug CLI til store filer):

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

Serve med vLLM (eksempel for Flash på 2 GPU’er):

Step 2: Start modelserveren

Når containeren kører, skal du udstille modellen som et lokalt OpenAI-kompatibelt endepunkt. Det gør det let at genbruge din eksisterende applikationskode og skifte backend uden at ændre din app-arkitektur.

Serve med vLLM (eksempel for Flash på 2 GPU’er):

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)

For servertilstand (OpenAI-kompatibel API):

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

Forespørg derefter via OpenAI-klient ved at sætte base_url="http://localhost:8000/v1".

SGLang-alternativ for potentielt bedre langt-kontekst-ydelse:

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

Step 3: Forespørg det lokale endepunkt fra 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)

Forventet ydelse og optimeringstips

• Tokens/sek.: På RTX 4090 med Q4 Flash: 15–40+ t/s ved 8K–32K kontekst (varierer med implementering). Falder ved 128K+ pga. attention/KV, men V4’s effektivitet hjælper. Multi-GPU skalerer godt med tensor-/pipeline-parallelisme.
• Optimeringer:
• Brug FlashAttention-3 eller vLLM’s PagedAttention.
• Spekulativ dekodning for 1,5–2× hastighedsforøgelse.
• Kontekstbeskæring eller komprimeringsteknikker.
• Overvåg med nvidia-smi; brug gpu_memory_utilization.
• For CPU: llama.cpp med --n-gpu-layers -1 (fuld offload hvis muligt) eller ren CPU med høj RAM.

Benchmark dit setup med værktøjer som llama-bench eller simple timing-scripts. Reel gennemløb afhænger af promptlængde, genereringslængde og hardware.

Udfordringer og begrænsninger ved lokal V4-udrulning

• Ressourceintensiv: Selv Flash kræver solid hardware for behagelige hastigheder ved lange kontekster.
• Kvantisering-afvejninger: Lavere bitdybde kan reducere ræsonneringskvalitet, især på komplekse opgaver—valider med benchmarks som SWE-Bench, MMLU eller dine domænespecifikke evalueringer.
• Softwaremodenhed: Som en ny forhåndsudgivelse (april 2026) ruller fuldt optimeret understøttelse ud i alle backends. Tjek GitHub-issues for vLLM, llama.cpp og HF.
• Download/lagring: Terabyte-skala modeller kræver hurtig internetforbindelse og lager.
• Strøm og varme: High-end setups bruger betydelig elektricitet.

For mange brugere fungerer hybride tilgange bedst: Kør mindre opgaver lokalt, og offload tung 1M-kontekst-ræsonnering til skyen efter behov.

Når lokalt ikke er nok: Smertefri integration med CometAPI

For mange teams er det klogeste træk slet ikke at tvinge en lokal udrulning. Mens lokal udrulning er suveræn for privatliv og kontrol, favoriserer skalering til produktion, håndtering af spidsbelastninger eller adgang til fuld ukvantiseret ydelse uden massiv hardwareinvestering ofte en pålidelig API.

CometAPI giver en samlet, OpenAI-kompatibel gateway til DeepSeek-modeller—inklusive den nyeste Deeppseek V4-serie—sammen med dusinvis af andre top-LLM’er (Claude, GPT, Llama, Qwen, Grok osv.).

Hvor API’et slår lokal udrulning

De aktuelle Deepseek V4-modeller er tilgængelige via OpenAI- og Anthropic-stil endepunkter, med base-URLs der forbliver stabile, mens modelnavnet ændres. Dokumentationen siger også, at modelnavnene deepseek-chat og deepseek-reasoner til sidst vil blive udfaset og mappe til V4-Flash-adfærd under overgangen.

Det er vigtigt, fordi lokal udrulning medfører driftsomkostninger. Hvis arbejdsbelastningen ikke er følsom overfor dataresidens, eller hvis dit team ønsker hurtigere time-to-value, er API-ruten normalt det rationelle valg. V4-Flash til $0,14 pr. 1M inputtokens ved cache-miss, $0,0028 pr. 1M inputtokens ved cache-hit og $0,28 pr. 1M outputtokens. Den samme side siger, at V4-Pro i øjeblikket er rabatteret 75% indtil 31. maj 2026 til $0,435 pr. 1M inputtokens ved cache-miss og $0,87 pr. 1M outputtokens.

Deepseek’s bedste alternativ: Hvor CometAPI passer ind

CometAPI er nyttigt, når målet ikke bare er at kalde DeepSeek V4 én gang, men at bygge en stak, der hurtigt kan skifte modeller. CometAPI siger, at de giver én API-nøgle til 500+ modeller, en OpenAI-kompatibel API, brugsanalyse og lavere priser end officielle leverandørrater. De positionerer sig også som en måde at undgå vendor lock-in og styre forbrug på tværs af flere udbydere.

Det gør CometAPI til en stærk anbefaling for teams, der evaluerer V4-Pro mod V4-Flash eller sammenligner DeepSeek med andre frontmodeller i samme applikation. I stedet for at koble en ny integration på hver gang modellen ændrer sig, kan applikationen beholde en stabil OpenAI-lignende klient og kun skifte værdien af model og base-URL. CometAPI’s V4-guide viser netop dette mønster.

Hurtig start med CometAPI til DeepSeek V4:

• Brug OpenAI SDK:
• Registrér/log ind på CometAPI.com.
• Generér en API-nøgle i konsollen.

Her er den hostede version af det samme integrationsmønster:

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)

Værdien af denne rute er driftsmæssig, ikke retorisk. Den fjerner infrastrukturarbejde, holder klientkoden portabel og giver teamet ét sted at teste omkostninger, latenstid og kvalitet på tværs af flere modeller. CometAPI siger også, at de sporer forbrug, latenstid og kaldsvolumen, hvilket er nyttigt, når prototypen bliver en produktionsarbejdsbyrde.

Hvornår vælger man lokal, API eller CometAPI

Den lokale vej er berettiget, når kontrol betyder mere end bekvemmelighed. API-vejen er berettiget, når hastighed og enkelhed betyder mere end ejerskab. CometAPI er mellemlaget, når teamet vil have portabilitet og omkostningskontrol uden at genopbygge integrationen hver gang model-familien skifter.

Ofte stillede spørgsmål

Kan DeepSeek V4 køre på en laptop?

Ikke i den praktiske forstand, som lokale inferens-tutorials antyder. De officielle materialer peger på multi-GPU- og multi-node-udrulning, og modelstørrelserne ligger langt over normale forbrugermemory-budgetter. En laptop er fin til API-adgang, men ikke til meningsfuld self-hosting af V4-Pro eller selv en komfortabel V4-Flash-opsætning.

Hvilken er bedre: V4-Pro eller V4-Flash?

V4-Pro er den stærkere model til ræsonnering, kodning og forskning. V4-Flash er det bedre standardvalg for hastighed, throughput og lavere omkostninger. Den officielle udgivelse og benchmark-tabellen peger på samme konklusion.

Er CometAPI påkrævet i lokal udrulning?

Nej. Det er et valgfrit produktionslag. DeepSeek’s egen API fungerer direkte, og lokal self-hosting er mulig via den officielle inferensvej. CometAPI bliver attraktivt, når du ønsker én kodevej på tværs af mange modeludbydere, omkostningssporing og nemmere skift mellem modelfamilier.

Konklusion

DeepSeek V4 er ikke bare endnu en modeludgivelse. Det er et langt-kontekst, agentfokuseret system med åbne vægte, officiel API-adgang og en klar opdeling mellem en high-end ræsonneringsmodel og en lavere-omkostnings throughput-model. De seneste officielle nyheder betyder noget, fordi de ændrer beslutningstræet: lokal udrulning er mulig, men kun for teams med seriøs GPU-infrastruktur; API-adgang er tilgængelig med det samme; og CometAPI er en fornuftig anbefaling, når portabilitet og omkostningsdisciplin betyder mere end at eje inferensstakken.

Hvis arbejdsbyrden er kompleks, og hardwaren findes, så start med V4-Pro. Hvis arbejdsbyrden er volumen-drevet, så start med V4-Flash. Hvis målet er at levere hurtigt og holde modelmulighederne åbne, så brug API-laget og hold din kode portabel. Det er den mest forsvarlige produktionsstrategi lige nu.

Handlingsrettede næste skridt:

1. Vurder din hardware og start med kvantiseret V4-Flash via Ollama eller LM Studio.
2. Eksperimentér med kodeeksemplerne ovenfor og benchmark mod dine arbejdsbelastninger.
3. Udforsk GGUF-kvantiseringer og community-optimeringer, efterhånden som de modnes efter udgivelsen.
4. Til produktion eller tungt løft: integrér CometAPI for pålidelig, omkostningseffektiv adgang til fuld V4-Pro/Flash uden at skulle håndtere hardware.