DeepSeek-V3.1 is een hybride Mixture-of-Experts (MoE) chatmodel dat in augustus 2025 door DeepSeek is uitgebracht en dat ondersteuning biedt twee inferentiemodi — een snelle "niet-denkende" modus en een doelbewuste "denkende" modus — vanuit hetzelfde controlepunt. Het model is beschikbaar op Hugging Face en kan lokaal worden uitgevoerd via verschillende paden (vLLM, Ollama/llama.cpp, Ollama-achtige GGUF's of grootschalige multi-GPU-opstellingen). Hieronder leg ik de vereisten uit, hoe de denkmodus werkt, verschillende lokale uitvoeringsopties (met uitvoerbare codefragmenten) en een stapsgewijs recept voor de implementatie van de denkmodus met voorbeelden voor het aanroepen van tools en tokensjablonen.
Wat is DeepSeek-V3.1 en waarom is het belangrijk?
DeepSeek-V3.1 is de v3-familie-update van DeepSeek die een hybride inferentieontwerp: hetzelfde model kan worden uitgevoerd in het denken (overleg, meerstappenplan) of niet-denkend (direct antwoord, sneller) modi door de chattemplate aan te passen. Architectonisch gezien is het een grote MoE-familie (basiscontrolepunt rond de 671B totale parameters, ~37B geactiveerd per token) met lange-context training uitgebreid tot 128K tokens en ondersteuning voor FP8 micro-scaling. DeepSeek positioneerde V3.1 als een agent-ready release: betere tool-aanroeping, verbeterde agentvaardigheden en hogere denkefficiëntie vergeleken met eerdere R1-releases. De release werd aangekondigd in augustus 2025 en is geïntegreerd in Hugging Face, CFD/OSS-tooling en handleidingen voor cloudimplementatie.
Hoe het hybride model werkt (beknopt)
- Eén controlepunt, twee sjablonen: Denk- versus niet-denkmodi worden gecontroleerd door de chatsjabloon en
<think>/</think>Tokenconventie in de prompt. De modelkaart documenteert de exacte voorvoegsels. - Verbeteringen aan agenten/tools: Boosts na de training maken slimmere toolaanroepen mogelijk: het model verwacht een strikt JSON-formaat voor toolaanroepen voor veilige, deterministische tooluitvoering.
- Prestatie-afwegingen: De denkmodus besteedt tokens aan interne denkketen-stijl redeneren en kan langzamer/tokenintensiever zijn; niet-denken is sneller en goedkoper. Benchmarks in de modelkaart laten aanzienlijke verbeteringen zien in redeneer- en codebenchmarks voor V3.1.
Hoe het model is gestructureerd
- MoE-ruggengraat: groot totaal aantal parameters met een kleinere geactiveerde subset per token (economische gevolgtrekking).
- Lange-context training: V3.1 breidt lange-contextfasen aanzienlijk uit (32k → grotere training voor lange documenten) ter ondersteuning van 128K+ vensters in sommige builds.
- FP8 native workflow: DeepSeek maakt veelvuldig gebruik van FP8-formaten (w8a8 / UE8M0) voor gewichts-/activeringsefficiëntie. Er bestaan community-conversiescripts als u de voorkeur geeft aan BF16/FP16.
Wat zijn de vereisten om DeepSeek-V3.1 lokaal uit te voeren? (Hardware, opslag en software)
Het uitvoeren van de vol V3.1-model (niet-gekwantiseerd) is een omvangrijke onderneming. Hieronder vindt u realistische categorieën van opstellingen en hun typische vereisten.
Praktische emmers
- Cluster / onderzoekslaboratorium (volledig model): meerdere GPU's met veel geheugen (H100/H800-klasse of veel Ada/Hopper GPU's), multi-node met tientallen GPU's, veel NVMe-opslag (honderden GB's) en gespecialiseerde inferentieframeworks (SGLang, vLLM, LMDeploy, TRT-LLM).
- High-end single-server (gekwantiseerd): mogelijk met zware kwantificering (INT4/AWQ/AWQ2/gguf) en frameworks zoals Ollama (vooraf verpakt) of community-GGUF's — vereist nog steeds tientallen tot honderden GB GPU RAM of slimme CPU+GPU offload.
- Ontwikkelaarslaptop / dev-box: niet haalbaar voor het volledige model; gebruik kleine, gedistilleerde/bijgewerkte varianten of maak verbinding met de lokale server/Ollama-instantie.
Hardware checklist (praktisch)
- GPU's: Voor echte inferentiedoorvoer van de volledige versie 3.1: multi-GPU-clusters (H100 / H800 / Ada Lovelace+). Voor FP8-uitvoering zijn GPU's met rekencapaciteit en driverondersteuning vereist.
- RAM en opslag: Verwacht honderden GB vrije schijfruimte voor de modelbestanden (modelpagina's vermelden enkele honderden GB, afhankelijk van formaat/kwantificering), plus werkruimte voor geconverteerde formaten. Ollama-metadata vermeldt een footprint van ~400 GB voor een DeepSeek V3.1 Ollama-pakket in de bibliotheek.
- Netwerk:Voor multi-node inference hebt u interconnects met een lage latentie (NVLink/InfiniBand) en orkestratietools voor tensorparallelle opstellingen nodig.
Software-checklist
- OS: Linux wordt aanbevolen voor community-inferentiehulpmiddelen (DeepSeek-Infer-demo vermeldt Linux/Python).
- Python: 3.10+ (in veel DeepSeek-voorbeelden). Typische pakketversies zijn vastgezet in de repository.
requirements.txt. - Kaders en hulpmiddelen (kies er één of meer): SGLang, vLLM, LMDeploy, TRT-LLM/TensorRT-LLM, LightLLM of Ollama voor eenvoudigere lokale installaties. Elk heeft instructies en verschillende precisie-/kwantificeringsondersteuning.
Praktische opmerking: Als u slechts één consumenten-GPU hebt (bijvoorbeeld 24-48 GB), zult u waarschijnlijk gekwantiseerde GGUF's of externe inferentie gebruiken. Als u een werkstation hebt met > 128 GB RAM plus een H100/H200-klasse GPU-cluster, kunt u met vLLM FP8/FP16-inferentie met hogere precisie uitvoeren.
Hoe kan ik DeepSeek-V3.1 lokaal uitvoeren?
Hieronder staan verschillende praktische paden die u kunt gebruiken, van het meest handmatige/flexibele pad tot het gemakkelijkste pad voor een enkele ontwikkelaarsbox. Ik zal stapsgewijze tutorials en codevoorbeelden aanbieden
Optie A - Officiële DeepSeek-Infer-demo (ontwikkelings-/clusterpad)
Dit is het voorbeeld/demo van de repository voor FP8/BF16-inferentie. Gebruik het als je meerdere knooppunten wilt gebruiken of wilt experimenteren met de officiële inferentiecode.
- Klonen, omgeving voorbereiden
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 (Hier staan de vastgezette Torch/Triton/Transformers versies die door het team worden aanbevolen.)
- Modelgewichten downloaden
- Downloaden van de Hugging Face-modelpagina (
deepseek-ai/DeepSeek-V3.1) en plaats ze onder/path/to/DeepSeek-V3Zowel de modelkaart als de repository vermelden de officiële Hugging Face-opslaglinks.
- Gewichten omzetten voor 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
- Interactieve generatie uitvoeren (gedistribueerd)
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
Dit is het canonieke voorbeeld uit de DeepSeek-repository voor cluster-style runs.
Optie B — vLLM (aanbevolen voor serverimplementaties en OpenAI-compatibele API)
vLLM ondersteunt DeepSeek in FP8/BF16-modi en biedt u een OpenAI-compatibele server. Het is een populaire productiemethode voor grote modellen vanwege geheugenoptimalisatie en API-compatibiliteit.
Start een vLLM-server die het model van Hugging Face ophaalt (voorbeeldpatroon):
# 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
Vraag vervolgens aanvullingen aan met curl of een OpenAI-compatibele client:
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-recepten en -documentatie bevatten DeepSeek-voorbeelden en notities over FP8-compatibiliteit en multi-GPU/pipeline-parallellisme. Voor zware modellen heb je nog steeds meerdere GPU's of een gekwantiseerde variant nodig.
Optie C — LMDeploy / SGLang / LightLLM & TensorRT-LLM (hoge prestaties)
De DeepSeek-repository beveelt expliciet aan SGLang, LMDeployen TensorRT-LLM als geoptimaliseerde engines voor DeepSeek V3. Ze bieden verbeterde inferentielatentie, doorvoer en FP8-kernels.
Een typische LMDeploy-aanroep (raadpleeg de LMDeploy-documentatie voor de exacte CLI):
# pseudo-example; refer to LMDeploy docs for exact options
lmdeploy serve --model /path/to/deepseek_v3.1 --precision fp8 --port 8080
SGLang-benchmarks en lanceringsrecepten zijn beschikbaar in de repository en in de SGLang-projectdatabase. benchmark/deepseek_v3 map. Gebruik deze stacks wanneer u een GPU-cluster beheert en productiesnelheid wilt.
Optie D — Ollama (de gemakkelijkste lokale ontwikkelingsroute, vaak voor één machine)
Als u DeepSeek op de minst belastende manier lokaal wilt uitvoeren (en u de schijfruimte wilt sparen), Ollama biedt verpakte modellen en een eenvoudige CLI (ollama pull, ollama runDeepSeek-V3.1 is beschikbaar in de Ollama-bibliotheek en kan lokaal worden uitgevoerd (voor sommige functies heeft Ollama mogelijk een recente/pre-releaseversie nodig).
Voorbeeld (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 abstraheert veel distributie-/kwantificeringsdetails en kan een uitstekende manier zijn om modelgedrag op één host te testen. Let op: de modelpagina vermeldt een pakketgrootte van ~404 GB voor de Ollama-invoer, dus plan schijfruimte en RAM dienovereenkomstig.
Wat is de denkmodus en hoe gebruik je deze?
DeepSeek-V3.1 implementeert een hybride denktoken aanpak: hetzelfde controlepunt kan in het denken modus (interne “gedachtenketen”-tokens) of niet-denkend modus door de chat-/promptsjabloon te wisselen. Het model gebruikt expliciete tokens zoals <think> (en sluiten </think> (in sommige sjablonen) om interne gedachteketens versus directe antwoordgeneratie aan te geven. De modelkaart documenteert niet-denkende en denkende voorvoegsels en laat zien hoe sjablonen verschillen.
Voorbeeld: een bericht construeren in Python (tokenizer helper)
De Hugging Face-modelkaart bevat een handig fragment waarin wordt getoond hoe je de chattemplate via de tokenizer kunt toepassen. Dit is het aanbevolen patroon voor het genereren van het denken or niet-denkend geformatteerde prompts:
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)
Stap over voor slechts thinking=True om een prompt te produceren die gebruik maakt van de <think> voorvoegsel; thinking=False Produceert het niet-denkende sjabloon. Het model zal zich verschillend gedragen (intern overleg versus onmiddellijke reactie) afhankelijk van deze vlag.
Snelle referentie - kleine probleemoplossing en beste praktijken
Als het GPU-geheugen opraakt: Probeer gekwantiseerde builds (AWQ/q4/INT4) of community-GGUF's; veel communityruimtes publiceren kwantificeringen voor lokaal gebruik. Ollama/vLLM kan ook kleinere gekwantiseerde builds aanbieden.
Als u wilt dat het model externe tools aanroept: Adopteer de ToolCall schema in de chatsjabloon exact. Test de JSON-indeling van de tool offline en controleer of je orkestratiecode (het onderdeel dat de tool uitvoert) gesanitiseerde, getypte JSON terugstuurt naar het model.
Als u een lange context nodig hebt: Gebruik vLLM of SGLang met plug-ins met lange context; DeepSeek is expliciet getraind/uitgebreid voor 32K/128K-contexten en gerelateerde tooling ondersteunt dat venster. Houd rekening met geheugencompromissen.
Kan ik DeepSeek-V3.1 daadwerkelijk op een laptop of kleine server draaien?
Kort antwoord: Ja, maar met een aantal kanttekeningen. Community-kwantificeringen (AWQ/GGUF/1-bit dynamisch) verkleinen de opslag- en geheugenvoetafdruk drastisch en stellen hobbyisten in staat om V3.1-varianten te draaien op high-end desktops (geclaimd: ~170 GB werkende set). Echter:
- Afweging tussen betrouwbaarheid en grootte: Agressieve kwantificering vermindert het geheugen, maar kan de redeneer-/codeprestaties beïnvloeden. Test met uw workloads.
- Juridisch & licenties: Het model is MIT-gelicentieerd volgens de modelkaart, maar kwantificeringen van derden kunnen hun eigen licenties hebben; controleer deze voordat u ze in productie neemt.
Laatste woorden
DeepSeek-V3.1 is een belangrijke stap in de richting van hybride 'agent'-modellen met expliciet denkend/niet-denkend gedrag en verbeterd toolgebruik. Als u het lokaal wilt uitvoeren, kies dan een pad dat past bij uw hardware en risicobereidheid:
Voor onderzoek: transformers + gekwantiseerde safetensoren en versnellen.
Voor productie en doorvoer: vLLM + multi-GPU (H100/H200).
Voor lokale experimenten: Ollama/llama.cpp + community GGUF's (samenvoegen + uitvoeren).
Beginnen
CometAPI is een uniform API-platform dat meer dan 500 AI-modellen van toonaangevende aanbieders – zoals de GPT-serie van OpenAI, Gemini van Google, Claude, Midjourney en Suno van Anthropic – samenvoegt in één, gebruiksvriendelijke interface voor ontwikkelaars. Door consistente authenticatie, aanvraagopmaak en responsverwerking te bieden, vereenvoudigt CometAPI de integratie van AI-mogelijkheden in uw applicaties aanzienlijk. Of u nu chatbots, beeldgenerators, muziekcomponisten of datagestuurde analysepipelines bouwt, met CometAPI kunt u sneller itereren, kosten beheersen en leveranciersonafhankelijk blijven – en tegelijkertijd profiteren van de nieuwste doorbraken in het AI-ecosysteem.
Ontwikkelaars hebben toegang tot DeepSeek-V3.1 Via CometAPI zijn de nieuwste modelversies vermeld vanaf de publicatiedatum van het artikel. Om te beginnen, verken de mogelijkheden van het model in de Speeltuin en raadpleeg de API-gids voor gedetailleerde instructies. Zorg ervoor dat u bent ingelogd op CometAPI en de API-sleutel hebt verkregen voordat u toegang krijgt. KomeetAPI bieden een prijs die veel lager is dan de officiële prijs om u te helpen integreren.