Sådan kører du DeepSeek-V3.1 på din lokale enhed

DeepSeek-V3.1 er en hybrid Mixture-of-Experts (MoE) chatmodel udgivet af DeepSeek i august 2025, der understøtter to inferenstilstande — en hurtig "ikke-tænkende" tilstand og en bevidst "tænkende" tilstand — fra samme checkpoint. Modellen er tilgængelig på Hugging Face og kan køres lokalt via flere stier (vLLM, Ollama/llama.cpp, Ollama-lignende GGUF'er eller storskala multi-GPU-opsætninger). Nedenfor gennemgår jeg krav, hvordan tænketilstanden fungerer, flere lokale kørselsmuligheder (med kørbare kodestykker) og en trinvis "Thinking Mode deployment"-opskrift med eksempler på værktøjskald og token-skabeloner.

Hvad er DeepSeek-V3.1, og hvorfor er det vigtigt?

DeepSeek-V3.1 er v3-familieopdateringen fra DeepSeek, der introducerer en hybrid inferensdesignDen samme model kan køres i tænker (overvejende, flertrins) eller ikke-tænkende (direkte svar, hurtigere) tilstande ved at ændre chatskabelonen. Arkitektonisk set er det en stor MoE-familie (basiskontrolpunkt omkring 671 mia. parametre i alt, ~37 mia. aktiveret pr. token) med langkonteksttræning udvidet til 128 tokens og FP8-mikroskaleringsunderstøttelse. DeepSeek positionerede V3.1 som en agentklar udgivelse: bedre værktøjskald, forbedrede agentfærdigheder og højere tænkeeffektivitet sammenlignet med tidligere R1-udgivelser. Udgivelsen blev annonceret i august 2025 og er blevet integreret i Hugging Face, CFD/OSS-værktøjer og cloud-implementeringsvejledninger.

Sådan fungerer hybridmodellen (kortfattet)

Et kontrolpunkt, to skabeloner: Tænkende vs. ikke-tænkende tilstande styres af chatskabelon og en <think>/</think> token-konventionen i prompten. Modelkortet dokumenterer de nøjagtige præfikser.
Forbedringer af agenter/værktøjer: Boosts efter træning muliggør smartere værktøjskald – modellen forventer et strengt JSON-format til værktøjskald for sikker, deterministisk værktøjsudførelse.
Ydelsesafvejninger: Tænketilstanden bruger tokens på intern tankekæde-lignende ræsonnement og kan være langsommere/mere token-intensiv; ikke-tænkning er hurtigere og billigere. Benchmarks i modelkortet viser betydelige forbedringer på tværs af ræsonnement og kodebenchmarks for V3.1.

Hvordan modellen er struktureret

MoE-rygraden: stort samlet parameterantal med en mindre aktiveret delmængde pr. token (økonomisk inferens).
LangkonteksttræningV3.1 udvider lange kontekstfaser betydeligt (32k → større træning på lange dokumenter) for at understøtte 128K+ vinduer i nogle builds.
FP8 native arbejdsgangDeepSeek bruger FP8-formater i vid udstrækning (w8a8 / UE8M0) for at øge vægten/aktiveringens effektivitet; der findes konverteringsskripter fra community'et, hvis du foretrækker BF16/FP16.

Hvad er kravene for at køre DeepSeek-V3.1 lokalt? (Hardware, lagerplads og software)

Kører fuld V3.1-modellen (ikke-kvantiseret) er en stor opgave. Nedenfor er realistiske kategorier af opsætninger og hvad de typisk kræver.

Praktiske spande

**Klynge / forskningslaboratorium (fuld model)**Flere GPU'er med høj hukommelse (H100/H800-klassen eller mange Ada/Hopper GPU'er), multi-node med snesevis af GPU'er, masser af NVMe-lagerplads (hundredvis af GB'er) og specialiserede inferensframeworks (SGLang, vLLM, LMDeploy, TRT-LLM).
Enkeltserver high-end (kvantiseret): muligt med kraftig kvantisering (INT4/AWQ/AWQ2/gguf) og frameworks som Ollama (forudpakket) eller community GGUF'er — kræver stadig ~tiere til hundreder af GB GPU RAM eller smart CPU+GPU offload.
Udviklerlaptop / udviklerboksIkke muligt for den fulde model; brug små destillerede/finjusterede varianter eller opret forbindelse til den lokale server/Ollama-instans.

