Slik bruker du DeepSeek-V3.1 API – en praktisk utviklerveiledning

DeepSeek-V3.1 er den nyeste hybride resonneringsmodellen fra DeepSeek som støtter både en rask «ikke-tenkende» chatmodus og en mer bevisst «tenkning/resonnering»-modus, tilbyr lang (opptil 128K) kontekst, strukturerte utganger og funksjonskall, og kan nås direkte via DeepSeeks OpenAI-kompatible API, via et Anthropic-kompatibelt endepunkt eller gjennom CometAPI. Nedenfor går jeg gjennom hva modellen er, referanse- og kostnadshøydepunkter, avanserte funksjoner (funksjonskall, JSON-utganger, resonneringsmodus), og gir deretter konkrete ende-til-ende-kodeeksempler: direkte DeepSeek REST-kall (curl / Node / Python), Anthropic-klientbruk og kall via CometAPI.

Hva er DeepSeek-V3.1, og hva er nytt i denne utgivelsen?

DeepSeek-V3.1 er den nyeste utgivelsen i DeepSeek V3-familien: en modelllinje med høy kapasitet og en blanding av eksperter for store språk som leverer en hybrid inferensdesign med to driftsmoduser – en rask ikke-tenkende prat modus og en tenker / resonnerer modus som kan eksponere spor av tankekjedestil for vanskeligere resonneringsoppgaver og agent-/verktøybruk. Utgivelsen legger vekt på raskere "tenknings"-forsinkelse, forbedrede verktøy-/agentfunksjoner og lengre konteksthåndtering for arbeidsflyter i dokumentskala.

Viktige praktiske lærdommer:

• To driftsmoduser: deepseek-chat for gjennomstrømning og kostnad, deepseek-reasoner (en resonneringsmodell) når du ønsker tankekjedespor eller høyere resonneringsnøyaktighet.
• Oppgradert agent-/verktøyhåndtering og forbedringer av tokenisering/kontekst for lange dokumenter.
• Kontekstlengde: opptil ~128 XNUMX tokens (muliggjør lange dokumenter, kodebaser, logger).

Gjennombrudd i referanseindeksen

DeepSeek-V3.1 viste betydelige forbedringer i kodingsutfordringer i den virkelige verden. I SWE-bench Verified-evalueringen, som måler hvor ofte modellen fikser GitHub-problemer for å sikre at enhetstester består, oppnådde V3.1 en suksessrate på 66 %, sammenlignet med 45 % for både V3-0324 og R1. I den flerspråklige versjonen løste V3.1 54.5 % av problemene, nesten dobbelt så mye som suksessraten på omtrent 30 % for de andre versjonene. I Terminal-Bench-evalueringen, som tester om modellen kan fullføre oppgaver i et live Linux-miljø, lyktes DeepSeek-V3.1 i 31 % av oppgavene, sammenlignet med henholdsvis 13 % og 6 % for de andre versjonene. Disse forbedringene viser at DeepSeek-V3.1 er mer pålitelig når det gjelder å kjøre kode og operere i virkelige verktøymiljøer.

Referansetester for informasjonssøking favoriserer også DeepSeek-V3.1 i surfing, søking og besvaring av spørsmål. I BrowseComp-evalueringen, som krever navigering og uttrekking av svar fra en nettside, besvarte V3.1 riktig 30 % av spørsmålene, sammenlignet med 9 % for R1. I den kinesiske versjonen oppnådde DeepSeek-V3.1 49 % nøyaktighet, sammenlignet med 36 % for R1. På Hard Language Exam (HLE) presterte V3.1 litt bedre enn R1, med henholdsvis 30 % til 25 % nøyaktighet. På dypsøkingsoppgaver som xbench-DeepSearch, som krever syntese av informasjon på tvers av kilder, scoret V3.1 71 % mot R1s 55 %. DeepSeek-V3.1 viste også en liten, men konsistent ledelse på referansetester som (strukturert resonnement), SimpleQA (besvarelse av faktabaserte spørsmål) og Seal0 (domenespesifikk besvarelse av spørsmål). Totalt sett presterte V3.1 betydelig bedre enn R1 i informasjonssøking og besvarelse av lette spørsmål.

