Hvordan kjøre DeepSeek V4 lokalt

TR

Den praktiske måten å kjøre DeepSeek V4 lokalt på er å bruke de offisielle åpne vektene med en høyytelses serving-stakk som vLLM, og deretter eksponere modellen via et lokalt OpenAI-kompatibelt endepunkt. DeepSeek sine nåværende offentlige materialer beskriver to modeller i V4-familien: DeepSeek-V4-Pro med 1,6T totale parametere / 49B aktive, og DeepSeek-V4-Flash med 284B totale parametere / 13B aktive, begge med 1M-token kontekst og tre resonnementmodus. vLLM sine nåværende eksempler for lokal utrulling retter seg mot 8× B200/B300 for Pro og 4× B200/B300 for Flash. Hvis du ikke har slik maskinvare, er en hostet løsning som CometAPI den mer praktiske veien.

DeepSeek AI lanserte en stor nyhet 24. april 2026 med forhåndsvisningen av DeepSeek-V4, med to kraftige Mixture-of-Experts (MoE)-modeller: DeepSeek-V4-Pro (1,6T totale parametere, 49B aktive) og DeepSeek-V4-Flash (284B totale, 13B aktive). Begge støtter et innebygd kontekstvindu på 1 million tokens—en gamechanger for langtids dokumentanalyse, agentiske arbeidsflyter, koding over massive kodebaser og retrieval-augmented generation (RAG) i stor skala.

Trent på over 32 billioner tokens med arkitektoniske innovasjoner som hybrid Compressed Sparse Attention (CSA) + Heavily Compressed Attention (HCA), manifold-constrained hyper-connections (mHC) og effektiv minnehåndtering, oppnår V4 opptil 73% reduksjon i inferens-FLOPs og 90% lavere KV-cache-fotavtrykk for 1M kontekster sammenlignet med V3.2. Ytelsen rivaliserer topp lukkede modeller samtidig som vektene er åpne (MIT-lisens) og ekstremt kostnadseffektive via API.

Å kjøre disse modellene lokalt gir enestående personvern, ingen løpende API-kostnader (utover maskinvare), offline-kapasitet og full tilpasning. Imidlertid gir skalaen utfordringer: V4-Pro sine fulle vekter overstiger 800GB nedlastinger, og inferens krever betydelig maskinvare eller aggressiv kvantisering.

Kan DeepSeek V4 virkelig kjøre lokalt?

Ja, men “lokalt” her betyr noe helt annet enn å kjøre en 7B-modell på en bærbar. DeepSeek sine egne materialer og vLLM-innlegget om støtte peker på store multi-GPU-systemer: V4-Pro er en 1,6T-parameter modell med 49B aktive parametere, mens V4-Flash er 284B totalt / 13B aktive. De offisielle utrullingseksemplene fra vLLM er skrevet for 8× B200/B300 på Pro og 4× B200/B300 på Flash. Det er det tydeligste praktiske signalet om at DeepSeek V4 er en lokal utrulling i bedriftsklassen, ikke et uformelt skrivebordsforsøk.

Det er en grunn til den skalaen. DeepSeek sier V4 støtter et kontekstvindu på 1M tokens, og den tekniske rapporten hevder at V4-Pro bruker bare 27% av FLOPs for enkelt-token-inferens og 10% av KV-cache sammenlignet med DeepSeek-V3.2 ved 1M kontekst. vLLM forklarer videre at, med bf16 KV-cache, bruker DeepSeek V4 9,62 GiB KV-cache per sekvens ved 1M kontekst, som er omtrent 8,7× mindre enn de estimerte 83,9 GiB for en sammenlignbar DeepSeek-V3.2-stakk. Med andre ord er V4 dramatisk mer effektiv enn tidligere generasjoner, men én million tokens er fortsatt et enormt systemproblem.

Arkitektur-sammenligning: DeepSeek V4 vs V3 og konkurrenter

V4s MoE-design aktiverer bare en brøkdel av parameterne per token, og holder beregningen nær en 13B–49B tett modell, samtidig som den drar nytte av kunnskapen i et mye større nettverk.

Hvilken Deepseek V4-modell bør du bruke?

For de fleste lokale utrullinger er DeepSeek-V4-Flash et bedre utgangspunkt. V4-Flash leverer resonnement som nærmer seg Pro på enklere agentoppgaver, samtidig som den er raskere og mer økonomisk.

