Hoe deepseek-v3.1 lokaal te implementeren via ollama: De Eastest-gids

DeepSeek-V3.1 is een hybride 'denkend/niet-denkend' MoE-taalmodel (671B in totaal, ≈37B geactiveerd per token) dat lokaal kan worden uitgevoerd met de juiste provider/kwantificering en tooling. Hieronder leg ik uit wat DeepSeek-V3.1 is, wat de hardware- en softwarevereisten zijn, stapsgewijze tutorials voor lokale uitvoering (Ollama + llama.cpp voorbeelden) en hoe je... Denkmodus implementeren en gebruiken (De <think>/</think> chatsjabloon) met codevoorbeelden die u kunt kopiëren/plakken.

Wat is DeepSeek-V3.1?

DeepSeek-V3.1 is de v3.1-release van DeepSeeks MoE-familie (Mixture-of-Experts). Het is ontworpen als een hybride inferentiemodel dat twee conversatiesjablonen/-modi ondersteunt: het denken en Niet-denken — vanuit hetzelfde controlepunt door de chatsjabloon te wijzigen. De modelarchitectuur is gebaseerd op het DeepSeek-V3 MoE-ontwerp (671 miljard parameters in totaal; ≈37 miljard parameters geactiveerd per token voor inferentie) en voegt verbeteringen toe na de training voor toolgebruik, agentvaardigheden en lange-contextverwerking.

Snelle hoogtepunten van de functies

Hybride Denken / Niet-denken modi (in- of uitgeschakeld door tokenisatie van chatsjablonen).
MoE-architectuur: groot totaal aantal parameters, maar beperkt aantal geactiveerde parameters per token (maakt efficiëntie mogelijk).
Verbeteringen na de training voor toolaanroepen en agentworkflows (toolaanroepindeling en agentsjablonen gedocumenteerd in de modelactiva).

Wat heb ik nodig om DeepSeek-V3.1 lokaal uit te voeren?

Het uitvoeren van de vol DeepSeek-V3.1 (raw checkpoints) is een zwaargewicht — training/checkpoint-opslag en inferentie-orkestratie zijn niet triviaal. Maar er zijn praktische mogelijkheden:

Hardware

Volledige gedistribueerde inferentie (onderzoek/cluster): meerdere GPU's met veel geheugen (klasse A100/H800) of een GPU-cluster met modelparallelle bediening (typisch voor 600B+ controlepunten). Alleen gebruiken als u productieonderzoeksclusters gebruikt.
Praktische lokale opties: gebruik de geactiveerde-param perspectief (≈37B geactiveerd) of een gekwantiseerde GGUF/1-bit dynamische build. Community-kwantificeringen (1-bit dynamisch/GGUF) verminderen de schijf- en RAM-vereisten aanzienlijk. Community-berichten melden bijvoorbeeld dat een checkpoint van 720 GB wordt gecomprimeerd tot ~170 GB GGUF voor een gekwantiseerde variant. Dit maakt lokale GPU-inferentie op één server haalbaar voor desktops/servers met voldoende resources.

Bottom line: Verwacht een workflow met een groot model (tientallen tot honderden GB schijfruimte voor gekwantiseerde artefacten). Gebruik voor GPU VRAM gekwantiseerde varianten en streef naar ≥24–48 GB VRAM voor een redelijke doorvoer. Gebruik anders CPU+swap met prestatie-afwegingen.

Software en hulpmiddelen

Python 3.10+ (voor transformer/tokenizer-tools en aangepaste scripts).

transformers (voor tokenizer- en helperfuncties) — de modelkaart toont voorbeelden met transformers.AutoTokenizer.

Een of meer lokale inferentie-runtimes:

Ollama (eenvoudig: ollama pull / ollama run integratie; sommige DeepSeek-builds op Ollama vereisen pre-releaseversies, controleer de model-/ollama-notitie.) Ollama is een standaard lokale runner geworden voor communitymodellen.
lama.cpp / ggml stapels of llama-server voor GGUF-gekwantiseerde bestanden — ideaal voor directe GGUF-uitvoering.
tekstgeneratie-inferentie / Triton / FlashAttention-stapels voor GPU-inferentie met hogere prestaties (geavanceerde configuraties).

Schijf: grote vrije ruimte voor modelbestanden (tientallen → honderden GB, afhankelijk van de kwantificering).