Når det gjelder resonneringseffektivitet, viser resultatene for tokenbruk effektiviteten. På AIME 2025 (en vanskelig matteeksamen) oppnådde V3.1-Think en nøyaktighet som var sammenlignbar med eller litt over R1 (88.4 % mot 87.5 %), men brukte omtrent 30 % færre tokens. På GPQA Diamond (en flerdomenseksamen for høyere utdanning) var de to modellene nesten like (80.1 % mot 81.0 %), men V3.1 brukte nesten halvparten av tokensene som R1. På LiveCodeBench-referanseindeksen, som vurderer koderesonnement, var V3.1 ikke bare mer nøyaktig (74.8 % mot 73.3 %), men også mer konsis. Dette viser at V3.1-Think er i stand til å gi detaljert resonnement samtidig som den unngår ordrikhet.

Totalt sett representerer V3.1 et betydelig generasjonssprang sammenlignet med V3-0324. Sammenlignet med R1 oppnådde V3.1 høyere nøyaktighet på nesten alle målestokker og var mer effektiv på tunge resonneringsoppgaver. Den eneste målestokken der R1 matchet var GPQA, men til nesten dobbelt så høy kostnad.

Hvordan får jeg tak i en API-nøkkel og setter opp en utviklingskonto?

Trinn 1: Registrer deg og opprett en konto

1. Gå til DeepSeeks utviklerportal (DeepSeek-dokumentasjon/konsoll). Opprett en konto med e-posten eller SSO-leverandøren din.
2. Fullfør eventuelle identitetskontroller eller faktureringsoppsett som kreves av portalen.

Trinn 2: Lag en API-nøkkel

1. Gå til dashbordet API-nøkkel → Opprett nøkkel. Gi nøkkelen din et navn (f.eks. dev-local-01).
2. Kopier nøkkelen og lagre den i en sikker hemmelighetsbehandler (se beste praksis for produksjon nedenfor).

Tips: Noen gatewayer og tredjepartsrutere (f.eks. CometAPI) lar deg bruke én gateway-nøkkel for å få tilgang til DeepSeek-modeller gjennom dem – det er nyttig for redundans mellom flere leverandører (se DeepSeek V3.1 API seksjon).

Hvordan setter jeg opp utviklingsmiljøet mitt (Linux/macOS/Windows)?

Dette er et enkelt, reproduserbart oppsett for Python og Node.js som fungerer for DeepSeek (OpenAI-kompatible endepunkter), CometAPI og Anthropic.

Forutsetninger

• Python 3.10+ (anbefales), pip, virtualenv.
• Node.js 18+ og npm/garn.
• krøll (for raske tester).

Python-miljø (trinn for trinn)

1. Opprett en prosjektmappe:

mkdir deepseek-demo && cd deepseek-demo
python -m venv .venv
source .venv/bin/activate   # macOS / Linux

# .venv\Scripts\activate    # Windows PowerShell

2. Installer minimale pakker:

pip install --upgrade pip
pip install requests
# Optional: install an OpenAI-compatible client if you prefer one:

pip install openai

3. Lagre API-nøkkelen din i miljøvariabler (aldri commit):

export DEEPSEEK_KEY="sk_live_xxx"
export CometAPI_KEY="or_xxx"
export ANTHROPIC_KEY="anthropic_xxx"

(Bruk av Windows PowerShell $env:DEEPSEEK_KEY = "…")

Nodemiljø (trinn for trinn)

1. Initialiser:

mkdir deepseek-node && cd deepseek-node
npm init -y
npm install node-fetch dotenv

2. Lag en .env file:

DEEPSEEK_KEY=sk_live_xxx
CometAPI_KEY=or_xxx
ANTHROPIC_KEY=anthropic_xxx

Hvordan kaller jeg DeepSeek-V3.1 direkte – trinnvise kodeeksempler?

DeepSeeks API er OpenAI-kompatibelt. Nedenfor er Kopier og lim inn eksempler: curl, Python (forespørsler og OpenAI SDK-stil) og Node.

Trinn 1: Enkelt krølleksempel

curl https://api.deepseek.com/v1/chat/completions \
  -H "Authorization: Bearer $DEEPSEEK_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-chat-v3.1",
    "messages": [
      {"role":"system","content":"You are a concise engineering assistant."},
      {"role":"user","content":"Give a 5-step secure deployment checklist for a Django app."}
    ],
    "max_tokens": 400,
    "temperature": 0.0,
    "reasoning_enabled": true
  }'

