Sådan implementerer du deepseek-v3.1 lokalt via ollama: Eastest Guide

DeepSeek-V3.1 er en hybrid "tænkende / ikke-tænkende" MoE-sprogmodel (671B i alt, ≈37B aktiveret pr. token), der kan køres lokalt, hvis du bruger den rigtige udbyder/kvantisering og værktøjer. Nedenfor forklarer jeg, hvad DeepSeek-V3.1 er, hardware-/softwarekravene, trinvise lokale kørselsvejledninger (Ollama + llama.cpp-eksempler), og hvordan man... Implementer og brug Thinking Mode (Den <think>/</think> chatskabelon) med kodeeksempler, du kan kopiere/indsætte.

Hvad er DeepSeek-V3.1?

DeepSeek-V3.1 er v3.1-udgivelsen af DeepSeeks MoE-familie (Mixture-of-Experts). Den blev designet som en hybrid inferensmodel, der understøtter to konversationsskabeloner/-tilstande — Tænker og Ikke-tænkende — fra samme checkpoint ved at ændre chatskabelonen. Modelarkitekturen spores til DeepSeek-V3 MoE-designet (671B parametre i alt; ≈37B parametre aktiveret pr. token til inferens) og tilføjer forbedringer efter træning til værktøjsbrug, agentfærdigheder og håndtering af lang kontekst.

Hurtige funktioner

Hybrid Tænkning / Ikke-tænkning tilstande (slået til/fra ved tokenisering af chatskabeloner).
MoE-arkitektur: stort samlet parameterantal, men begrænsede aktiverede parametre pr. token (muliggør effektivitet).
Boosts efter træning for værktøjskald og agentarbejdsgange (værktøjskaldsformat og agentskabeloner dokumenteret i modelaktiverne).

Hvad skal jeg bruge for at køre DeepSeek-V3.1 lokalt?

Kører fuld DeepSeek-V3.1 (rå checkpoints) er sværvægter — træning/checkpoint-lagring og inferensorkestrering er ikke trivielle. Men der er praktiske veje:

Hardware

**Fuld distribueret inferens (forskning/klynge)**Flere GPU'er med høj hukommelse (A100/H800-klassen) eller en GPU-klynge med modelparallel servering (typisk for 600B+ checkpoints). Brug kun, hvis du kører produktionsforskningsklynger.
Praktiske lokale muligheder: brug den aktiveret-parameter perspektiv (≈37B aktiveret) eller en kvantiseret GGUF/1-bit dynamisk build. Community-kvantiseringer (1-bit dynamisk / GGUF) reducerer disk+RAM-kravene betydeligt — f.eks. rapporterer community-indlæg, at et 720 GB checkpoint komprimeres ned til ~170 GB GGUF for en kvantiseret variant. Det gør lokal single-server GPU-inferens mulig for velressourcede desktops/servere.

Bundlinie: Forvent en arbejdsgang med store modeller (tiere til få hundreder af GB disk til kvantiserede artefakter); for GPU VRAM, brug kvantiserede varianter og sigt efter ≥24-48 GB VRAM for at opnå en rimelig gennemløbshastighed; ellers brug CPU+swap med ydeevneafvejninger.

Software og værktøjer

Python 3.10+ (til transformer/tokenizer-værktøjer og brugerdefinerede scripts).

transformers (for tokenizer- og hjælpefunktioner) — modelkortet viser eksempler ved hjælp af transformers.AutoTokenizer.

En eller flere lokale inferenskørselstider:

Ollama (let: ollama pull / ollama run integration; nogle DeepSeek-builds på Ollama kræver pre-release-versioner, tjek model/ollama-noten). Ollama er blevet en standard lokal kører for fællesskabsmodeller.
llama.cpp / ggml stakke eller llama-server til GGUF-kvantiserede filer — fantastisk til direkte GGUF-udførelse.
tekstgenereringsinferens / Triton / FlashAttention-stakke til GPU-inferens med højere ydeevne (avancerede opsætninger).

Disk: stor ledig plads til modelfiler (tiere → hundreder af GB afhængigt af kvantisering).

Modelartefakter (hvilken fil skal hentes)

Officielle safetensorer / BF16 / FP8 / GGUF-varianter: Hugging Face er vært for V3.1-modelartefakter og flere kvantiseringer. Hvis du har brug for en GGUF/kvantiseret fil til llama.cpp, kig efter en kvantiseringsudgivelse fra et fællesskab (eller et konverteringsscript fra safetensors → GGUF) — modelkortet viser kvantiserede varianter.

Hvordan forbereder jeg modellen til lokal inferens?