Modelartefacten (welk bestand moet ik ophalen)

Officiële safetensors / BF16 / FP8 / GGUF-varianten: Hugging Face host V3.1-modelartefacten en meerdere kwantificeringen. Als u een GGUF/gekwantiseerd bestand nodig hebt voor llama.cpp, zoek naar een community-kwantiseringsrelease (of een conversiescript van safetensors → GGUF) — de modelkaart vermeldt gekwantiseerde varianten.

Hoe bereid ik het model voor op lokale inferentie?

Hieronder vindt u de aanbevolen voorbereidingsstappen, gerangschikt van eenvoudig → geavanceerd.

Stap 1 — Kies een runtime (aanbeveling)

Beginners-/sneltest: Ollama — minimale configuratie: downloaden, model uitvoeren, API aanroepen. Let op: sommige DeepSeek-V3.1-builds gebruiken Ollama v0.11.7 als vereiste voor specifieke functies.
Geavanceerde / laag niveau controle: llama.cpp + GGUF-kwantificering (indien een GGUF-kwantificering beschikbaar is). Dit geeft u directe controle over de inferentie en integratie met llama-server.

Stap 2 — Download het model

Als u Ollama gebruikt:

# install ollama (see https://ollama.com/docs)

# Pull the model (this downloads the model to your machine)
ollama pull deepseek-ai/DeepSeek-V3.1
# or a specific tag: ollama pull deepseek-ai/DeepSeek-V3.1:quant-q4_0

(Ollama's run wordt automatisch getrokken indien niet aanwezig; pull (Hiermee kunt u de timing bepalen.)

Als je Hugging Face + llama.cpp gebruikt:

# Example: download via huggingface-cli or hf_transfer

pip install huggingface_hub
hf_hub_download(repo_id="deepseek-ai/DeepSeek-V3.1", filename="DeepSeek-V3.1.gguf")
# or use a community quant file (gguf) referenced on the Hugging Face model page

Met Hugging Face worden modelartefacten, sjablonen en kwantificeringen op de modelkaart weergegeven.

Stap 3 — Converteren/kwantiseren (optioneel)

Als je alleen safetensors of BF16-artefacten vindt, maar GGUF nodig hebt voor llama.cpp, gebruik de conversiescripts in llama.cpp (of communitytools) om te converteren → kwantiseren. Er zijn communitytools voor 1-bits dynamische kwantisering die de nauwkeurigheid behouden terwijl de bestandsgrootte wordt verkleind; zie de communityberichten die rapporteren tot ~170 GB.

Hoe kan ik DeepSeek-V3.1 lokaal uitvoeren? (Praktische handleidingen)

Ik zal laten zien Ollama (gemakkelijk, aanbevolen) en lama.cpp (GGUF) voorbeelden plus een kort Python voorbeeld met behulp van de model-card tokenizer helpers.

A — Hardlopen met Ollama (snelle start)

Installeer Ollama (volg de officiële instructies).
Trek het model op en voer het uit:

# pull model to disk (optional; run will pull automatically)

ollama pull deepseek-ai/DeepSeek-V3.1

# start an interactive session (runs model and exposes local API)

ollama run deepseek-ai/DeepSeek-V3.1

Maak een HTTP-verzoek aan de lokale Ollama-server:

# curl usage example (local Ollama server usually listens on port 11434)

curl -sS -X POST 'http://localhost:11434/api/generate' \
  -H 'Content-Type: application/json' \
  -d '{
    "model":"deepseek-ai/DeepSeek-V3.1",
    "prompt":"Explain the difference between thinking and non-thinking mode in DeepSeek.",
    "max_tokens":256
  }'

De CLI- en API-patronen van Ollama zijn ontworpen om eenvoudig te zijn: ollama run zal indien nodig een modelserver ophalen en starten. Zie de Ollama-documentatie en modelpagina's voor geheugentips en exacte modelnamen/tags.

B — Een gekwantiseerde GGUF uitvoeren via llama.cpp

Bouw llama.cpp met CUDA (optioneel) of CPU:

git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
# for CUDA:

make clean && make LLAMA_CUBLAS=1
# or CPU only:

make

Plaats het model-GGUF-bestand in een pad en voer het volgende uit:

./main -m /path/to/DeepSeek-V3.1.q4_K_M.gguf \
  -p "Explain how to enable thinking mode." \
  --temp 0.2 --n_predict 512