Merknader: reasoning_enabled veksler mellom Tenk-modus (leverandørflagg). Det nøyaktige flaggnavnet kan variere fra leverandør til leverandør – sjekk modelldokumentasjonen.

Trinn 2: Python (forespørsler) med enkel telemetri

import os, requests, time, json

API_KEY = os.environ
URL = "https://api.deepseek.com/v1/chat/completions"

payload = {
  "model": "deepseek-chat-v3.1",
  "messages": [
    {"role": "system", "content": "You are a helpful coding assistant."},
    {"role": "user", "content": "Refactor this Flask function to be testable: ..."}
  ],
  "max_tokens": 600,
  "temperature": 0.1,
  "reasoning_enabled": True
}

start = time.time()
r = requests.post(URL, headers={
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json"
}, json=payload, timeout=60)

elapsed = time.time() - start
print("Status:", r.status_code, "Elapsed:", elapsed)
data = r.json()
print(json.dumps(data, indent=2))

CometAPI: Helt gratis tilgang til DeepSeek V3.1

For utviklere som ønsker umiddelbar tilgang uten registrering, tilbyr CometAPI et attraktivt alternativ til DeepSeek V3.1 (modellnavn: deepseek-v3-1-250821; deepseek-v3.1). Denne gateway-tjenesten samler flere AI-modeller gjennom et enhetlig API, og gir tilgang til DeepSeek og tilbyr andre fordeler, inkludert automatisk failover, bruksanalyse og forenklet fakturering på tvers av leverandører.

Først, opprett en CometAPI-konto på https://www.cometapi.com/– hele prosessen tar bare to minutter og krever kun bekreftelse av e-postadresse. Når du er logget inn, genererer du en ny nøkkel i delen «API-nøkkel». https://www.cometapi.com/ tilbyr gratis kreditter for nye kontoer og 20 % rabatt på den offisielle API-prisen.

Teknisk implementering krever minimale kodeendringer. Bare endre API-endepunktet ditt fra en direkte DeepSeek-URL til CometAPI-gatewayen.

Merk: API-et støtter strømming (stream: true), max_tokens, temperatur, stoppsekvenser og funksjonskallfunksjoner som ligner på andre OpenAI-kompatible API-er.

Hvordan kan jeg kalle DeepSeek ved hjelp av Anthropic SDK-er?

DeepSeek tilbyr et Anthropic-kompatibelt endepunkt, slik at du kan gjenbruke Anthropc SDK-er eller Claude Code-verktøy ved å peke SDK-en til https://api.deepseek.com/anthropic og setter modellnavnet til deepseek-chat (eller deepseek-reasoner der det støttes).

Kall på DeepSeek-modellen via Anthropic API

Installer Anthropic SDK: pip install anthropic. Konfigurer miljøet ditt:

export ANTHROPIC_BASE_URL=https://api.deepseek.com/anthropic  
export ANTHROPIC_API_KEY=YOUR_DEEPSEEK_KEY

Opprett en melding:

import anthropic
client = anthropic.Anthropic()
message = client.messages.create(
model="deepseek-chat",
max_tokens=1000,
system="You are a helpful assistant.",
messages=[
{
"role": "user",
"content": [
{
"type": "text",
"text": "Hi, how are you?"
}
]
}
]
)
print(message.content)

Bruk DeepSeek i Claude-kode

Installer: npm install -g @anthropic-ai/claude-code. Konfigurer miljøet ditt:

export ANTHROPIC_BASE_URL=https://api.deepseek.com/anthropic
export ANTHROPIC_AUTH_TOKEN=${YOUR_API_KEY}
export ANTHROPIC_MODEL=deepseek-chat
export ANTHROPIC_SMALL_FAST_MODEL=deepseek-chat

Gå inn i prosjektkatalogen og kjør Claude-koden:

cd my-project  
claude

Bruk DeepSeek i Claude-kode via CometAPI

CometAPI støtter Claude Code. Etter installasjon, når du konfigurerer miljøet, erstatter du ganske enkelt basis-URL-en med https://www.cometapi.com/console/ og nøkkelen med CometAPIs nøkkel for å bruke CometAPIs DeepSeek-modell i Claude Code.

# Navigate to your project folder cd your-project-folder 

# Set environment variables (replace sk-... with your actual token) 
export ANTHROPIC_AUTH_TOKEN=sk-... 
export ANTHROPIC_BASE_URL=https://www.cometapi.com/console/ 
# Start Claude Code 