Hardware-tjekliste (praktisk)

GPU'erFor reel inferensgennemstrømning af den fulde V3.1: multi-GPU-klynger (H100 / H800 / Ada Lovelace+). Til FP8-udførelse kræves GPU'er med beregningskapacitet og driverunderstøttelse.
RAM og lagerpladsForvent hundredvis af GB ledig diskplads til modelfilerne (modelsiderne angiver et par hundrede GB afhængigt af format/kvantisering), plus arbejdsplads til konverterede formater. Ollama-metadata angiver et ~400 GB fodaftryk for en DeepSeek V3.1 Ollama-pakke i biblioteket.
NetværkTil inferens med flere noder har du brug for sammenkoblinger med lav latenstid (NVLink/InfiniBand) og orkestreringsværktøjer til tensor-parallelle opsætninger.

Softwaretjekliste

OSLinux anbefales til community-inferensværktøjer (DeepSeek-Infer-demoen viser Linux/Python).
Python: 3.10+ (i mange DeepSeek-eksempler). Typiske pakkeversioner er fastgjort i arkivet requirements.txt.
Rammer og værktøjer (vælg en eller flere): SGLang, vLLM, LMDeploy, TRT-LLM/TensorRT-LLM, LightLLM eller Ollama til enklere lokale installationer. Hver har instruktioner og forskellig præcisions-/kvantiseringsunderstøttelse.

Praktisk bemærkning: Hvis du kun har én forbruger-GPU (f.eks. 24-48 GB), vil du sandsynligvis bruge kvantiserede GGUF'er eller fjerninferens. Hvis du har en arbejdsstation med >128 GB RAM plus en H100/H200-klasse GPU-klynge, kan du sigte mod FP8/FP16-inferens med højere kvalitet med vLLM.

Hvordan kører jeg DeepSeek-V3.1 lokalt?

Nedenfor er flere praktiske metoder, du kan bruge, fra den mest manuelle/fleksible til den nemmeste metode til en enkelt udvikler. Jeg vil give trinvise vejledninger og kodeeksempler.

Mulighed A — Officiel DeepSeek-Infer-demo (udviklings-/klyngesti)

Dette er repoets eksempel/demo for FP8/BF16-inferens. Brug det, hvis du planlægger multi-node eller ønsker at eksperimentere med den officielle inferenskode.

Klon, forbered miljø

git clone https://github.com/deepseek-ai/DeepSeek-V3.git
cd DeepSeek-V3/inference
# Create a dedicated venv / conda env

python -m venv venv && source venv/bin/activate
pip install -r requirements.txt

(Repo inference/requirements.txt viser en liste over de fastgjorte fakkel-/triton-/transformer-versioner, der er anbefalet af teamet.)

Download modelvægte

Download fra siden med krammeansigtsmodellen (deepseek-ai/DeepSeek-V3.1) og placer dem under /path/to/DeepSeek-V3Modelkortet og lageret nævner begge de officielle Hugging Face-opbevaringslinks.

Konverter vægte til demo

# example conversion command shown in the repo

python convert.py --hf-ckpt-path /path/to/DeepSeek-V3 --save-path /path/to/DeepSeek-V3-Demo --n-experts 256 --model-parallel 16

Kør interaktiv generering (distribueret)

torchrun --nnodes 2 --nproc-per-node 8 --node-rank $RANK --master-addr $ADDR \
  generate.py --ckpt-path /path/to/DeepSeek-V3-Demo --config configs/config_671B.json \
  --interactive --temperature 0.7 --max-new-tokens 200

Dette er det kanoniske eksempel fra DeepSeek-repoet til kørsel i klyngestil.

Mulighed B — vLLM (anbefales til serverinstallationer og OpenAI-kompatibel API)

vLLM understøtter DeepSeek i FP8/BF16-tilstande og giver dig en OpenAI-kompatibel server. Det er en populær produktionssti for store modeller på grund af hukommelsesoptimeringer og API-kompatibilitet.

