Cara Menggunakan API DeepSeek-V3.1 — tutorial pembangun praktikal

DeepSeek-V3.1 ialah model penaakulan hibrid terbaharu daripada DeepSeek yang menyokong kedua-dua mod sembang "tidak berfikir" yang pantas dan mod "berfikir/penaakulan" yang lebih disengajakan, menawarkan konteks yang panjang (sehingga 128K), output berstruktur dan panggilan fungsi, serta boleh diakses terus melalui OpenAI-compatible API, DeepSeek's OpenAI-compatible endpoint, atau Compatible API melalui Compatible API. Di bawah ini saya membimbing anda tentang model, tanda aras dan sorotan kos, ciri lanjutan (panggilan fungsi, output JSON, mod penaakulan), kemudian berikan contoh kod hujung ke hujung konkrit: panggilan DeepSeek REST langsung (curl / Node / Python), penggunaan klien Anthropic dan panggilan melalui CometAPI.

Apakah DeepSeek-V3.1 dan apakah yang baharu dalam keluaran ini?

DeepSeek-V3.1 ialah keluaran terbaharu dalam keluarga DeepSeek V3: barisan model bahasa besar berkapasiti tinggi, campuran pakar yang menghantar reka bentuk inferens hibrid dengan dua "mod" operasi - cepat sembang tanpa fikir mod dan a berfikir / penaakulan mod yang boleh mendedahkan jejak gaya rantaian pemikiran untuk tugas penaakulan yang lebih sukar dan penggunaan ejen/alat. Keluaran ini menekankan kependaman "berfikir" yang lebih pantas, keupayaan alat/ejen yang dipertingkatkan dan pengendalian konteks yang lebih lama untuk aliran kerja berskala dokumen.

Petua praktikal utama:

• Dua mod operasi: deepseek-chat untuk pengeluaran dan kos, deepseek-reasoner (model penaakulan) apabila anda mahukan jejak rantaian pemikiran atau kesetiaan penaakulan yang lebih tinggi.
• Pengendalian ejen/alat yang ditingkatkan dan penambahbaikan tokenizer/konteks untuk dokumen panjang.
• Panjang konteks: sehingga ~128K token (membolehkan dokumen panjang, pangkalan kod, log).

Penembusan Penanda Aras

DeepSeek-V3.1 menunjukkan peningkatan yang ketara dalam cabaran pengekodan dunia sebenar. Dalam penilaian SWE-bench Verified, yang mengukur kekerapan model membetulkan isu GitHub untuk memastikan ujian unit lulus, V3.1 mencapai kadar kejayaan 66%, berbanding 45% untuk kedua-dua V3-0324 dan R1. Dalam versi berbilang bahasa, V3.1 menyelesaikan 54.5% isu, hampir dua kali ganda daripada kira-kira 30% kadar kejayaan versi lain. Dalam penilaian Terminal-Bench, yang menguji sama ada model itu boleh menyelesaikan tugasan dengan jayanya dalam persekitaran Linux langsung, DeepSeek-V3.1 berjaya dalam 31% tugasan, berbanding 13% dan 6% untuk versi lain, masing-masing. Penambahbaikan ini menunjukkan bahawa DeepSeek-V3.1 lebih dipercayai dalam melaksanakan kod dan beroperasi dalam persekitaran alat dunia sebenar.

Penanda aras mendapatkan maklumat juga memihak kepada DeepSeek-V3.1 dalam menyemak imbas, mencari dan menjawab soalan. Dalam penilaian BrowseComp, yang memerlukan menavigasi dan mengekstrak jawapan daripada halaman web, V3.1 menjawab 30% soalan dengan betul, berbanding 9% untuk R1. Dalam versi Cina, DeepSeek-V3.1 mencapai ketepatan 49%, berbanding 36% untuk R1. Pada Peperiksaan Bahasa Keras (HLE), V3.1 sedikit mengatasi prestasi R1, masing-masing mencapai ketepatan 30% hingga 25%. Mengenai tugas carian mendalam seperti xbench-DeepSearch, yang memerlukan mensintesis maklumat merentas sumber, V3.1 mendapat markah 71% hingga 1% R55. DeepSeek-V3.1 juga menunjukkan petunjuk yang kecil tetapi konsisten pada penanda aras seperti (penaakulan berstruktur), SimpleQA (menjawab soalan fakta) dan Seal0 (menjawab soalan khusus domain). Secara keseluruhan, V3.1 mengatasi R1 dengan ketara dalam pencarian maklumat dan menjawab soalan yang ringan.

Dari segi kecekapan penaakulan, hasil penggunaan token menunjukkan keberkesanannya. Pada AIME 2025 (peperiksaan matematik yang sukar), V3.1-Think mencapai ketepatan setanding atau melebihi sedikit R1 (88.4% berbanding 87.5%), tetapi menggunakan kira-kira 30% lebih sedikit token. Pada GPQA Diamond (peperiksaan siswazah berbilang domain), kedua-dua model adalah hampir sekata (80.1% berbanding 81.0%), tetapi V3.1 menggunakan hampir separuh token sebagai R1. Pada penanda aras LiveCodeBench, yang menilai penaakulan kod, V3.1 bukan sahaja lebih tepat (74.8% berbanding 73.3%) tetapi juga lebih ringkas. Ini menunjukkan bahawa V3.1-Think mampu memberikan penaakulan terperinci sambil mengelakkan keterlaluan.