Bruk DeepSeek-V4-Pro når du bryr deg mer om absolutt kapasitet enn effektivitet. Pro er den sterkere modellen for hardere resonnement, koding og agentiske oppgaver. Benchmark-tabellene viser hvorfor: i den offisielle sammenligningen når V4-Pro-Base 90.1 MMLU, 76.8 HumanEval og 51.5 LongBench-V2, mens V4-Flash-Base scorer 88.7, 69.5 og 44.7. Begge er sterke; Pro presser høyere når du trenger best mulig resultat.

En enkel lesning av tabellen er nok for produktplanlegging. Flash er ikke en nedstrippet leketøy-modell; den er en seriøs langkontekst-assistent med lavere kostnad. Pro er modellen å teste først når problemet er hardt, tilstandsfullt eller nært en produksjonskunnskapsflyt.

Anbefalt lokal stakk

1) vLLM for produksjonslignende serving

Den sterkeste offisielle løsningen i dag er vLLM. vLLM-teamet sier at de nå støtter DeepSeek V4-familien og gir konkrete enkelt-node-oppstartskommandoer for begge modellene. Innlegget rammer inn V4 som en langkontekst modellfamilie designet for oppgaver opp til én million tokens og beskriver implementasjonsarbeidet som trengs for hybrid KV-cache, kjernefusjon og disaggregert serving.

For V4-Pro retter vLLMs eksempel seg mot 8× B200 eller 8× B300. For V4-Flash retter eksemplet seg mot 4× B200 eller 4× B300. Kommandoene bruker også --kv-cache-dtype fp8, --block-size 256, --enable-expert-parallel, og DeepSeek-spesifikke parser-flagg som --tokenizer-mode deepseek_v4, --tool-call-parser deepseek_v4 og --reasoning-parser deepseek_v4. Den kombinasjonen er et veldig sterkt hint om hvordan DeepSeek forventer seriøs selvhosting skal gjø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 å bytte til V4-Pro, behold samme mønster og endre modellen til deepseek-ai/DeepSeek-V4-Pro, med data-parallel-størrelsen flyttet til Pro-eksemplet i vLLMs innlegg. Det er den enkleste måten å begynne å teste lokalt uten å gjenoppfinne serving-stakken.

2) DeepSeek sitt depot for inferens-hjelpere

Deepseek V4 inkluderer ikke en Jinja-format chat-mal. I stedet leverer den en dedikert encoding-mappe med Python-skript og testtilfeller for å konvertere OpenAI-stil-meldinger til modell-inndata-strenger og for å parse utdata. Samme side sier at man skal konsultere inference-mappen for detaljer om lokal utrulling, inkludert vektkonvertering og interaktive chat-demoer. Det er nyttig hvis du vil bygge en tilpasset frontend eller ha tett kontroll på promptformatering.

3) CometAPI som den praktiske reserveplanen

Hvis du ikke har B200/B300-klasse maskinvare, er en hostet rute det fornuftige valget. CometAPI sier at de tilbyr én API-nøkkel for alt, tilgang til 500+ AI-modeller, og priser som er 20–40% billigere enn offisielle leverandørtakster. De publiserer også dedikerte DeepSeek V4-sider, inkludert DeepSeek-V4-Pro og DeepSeek-V4-Flash, med OpenAI-kompatible integrasjonseksempler.

Steg-for-steg: Slik kjører du DeepSeek V4 lokalt

1. Forutsetninger

• OS: Linux anbefales (Ubuntu 22.04/24.04) for best CUDA/ROCm-støtte. Windows via WSL2 eller native. macOS med Metal (begrenset for de største modellene).
• Drivere: NVIDIA CUDA 12.4+ (eller siste). AMD ROCm for Radeon-kort.
• Python 3.11+, Git, og tilstrekkelig diskplass.
• Hugging Face-konto for gatede modeller (hvis aktuelt): huggingface-cli login.

2. Enkleste måte: Ollama eller LM Studio (nybegynnervennlig)

Ollama gir den enkleste CLI- og WebUI-opplevelsen. Per slutten av april 2026 kan full V4-støtte kreve tilpassede Modelfiles eller community-tagger, men kvantiserte V4-Flash-versjoner kommer raskt.

Installer Ollama (Linux/macOS):

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

Kjør en kompatibel modell (start med mindre eller sjekk for V4-tagger):

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

For tilpasset: Opprett 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

Deretter kjør: ollama create my-v4-flash -f Modelfile.

LM Studio: GUI-alternativ. Last ned fra lmstudio.ai, søk/bla på HF etter DeepSeek-V4 GGUF-kvantiseringer (TheBloke-stil eller offisielle), last og chat. Utmerket for eksperimentering med kontekst-skyvere og GPU-offloading.

