Cara Menggunakan API DeepSeek-V3.1 — tutorial pengembang praktis

DeepSeek-V3.1 adalah model penalaran hibrida terbaru dari DeepSeek yang mendukung mode obrolan "non-berpikir" yang cepat dan mode "berpikir/bernalar" yang lebih deliberatif, menawarkan konteks yang panjang (hingga 128K), keluaran terstruktur, dan pemanggilan fungsi, serta dapat diakses langsung melalui API DeepSeek yang kompatibel dengan OpenAI, melalui titik akhir yang kompatibel dengan Anthropic, atau melalui CometAPI. Di bawah ini saya akan menjelaskan apa itu model, tolok ukur dan sorotan biaya, fitur-fitur lanjutan (pemanggilan fungsi, keluaran JSON, mode penalaran), kemudian memberikan contoh kode ujung ke ujung yang konkret: panggilan REST DeepSeek langsung (curl/Node/Python), penggunaan klien Anthropic, dan pemanggilan melalui CometAPI.

Apa itu DeepSeek-V3.1 dan apa yang baru dalam rilis ini?

DeepSeek-V3.1 adalah rilis terbaru dalam keluarga DeepSeek V3: lini model bahasa besar berkapasitas tinggi, campuran para ahli yang mengirimkan desain inferensi hibrida dengan dua “mode” operasional — cepat obrolan tanpa berpikir modus dan a berpikir / bernalar Mode yang dapat mengekspos jejak gaya rantai pemikiran untuk tugas penalaran yang lebih sulit dan penggunaan agen/alat. Rilis ini menekankan latensi "berpikir" yang lebih cepat, peningkatan kapabilitas alat/agen, dan penanganan konteks yang lebih lama untuk alur kerja berskala dokumen.

Hal-hal praktis yang dapat diambil:

• Dua mode operasi: deepseek-chat untuk throughput dan biaya, deepseek-reasoner (model penalaran) ketika Anda menginginkan jejak rantai pemikiran atau kesetiaan penalaran yang lebih tinggi.
• Peningkatan penanganan agen/alat dan perbaikan tokenizer/konteks untuk dokumen panjang.
• Panjang konteks: hingga ~128K token (mengaktifkan dokumen panjang, basis kode, log).

Terobosan Tolok Ukur

DeepSeek-V3.1 menunjukkan peningkatan signifikan dalam tantangan pengkodean di dunia nyata. Dalam evaluasi SWE-bench Verified, yang mengukur seberapa sering model memperbaiki masalah GitHub untuk memastikan pengujian unit berhasil, V3.1 mencapai tingkat keberhasilan 66%, dibandingkan dengan 45% untuk V3-0324 dan R1. Dalam versi multibahasa, V3.1 menyelesaikan 54.5% masalah, hampir dua kali lipat tingkat keberhasilan versi lainnya yang sekitar 30%. Dalam evaluasi Terminal-Bench, yang menguji apakah model dapat berhasil menyelesaikan tugas di lingkungan Linux langsung, DeepSeek-V3.1 berhasil dalam 31% tugas, dibandingkan dengan 13% dan 6% untuk versi lainnya. Peningkatan ini menunjukkan bahwa DeepSeek-V3.1 lebih andal dalam mengeksekusi kode dan beroperasi di lingkungan alat dunia nyata.

Benchmark pencarian informasi juga mengungguli DeepSeek-V3.1 dalam penelusuran, pencarian, dan tanya jawab. Dalam evaluasi BrowseComp, yang mengharuskan navigasi dan ekstraksi jawaban dari halaman web, V3.1 menjawab 30% pertanyaan dengan benar, dibandingkan dengan 9% untuk R1. Dalam versi bahasa Mandarin, DeepSeek-V3.1 mencapai akurasi 49%, dibandingkan dengan 36% untuk R1. Pada Ujian Bahasa Keras (HLE), V3.1 sedikit mengungguli R1, dengan akurasi masing-masing 30% hingga 25%. Pada tugas pencarian mendalam seperti xbench-DeepSearch, yang mengharuskan sintesis informasi dari berbagai sumber, V3.1 memperoleh skor 71%, sementara R1 hanya 55%. DeepSeek-V3.1 juga menunjukkan keunggulan yang kecil namun konsisten pada benchmark seperti (penalaran terstruktur), SimpleQA (jawaban pertanyaan faktual), dan Seal0 (jawaban pertanyaan spesifik domain). Secara keseluruhan, V3.1 secara signifikan mengungguli R1 dalam pencarian informasi dan menjawab pertanyaan ringan.