Start en vLLM-server, der henter modellen fra Hugging Face (eksempelmønster):

# this will download/serve the model (replace with exact model id if needed)

vllm serve deepseek-ai/DeepSeek-V3.1 --host 0.0.0.0 --port 8000

Anmod derefter om færdiggørelser med curl eller en OpenAI-kompatibel klient:

curl -s -X POST "http://localhost:8000/v1/completions" \
  -H "Content-Type: application/json" \
  -d '{"model":"DeepSeek-V3.1","prompt":"Explain the QuickSort algorithm", "max_tokens":200}'

vLLM-opskrifter og -dokumentation inkluderer DeepSeek-eksempler og noter om FP8-kompatibilitet og multi-GPU/pipeline-parallelisme. Til tunge modeller skal du stadig bruge flere GPU'er eller en kvantiseret variant.

Mulighed C — LMDeploy / SGLang / LightLLM & TensorRT-LLM (høj ydeevne)

DeepSeek-arkivet anbefaler eksplicit SGLang, LMDeployog TensorRT-LLM som optimerede motorer til DeepSeek V3. De leverer forbedret inferensforsinkelse, gennemløb og FP8-kerner.

En typisk LMDeploy-kaldelse (se LMDeploy-dokumentationen for den nøjagtige CLI):

# pseudo-example; refer to LMDeploy docs for exact options

lmdeploy serve --model /path/to/deepseek_v3.1 --precision fp8 --port 8080

SGLang-benchmarks og lanceringsopskrifter er tilgængelige i repoet og i SGLang-projektets benchmark/deepseek_v3 mappe. Brug disse stakke, når du styrer en GPU-klynge og ønsker produktionsgennemstrømning.

Mulighed D — Ollama (den nemmeste lokale udviklingsrute, ofte med én maskine)