Secara keseluruhan, V3.1 mewakili lonjakan generasi yang ketara berbanding V3-0324. Berbanding dengan R1, V3.1 mencapai ketepatan yang lebih tinggi pada hampir setiap penanda aras dan lebih berkesan pada tugas penaakulan yang berat. Satu-satunya penanda aras di mana R1 dipadankan ialah GPQA, tetapi pada kos hampir dua kali ganda.

Bagaimanakah saya boleh mendapatkan kunci API dan menyediakan akaun pembangunan?

Langkah 1: Daftar dan buat akaun

1. Lawati portal pembangun DeepSeek (dokumen / konsol DeepSeek). Buat akaun dengan e-mel atau pembekal SSO anda.
2. Lengkapkan sebarang semakan identiti atau persediaan pengebilan yang diperlukan oleh portal.

Langkah 2: Buat kunci API

1. Dalam papan pemuka, pergi ke Keys API → Cipta Kunci. Namakan kunci anda (cth, dev-local-01).
2. Salin kunci dan simpannya dalam pengurus rahsia yang selamat (lihat amalan terbaik pengeluaran di bawah).

Petua: Sesetengah get laluan dan penghala pihak ketiga (cth, CometAPI) membenarkan anda menggunakan kunci get laluan tunggal untuk mengakses model DeepSeek melaluinya — yang berguna untuk redundansi berbilang penyedia (lihat API DeepSeek V3.1 bahagian).

Bagaimanakah cara saya menyediakan persekitaran pembangunan saya (Linux/macOS/Windows)?

Ini ialah persediaan mudah dan boleh dihasilkan semula untuk Python dan Node.js yang berfungsi untuk DeepSeek (titik akhir serasi OpenAI), CometAPI dan Anthropic.

Prasyarat

• Python 3.10+ (disyorkan), pip, virtualenv.
• Node.js 18+ dan npm/yarn.
• curl (untuk ujian cepat).

Persekitaran Python (langkah demi langkah)

1. Buat dir projek:

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

# .venv\Scripts\activate    # Windows PowerShell

2. Pasang pakej minimum:

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

pip install openai

3. Simpan kunci API anda kepada pembolehubah persekitaran (jangan sekali-kali melakukan):

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

(Penggunaan Windows PowerShell $env:DEEPSEEK_KEY = "…")

Persekitaran nod (langkah demi langkah)

1. Permulaan:

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

2. Mewujudkan .env fail:

DEEPSEEK_KEY=sk_live_xxx
CometAPI_KEY=or_xxx
ANTHROPIC_KEY=anthropic_xxx

Bagaimanakah cara saya menghubungi DeepSeek-V3.1 secara terus — contoh kod langkah demi langkah?

API DeepSeek adalah serasi OpenAI. Di bawah adalah Salin tampal contoh: curl, Python (permintaan dan gaya SDK openai), dan Node.

Langkah 1: Contoh curl mudah

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

Nota: reasoning_enabled togol mod Fikir (bendera vendor). Nama bendera yang tepat boleh berbeza mengikut pembekal — semak dokumen model.

Langkah 2: Python (permintaan) dengan telemetri mudah

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: Akses Percuma Sepenuhnya kepada DeepSeek V3.1

Bagi pembangun yang mencari akses segera tanpa pendaftaran, CometAPI menawarkan alternatif yang menarik kepada DeepSeek V3.1(Nama model: deepseek-v3-1-250821; deepseek-v3.1). Perkhidmatan get laluan ini mengagregatkan berbilang model AI melalui API bersatu, menyediakan akses kepada DeepSeek dan menawarkan faedah lain, termasuk failover automatik, analitis penggunaan dan pengebilan merentas penyedia yang dipermudahkan.

Mula-mula, buat akaun CometAPI di https://www.cometapi.com/—keseluruhan proses hanya mengambil masa dua minit dan hanya memerlukan pengesahan alamat e-mel. Setelah log masuk, jana kunci baharu dalam bahagian "Kunci API". https://www.cometapi.com/ menawarkan kredit percuma untuk akaun baharu dan diskaun 20% pada harga API rasmi.

Pelaksanaan teknikal memerlukan perubahan kod yang minimum. Cuma tukar titik akhir API anda daripada URL DeepSeek terus kepada get laluan CometAPI.

Nota: API menyokong penstriman (stream: true), max_tokens, suhu, jujukan berhenti dan ciri panggilan fungsi yang serupa dengan API serasi OpenAI yang lain.

Bagaimanakah saya boleh menghubungi DeepSeek menggunakan SDK Anthropic?

DeepSeek menyediakan titik akhir yang serasi dengan Anthropic supaya anda boleh menggunakan semula alat Anthropc SDK atau Claude Code dengan menghalakan SDK ke https://api.deepseek.com/anthropic dan menetapkan nama model kepada deepseek-chat (Atau deepseek-reasoner di mana disokong).

