Sådan bruger du DeepSeek-V3.1 API — en praktisk udviklervejledning

DeepSeek-V3.1 er den nyeste hybride ræsonnementmodel fra DeepSeek, der understøtter både en hurtig "ikke-tænkende" chattilstand og en mere bevidst "tænkende/ræsonnerende" tilstand, tilbyder lang (op til 128K) kontekst, strukturerede output og funktionskald, og kan tilgås direkte via DeepSeeks OpenAI-kompatible API, via et Anthropic-kompatibelt endpoint eller gennem CometAPI. Nedenfor gennemgår jeg modellen, benchmark- og omkostningshøjdepunkter, avancerede funktioner (funktionskald, JSON-output, ræsonnementtilstand), og giver derefter konkrete end-to-end-kodeeksempler: direkte DeepSeek REST-kald (curl / Node / Python), Anthropic-klientbrug og kald via CometAPI.

Hvad er DeepSeek-V3.1, og hvad er nyt i denne udgivelse?

DeepSeek-V3.1 er den seneste udgivelse i DeepSeek V3-familien: en højkapacitets, blanding af eksperter store sprogmodeller, der leverer en hybrid inferensdesign med to driftstilstande — en hurtig ikke-tænkende chat tilstand og en tænker / ræsonnerer tilstand, der kan afsløre spor af tankekædestile til vanskeligere ræsonnementsopgaver og agent-/værktøjsbrug. Udgivelsen lægger vægt på hurtigere "tænknings"-latens, forbedrede værktøjs-/agentfunktioner og længere konteksthåndtering til arbejdsgange i dokumentskala.

Vigtige praktiske pointer:

• To driftstilstande: deepseek-chat for gennemløbshastighed og omkostninger, deepseek-reasoner (en ræsonnementsmodel) når du ønsker tankekædespor eller højere ræsonnementsnøjagtighed.
• Opgraderet agent-/værktøjshåndtering og tokenizer-/kontekstforbedringer til lange dokumenter.
• Kontekstlængde: op til ~128K tokens (muliggør lange dokumenter, kodebaser, logs).

Benchmark-gennembrud

DeepSeek-V3.1 viste betydelige forbedringer i kodningsudfordringer i den virkelige verden. I SWE-bench Verified-evalueringen, som måler, hvor ofte modellen retter GitHub-problemer for at sikre, at enhedstests består, opnåede V3.1 en succesrate på 66% sammenlignet med 45% for både V3-0324 og R1. I den flersprogede version løste V3.1 54.5% af problemerne, næsten dobbelt så stor som succesraten på cirka 30% for de andre versioner. I Terminal-Bench-evalueringen, som tester, om modellen kan udføre opgaver i et live Linux-miljø, lykkedes det DeepSeek-V3.1 at udføre 31% af opgaverne, sammenlignet med henholdsvis 13% og 6% for de andre versioner. Disse forbedringer viser, at DeepSeek-V3.1 er mere pålidelig til at udføre kode og fungere i virkelige værktøjsmiljøer.

Benchmarks for informationssøgning favoriserer også DeepSeek-V3.1 i browsing, søgning og besvarelse af spørgsmål. I BrowseComp-evalueringen, som kræver navigation og udtrækning af svar fra en webside, besvarede V3.1 korrekt 30% af spørgsmålene, sammenlignet med 9% for R1. I den kinesiske version opnåede DeepSeek-V3.1 en nøjagtighed på 49%, sammenlignet med 36% for R1. På Hard Language Exam (HLE) klarede V3.1 sig en smule bedre end R1 og opnåede henholdsvis 30% til 25% nøjagtighed. På dybdegående søgeopgaver som xbench-DeepSearch, som kræver syntese af information på tværs af kilder, scorede V3.1 71% mod R1's 55%. DeepSeek-V3.1 viste også en lille, men konsekvent føring på benchmarks som (struktureret ræsonnement), SimpleQA (faktuel spørgsmålsbesvarelse) og Seal0 (domænespecifik spørgsmålsbesvarelse). Samlet set klarede V3.1 sig signifikant bedre end R1 i informationssøgning og letvægtsspørgsmålsbesvarelse.

Med hensyn til effektivitet i ræsonnement demonstrerer resultaterne af token-brugen dens effektivitet. På AIME 2025 (en vanskelig matematikeksamen) opnåede V3.1-Think en nøjagtighed, der var sammenlignelig med eller lidt oversteg R1 (88.4 % versus 87.5 %), men brugte cirka 30 % færre tokens. På GPQA Diamond (en kandidateksamen med flere domæner) var de to modeller næsten lige (80.1 % vs. 81.0 %), men V3.1 brugte næsten halvdelen af ​​de tokens, der blev brugt i R1. På LiveCodeBench-benchmarken, som vurderer koderæsonnement, var V3.1 ikke kun mere præcis (74.8 % vs. 73.3 %), men også mere præcis. Dette viser, at V3.1-Think er i stand til at give detaljeret ræsonnement, samtidig med at det undgår ordgråhed.