Dalam hal efisiensi penalaran, hasil penggunaan token menunjukkan efektivitasnya. Pada AIME 2025 (ujian matematika yang sulit), V3.1-Think mencapai akurasi yang sebanding atau sedikit melebihi R1 (88.4% versus 87.5%), tetapi menggunakan token sekitar 30% lebih sedikit. Pada GPQA Diamond (ujian pascasarjana multi-domain), kedua model hampir seimbang (80.1% vs. 81.0%), tetapi V3.1 menggunakan hampir setengah token yang digunakan R1. Pada uji tolok ukur LiveCodeBench, yang menilai penalaran kode, V3.1 tidak hanya lebih akurat (74.8% vs. 73.3%) tetapi juga lebih ringkas. Hal ini menunjukkan bahwa V3.1-Think mampu memberikan penalaran yang detail sekaligus menghindari verbositas.

Secara keseluruhan, V3.1 menunjukkan lompatan generasi yang signifikan dibandingkan dengan V3-0324. Dibandingkan dengan R1, V3.1 mencapai akurasi yang lebih tinggi di hampir setiap benchmark dan lebih efektif pada tugas penalaran yang berat. Satu-satunya benchmark yang cocok dengan R1 adalah GPQA, tetapi dengan biaya yang hampir dua kali lipat.

Bagaimana cara memperoleh kunci API dan menyiapkan akun pengembangan?

Langkah 1: Daftar dan buat akun

1. Kunjungi portal pengembang DeepSeek (dokumen/konsol DeepSeek). Buat akun dengan penyedia email atau SSO Anda.
2. Selesaikan pemeriksaan identitas atau pengaturan penagihan yang diperlukan oleh portal.

Langkah 2: Buat kunci API

1. Di dasbor, buka Keys API → Buat Kunci. Beri nama kunci Anda (misalnya, dev-local-01).
2. Salin kuncinya dan simpan dalam pengelola rahasia yang aman (lihat praktik terbaik produksi di bawah).

Tip: Beberapa gateway dan router pihak ketiga (misalnya, CometAPI) memungkinkan Anda menggunakan satu kunci gateway untuk mengakses model DeepSeek melalui mereka — hal ini berguna untuk redundansi multi-penyedia (lihat API DeepSeek V3.1 bagian).

Bagaimana cara mengatur lingkungan pengembangan saya (Linux/macOS/Windows)?

Ini adalah pengaturan yang sederhana dan dapat direproduksi untuk Python dan Node.js yang berfungsi untuk DeepSeek (titik akhir yang kompatibel dengan OpenAI), CometAPI, dan Anthropic.

Prasyarat

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

Lingkungan Python (langkah demi langkah)

1. Buat direktori proyek:

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

# .venv\Scripts\activate    # Windows PowerShell

2. Instal paket minimal:

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 ke variabel lingkungan (jangan pernah komit):

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

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

Lingkungan Node (langkah demi langkah)

1. Inisialisasi:

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

2. Membuat .env File:

DEEPSEEK_KEY=sk_live_xxx
CometAPI_KEY=or_xxx
ANTHROPIC_KEY=anthropic_xxx

Bagaimana cara memanggil DeepSeek-V3.1 secara langsung — contoh kode langkah demi langkah?

API DeepSeek kompatibel dengan OpenAI. Berikut ini adalah salin-tempel contoh: curl, Python (permintaan dan gaya SDK openai), dan Node.js.

Langkah 1: Contoh ikal sederhana

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

Catatan: reasoning_enabled Mengaktifkan mode Think (bendera vendor). Nama bendera yang tepat dapat bervariasi tergantung penyedia — periksa dokumen model.

Langkah 2: Python (permintaan) dengan telemetri sederhana

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 Sepenuhnya Gratis ke DeepSeek V3.1

Bagi pengembang yang menginginkan akses langsung tanpa registrasi, CometAPI menawarkan alternatif yang menarik untuk DeepSeek V3.1 (Nama model: deepseek-v3-1-250821; deepseek-v3.1). Layanan gateway ini menggabungkan beberapa model AI melalui API terpadu, menyediakan akses ke DeepSeek dan menawarkan manfaat lainnya, termasuk failover otomatis, analitik penggunaan, dan penagihan lintas penyedia yang disederhanakan.

Pertama, buat akun CometAPI di https://www.cometapi.com/—Seluruh proses hanya membutuhkan dua menit dan hanya memerlukan verifikasi alamat email. Setelah masuk, buat kunci baru di bagian "Kunci API". https://www.cometapi.com/ menawarkan kredit gratis untuk akun baru dan diskon 20% dari harga API resmi.

Implementasi teknis hanya memerlukan sedikit perubahan kode. Cukup ubah titik akhir API Anda dari URL DeepSeek langsung ke gateway CometAPI.

Catatan: API mendukung streaming (stream: true), max_tokens, suhu, urutan penghentian, dan fitur pemanggilan fungsi yang serupa dengan API lain yang kompatibel dengan OpenAI.

Bagaimana saya dapat memanggil DeepSeek menggunakan SDK Antropik?

DeepSeek menyediakan titik akhir yang kompatibel dengan Anthropic sehingga Anda dapat menggunakan kembali SDK Anthropc atau perkakas Claude Code dengan mengarahkan SDK ke https://api.deepseek.com/anthropic dan mengatur nama model ke deepseek-chat (Atau deepseek-reasoner jika didukung).