Gunakan Model DeepSeek melalui API Anthropic

Pasang Anthropic SDK: pip install anthropic. Konfigurasikan persekitaran anda:

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

Buat mesej:

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)

Gunakan DeepSeek dalam Kod Claude

Pasang : npm install -g @anthropic-ai/claude-code. Konfigurasikan persekitaran anda:

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

Masukkan Direktori Projek dan Jalankan Kod Claude:

cd my-project  
claude

Gunakan DeepSeek dalam Kod Claude melalui CometAPI

CometAPI menyokong Kod Claude. Selepas pemasangan, apabila mengkonfigurasi persekitaran, cuma gantikan URL asas dengan https://www.cometapi.com/console/ dan kunci dengan Kunci CometAPI untuk menggunakan model DeepSeek CometAPI dalam Kod Claude.

# 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

Nota:

• DeepSeek memetakan nama model Anthropic yang tidak disokong deepseek-chat.
• Lapisan keserasian Anthropic menyokong system, messages, temperature, penstriman, urutan hentikan dan tatasusunan pemikiran.

Apakah konkrit, amalan terbaik pengeluaran (keselamatan, kos, kebolehpercayaan)?

Di bawah ialah corak pengeluaran yang disyorkan yang digunakan untuk DeepSeek atau sebarang penggunaan LLM volum tinggi.

Rahsia & identiti

• Simpan kunci API dalam pengurus rahsia (jangan gunakan .env dalam prod). Putar kekunci dengan kerap dan buat kunci setiap perkhidmatan dengan keistimewaan yang paling sedikit.
• Gunakan projek/akaun berasingan untuk dev/staging/prod.

Had kadar & cuba semula

• Melaksanakan mundur eksponen pada HTTP 429/5xx dengan jitter. Hadkan percubaan cuba semula (cth, 3 percubaan).
• Gunakan kunci idempotensi untuk permintaan yang mungkin berulang.

Contoh Python — cuba semula dengan mundur

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

Pengurusan kos

• Hadkan max_tokens dan elakkan meminta output yang besar secara tidak sengaja.
• Jawapan model cache di mana sesuai (terutama untuk gesaan berulang). DeepSeek secara eksplisit membezakan cache hit vs miss dalam harga — caching menjimatkan wang.
• Penggunaan deepseek-chat untuk balasan kecil rutin; simpanan deepseek-reasoner untuk kes yang benar-benar memerlukan CoT (lebih mahal).

Kebolehlihatan & pembalakan

• Log metadata sahaja tentang permintaan dalam teks biasa (cincang segera, kiraan token, kependaman). Elakkan daripada mengelog data pengguna penuh atau kandungan sensitif. Simpan ID permintaan/tindak balas untuk sokongan dan penyelarasan pengebilan.
• Jejaki penggunaan token setiap permintaan dan dedahkan belanjawan/makluman tentang kos.

Kawalan keselamatan & halusinasi

• Penggunaan output alat dan pengesah deterministik untuk apa-apa perkara yang kritikal keselamatan (kewangan, undang-undang, perubatan).
• Untuk output berstruktur, gunakan response_format+Skema JSON dan sahkan output sebelum mengambil tindakan yang tidak dapat dipulihkan.

Corak penyebaran

• Jalankan panggilan model daripada proses pekerja khusus untuk mengawal serentak dan beratur.
• Muatkan tugas berat kepada pekerja async (Saderi, tugas Fargate, kerja Cloud Run) dan balas kepada pengguna dengan penunjuk kemajuan.
• Untuk keperluan kependaman/penghasilan yang melampau pertimbangkan SLA pembekal dan sama ada untuk mengehos sendiri atau menggunakan pemecut pembekal.

Nota penutup

DeepSeek-V3.1 ialah model hibrid pragmatik yang direka untuk kedua-dua sembang pantas dan tugas agen yang kompleks. Bentuk API serasi OpenAI menjadikan pemindahan mudah untuk banyak projek, manakala lapisan keserasian Anthropic dan CometAPI menjadikannya fleksibel untuk ekosistem sedia ada. Penanda aras dan laporan komuniti menunjukkan pertukaran kos/prestasi yang menjanjikan — tetapi seperti mana-mana model baharu, sahkannya pada beban kerja dunia sebenar anda (gesan, panggilan fungsi, semakan keselamatan, kependaman) sebelum pelancaran pengeluaran penuh.

Pada CometAPI, anda boleh menjalankannya dengan selamat dan berinteraksi dengannya melalui API serasi OpenAI atau mesra pengguna taman permainan, tanpa had kadar.

👉 Gunakan DeepSeek-V3.1 di CometAPI sekarang!

Mengapa menggunakan CometAPI?

• Pemultipleksan pembekal: tukar pembekal tanpa penulisan semula kod.
• Pengebilan/metrik bersatu: jika anda mengarahkan berbilang model melalui CometAPI, anda mendapat satu permukaan penyepaduan.
• Metadata model: lihat panjang konteks dan parameter aktif bagi setiap varian model.