Nedenfor er de anbefalede tilberedningstrin arrangeret fra simpel → avanceret.

Trin 1 — Vælg en runtime (anbefaling)

Begynder / hurtig test: Ollama — minimal opsætning: download, kørsel af model, kald af API. Bemærk: Nogle DeepSeek-V3.1-builds angiver, at Ollama v0.11.7 er påkrævet for specifikke funktioner.
Avanceret / lavniveau kontrol: llama.cpp + GGUF-kvantitet (hvis en GGUF-kvantisering er tilgængelig). Dette giver dig direkte inferenskontrol og integration med llama-server.

Trin 2 — Download modellen

Hvis du bruger Ollama:

# 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

(Ollamas run trækker automatisk, hvis den ikke er til stede; pull giver dig mulighed for at kontrollere timingen.)

Hvis du bruger Hugging Face + llama.cpp:

# 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

Hugging Face viser modelartefakter, skabeloner og kvantiseringer på modelkortet.

Trin 3 — Konvertér/kvantiser (valgfrit)

Hvis du kun finder safetensorer eller BF16-artefakter, men har brug for GGUF til llama.cpp, brug konverteringsskripterne i llama.cpp (eller fællesskabsværktøjer) til at konvertere → kvantisere. Der findes fællesskabsværktøjer til 1-bit dynamisk kvantisering, der bevarer nøjagtigheden, samtidig med at størrelsen reduceres; se fællesskabsindlæggene, der rapporterer ned til ~170 GB.

Hvordan kører jeg egentlig DeepSeek-V3.1 lokalt? (Praktiske kørselsvejledninger)

Jeg skal vise Ollama (nemt, anbefales) og call.cpp (GGUF) eksempler plus et kort Python-eksempel ved brug af model-card tokenizer-hjælperne.

A — Løb med Ollama (hurtigstart)

Installer Ollama (følg de officielle instruktioner).
Træk og kør modellen:

# 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

Foretag en HTTP-anmodning til den 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
  }'

Ollamas CLI- og API-mønstre er designet til at være enkle: ollama run vil trække om nødvendigt og starte en modelserver. Se Ollama-dokumentationen og modelsiderne for hukommelsestips og nøjagtige modelnavne/tags.

B — Kørsel af en kvantiseret GGUF via llama.cpp

Byg llama.cpp med CUDA (valgfrit) eller CPU:

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

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

make

Placer model-GGUF-filen i en sti og kør:

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

Til serverbrug, llama-server (fællesskabsprojekt) kan eksponere et HTTP-slutpunkt:

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}'

Brug GGUF-kvantiseringer fra fællesskabet (q4/q8/1-bit dynamisk) til at passe ind i GPU/CPU-budgetter; llama.cpp repo tilbyder konverteringsværktøjer og vejledning.

C — Python-eksempel ved brug af tokenizer + chat-skabelonen

Krammeansigt modelkort giver en tokenizer.apply_chat_template hjælper og viser, hvordan man koder en samtale med thinking=TrueHer er et minimalt Python-eksempel tilpasset fra modelkortet:

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

Du kan derefter indsætte den tokeniserede prompt i din inferenskørsel (Ollama/llama.cpp/TGI) afhængigt af din stak.

Hvordan fungerer Thinking Mode, og hvordan implementerer jeg den lokalt?

DeepSeek-V3.1 anvendelser chatskabeloner der indeholder en særlig tænkebrik (f.eks. <think> og </think>). Den skabelon bestemmer, om modellen er i tænkende eller ikke-tænkende tilstand:

Ikke-tænkende skabelonsteder </think> i assistentpræfikset, som instruerer modellen til at producere direkte svar (toolcall-format understøttes i ikke-tænkende).
Tænker skabelonsteder <think> i assistentpræfikset, som får modellen til at udsende interne mellemliggende signaler i form af tankekæder (modellen er trænet til at bruge denne token-sekvens til at ræsonnere internt og producere flertrinssvar af højere kvalitet). Krammeansigts-modelkortet dokumenterer disse præcise tokens og tokenizer.apply_chat_template(..., thinking=True) API.

Programmatisk skift (eksempler)

A — Med tokenizeren (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)

Foder prompt_thinking til din inferenskørsel for at få tænkeadfærden.

B — Med rå prompt (llama.cpp / manual):

indsatte <think> før assistenten drejer sig, når du beder om det:

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

(Den præcise token-indramning findes på modelkortet — du skal respektere afstand og særlige markører, hvis du bruger den rå skabelon.)