Samlet set repræsenterer V3.1 et betydeligt generationsspring sammenlignet med V3-0324. Sammenlignet med R1 opnåede V3.1 højere nøjagtighed på næsten alle benchmarks og var mere effektiv til tunge ræsonnementsopgaver. Det eneste benchmark, hvor R1 matchede, var GPQA, men til næsten dobbelt så høje omkostninger.

Hvordan får jeg en API-nøgle og opretter en udviklingskonto?

Trin 1: Tilmeld dig og opret en konto

1. Besøg DeepSeeks udviklerportal (DeepSeek-dokumentation/konsol). Opret en konto med din e-mail eller SSO-udbyder.
2. Udfør alle identitetskontroller eller faktureringsopsætninger, der kræves af portalen.

Trin 2: Opret en API-nøgle

1. Gå til dashboardet API nøgler → Opret nøgleNavngiv din nøgle (f.eks. dev-local-01).
2. Kopier nøglen, og gem den i en sikker hemmelig manager (se bedste praksis for produktion nedenfor).

Tip: Nogle gateways og tredjepartsroutere (f.eks. CometAPI) giver dig mulighed for at bruge en enkelt gateway-nøgle til at få adgang til DeepSeek-modeller gennem dem – det er nyttigt til redundans mellem flere udbydere (se DeepSeek V3.1 API afsnit).

Hvordan konfigurerer jeg mit udviklingsmiljø (Linux/macOS/Windows)?

Dette er en simpel, reproducerbar opsætning til Python og Node.js, der fungerer til DeepSeek (OpenAI-kompatible endpoints), CometAPI og Anthropic.

Forudsætninger

• Python 3.10+ (anbefales), pip, virtualenv.
• Node.js 18+ og npm/yarn.
• krøl (til hurtige tests).

Python-miljø (trin for trin)

1. Opret en projektmappe:

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. Gem din API-nøgle i miljøvariabler (commit aldrig):

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

(Brug af Windows PowerShell $env:DEEPSEEK_KEY = "…")

Nodemiljø (trin for trin)

1. Initialiser:

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

2. Opret en .env fil:

DEEPSEEK_KEY=sk_live_xxx
CometAPI_KEY=or_xxx
ANTHROPIC_KEY=anthropic_xxx

Hvordan kalder jeg DeepSeek-V3.1 direkte — trinvise kodeeksempler?

DeepSeeks API er OpenAI-kompatibel. Nedenfor er kopier indsæt eksempler: curl, Python (forespørgsler og OpenAI SDK-stil) og Node.

Trin 1: Eksempel på simpel krølning

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

Bemærkninger: reasoning_enabled Slår Think-tilstand til/fra (leverandørflag). Det nøjagtige flagnavn kan variere afhængigt af udbyderen — tjek modeldokumentationen.

Trin 2: Python (anmodninger) med simpel 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 adgang til DeepSeek V3.1

For udviklere, der søger øjeblikkelig adgang uden registrering, tilbyder CometAPI et overbevisende alternativ til DeepSeek V3.1 (modelnavn: deepseek-v3-1-250821; deepseek-v3.1). Denne gateway-tjeneste samler flere AI-modeller gennem en samlet API, hvilket giver adgang til DeepSeek og tilbyder andre fordele, herunder automatisk failover, brugsanalyse og forenklet fakturering på tværs af udbydere.

Først skal du oprette en CometAPI-konto på https://www.cometapi.com/— hele processen tager kun to minutter og kræver kun verifikation af e-mailadresse. Når du er logget ind, skal du generere en ny nøgle i afsnittet "API-nøgle". https://www.cometapi.com/ tilbyder gratis kreditter til nye konti og 20% ​​rabat på den officielle API-pris.

Teknisk implementering kræver minimale kodeændringer. Du skal blot ændre dit API-slutpunkt fra en direkte DeepSeek-URL til CometAPI-gatewayen.

Bemærk: API'en understøtter streaming (stream: true), max_tokens, temperatur, stopsekvenser og funktionskaldsfunktioner svarende til andre OpenAI-kompatible API'er.

Hvordan kan jeg kalde DeepSeek ved hjælp af Anthropic SDK'er?