Hvis du ønsker den lavest mulige friktionsmetode til at køre DeepSeek lokalt (og du kan spare disken), Ollama leverer pakkede modeller og en simpel CLI (ollama pull, ollama runDeepSeek-V3.1 findes i Ollama-biblioteket og kan køres lokalt (Ollama kræver muligvis en nyere/forhåndsudgivet version for nogle funktioner).

Eksempel (Ollama CLI):

# Pull the model (downloads the model artifacts to your disk)

ollama pull deepseek-v3.1

# Start an interactive session:

ollama run deepseek-v3.1

# Or run as a local API server (Ollama supports a local API)

# Example: POSTing to Ollama's local API (adjust host/port to your setup)
curl -X POST http://localhost:11434/api/generate \
  -H 'Content-Type: application/json' \
  -d '{"model":"deepseek-v3.1","prompt":"Summarize the following paper: ..."}'

Ollama abstraherer mange distributions-/kvantiseringsdetaljer og kan være en god måde at teste modeladfærd på en enkelt vært. Bemærk: Modelsiden angiver en pakkestørrelse på ~404 GB til Ollama-posten, så planlæg disk og RAM i overensstemmelse hermed.

Hvad er tænketilstand, og hvordan bruger man den

DeepSeek-V3.1 implementerer en hybrid tænkningstoken tilgang: det samme checkpoint kan køre i tænker tilstand (interne "tankekæde"-tokens) eller ikke-tænkende tilstand ved at skifte chat-/promptskabelonen. Modellen bruger eksplicitte tokens som f.eks. <think> (og lukning </think> (i nogle skabeloner) for at signalere intern tankekæde versus direkte svargenerering. Modelkortet dokumenterer præfikser for ikke-tænkning og tænkende præfikser og viser, hvordan skabeloner adskiller sig.

Eksempel: opbygning af en besked i Python (tokenizer-hjælper)

Modelkortet med et krammeansigt indeholder et praktisk uddrag, der viser, hvordan man anvender chatskabelonen via tokenizeren. Dette er det anbefalede mønster til generering af et tænker or ikke-tænkende formaterede prompter:

import transformers
tokenizer = transformers.AutoTokenizer.from_pretrained("deepseek-ai/DeepSeek-V3.1")

messages = [
    {"role": "system", "content": "You are a helpful assistant"},
    {"role": "user", "content": "Who are you?"},
    {"role": "assistant", "content": "<think>Hmm</think>I am DeepSeek"},
    {"role": "user", "content": "1+1=?"}
]

# Thinking mode

tokenizer.apply_chat_template(messages, tokenize=False, thinking=True, add_generation_prompt=True)

# Non-thinking mode

tokenizer.apply_chat_template(messages, tokenize=False, thinking=False, add_generation_prompt=True)

Kontakt thinking=True at producere en prompt, der bruger <think> præfiks; thinking=False producerer den ikke-tænkende skabelon. Modellen vil opføre sig forskelligt (intern overvejelse vs. øjeblikkelig reaktion) afhængigt af dette flag.

Hurtig reference — små fejlfindingsmuligheder og bedste praksisser

Hvis du løber tør for GPU-hukommelse: Prøv kvantiserede builds (AWQ/q4/INT4) eller community GGUF'er; mange community spaces udgiver kvantiseringer til lokal brug. Ollama / vLLM kan også håndtere mindre kvantiserede builds.

Hvis du har brug for, at modellen kalder eksterne værktøjer: Vedtag Værktøjsopkald skemaet i chatskabelonen præcist. Test værktøjets JSON-format offline, og kontroller, at din orkestreringskode (den del, der udfører værktøjet) returnerer renset, typeskrevet JSON tilbage til modellen.

Hvis du har brug for en lang kontekst: Brug vLLM eller SGLang med plugins til lang kontekst; DeepSeek blev eksplicit trænet/udvidet til 32K/128K kontekster, og relaterede værktøjer understøtter dette vindue. Forvent hukommelsesafvejninger.

Kan jeg rent faktisk køre DeepSeek-V3.1 på en bærbar computer eller en lille server?

Kort svar: Ja, men med forbehold. Fællesskabskvantiseringer (AWQ/GGUF/1-bit dynamic) reducerer lager- og hukommelsesforbruget drastisk og har gjort det muligt for hobbybrugere at køre V3.1-varianter på avancerede desktops (påstande om ~170 GB arbejdssæt). Imidlertid:

Afvejning af troskab vs. størrelse: Aggressiv kvantisering reducerer hukommelsen, men kan påvirke ræsonnement/kodningsydeevnen. Test på dine arbejdsbelastninger.
Jura og licensering: Modellen er MIT-licenseret i henhold til modelkortet, men tredjepartskvantiseringer kan have deres egne licenser; gennemgå dem før produktionsbrug.

Afsluttende ord

DeepSeek-V3.1 er et vigtigt skridt mod hybride "agent"-modeller med eksplicit tænkende/ikke-tænkende adfærd og forbedret værktøjsbrug. Hvis du vil køre det lokalt, skal du vælge en sti, der matcher din hardware og risikotolerance:

Til forskning: transformers + kvantiserede sikkerhedstensorer og acceleration.

For produktion og gennemløb: vLLM + multi-GPU (H100/H200).

Til lokale eksperimenter: Ollama/llama.cpp + fællesskabets GGUF'er (flet + kør).

Kom godt i gang

CometAPI er en samlet API-platform, der samler over 500 AI-modeller fra førende udbydere – såsom OpenAIs GPT-serie, Googles Gemini, Anthropics Claude, Midjourney, Suno og flere – i en enkelt, udviklervenlig grænseflade. Ved at tilbyde ensartet godkendelse, formatering af anmodninger og svarhåndtering forenkler CometAPI dramatisk integrationen af AI-funktioner i dine applikationer. Uanset om du bygger chatbots, billedgeneratorer, musikkomponister eller datadrevne analysepipelines, giver CometAPI dig mulighed for at iterere hurtigere, kontrollere omkostninger og forblive leverandøruafhængig – alt imens du udnytter de seneste gennembrud på tværs af AI-økosystemet.

Udviklere kan få adgang DeepSeek-V3.1 via CometAPI er de seneste modelversioner, der er angivet, fra artiklens udgivelsesdato. For at begynde med, skal du udforske modellens muligheder i Legeplads og konsulter API guide for detaljerede instruktioner. Før du får adgang, skal du sørge for at være logget ind på CometAPI og have fået API-nøglen. CometAPI tilbyde en pris, der er langt lavere end den officielle pris, for at hjælpe dig med at integrere.