Slik distribuerer du deepseek-v3.1 lokalt via ollama: Eastest-guiden

DeepSeek-V3.1 er en hybrid «tenkende / ikke-tenkende» MoE-språkmodell (671B totalt, ≈37B aktivert per token) som kan kjøres lokalt hvis du bruker riktig leverandør/kvantisering og verktøy. Nedenfor forklarer jeg hva DeepSeek-V3.1 er, maskinvare-/programvarekravene, trinnvise lokale kjøreveiledninger (Ollama + llama.cpp-eksempler), og hvordan du gjør det. distribuer og bruk tenkemodus (Den <think>/</think> chatmal) med kodeeksempler du kan kopiere/lime inn.

Hva er DeepSeek-V3.1?

DeepSeek-V3.1 er v3.1-utgivelsen av DeepSeeks MoE-familie (Mixture-of-Experts). Den ble designet som en hybrid inferensmodell som støtter to konversasjonsmaler/-moduser – tenker og Ikke-tenkende — fra samme sjekkpunkt ved å endre chatmalen. Modellarkitekturen spores til DeepSeek-V3 MoE-designet (671 milliarder parametere totalt; ≈37 milliarder parametere aktivert per token for inferens) og legger til forbedringer etter trening for verktøybruk, agentferdigheter og håndtering av lang kontekst.

Hurtigfunksjonshøydepunkter

Hybrid Tenkende / Ikke-tenkende moduser (aktiveres ved tokenisering av chatmaler).
MoE-arkitektur: stort totalt antall parametere, men begrenset antall aktiverte parametere per token (muliggjør effektivitet).
Forsterkninger etter opplæring for verktøykall og agentarbeidsflyter (verktøykallformat og agentmaler dokumentert i modellressursene).

Hva trenger jeg for å kjøre DeepSeek-V3.1 lokalt?

Kjører fullt DeepSeek-V3.1 (rå kontrollpunkter) er tungvekter – trening/lagring av kontrollpunkter og orkestrering av inferens er ikke trivielle. Men det finnes praktiske veier:

maskinvare

**Full distribuert inferens (forskning / klynge)**flere GPU-er med høyt minne (A100/H800-klassen) eller en GPU-klynge med modellparallell servering (typisk for sjekkpunkter på over 600 BI). Bruk kun hvis du kjører produksjonsforskningsklynger.
Praktiske lokale alternativer: bruke aktivert parameter perspektiv (≈37B aktivert) eller en kvantisert GGUF/1-bit dynamisk bygging. Fellesskapskvantiseringer (1-bit dynamisk / GGUF) reduserer disk+RAM-kravene betydelig – f.eks. rapporterer fellesskapsinnlegg at de komprimerer et 720 GB sjekkpunkt ned til ~170 GB GGUF for en kvantisert variant. Det gjør lokal GPU-inferens for én server mulig for ressurssterke stasjonære datamaskiner/servere.

Bottom line: Forvent en arbeidsflyt med store modeller (titalls til lave hundrevis av GB disk for kvantiserte artefakter); for GPU VRAM, bruk kvantiserte varianter og målrett ≥24–48 GB VRAM for rimelig gjennomstrømning; ellers bruk CPU+swap med ytelsesavveininger.

Programvare og verktøy

Python 3.10+ (for transformer-/tokenizer-verktøy og tilpassede skript).

transformers (for tokenizer- og hjelpefunksjoner) – modellkortet viser eksempler som bruker transformers.AutoTokenizer.

En eller flere lokale inferenskjøringer:

Ollama (lett: ollama pull / ollama run integrasjon; noen DeepSeek-bygg på Ollama krever forhåndsversjoner, sjekk modell-/ollama-notatet). Ollama har blitt en standard lokal løper for fellesskapsmodeller.
llama.cpp / ggml stabler eller llama-server for GGUF-kvantiserte filer – flott for direkte GGUF-utførelse.
tekstgenereringsslutning / Triton / FlashAttention-stabler for GPU-inferens med høyere ytelse (avanserte oppsett).

Disk: stor ledig plass for modellfiler (titalls → hundrevis av GB avhengig av kvantisering).

Modellartefakter (hvilken fil som skal hentes)

Offisielle safetensorer / BF16 / FP8 / GGUF-varianter: Hugging Face er vert for V3.1-modellartefakter og flere kvantiseringer. Hvis du trenger en GGUF/kvantisert fil for llama.cpp, se etter en kvantiseringsutgivelse fra fellesskapet (eller et konverteringsskript fra safetensors → GGUF) — modellkortet viser kvantiserte varianter.

Hvordan forbereder jeg modellen for lokal inferens?

Nedenfor er de anbefalte tilberedningstrinnene ordnet fra enkel → avansert.

Trinn 1 – Velg en kjøretid (anbefaling)