DeepSeek leverer et Anthropic-kompatibelt slutpunkt, så du kan genbruge Anthropc SDK'er eller Claude Code-værktøjer ved at pege SDK'et på https://api.deepseek.com/anthropic og indstille modelnavnet til deepseek-chat (eller deepseek-reasoner hvor det understøttes).

Aktivér DeepSeek-modellen via Anthropic API

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

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

Opret en besked:

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)

Brug DeepSeek i Claude Code

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

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å ind i projektmappen, og udfør Claude Code:

cd my-project  
claude

Brug DeepSeek i Claude-kode via CometAPI

CometAPI understøtter Claude Code. Efter installationen, når du konfigurerer miljøet, skal du blot erstatte basis-URL'en med https://www.cometapi.com/console/ og nøglen med CometAPIs nøgle for at bruge CometAPIs DeepSeek-model 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

Bemærkninger:

• DeepSeek knytter ikke-understøttede antropiske modelnavne til deepseek-chat.
• Det antropiske kompatibilitetslag understøtter system, messages, temperature, streaming, stopsekvenser og tænkende arrays.

Hvad er bedste praksis i konkret produktion (sikkerhed, omkostninger, pålidelighed)?

Nedenfor er anbefalede produktionsmønstre, der gælder for DeepSeek eller enhver LLM-brug i høj volumen.

Hemmeligheder og identitet

• Gem API-nøgler i en hemmelig manager (brug ikke .env (i prod). Roter nøgler regelmæssigt, og opret nøgler pr. tjeneste med færrest rettigheder.
• Brug separate projekter/konti til udvikling/staging/produktion.

Hastighedsgrænser og genforsøg

• Implement eksponentiel tilbageslag på HTTP 429/5xx med jitter. Begrænsning af gentagne forsøg (f.eks. 3 forsøg).
• Brug idempotensnøgler til anmodninger, der kan gentages.

Python-eksempel — prøv igen 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")

Omkostningsstyring

• Begræns max_tokens og undgå utilsigtet at anmode om store mængder output.
• Cache-modelsvar hvor det er relevant (især ved gentagne prompts). DeepSeek skelner eksplicit mellem cache-hit og miss i prissætningen — caching sparer penge.
• Brug deepseek-chat til rutinemæssige små svar; reserver deepseek-reasoner i tilfælde, der virkelig har brug for CoT (det er dyrere).

Observerbarhed og logning

• Log kun metadata om anmodninger i klartekst (prompt-hashes, token-antal, latenstider). Undgå at logføre fulde brugerdata eller følsomt indhold. Gem anmodnings-/svar-ID'er til support og faktureringsafstemning.
• Spor tokenforbrug pr. anmodning og eksponér budgettering/advarsler om omkostninger.

Sikkerheds- og hallucinationskontroller

• Brug værktøjsoutput og deterministiske validatorer for alt sikkerhedskritisk (økonomisk, juridisk, medicinsk).
• For strukturerede output, brug response_format+JSON-skema og valider output, før der udføres handlinger, der ikke kan fortrydes.

Implementeringsmønstre

• Kør modelkald fra en dedikeret arbejdsproces for at kontrollere samtidighed og køopsætning.
• Offload tunge job til asynkrone arbejdere (Celery, Fargate-opgaver, Cloud Run-job) og svar brugerne med statusindikatorer.
• Ved ekstreme latens-/gennemstrømningsbehov skal du overveje udbyder-SLA'er og om du skal hoste dig selv eller bruge udbyderacceleratorer.

Lukningsnotat

DeepSeek-V3.1 er en pragmatisk hybridmodel designet til både hurtig chat og komplekse agentopgaver. Dens OpenAI-kompatible API-form gør migrering ligetil for mange projekter, mens Anthropic- og CometAPI-kompatibilitetslagene gør den fleksibel til eksisterende økosystemer. Benchmarks og community-rapporter viser lovende omkostnings-/ydelsesafvejninger – men som med enhver ny model, validér den på dine virkelige arbejdsbelastninger (promptering, funktionskald, sikkerhedstjek, latenstid) før fuld produktionsudrulning.

På CometAPI kan du køre det sikkert og interagere med det via en OpenAI-kompatibel API eller et brugervenligt legeplads, uden satsgrænser.

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

Hvorfor bruge Comet API?

• Udbydermultipleksering: skift udbydere uden omskrivning af kode.
• Samlet fakturering/målingerHvis du sender flere modeller gennem CometAPI, får du én integrationsoverflade.
• Modelmetadata: se kontekstlængde og aktive parametre pr. modelvariant.