Voor servergebruik, llama-server (communityproject) kan een HTTP-eindpunt blootstellen:

llama-server -m /path/to/DeepSeek-V3.1.q4_K_M.gguf
# then POST to the server like:

curl -X POST "http://localhost:8080/api/v1/generate" -d '{"prompt":"Hello","max_tokens":200}'

Gebruik community GGUF-kwantificeringen (q4/q8/1-bit dynamisch) om in GPU/CPU-budgetten te passen; llama.cpp repo biedt conversietools en begeleiding.

C — Python-voorbeeld met behulp van de tokenizer + chatsjabloon

Het modelkaartje Hugging Face biedt een tokenizer.apply_chat_template helper en laat zien hoe je een gesprek codeert met thinking=TrueHier is een minimaal Python-voorbeeld, aangepast van de modelkaart:

from transformers import AutoTokenizer

tokenizer = 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=?"}
]

# apply thinking chat template

s = tokenizer.apply_chat_template(messages, tokenize=False, thinking=True, add_generation_prompt=True)
print(s)  # the template includes the special <think> token placement

Vervolgens kunt u de getokeniseerde prompt invoeren in uw inferentie-runtime (Ollama/llama.cpp/TGI), afhankelijk van uw stack.

Hoe werkt Thinking Mode en hoe implementeer ik het lokaal?

DeepSeek-V3.1 gebruikt chatsjablonen die een speciaal denkteken bevatten (bijv. <think> en </think>). De sjabloon bepaalt of het model zich in de Denk- of Niet-Denkend-modus bevindt:

Niet-denken sjabloon plaatsen </think> in het assistent-prefix, dat het model instrueert om directe antwoorden te produceren (het toolcall-formaat wordt ondersteund in niet-denkend).
het denken sjabloon plaatsen <think> in het assistent-prefix dat het model tussenliggende signalen laat produceren in de stijl van een interne gedachteketen (het model is getraind om die tokenreeks te gebruiken om intern te redeneren en antwoorden van hogere kwaliteit in meerdere stappen te produceren). De Hugging Face-modelkaart documenteert deze exacte tokens en de tokenizer.apply_chat_template(..., thinking=True) API.

Programmatische schakelaar (voorbeelden)

A — Met de tokenizer (Python):

# thinking=True or thinking=False changes how the prompt is formatted

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

Voeden prompt_thinking aan uw inferentie-runtime om het Denkgedrag te verkrijgen.

B — Met onbewerkte prompt (llama.cpp / manual):

Invoegen <think> voordat de assistent aan de beurt is wanneer u daarom vraagt:

<｜begin_of_sentence｜>You are a helpful assistant<｜User｜>How to optimize this code?<｜Assistant｜><think>

(Het exacte token-kader staat in de modelkaart — u moet rekening houden met de afstand en speciale markeringen als u het onbewerkte sjabloon gebruikt.)

C — Met Ollama (UI-schakelaar):
De officiële DeepSeek webdemo en release notes vermelden een "DeepThink"-schakelaar/knop voor het wisselen van modus in de gehoste gebruikersinterface. Lokaal zou Ollama of je app dit gedrag moeten repliceren door de chatsjabloon te wisselen (d.w.z. de prompt die je naar de runtime stuurt te wijzigen tussen de twee getokeniseerde formulieren). Als je DeepSeek via Ollama uitvoert, kun je dit in je applicatie implementeren door twee promptsjablonen te onderhouden (denkend versus niet-denkend) en te schakelen tussen de sjablonen die je via de Ollama API doorgeeft.

Hoe implementeer ik de Thinking Mode als agent (tool calls, code agents)?

DeepSeek-V3.1-documenten gereedschapsoproep en agent Sjablonen in de modelactiva. Het model verwacht dat tools worden gepresenteerd in een specifiek JSON-/instructieformaat en ondersteunt het aaneenschakelen van meerdere toolaanroepen in één beurt als u de exacte wrappertokens volgt die in de modelkaart worden beschreven.

Voorbeeld: eenvoudige tool-call wrapper (pseudo)

Het model specificeert een gereedschapsdescriptorblok en een strikt tool_calls_begin / tool_call_begin formaat. Een minimaal voorbeeld (conceptueel):

## Tools

You have access to the following tools:

### web_search

Description: Query the web
Parameters: {"q": "string"}

<｜begin_of_sentence｜>{system prompt}