Nybegynner / rask test: Ollama – minimal oppsett: last ned, kjør modell, kall API. Merk: noen DeepSeek-V3.1-bygg bemerker Ollama v0.11.7 som nødvendig for spesifikke funksjoner.
Avansert / lavnivåkontroll: llama.cpp + GGUF-kvantitet (hvis en GGUF-kvantisering er tilgjengelig). Dette gir deg direkte inferenskontroll og integrasjon med llama-server.

Trinn 2 – Last ned modellen

Hvis du bruker 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 vil trekke automatisk hvis ikke tilstede; pull lar deg kontrollere timingen.)

Hvis du bruker 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 modellartefakter, maler og kvantiseringer på modellkortet.

Trinn 3 – Konverter/kvantiser (valgfritt)

Hvis du bare finner safetensorer eller BF16-artefakter, men trenger GGUF for llama.cpp, bruk konverteringsskriptene i llama.cpp (eller fellesskapsverktøy) for å konvertere → kvantisere. Det finnes fellesskapsverktøy for 1-bit dynamisk kvantisering som bevarer nøyaktigheten samtidig som de krymper størrelsen; se fellesskapsinnleggene som rapporterer ned til ~170 GB.

Hvordan kjører jeg egentlig DeepSeek-V3.1 lokalt? (Praktiske kjøreveiledninger)

Jeg skal vise Ollama (enkelt, anbefalt) og ring.cpp (GGUF) eksempler pluss et kort Python-eksempel som bruker modellkort-tokenizer-hjelperne.

A — Løping med Ollama (hurtigstart)

Installer Ollama (følg de offisielle instruksjonene).
Trekk og kjø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

Send en HTTP-forespørsel til den lokale Ollama-serveren:

# 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 for å være enkle: ollama run vil hente om nødvendig og starte en modellserver. Se Ollama-dokumentasjonen og modellsidene for minnetips og nøyaktige modellnavn/-tagger.

B — Kjøre en kvantisert GGUF via llama.cpp

Bygge llama.cpp med CUDA (valgfritt) 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

Plasser modell-GGUF-filen i en bane og kjø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

For serverbruk, llama-server (fellesskapsprosjekt) kan eksponere et HTTP-endepunkt:

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

Bruk fellesskapets GGUF-kvantiseringer (q4/q8/1-bit dynamisk) for å tilpasse dem til GPU/CPU-budsjetter; llama.cpp repo tilbyr konverteringsverktøy og veiledning.

C — Python-eksempel ved bruk av tokenizer + chat-malen

Modellkortet Hugging Face gir en tokenizer.apply_chat_template hjelper og viser hvordan man koder en samtale med thinking=TrueHer er et minimalt Python-eksempel tilpasset fra modellkortet:

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 deretter mate den tokeniserte prompten inn i inferenskjøretiden din (Ollama/llama.cpp/TGI), avhengig av stakken din.

Hvordan fungerer tenkemodus, og hvordan distribuerer jeg den lokalt?

DeepSeek-V3.1 bruker chatmaler som inneholder en spesiell tenkebrikke (f.eks. <think> og </think>). Den mal avgjør om modellen er i tenkemodus eller ikke-tenkende modus:

Ikke-tenkende malplasser </think> i assistentprefikset, som instruerer modellen til å produsere direkte svar (verktøykallformat støttes i ikke-tenkning).
tenker malplasser <think> i assistentprefikset som får modellen til å sende ut interne mellomliggende signaler i tankekjedestil (modellen er trent til å bruke den tokensekvensen til å resonnere internt og produsere flertrinnssvar av høyere kvalitet). Klemfjesmodellkortet dokumenterer disse nøyaktige tokenene og tokenizer.apply_chat_template(..., thinking=True) API.

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

Fôr prompt_thinking til inferenskjøretiden din for å få tenkeatferden.

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

innfelt <think> før assistenten snur seg når du ber om det:

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

(Den nøyaktige token-innrammingen er i modellkortet – du må respektere avstand og spesielle markører hvis du bruker den rå malen.)

C — Med Ollama (brukergrensesnitt-veksler):
Den offisielle DeepSeek-nettdemoen og utgivelsesnotatene nevner en «DeepThink»-bryter/knapp for å bytte modus i det hostede brukergrensesnittet. Lokalt bør Ollama eller appen din gjenskape denne oppførselen ved å bytte chatmalen (dvs. endre ledeteksten du sender til kjøretiden mellom de to tokeniserte skjemaene). Hvis du kjører DeepSeek via Ollama, kan du implementere dette i applikasjonen din ved å opprettholde to ledetekstmaler (tenkende vs. ikke-tenkende) og veksle mellom hvilke du sender gjennom Ollama API-et.

Hvordan distribuerer jeg tenkemodus som en agent (verktøykall, kodeagenter)?

DeepSeek-V3.1-dokumenter verktøykall og agenten maler i modellens ressurser. Modellen forventer at verktøy presenteres i et spesifikt JSON-/instruksjonsformat og støtter kjedekobling av flere verktøykall i én runde hvis du følger de nøyaktige innpakningstokenene som er beskrevet i modellkortet.

Eksempel: enkel verktøykall-wrapper (pseudo)

Modellen spesifiserer en verktøybeskrivelsesblokk og en streng tool_calls_begin / tool_call_begin format. Et minimalt eksempel (konseptuelt):

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

Verktøyutdataene skal deretter mates tilbake til modellen i neste runde i henhold til modellens foreskrevne format (se assets/search_tool_trajectory.html (på modellsiden for den nøyaktige flyten). Implementeringsagenter krever programmatisk orkestrering: kall verktøy → hent resultat → injiser resultatet tilbake i chatkonteksten nøyaktig slik malen foreskriver → kall modellen på nytt.

Praktiske tips, feilsøking og sikkerhetsmerknader (hva bør jeg se etter?)

Tokenmaler er strenge. Bruk modellens tokenizer.apply_chat_template eller gjengi den nøyaktige <think>/</think> tokens som vist. Feil avstand eller manglende markører vil endre modellens oppførsel.
Verktøyformatet må være gyldig JSON. Modellen vil analysere verktøyargumenter som JSON – ugyldig JSON vil bryte verktøykall.
Kvantiseringsavveininger. 1-bit dynamiske/aggressive kvantiseringer krymper lagringsplass og RAM, men kan endre numerisk gjengivelse noe. Test på arbeidsbelastningene dine. Fellesskapskvantiseringer som reduserer 80 % av diskbruken finnes (eksempelrapport: 720 GB → ~170 GB), men valider alltid med ledetekstene dine.
Ollama-kompatibilitet. Noen DeepSeek-varianter bemerker at Ollama v0.11.7 er nødvendig for forhåndsutgivelsesfunksjoner – sjekk Ollama-modellsiden og oppdater deretter.

Eksempel på ende-til-ende-løsning: kjør DeepSeek-V3.1 lokalt med tenkemodus (minigjennomgang)

Installer Ollama og hent modellen:

# install ollama per docs, then:

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

Bruk Python-tokenizeren til å lage en tenkeprompt:

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 verktøykall i toolcall-formatet, analyser JSON-filen og kjør verktøyet, og injiser deretter resultatene i den neste meldingen i henhold til modellkortmalene.

Hvordan bør du velge distribusjonsveien din?

Hvis du vil ha den raskeste veien til eksperimentet: bruke Ollama og eksemplene på Hugging Face-modellkortet. Ollama skjuler mange infrastrukturdetaljer og gir et lokalt HTTP API.
Hvis du trenger lavere kostnad / mer portabilitet: bruk et fellesskap GGUF kvantisert artefakt og kjør med llama.cpp or llama-serverKvantisering sparer disk og minne, men test nøyaktigheten for arbeidsmengden din.
Hvis du bygger agenter eller verktøy: følg modellkortets verktøykall og agenten maler nøyaktig; orkestrer verktøyutdata tilbake i modellkontekst.

Komme i gang

CometAPI er en enhetlig API-plattform som samler over 500 AI-modeller fra ledende leverandører – som OpenAIs GPT-serie, Googles Gemini, Anthropics Claude, Midjourney, Suno og flere – i ett enkelt, utviklervennlig grensesnitt. Ved å tilby konsistent autentisering, forespørselsformatering og svarhåndtering, forenkler CometAPI dramatisk integreringen av AI-funksjoner i applikasjonene dine. Enten du bygger chatboter, bildegeneratorer, musikkomponister eller datadrevne analysepipeliner, lar CometAPI deg iterere raskere, kontrollere kostnader og forbli leverandøruavhengig – alt samtidig som du utnytter de nyeste gjennombruddene på tvers av AI-økosystemet.

Utviklere har tilgang DeepSeek V3.1 Gjennom CometAPI er de nyeste modellversjonene som er oppført per artikkelens publiseringsdato. For å begynne, utforsk modellens muligheter i lekeplass og konsulter API-veiledning for detaljerte instruksjoner. Før du får tilgang, må du sørge for at du har logget inn på CometAPI og fått API-nøkkelen. CometAPI tilby en pris som er langt lavere enn den offisielle prisen for å hjelpe deg med å integrere.

Konklusjon

DeepSeek-V3.1 bringer en praktisk hybrid inferensfilosofi (ett sjekkpunkt + malbasert tankeatferd) som gjør det enkelt å eksperimentere med tankekjede-lignende resonnement og bruk av agentverktøy når du respekterer chatmalene og verktøykravene. Bruk Hugging Face-modellkortet og DeepSeek-utgivelsesnotatene som ditt første stopp, velg en lokal kjøretid (Ollama for enkelhets skyld, llama.cpp for kontroll), og test kvantiserte bygg for praktiske lokale distribusjoner.