Open WebUI: Lag over Ollama for et ChatGPT-lignende grensesnitt (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

Tilgjengelig på http://localhost:8080.

3. Avansert: Hugging Face + vLLM eller SGLang (høy ytelse)

For maksimal hastighet og 1M kontekststøtte, bruk vLLM (utmerket MoE- og PagedAttention-støtte):

Steg 1: Klargjør miljøet

Start med å installere den nåværende vLLM-stakken og sørg for at CUDA, drivere og GPU-topologi matcher modellen du vil kjø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 nyttig utgangspunkt enten du bygger en chat-app, en kodeassistent eller en agent-arbeidsflyt.

Installation:

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

Download model (use CLI for large files):

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

Serve with vLLM (example for Flash on 2 GPUs):

Step 2: Launch the model server

Når containeren er oppe, eksponer modellen som et OpenAI-kompatibelt lokalt endepunkt. Det gjør det enkelt å gjenbruke eksisterende applikasjonskode og bytte backend uten å endre app-arkitekturen.

Serve with vLLM (example for Flash on 2 GPUs):

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 server-modus (OpenAI-kompatibel API):

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

Spørr deretter via OpenAI-klienten ved å sette base_url="http://localhost:8000/v1".

SGLang-alternativ for potensielt bedre langkontekst-ytelse:

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

Steg 3: Spørr det lokale endepunktet 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 ytelse og optimaliseringstips

• Tokens/s: På RTX 4090 med Q4 Flash: 15–40+ t/s ved 8K–32K kontekst (varierer med implementasjon). Fall ved 128K+ på grunn av attention/KV, men V4s effektivitet hjelper. Multi-GPU skalerer godt med tensor-/pipeline-parallellisme.
• Optimaliseringer:
• Bruk FlashAttention-3 eller vLLMs PagedAttention.
• Spekulativ dekoding for 1,5–2× hastighetsøkning.
• Kontekstbeskjæring eller komprimeringsteknikker.
• Overvåk med nvidia-smi; bruk gpu_memory_utilization.
• For CPU: llama.cpp med --n-gpu-layers -1 (all offload om mulig) eller ren CPU med høy RAM.

Benchmark oppsettet ditt med verktøy som llama-bench eller enkle tidsmålingsskript. Reell gjennomstrømning avhenger av promptlengde, genereringslengde og maskinvare.

Utfordringer og begrensninger ved lokal V4-utrulling

• Ressursintensitet: Selv Flash krever anstendig maskinvare for komfortable hastigheter ved lange kontekster.
• Kvantisering-avveiinger: Lavere bit kan redusere resonnementskvaliteten, spesielt på komplekse oppgaver—valider med benchmarks som SWE-Bench, MMLU eller dine domenespesifikke evalueringer.
• Programvaremognad: Som en ny forhåndsvisning (april 2026) rulles full optimalisert støtte ut i alle backend-er. Sjekk GitHub-issues for vLLM, llama.cpp og HF.
• Nedlasting/Lagring: Terabyte-skala modeller trenger raskt internett og lagring.
• Strøm og varme: High-end oppsett bruker betydelig strøm.

For mange brukere fungerer hybride tilnærminger best: Kjør mindre oppgaver lokalt, offload tungt 1M-kontekst-resonnement til skyen ved behov.

Når lokalt ikke er nok: Sømfri integrasjon med CometAPI

For mange team er det smarteste trekket å ikke tvinge en lokal utrulling i det hele tatt. Mens lokal utrulling utmerker seg for personvern og kontroll, vil skalering til produksjon, håndtere toppbelastning eller få full ukvantisert ytelse uten massiv maskinvareinvestering ofte favorisere et pålitelig API.

CometAPI tilbyr en samlet, OpenAI-kompatibel gateway til DeepSeek-modeller—inkludert den nyeste Deeppseek V4-serien—sammen med dusinvis av andre topp-LLM-er (Claude, GPT, Llama, Qwen, Grok, etc.).

Der API slår lokal utrulling

De nåværende Deepseek V4-modellene er tilgjengelige via OpenAI-stil og Anthropic-stil endepunkter, med base-URL-er som forblir stabile mens modellnavnet endres. Dokumentene sier også at modellenavnene deepseek-chat og deepseek-reasoner etter hvert vil bli avskrevet og mappe til V4-Flash-adferd under overgangen.

Det betyr noe fordi lokal utrulling har operasjonell kostnad. Hvis arbeidslasten ikke er sensitiv for dataresidens eller hvis teamet ditt ønsker raskere time-to-value, er API-ruten vanligvis det rasjonelle valget. V4-Flash til $0.14 per 1M inndatatokens ved cache miss, $0.0028 per 1M inndatatokens ved cache hit, og $0.28 per 1M utdata-tokens. Samme side sier at V4-Pro for øyeblikket er rabattert 75% til og med 31. mai 2026, til $0.435 per 1M inndatatokens ved cache miss og $0.87 per 1M utdata-tokens.

Deepseek sitt beste alternativ: Hvor CometAPI passer inn

CometAPI er nyttig når målet ikke bare er å kalle DeepSeek V4 én gang, men å bygge en stakk som raskt kan bytte modeller. CometAPI sier de tilbyr én API-nøkkel for 500+ modeller, en OpenAI-kompatibel API, bruksanalyser og lavere priser enn offisielle leverandørrater. De posisjonerer seg også som en måte å unngå leverandørlåsing og styre utgifter på tvers av flere leverandører.

Det gjør CometAPI til en sterk anbefaling for team som evaluerer V4-Pro mot V4-Flash, eller sammenligner DeepSeek med andre frontmodeller i samme applikasjon. I stedet for å kable en ny integrasjon hver gang modellen endres, kan applikasjonen beholde en stabil OpenAI-stil-klient og bare bytte model-verdi og base-URL. CometAPI’s V4 guide viser akkurat det mønsteret.

Rask start med CometAPI for DeepSeek V4:

• Bruk OpenAI SDK:
• Registrer/logg inn på CometAPI.com.
• Generer en API-nøkkel i konsollen.

Her er den hostede versjonen av samme integrasjonsmø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)