## Tools

...tool descriptions...

<｜User｜>Find the population of Tokyo<｜Assistant｜></think>
<｜tool_calls_begin｜><｜tool_call_begin｜>web_search<｜tool_sep｜>{"q":"population of Tokyo 2025"}<｜tool_call_end｜><｜tool_calls_end｜>

De uitvoer van de tool moet vervolgens in de volgende beurt worden teruggekoppeld naar het model volgens het voorgeschreven formaat van het model (zie assets/search_tool_trajectory.html (op de modelpagina voor de exacte stroom). Het implementeren van agents vereist programmatische orkestratie: roep de tool aan → leg het resultaat vast → injecteer het resultaat terug in de chatcontext, precies zoals de sjabloon voorschrijft → roep het model opnieuw aan.

Praktische tips, probleemoplossing en veiligheidsinstructies (Waar moet ik op letten?)

Tokensjablonen zijn strikt. Gebruik het model tokenizer.apply_chat_template of reproduceer de exacte <think>/</think> tokens zoals weergegeven. Onjuiste afstand of ontbrekende markeringen veranderen het modelgedrag.
Het formaat van de tool moet geldige JSON zijn. Het model parseert toolargumenten als JSON. Ongeldige JSON zorgt ervoor dat toolaanroepen niet werken.
Afwegingen bij kwantisering. 1-bits dynamische/agressieve kwantificeringen verkleinen de opslagruimte en het RAM-geheugen, maar kunnen de numerieke betrouwbaarheid enigszins beïnvloeden. Test dit met uw workloads. Er bestaan community-kwantificeringen die 80% van het schijfgebruik verlagen (voorbeeldrapport: 720 GB → ~170 GB), maar valideer altijd met uw prompts.
Ollama-compatibiliteit. Sommige DeepSeek-varianten geven aan dat Ollama v0.11.7 vereist is voor pre-releasefuncties. Controleer de Ollama-modelpagina en werk deze dienovereenkomstig bij.

Voorbeeld van begin tot eind: voer DeepSeek-V3.1 lokaal uit met de Thinking Mode (mini-walkthrough)

Installeer Ollama en haal het model op:

# install ollama per docs, then:

ollama pull deepseek-ai/DeepSeek-V3.1
ollama run deepseek-ai/DeepSeek-V3.1 &

Gebruik de Python-tokenizer om een denkopdracht samen te stellen:

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

msgs = [
  {"role":"system","content":"You are a helpful assistant."},
  {"role":"user","content":"Plan a multi-step strategy to prototype a mobile app in 2 weeks."}
]
prompt = tokenizer.apply_chat_template(msgs, thinking=True, add_generation_prompt=True)

import requests
resp = requests.post("http://localhost:11434/api/generate", json={
    "model": "deepseek-ai/DeepSeek-V3.1",
    "prompt": prompt,
    "max_tokens": 400
})
print(resp.json())

Als het model een toolaanroep retourneert in de toolcall-indeling, parseer dan de JSON en voer de tool uit. Injecteer vervolgens de resultaten in het volgende bericht volgens de modelkaartsjablonen.

Hoe kiest u uw implementatiepad?

Als u de snelste manier wilt om te experimenteren: . Ollama en de voorbeelden van de Hugging Face-modelkaart. Ollama verbergt veel infrastructuurdetails en biedt een lokale HTTP API.
Als u lagere kosten / meer draagbaarheid nodig hebt: gebruik een community GGUF gekwantiseerd artefact en ren met llama.cpp or llama-serverKwantisering bespaart schijfruimte en geheugen, maar test de nauwkeurigheid van uw werklast.
Als u agents of tools bouwt: volg de modelkaart gereedschapsoproep en agent sjablonen exact; orkestreer de uitvoer van de tool terug in de modelcontext.

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.

Conclusie

DeepSeek-V3.1 biedt een praktische hybride inferentiefilosofie (één controlepunt + sjabloongebaseerd denkgedrag) die het experimenteren met ketengedachte-redeneringen en het gebruik van agenttools eenvoudig maakt, mits u de chattemplates en toolingvereisten respecteert. Gebruik de Hugging Face-modelkaart en de release-opmerkingen van DeepSeek als eerste stap, kies een lokale runtime (Ollama voor de eenvoud, llama.cpp (voor controle) en test gekwantiseerde builds voor praktische lokale implementaties.