C — Med Ollama (brugergrænseflade-skift):
Den officielle DeepSeek webdemo og udgivelsesnoter nævner en "DeepThink"-knap til at skifte tilstande i den hostede brugergrænseflade. Lokalt bør Ollama eller din app replikere denne adfærd ved at skifte chatskabelonen (dvs. ændre den prompt, du sender til runtime, mellem de to tokeniserede formularer). Hvis du kører DeepSeek via Ollama, kan du implementere dette i din applikation ved at vedligeholde to promptskabeloner (tænkende vs. ikke-tænkende) og skifte mellem, hvilke du sender via Ollama API'en.

Hvordan implementerer jeg Thinking Mode som en agent (værktøjskald, kodeagenter)?

DeepSeek-V3.1-dokumenter værktøjsopkald og agent skabeloner i modelaktiverne. Modellen forventer, at værktøjer præsenteres i et specifikt JSON-/instruktionsformat og understøtter sammenkædning af flere værktøjskald i en enkelt tur, hvis du følger de nøjagtige wrapper-tokens, der er beskrevet på modelkortet.

Eksempel: simpel værktøjskaldsindpakning (pseudo)

Modellen specificerer en værktøjsbeskrivelsesblok og en streng tool_calls_begin / tool_call_begin format. Et minimalt eksempel (konceptuelt):

## 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｜>

Værktøjets output skal derefter føres tilbage til modellen i næste omgang i henhold til modellens foreskrevne format (se assets/search_tool_trajectory.html (på modelsiden for det nøjagtige flow). Implementering af agenter kræver programmatisk orkestrering: kald af værktøj → indfang resultat → injicer resultat tilbage i chatkonteksten præcis som skabelonen foreskriver → kald modellen igen.

Praktiske tips, fejlfinding og sikkerhedsnoter (Hvad skal jeg være opmærksom på?)

Token-skabeloner er strenge. Brug modellens tokenizer.apply_chat_template eller genskabe den nøjagtige <think>/</think> tokens som vist. Forkert afstand eller manglende markører vil ændre modellens adfærd.
Værktøjsformatet skal være gyldigt JSON. Modellen vil analysere værktøjsargumenter som JSON — ugyldig JSON vil afbryde værktøjskald.
Kvantiseringsafvejninger. 1-bit dynamiske/aggressive kvantiseringer reducerer lagerplads og RAM, men kan ændre den numeriske nøjagtighed en smule. Test på dine arbejdsbelastninger. Fællesskabskvantiseringer, der reducerer 80 % af diskforbruget, findes (eksempelrapport: 720 GB → ~170 GB), men valider altid med dine prompts.
Ollama-kompatibilitet. Nogle DeepSeek-varianter angiver Ollama v0.11.7 som påkrævet for pre-release-funktioner — tjek Ollama-modelsiden og opdater i overensstemmelse hermed.

Eksempel end-to-end: Kør DeepSeek-V3.1 lokalt med Thinking Mode (mini-gennemgang)

Installer Ollama og hent modellen:

# install ollama per docs, then:

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

Brug Python-tokenizeren til at skrive en tænkeprompt:

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())

Hvis modellen returnerer et værktøjskald i toolcall-formatet, skal du parse JSON'en og køre værktøjet, og derefter injicere resultaterne i den næste besked i henhold til modelkortskabelonerne.

Hvordan bør du vælge din implementeringssti?

Hvis du vil have den hurtigste vej til eksperimentet: brug Ollama og eksemplerne på Hugging Face-modelkortet. Ollama skjuler mange infrastrukturdetaljer og giver en lokal HTTP API.
Hvis du har brug for lavere omkostninger / mere bærbarhed: brug et fællesskab GGUF kvantiseret artefakt og kør med llama.cpp or llama-serverKvantisering sparer disk og hukommelse, men test nøjagtigheden for din arbejdsbyrde.
Hvis du bygger midler eller værktøj: følg modelkortets værktøjsopkald og agent skabeloner præcist; orkestrer værktøjsoutput tilbage i modelkontekst.

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.

Konklusion

DeepSeek-V3.1 bringer en praktisk hybrid inferensfilosofi (et checkpoint + skabelonbaseret tankeadfærd), der gør det nemt at eksperimentere med tankekæde-lignende ræsonnement og brug af agentværktøjer, når du respekterer chatskabelonerne og værktøjskravene. Brug Hugging Face-modelkortet og DeepSeek-udgivelsesnoterne som dit første stop, og vælg en lokal runtime (Ollama for enkelhedens skyld, llama.cpp til kontrol) og test kvantiserede builds til praktiske lokale implementeringer.