Memanggil Model DeepSeek melalui API Antropik

Instal SDK Antropik: pip install antropik. Konfigurasikan lingkungan Anda:

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

Buat pesan:

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 di Claude Code

Instal: npm install -g @anthropic-ai/claude-code. Konfigurasikan lingkungan 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

Masuk ke Direktori Proyek, dan Jalankan Kode Claude:

cd my-project  
claude

Gunakan DeepSeek di Claude Code melalui CometAPI

CometAPI mendukung Claude Code. Setelah instalasi, saat mengonfigurasi lingkungan, cukup ganti URL dasar dengan https://www.cometapi.com/console/ dan kuncinya dengan Kunci CometAPI untuk menggunakan model DeepSeek CometAPI di 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

Catatan:

• DeepSeek memetakan nama model Antropik yang tidak didukung ke deepseek-chat.
• Lapisan kompatibilitas Antropik mendukung system, messages, temperature, streaming, urutan henti, dan susunan berpikir.

Apa praktik produksi terbaik yang konkret (keamanan, biaya, keandalan)?

Berikut adalah pola produksi yang direkomendasikan yang berlaku untuk DeepSeek atau penggunaan LLM bervolume tinggi.

Rahasia & identitas

• Simpan kunci API di manajer rahasia (jangan gunakan .env dalam prod). Putar kunci secara berkala dan buat kunci per layanan dengan hak istimewa paling sedikit.
• Gunakan proyek/akun terpisah untuk dev/staging/prod.

Batasan kecepatan & percobaan ulang

• Implementasi VE kemunduran eksponensial pada HTTP 429/5xx dengan jitter. Batasi upaya percobaan ulang (misalnya, 3 kali percobaan).
• Gunakan kunci idempotensi untuk permintaan yang mungkin diulang.

Contoh Python — coba lagi 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")

Manajemen biaya

• batas max_tokens dan hindari permintaan output yang besar secara tidak sengaja.
• Respons model cache jika sesuai (terutama untuk permintaan berulang). DeepSeek secara eksplisit membedakan cache hit vs miss dalam penetapan harga — caching menghemat biaya.
• penggunaan deepseek-chat untuk balasan kecil rutin; cadangan deepseek-reasoner untuk kasus yang benar-benar membutuhkan CoT (biayanya lebih mahal).

Observabilitas & pencatatan

• Catat hanya metadata permintaan dalam bentuk teks biasa (hash prompt, jumlah token, latensi). Hindari pencatatan data pengguna lengkap atau konten sensitif. Simpan ID permintaan/respons untuk rekonsiliasi dukungan dan penagihan.
• Melacak penggunaan token per permintaan dan memaparkan penganggaran/peringatan mengenai biaya.

Kontrol keselamatan & halusinasi

• penggunaan keluaran alat dan validator deterministik untuk apa pun yang menyangkut keselamatan (keuangan, hukum, medis).
• Untuk keluaran terstruktur, gunakan response_format+skema JSON dan validasi keluaran sebelum mengambil tindakan yang tidak dapat dibatalkan.

Pola penyebaran

• Jalankan panggilan model dari proses pekerja khusus untuk mengontrol konkurensi dan antrean.
• Memindahkan pekerjaan berat ke pekerja asinkron (tugas Celery, Fargate, pekerjaan Cloud Run) dan menanggapi pengguna dengan indikator kemajuan.
• Untuk kebutuhan latensi/throughput yang ekstrem, pertimbangkan SLA penyedia dan apakah akan melakukan hosting sendiri atau menggunakan akselerator penyedia.

Catatan penutup

DeepSeek-V3.1 adalah model hibrida pragmatis yang dirancang untuk obrolan cepat dan tugas agen yang kompleks. Bentuk API-nya yang kompatibel dengan OpenAI memudahkan migrasi untuk banyak proyek, sementara lapisan kompatibilitas Anthropic dan CometAPI membuatnya fleksibel untuk ekosistem yang ada. Tolok ukur dan laporan komunitas menunjukkan tradeoff biaya/kinerja yang menjanjikan — tetapi seperti halnya model baru lainnya, validasi model ini pada beban kerja Anda di dunia nyata (prompting, pemanggilan fungsi, pemeriksaan keamanan, latensi) sebelum peluncuran produksi penuh.

Di CometAPI, Anda dapat menjalankannya dengan aman dan berinteraksi dengannya melalui API yang kompatibel dengan OpenAI atau ramah pengguna tempat bermain, tanpa batas kecepatan.

👉 Deploy DeepSeek-V3.1 di CometAPI sekarang!

Mengapa menggunakan CometAPI?

• Multiplexing penyedia: ganti penyedia tanpa penulisan ulang kode.
• Penagihan/metrik terpadu: jika Anda merutekan beberapa model melalui CometAPI, Anda mendapatkan permukaan integrasi tunggal.
• Metadata model: melihat panjang konteks dan parameter aktif per varian model.