Verdien av denne ruten er operasjonell, ikke retorisk. Den fjerner infrastrukturarbeid, holder klientkoden portabel, og gir teamet ett sted å teste kostnad, latens og kvalitet på tvers av flere modeller. CometAPI sier også at de sporer forbruk, latens og kallvolum, noe som er nyttig når prototypen blir en produksjonsarbeidslast.

Når velge lokalt, API eller CometAPI

Den lokale veien er berettiget når kontroll betyr mer enn bekvemmelighet. API-veien er berettiget når fart og enkelhet betyr mer enn eierskap. CometAPI er mellomlaget når teamet ønsker portabilitet og kostnadskontroll uten å bygge om integrasjonen hver gang modellen endres.

FAQ

Kan DeepSeek V4 kjøre på en laptop?

Ikke i den praktiske betydningen som lokale inferensveiledninger antyder. De offisielle materialene peker på multi-GPU og multi-node utrulling, og modellstørrelsene ligger langt over ordinære forbruker-minnebudsjetter. En laptop er fin for API-tilgang, men ikke for meningsfull selvhosting av V4-Pro eller engang en komfortabel V4-Flash-oppsett.

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

V4-Pro er den sterkere modellen for resonnement, koding og forskning. V4-Flash er bedre standardvalg for hastighet, gjennomstrømning og lavere kostnad. Den offisielle utgivelsen og benchmark-tabellen peker mot samme konklusjon.

Er CometAPI påkrevd i lokal utrulling?

Nei. Det er et valgfritt produksjonslag. DeepSeek sin egen API fungerer direkte, og lokal selvhosting er mulig gjennom den offisielle inferensstien. CometAPI blir attraktivt når du vil ha én kodebane på tvers av mange modellleverandører, kostnadssporing og enklere bytte mellom modellfamilier.

Konklusjon

DeepSeek V4 er ikke bare en ny modellutgivelse. Det er et langkontekst, agentfokusert system med åpne vekter, offisiell API-tilgang og et tydelig skille mellom en høy-ende resonnementmodell og en lavkost gjennomstrømmingsmodell. De siste offisielle nyhetene betyr noe fordi de endrer beslutningstreet: lokal utrulling er mulig, men bare for team med seriøs GPU-infrastruktur; API-tilgang er tilgjengelig umiddelbart; og CometAPI er en fornuftig anbefaling når portabilitet og kostnadsdisiplin betyr mer enn å eie inferens-stakken.

Hvis arbeidslasten er kompleks og maskinvaren finnes, start med V4-Pro. Hvis arbeidslasten er volumbasert, start med V4-Flash. Hvis målet er å levere raskt og holde modellalternativene åpne, bruk API-laget og hold koden portabel. Det er den mest forsvarlige produksjonsstrategien akkurat nå.

Handlingsorienterte neste steg:

1. Vurder maskinvaren din og start med kvantisert V4-Flash via Ollama eller LM Studio.
2. Eksperimenter med kodeeksemplene over og benchmark mot dine arbeidslaster.
3. Utforsk GGUF-kvanter og community-optimaliseringer etter hvert som de modnes etter utgivelsen.
4. For produksjon eller tung last, integrer CometAPI for pålitelig, kostnadseffektiv tilgang til full V4-Pro/Flash uten å administrere maskinvare.