claude

Merknader:

• DeepSeek tilordner ustøttede antropiske modellnavn til deepseek-chat.
• Det antropiske kompatibilitetslaget støtter system, messages, temperature, strømming, stoppsekvenser og tenkende arrayer.

Hva er beste praksis for konkret produksjon (sikkerhet, kostnad, pålitelighet)?

Nedenfor finner du anbefalte produksjonsmønstre som gjelder for DeepSeek eller annen bruk av store LLM-programmer.

Hemmeligheter og identitet

• Lagre API-nøkler i en hemmelig manager (ikke bruk .env (i prod). Roter nøkler regelmessig og opprett nøkler per tjeneste med færrest rettigheter.
• Bruk separate prosjekter/kontoer for utvikling/staging/produksjon.

Frekvensgrenser og nye forsøk

• Implementere eksponentiell tilbakeslag på HTTP 429/5xx med jitter. Begrenset antall nye forsøk (f.eks. 3 forsøk).
• Bruk idempotensnøkler for forespørsler som kan gjentas.

Python-eksempel – prøv på nytt med backoff

import time, random, requests

def post_with_retries(url, headers, payload, attempts=3):
    for i in range(attempts):
        r = requests.post(url, json=payload, headers=headers, timeout=60)
        if r.status_code == 200:
            return r.json()
        if r.status_code in (429, 502, 503, 504):
            backoff = (2 ** i) + random.random()
            time.sleep(backoff)
            continue
        r.raise_for_status()
    raise RuntimeError("Retries exhausted")

Kostnadsstyring

• Grense max_tokens og unngå å utilsiktet be om store mengder data.
• Svar på hurtigbuffermodell der det er passende (spesielt for gjentatte forespørsler). DeepSeek skiller eksplisitt mellom treff og bom i mellomlagring i prissetting – mellomlagring sparer penger.
• Bruk deepseek-chat for rutinemessige små svar; reserver deepseek-reasoner for tilfeller som virkelig trenger CoT (det er dyrere).

Observerbarhet og logging

• Logg kun metadata om forespørsler i klartekst (forespørselshasher, tokenantall, latenser). Unngå å logge fullstendige brukerdata eller sensitivt innhold. Lagre forespørsels-/svar-ID-er for støtte og fakturaavstemming.
• Spor tokenbruk per forespørsel og eksponer budsjettering/varsler om kostnader.

Sikkerhets- og hallusinasjonskontroller

• Bruk verktøyutganger og deterministiske validatorer for alt sikkerhetskritisk (økonomisk, juridisk, medisinsk).
• For strukturerte utdata, bruk response_format+JSON-skjema og valider utdata før du utfører irreversible handlinger.

Distribusjonsmønstre

• Kjør modellkall fra en dedikert arbeidsprosess for å kontrollere samtidighet og kø.
• Avlast tunge jobber til asynkrone arbeidere (Celery, Fargate-oppgaver, Cloud Run-jobber) og svar brukerne med fremdriftsindikatorer.
• Ved behov for ekstreme latens-/gjennomstrømningshastigheter bør du vurdere leverandørens tjenestenivåavtaler og om du skal hoste dem selv eller bruke leverandørakseleratorer.

Avsluttende notat

DeepSeek-V3.1 er en pragmatisk hybridmodell designet for både rask chat og komplekse agentoppgaver. Den OpenAI-kompatible API-formen gjør migrering enkel for mange prosjekter, mens Anthropic- og CometAPI-kompatibilitetslagene gjør den fleksibel for eksisterende økosystemer. Referanseverdier og fellesskapsrapporter viser lovende kostnads-/ytelsesavveininger – men som med enhver ny modell, valider den på dine virkelige arbeidsbelastninger (spørring, funksjonskall, sikkerhetskontroller, latens) før full produksjonsutrulling.

På CometAPI kan du kjøre den sikkert og samhandle med den via et OpenAI-kompatibelt API eller en brukervennlig lekeplass, uten rentebegrensninger.

👉 Implementer DeepSeek-V3.1 på CometAPI nå!

Hvorfor bruke Comet API?

• Leverandørmultipleksingbytt leverandør uten å måtte omskrive kode.
• Enhetlig fakturering/målingerHvis du ruter flere modeller gjennom CometAPI, får du én enkelt integrasjonsflate.
• Modellmetadata: vis kontekstlengde og aktive parametere per modellvariant.