Panduan Lengkap DeepSeek API: Model AI Berperforma Tinggi dengan Biaya Terjangkau
Penulis: Ruby Abdullah Tanggal: 14 Oktober 2026Introduction
DeepSeek adalah perusahaan AI asal Tiongkok yang telah mencuri perhatian dunia teknologi dengan merilis model-model bahasa besar (LLM) yang performanya setara, bahkan dalam beberapa benchmark melampaui, model-model premium seperti GPT-4 dan Claude. Yang lebih menarik lagi, DeepSeek menawarkan API dengan harga yang jauh lebih terjangkau dibandingkan kompetitor.
Dalam tutorial ini, kita akan membahas secara menyeluruh cara menggunakan DeepSeek API, mulai dari instalasi dasar hingga fitur-fitur lanjutan seperti function calling, JSON mode, kemampuan multimodal, dan reasoning dengan DeepSeek-R1. Tutorial ini ditulis dengan pendekatan praktis dan hands-on, sehingga Anda bisa langsung mencoba setiap contoh kode yang diberikan.
Mengapa DeepSeek API?
Ada beberapa alasan kuat mengapa DeepSeek API layak dipertimbangkan untuk proyek AI Anda:
Model yang Tersedia
DeepSeek menyediakan dua model utama melalui API:
- deepseek-chat (DeepSeek-V3): Model general-purpose yang sangat capable untuk berbagai tugas, mulai dari penulisan, coding, analisis data, hingga percakapan. Model ini adalah pilihan utama untuk sebagian besar use case.
- deepseek-reasoner (DeepSeek-R1): Model khusus yang dioptimalkan untuk penalaran kompleks (reasoning). DeepSeek-R1 menggunakan chain-of-thought reasoning secara internal sebelum memberikan jawaban akhir, membuatnya sangat kuat untuk masalah matematika, logika, dan coding yang kompleks.
Instalasi & Setup
Persyaratan
Sebelum memulai, pastikan Anda memiliki:
- Python 3.8 atau lebih baru terinstal di sistem Anda
- Akun DeepSeek dan API key (daftar di platform.deepseek.com)
- Koneksi internet yang stabil
Instalasi OpenAI SDK
Karena DeepSeek API kompatibel dengan format OpenAI, kita akan menggunakan library openai untuk Python. Instal dengan pip:
pip install openai
Jika Anda juga ingin menggunakan fitur async, pastikan library sudah mendukungnya (versi 1.0 ke atas sudah mendukung async secara default).
Mendapatkan API Key
Konfigurasi Environment Variable
Simpan API key Anda sebagai environment variable agar tidak ter-expose di kode:
# Linux/macOS
export DEEPSEEKAPIKEY="sk-xxxxxxxxxxxxxxxxxxxxxxxx"
Windows (PowerShell)
$env:DEEPSEEKAPIKEY="sk-xxxxxxxxxxxxxxxxxxxxxxxx"
Untuk penggunaan permanen, tambahkan ke file .bashrc, .zshrc, atau buat file .env:
# File: .env
DEEPSEEKAPIKEY=sk-xxxxxxxxxxxxxxxxxxxxxxxx
Inisialisasi Client
Berikut cara menginisialisasi client DeepSeek menggunakan OpenAI SDK:
from openai import OpenAI
import os
client = OpenAI(
apikey=os.getenv("DEEPSEEKAPIKEY"),
baseurl="https://api.deepseek.com"
)
Perhatikan bahwa satu-satunya perbedaan dengan konfigurasi OpenAI standar adalah parameter baseurl yang diarahkan ke https://api.deepseek.com. Ini yang membuat migrasi dari OpenAI ke DeepSeek sangat mudah.
Basic Usage
Chat Completion
Penggunaan paling dasar dari DeepSeek API adalah chat completion. Berikut contoh sederhana:
from openai import OpenAI
import os
client = OpenAI(
apikey=os.getenv("DEEPSEEKAPIKEY"),
baseurl="https://api.deepseek.com"
)
response = client.chat.completions.create(
model="deepseek-chat",
messages=[
{"role": "system", "content": "Kamu adalah asisten AI yang membantu dan ramah. Jawab dalam bahasa Indonesia."},
{"role": "user", "content": "Jelaskan apa itu machine learning dalam 3 paragraf."}
],
temperature=0.7,
maxtokens=1024
)
print(response.choices[0].message.content)
Parameter yang tersedia pada chat completion:
- model: Model yang digunakan (
deepseek-chatataudeepseek-reasoner) - messages: Daftar pesan dalam format chat (system, user, assistant)
- temperature: Mengontrol kreativitas output (0.0 = deterministik, 1.0 = lebih kreatif). Default: 1.0
- maxtokens: Batas maksimum token yang dihasilkan
- topp: Nucleus sampling, alternatif dari temperature
- frequencypenalty: Mengurangi pengulangan kata (-2.0 hingga 2.0)
- presencepenalty: Mendorong topik baru (-2.0 hingga 2.0)
- stop: Daftar string yang menghentikan generasi
Multi-turn Conversation
Untuk percakapan multi-turn, Anda perlu menyertakan riwayat percakapan sebelumnya:
from openai import OpenAI
import os
client = OpenAI(
apikey=os.getenv("DEEPSEEKAPIKEY"),
baseurl="https://api.deepseek.com"
)
messages = [
{"role": "system", "content": "Kamu adalah tutor programming yang sabar dan detail."},
{"role": "user", "content": "Apa itu list comprehension di Python?"},
]
Turn pertama
response = client.chat.completions.create(
model="deepseek-chat",
messages=messages,
temperature=0.7
)
assistantreply = response.choices[0].message.content
print("Assistant:", assistantreply)
Tambahkan jawaban assistant ke riwayat
messages.append({"role": "assistant", "content": assistantreply})
Turn kedua
messages.append({"role": "user", "content": "Berikan contoh list comprehension dengan kondisi filter."})
response = client.chat.completions.create(
model="deepseek-chat",
messages=messages,
temperature=0.7
)
print("Assistant:", response.choices[0].message.content)
Streaming
Streaming memungkinkan Anda menerima respons secara bertahap (token per token), memberikan pengalaman yang lebih responsif bagi pengguna. Ini sangat berguna untuk aplikasi chat real-time:
from openai import OpenAI
import os
client = OpenAI(
apikey=os.getenv("DEEPSEEKAPIKEY"),
baseurl="https://api.deepseek.com"
)
stream = client.chat.completions.create(
model="deepseek-chat",
messages=[
{"role": "system", "content": "Kamu adalah penulis kreatif berbahasa Indonesia."},
{"role": "user", "content": "Tulis sebuah cerita pendek tentang robot yang belajar memasak."}
],
temperature=0.8,
maxtokens=2048,
stream=True
)
print("Respons streaming:")
fullresponse = ""
for chunk in stream:
if chunk.choices[0].delta.content is not None:
content = chunk.choices[0].delta.content
print(content, end="", flush=True)
fullresponse += content
print("\n\nSelesai!")
print(f"Total karakter: {len(fullresponse)}")
Async Streaming
Untuk aplikasi yang membutuhkan performa lebih baik, Anda bisa menggunakan async client:
import asyncio
from openai import AsyncOpenAI
import os
client = AsyncOpenAI(
apikey=os.getenv("DEEPSEEKAPIKEY"),
baseurl="https://api.deepseek.com"
)
async def chatstreaming():
stream = await client.chat.completions.create(
model="deepseek-chat",
messages=[
{"role": "user", "content": "Jelaskan konsep async/await dalam Python."}
],
stream=True
)
async for chunk in stream:
if chunk.choices[0].delta.content is not None:
print(chunk.choices[0].delta.content, end="", flush=True)
print()
asyncio.run(chatstreaming())
Advanced Usage
Function Calling
Function calling memungkinkan model untuk memanggil fungsi yang Anda definisikan. Ini sangat berguna untuk membangun AI agent yang bisa berinteraksi dengan sistem eksternal:
from openai import OpenAI
import json
import os
client = OpenAI(
apikey=os.getenv("DEEPSEEKAPIKEY"),
baseurl="https://api.deepseek.com"
)
Definisi tools/functions
tools = [
{
"type": "function",
"function": {
"name": "getweather",
"description": "Mendapatkan informasi cuaca terkini untuk kota tertentu",
"parameters": {
"type": "object",
"properties": {
"city": {
"type": "string",
"description": "Nama kota, misalnya Jakarta, Surabaya"
},
"unit": {
"type": "string",
"enum": ["celsius", "fahrenheit"],
"description": "Satuan temperatur"
}
},
"required": ["city"]
}
}
},
{
"type": "function",
"function": {
"name": "calculatebmi",
"description": "Menghitung Body Mass Index (BMI)",
"parameters": {
"type": "object",
"properties": {
"weightkg": {
"type": "number",
"description": "Berat badan dalam kilogram"
},
"heightcm": {
"type": "number",
"description": "Tinggi badan dalam sentimeter"
}
},
"required": ["weightkg", "heightcm"]
}
}
}
]
Implementasi fungsi
def getweather(city, unit="celsius"):
# Dalam produksi, ini akan memanggil API cuaca
weatherdata = {
"Jakarta": {"temp": 32, "condition": "Cerah berawan", "humidity": 75},
"Surabaya": {"temp": 34, "condition": "Cerah", "humidity": 65},
"Bandung": {"temp": 24, "condition": "Berawan", "humidity": 80},
}
data = weatherdata.get(city, {"temp": 28, "condition": "Tidak diketahui", "humidity": 70})
return json.dumps({"city": city, "temperature": data["temp"], "unit": unit,
"condition": data["condition"], "humidity": data["humidity"]})
def calculatebmi(weightkg, heightcm):
heightm = heightcm / 100
bmi = weightkg / (heightm 2)
if bmi < 18.5:
category = "Berat badan kurang"
elif bmi < 25:
category = "Normal"
elif bmi < 30:
category = "Berat badan berlebih"
else:
category = "Obesitas"
return json.dumps({"bmi": round(bmi, 1), "category": category})
Kirim request dengan tools
messages = [
{"role": "user", "content": "Bagaimana cuaca di Jakarta hari ini?"}
]
response = client.chat.completions.create(
model="deepseek-chat",
messages=messages,
tools=tools,
toolchoice="auto"
)
Proses tool calls
responsemessage = response.choices[0].message
if responsemessage.toolcalls:
messages.append(responsemessage)
for toolcall in responsemessage.toolcalls:
functionname = toolcall.function.name
functionargs = json.loads(toolcall.function.arguments)
# Panggil fungsi yang sesuai
if functionname == "getweather":
result = getweather(functionargs)
elif functionname == "calculatebmi":
result = calculatebmi(functionargs)
else:
result = json.dumps({"error": "Fungsi tidak ditemukan"})
messages.append({
"toolcallid": toolcall.id,
"role": "tool",
"content": result
})
# Kirim hasil fungsi kembali ke model
finalresponse = client.chat.completions.create(
model="deepseek-chat",
messages=messages
)
print(finalresponse.choices[0].message.content)
else:
print(responsemessage.content)
JSON Mode
JSON mode memastikan output model selalu dalam format JSON yang valid. Ini sangat berguna ketika Anda perlu mengolah output secara programatis:
from openai import OpenAI
import json
import os
client = OpenAI(
apikey=os.getenv("DEEPSEEKAPIKEY"),
baseurl="https://api.deepseek.com"
)
response = client.chat.completions.create(
model="deepseek-chat",
messages=[
{"role": "system", "content": "Kamu adalah API yang mengembalikan data dalam format JSON."},
{"role": "user", "content": """Analisis sentimen dari review berikut dan kembalikan dalam format JSON
dengan field: text, sentiment (positive/negative/neutral), confidence (0-1), keywords (array).
Review: "Makanan di restoran ini sangat enak dan pelayanannya ramah.
Sayangnya harganya agak mahal untuk porsi yang diberikan.
Tapi overall saya cukup puas dan akan kembali lagi."
"""}
],
responseformat={"type": "jsonobject"},
temperature=0.3
)
result = json.loads(response.choices[0].message.content)
print(json.dumps(result, indent=2, ensureascii=False))
Contoh penggunaan JSON mode untuk ekstraksi data terstruktur:
from openai import OpenAI
import json
import os
client = OpenAI(
apikey=os.getenv("DEEPSEEKAPIKEY"),
baseurl="https://api.deepseek.com"
)
invoicetext = """
INVOICE #001
Tanggal: 15 Oktober 2026
Dari: PT ABC Teknologi
Kepada: PT XYZ Indonesia
Item:
Jasa konsultasi AI - 10 jam x Rp 2.000.000 = Rp 20.000.000
Development chatbot - 1 unit = Rp 50.000.000
Training karyawan - 2 sesi x Rp 5.000.000 = Rp 10.000.000
Subtotal: Rp 80.000.000
PPN 11%: Rp 8.800.000
Total: Rp 88.800.000
"""
response = client.chat.completions.create(
model="deepseek-chat",
messages=[
{"role": "system", "content": """Ekstrak data dari invoice ke format JSON dengan struktur:
{
"invoicenumber": string,
"date": string,
"from": string,
"to": string,
"items": [{"description": string, "quantity": number, "unitprice": number, "total": number}],
"subtotal": number,
"taxrate": number,
"taxamount": number,
"grandtotal": number
}"""},
{"role": "user", "content": invoicetext}
],
responseformat={"type": "jsonobject"},
temperature=0
)
invoicedata = json.loads(response.choices[0].message.content)
print(json.dumps(invoicedata, indent=2, ensureascii=False))
Vision / Multimodal
DeepSeek juga mendukung input gambar (multimodal). Anda dapat mengirim gambar bersama teks untuk analisis visual:
from openai import OpenAI
import base64
import os
client = OpenAI(
apikey=os.getenv("DEEPSEEKAPIKEY"),
baseurl="https://api.deepseek.com"
)
Metode 1: Menggunakan URL gambar
response = client.chat.completions.create(
model="deepseek-chat",
messages=[
{
"role": "user",
"content": [
{"type": "text", "text": "Jelaskan apa yang ada di gambar ini dalam bahasa Indonesia."},
{
"type": "imageurl",
"imageurl": {
"url": "https://example.com/gambar-arsitektur.png"
}
}
]
}
],
maxtokens=1024
)
print(response.choices[0].message.content)
Metode 2: Menggunakan base64 encoded image
def analyzelocalimage(imagepath, prompt):
with open(imagepath, "rb") as f:
imagedata = base64.b64encode(f.read()).decode("utf-8")
# Deteksi tipe file
ext = imagepath.lower().split(".")[-1]
mimetypes = {"png": "image/png", "jpg": "image/jpeg", "jpeg": "image/jpeg",
"gif": "image/gif", "webp": "image/webp"}
mimetype = mimetypes.get(ext, "image/png")
response = client.chat.completions.create(
model="deepseek-chat",
messages=[
{
"role": "user",
"content": [
{"type": "text", "text": prompt},
{
"type": "imageurl",
"imageurl": {
"url": f"data:{mimetype};base64,{imagedata}"
}
}
]
}
],
maxtokens=1024
)
return response.choices[0].message.content
Contoh penggunaan
result = analyzelocalimage("diagram.png", "Jelaskan diagram arsitektur ini.")
print(result)
Reasoning dengan DeepSeek-R1
DeepSeek-R1 (model deepseek-reasoner) adalah model yang dioptimalkan untuk penalaran kompleks. Model ini menggunakan chain-of-thought reasoning secara internal, dan Anda bisa melihat proses berpikirnya melalui field reasoningcontent:
from openai import OpenAI
import os
client = OpenAI(
apikey=os.getenv("DEEPSEEKAPIKEY"),
baseurl="https://api.deepseek.com"
)
response = client.chat.completions.create(
model="deepseek-reasoner",
messages=[
{"role": "user", "content": """Sebuah perusahaan memiliki 3 mesin produksi.
Mesin A menghasilkan 40% produk dengan tingkat cacat 2%.
Mesin B menghasilkan 35% produk dengan tingkat cacat 3%.
Mesin C menghasilkan 25% produk dengan tingkat cacat 5%.
Jika sebuah produk dipilih secara acak dan ternyata cacat,
berapa probabilitas produk tersebut berasal dari Mesin B?
Gunakan Teorema Bayes untuk menyelesaikannya."""}
]
)
Lihat proses reasoning (chain of thought)
if hasattr(response.choices[0].message, "reasoningcontent") and response.choices[0].message.reasoningcontent:
print("=== Proses Reasoning ===")
print(response.choices[0].message.reasoningcontent)
print()
Jawaban akhir
print("=== Jawaban Akhir ===")
print(response.choices[0].message.content)
Contoh penggunaan DeepSeek-R1 untuk masalah coding yang kompleks:
from openai import OpenAI
import os
client = OpenAI(
apikey=os.getenv("DEEPSEEKAPIKEY"),
baseurl="https://api.deepseek.com"
)
response = client.chat.completions.create(
model="deepseek-reasoner",
messages=[
{"role": "user", "content": """Implementasikan algoritma Dijkstra dalam Python
untuk mencari jalur terpendek dalam graph berbobot.
Jelaskan kompleksitas waktu dan ruangnya,
serta berikan contoh penggunaan dengan graph yang memiliki minimal 6 node."""}
]
)
print(response.choices[0].message.content)
Catatan penting tentang DeepSeek-R1:
- Model ini membutuhkan waktu respons yang lebih lama karena proses reasoning internal
- Biaya per token sedikit lebih tinggi dibandingkan deepseek-chat, namun tetap jauh lebih murah dibandingkan model reasoning kompetitor
- Sangat cocok untuk masalah yang membutuhkan penalaran bertahap: matematika, logika, coding kompleks, dan analisis mendalam
- Tidak mendukung system message, jadi masukkan semua instruksi ke user message
Prefix Caching
DeepSeek API mendukung prefix caching secara otomatis. Ketika Anda mengirim request berulang dengan prefix yang sama (misalnya system prompt yang sama), token yang sudah di-cache akan dikenakan biaya lebih murah. Ini sangat bermanfaat untuk aplikasi chatbot di mana system prompt tetap konsisten:
from openai import OpenAI
import os
client = OpenAI(
apikey=os.getenv("DEEPSEEKAPIKEY"),
baseurl="https://api.deepseek.com"
)
SYSTEMPROMPT = """Kamu adalah customer service AI untuk toko online ElektroMart.
Tugas kamu:
Menjawab pertanyaan tentang produk elektronik
Membantu proses pengembalian barang
Memberikan rekomendasi produk berdasarkan kebutuhan pelanggan
Menjelaskan kebijakan garansi dan pengiriman
Aturan:
- Selalu sopan dan profesional
- Jawab dalam bahasa Indonesia
- Jika tidak tahu jawabannya, arahkan ke customer service manusia
- Jangan memberikan informasi harga yang tidak akurat
"""
Request pertama - system prompt akan di-cache
response1 = client.chat.completions.create(
model="deepseek-chat",
messages=[
{"role": "system", "content": SYSTEMPROMPT},
{"role": "user", "content": "Apa kebijakan pengembalian barang?"}
]
)
Request kedua - system prompt sudah di-cache, lebih murah
response2 = client.chat.completions.create(
model="deepseek-chat",
messages=[
{"role": "system", "content": SYSTEMPROMPT},
{"role": "user", "content": "Laptop apa yang cocok untuk mahasiswa?"}
]
)
Cek penggunaan token dan cache hit
print(f"Request 1 - Usage: {response1.usage}")
print(f"Request 2 - Usage: {response2.usage}")
Best Practices
Prompt Engineering untuk DeepSeek
Berikut beberapa tips prompt engineering yang efektif untuk DeepSeek:
1. Gunakan system prompt yang jelas dan spesifik
# Kurang baik
messages = [
{"role": "system", "content": "Kamu adalah asisten."},
{"role": "user", "content": "Bantu saya membuat website."}
]
Lebih baik
messages = [
{"role": "system", "content": """Kamu adalah web developer senior dengan keahlian di:
- Frontend: HTML, CSS, JavaScript, React
- Backend: Python, Node.js
- Database: PostgreSQL, MongoDB
Saat memberikan kode:
Selalu berikan komentar yang jelas
Ikuti best practices dan design patterns
Pertimbangkan aspek keamanan
Berikan penjelasan singkat untuk setiap bagian kode"""},
{"role": "user", "content": "Buatkan landing page responsif untuk startup fintech dengan fitur: hero section, fitur produk, testimonial, dan contact form."}
]
2. Gunakan few-shot examples untuk output yang konsisten
messages = [
{"role": "system", "content": "Kamu adalah sistem klasifikasi tiket support."},
{"role": "user", "content": "Tiket: Aplikasi crash saat login"},
{"role": "assistant", "content": '{"kategori": "bug", "prioritas": "tinggi", "departemen": "engineering"}'},
{"role": "user", "content": "Tiket: Bagaimana cara mengubah password?"},
{"role": "assistant", "content": '{"kategori": "pertanyaan", "prioritas": "rendah", "departemen": "support"}'},
{"role": "user", "content": "Tiket: Fitur export PDF tidak berfungsi sejak update terakhir"}
]
3. Berikan batasan dan format output yang eksplisit
messages = [
{"role": "user", "content": """Rangkum artikel berikut dalam format:
- Judul ringkasan (maksimal 10 kata)
- 3 poin utama (masing-masing 1-2 kalimat)
- Kesimpulan (1 kalimat)
- Kata kunci: 5 kata kunci relevan
Artikel: [isi artikel di sini]"""}
]
Cost Optimization
Mengoptimalkan biaya penggunaan API adalah hal yang penting, terutama untuk aplikasi produksi. Berikut strategi-strategi yang bisa diterapkan:
1. Pilih model yang tepat untuk tugas yang tepat
def choosemodel(taskcomplexity):
"""Pilih model berdasarkan kompleksitas tugas."""
if taskcomplexity == "simple":
# Tugas sederhana: klasifikasi, ekstraksi, format
return "deepseek-chat"
elif taskcomplexity == "complex":
# Tugas kompleks: reasoning, matematika, coding rumit
return "deepseek-reasoner"
else:
return "deepseek-chat"
2. Batasi maxtokens sesuai kebutuhan
# Untuk jawaban singkat (klasifikasi, ya/tidak)
response = client.chat.completions.create(
model="deepseek-chat",
messages=messages,
maxtokens=100 # Batasi token output
)
Untuk konten panjang (artikel, kode)
response = client.chat.completions.create(
model="deepseek-chat",
messages=messages,
maxtokens=4096
)
3. Implementasikan caching di level aplikasi
import hashlib
import json
class ResponseCache:
def init(self):
self.cache = {}
def getcachekey(self, messages, model):
content = json.dumps({"messages": messages, "model": model}, sortkeys=True)
return hashlib.md5(content.encode()).hexdigest()
def get(self, messages, model):
key = self.getcachekey(messages, model)
return self.cache.get(key)
def set(self, messages, model, response):
key = self.getcachekey(messages, model)
self.cache[key] = response
cache = ResponseCache()
def cachedcompletion(client, messages, model="deepseek-chat", kwargs):
cached = cache.get(messages, model)
if cached:
print("Cache hit!")
return cached
response = client.chat.completions.create(
model=model,
messages=messages,
kwargs
)
cache.set(messages, model, response)
return response
4. Kompres context yang panjang
def summarizehistory(client, messages, keeplastn=4):
"""Kompres riwayat chat yang panjang untuk menghemat token."""
if len(messages) <= keeplastn + 1: # +1 untuk system message
return messages
systemmsg = messages[0] if messages[0]["role"] == "system" else None
oldmessages = messages[1:-keeplastn] if systemmsg else messages[:-keeplastn]
recentmessages = messages[-keeplastn:]
# Ringkas percakapan lama
summaryresponse = client.chat.completions.create(
model="deepseek-chat",
messages=[
{"role": "user", "content": f"Ringkas percakapan berikut dalam 2-3 kalimat:\n{json.dumps(oldmessages, ensureascii=False)}"}
],
maxtokens=200
)
summary = summaryresponse.choices[0].message.content
compressed = []
if systemmsg:
compressed.append(systemmsg)
compressed.append({"role": "system", "content": f"Ringkasan percakapan sebelumnya: {summary}"})
compressed.extend(recentmessages)
return compressed
Error Handling
Penanganan error yang baik sangat penting untuk aplikasi produksi:
from openai import OpenAI, APIError, APIConnectionError, RateLimitError, APITimeoutError
import time
import os
client = OpenAI(
apikey=os.getenv("DEEPSEEKAPIKEY"),
baseurl="https://api.deepseek.com"
)
def robustcompletion(messages, model="deepseek-chat", maxretries=3, kwargs):
"""Wrapper yang menangani berbagai error dengan retry logic."""
for attempt in range(maxretries):
try:
response = client.chat.completions.create(
model=model,
messages=messages,
kwargs
)
return response
except RateLimitError as e:
waittime = 2 attempt 5 # Exponential backoff: 5s, 10s, 20s
print(f"Rate limit tercapai. Menunggu {waittime} detik... (percobaan {attempt + 1}/{maxretries})")
time.sleep(waittime)
except APITimeoutError as e:
waittime = 2 attempt 3
print(f"Request timeout. Menunggu {waittime} detik... (percobaan {attempt + 1}/{maxretries})")
time.sleep(waittime)
except APIConnectionError as e:
waittime = 2 * attempt 2
print(f"Koneksi gagal: {e}. Menunggu {waittime} detik... (percobaan {attempt + 1}/{maxretries})")
time.sleep(waittime)
except APIError as e:
if e.statuscode == 503:
# Server overloaded
waittime = 2 * attempt 10
print(f"Server overloaded. Menunggu {waittime} detik...")
time.sleep(waittime)
elif e.statuscode == 400:
# Bad request - jangan retry
print(f"Bad request: {e.message}")
raise
else:
print(f"API Error ({e.statuscode}): {e.message}")
raise
raise Exception(f"Gagal setelah {maxretries} percobaan")
Penggunaan
try:
response = robustcompletion(
messages=[{"role": "user", "content": "Halo, apa kabar?"}],
model="deepseek-chat",
maxretries=3,
timeout=30
)
print(response.choices[0].message.content)
except Exception as e:
print(f"Error final: {e}")
Untuk monitoring penggunaan token dan biaya:
def logusage(response, model):
"""Log penggunaan token untuk monitoring biaya."""
usage = response.usage
# Harga per 1M token (perkiraan, cek harga terbaru di website DeepSeek)
pricing = {
"deepseek-chat": {"input": 0.27, "output": 1.10},
"deepseek-reasoner": {"input": 0.55, "output": 2.19},
}
prices = pricing.get(model, pricing["deepseek-chat"])
input
cost = (usage.prompttokens / 1000000) prices["input"]
output
cost = (usage.completiontokens / 1000000) prices["output"]
total
cost = inputcost + outputcost
print(f"Model: {model}")
print(f"Input tokens: {usage.prompttokens}")
print(f"Output tokens: {usage.completiontokens}")
print(f"Total tokens: {usage.totaltokens}")
print(f"Estimasi biaya: ${totalcost:.6f}")
return {"tokens": usage.totaltokens, "costusd": total_cost}
Perbandingan dengan Provider Lain
Berikut perbandingan DeepSeek API dengan provider LLM populer lainnya:
Harga (per 1 Juta Token)
| Provider | Model | Input | Output |
|----------|-------|-------|--------|
| DeepSeek | deepseek-chat (V3) | $0.27 | $1.10 |
| DeepSeek | deepseek-reasoner (R1) | $0.55 | $2.19 |
| OpenAI | GPT-4o | $2.50 | $10.00 |
| OpenAI | GPT-4o-mini | $0.15 | $0.60 |
| Anthropic | Claude Sonnet 4 | $3.00 | $15.00 |
| Anthropic | Claude Haiku 3.5 | $0.80 | $4.00 |
| Google | Gemini 1.5 Pro | $1.25 | $5.00 |
Dari tabel di atas, terlihat jelas bahwa DeepSeek menawarkan harga yang sangat kompetitif. Untuk model utama deepseek-chat, biaya input-nya sekitar 10x lebih murah dibandingkan GPT-4o dan Claude Sonnet 4. Bahkan model reasoning DeepSeek-R1 masih jauh lebih murah dibandingkan model standar dari kompetitor.
Performa Benchmark
DeepSeek-V3 menunjukkan performa yang sangat baik di berbagai benchmark:
- MMLU: Setara dengan GPT-4o dan Claude Sonnet
- HumanEval (Coding): Skor sangat tinggi, kompetitif dengan model-model terbaik
- MATH: DeepSeek-R1 unggul di benchmark matematika
- Arena ELO: Peringkat tinggi di Chatbot Arena
Kelebihan dan Kekurangan
Kelebihan DeepSeek:- Harga sangat terjangkau, cocok untuk startup dan proyek dengan budget terbatas
- Performa setara model premium di banyak tugas
- Kompatibel dengan OpenAI SDK, mudah migrasi
- Model open source tersedia untuk self-hosting
- Prefix caching otomatis menghemat biaya lebih lanjut
- Server berlokasi di Tiongkok, latensi mungkin lebih tinggi untuk pengguna di luar Asia
- Ekosistem dan dokumentasi belum selengkap OpenAI
- Ketersediaan server bisa fluktuatif saat load tinggi
- Fitur multimodal belum sekomprehensif GPT-4o
- Pertimbangan privasi data untuk kasus penggunaan yang sensitif
Kapan Menggunakan DeepSeek?
- Gunakan DeepSeek ketika: budget terbatas, tugas-tugas umum (chat, coding, analisis), prototipe cepat, project internal, batch processing besar
- Pertimbangkan OpenAI/Anthropic ketika: membutuhkan latensi rendah global, kebutuhan compliance data ketat, fitur enterprise (fine-tuning, dedicated capacity), multimodal canggih
Conclusion
DeepSeek API merupakan alternatif yang sangat menarik di ekosistem AI API saat ini. Dengan harga yang jauh lebih terjangkau dibandingkan kompetitor utama seperti OpenAI dan Anthropic, namun tetap menawarkan performa yang kompetitif, DeepSeek membuka peluang bagi lebih banyak developer dan perusahaan untuk memanfaatkan teknologi AI tanpa harus merogoh kocek terlalu dalam.
Keuntungan utama menggunakan DeepSeek API antara lain: