Cara Menggunakan Function Calling dengan DeepSeek V4 Pro API

DeepSeek memindahkan V4 Pro dari pratinjau pada 12 Agustus 2026, dan liputan peluncuran menyoroti alur kerja agen: pengodean, penggunaan alat, dan tugas jangka panjang yang merangkai puluhan langkah tanpa kehilangan fokus. Posisi ini membuat satu fitur API lebih penting dari yang lain, yaitu pemanggilan fungsi, dan ini adalah fitur yang belum disentuh oleh panduan minggu peluncuran. Setiap tutorial sejauh ini berhenti pada penyelesaian obrolan.

Artikel ini melangkah lebih jauh: definisikan skema alat, lakukan panggilan alat pertama Anda dengan SDK Python openai standar, bangun lingkaran agen penuh, lalu uji semuanya di Apidog sebelum agen Anda diluncurkan. Jika Anda belum memiliki kunci API DeepSeek, siapkan satu dengan panduan kami tentang cara menggunakan API DeepSeek V4, lalu kembali lagi.

tombol

Ringkasan

deepseek-v4-pro (build GA DeepSeek-V4-Pro-0813) mendukung pemanggilan fungsi gaya OpenAI: kirim array `tools`, terima `tool_calls`, kembalikan hasil sebagai pesan `tool`. SDK `openai` standar berfungsi terhadap `https://api.deepseek.com`.
Loop agen lengkap adalah sekitar 30 baris Python: panggil, eksekusi, tambahkan, ulangi sampai model berhenti meminta alat. Panggilan paralel dan keluaran terstruktur didukung; mode berpikir menambahkan `reasoning_content`.
Harga caching prefiks otomatis untuk input yang mengenai cache adalah $0,003625 per juta token, 120x lebih murah daripada yang tidak mengenai cache. Itulah yang membuat loop agen yang dalam menjadi terjangkau.
Kualitas pemanggilan alat bervariasi tergantung pada harness dan skema Anda. Uji alat Anda yang sebenarnya terhadap model langsung, bukan pada benchmark.

Mengapa pemanggilan alat adalah kasus penggunaan utama V4 Pro

DeepSeek membangun V4 Pro untuk agen, dan lembar spesifikasi terlihat seperti daftar periksa runtime agen:

Spesifikasi	DeepSeek V4 Pro
Arsitektur	Sparse MoE: 1.6T parameter total, 49B aktif per token
Jendela konteks	1M token
Output maks	384K token
Harga input	$0,435/M token (cache miss), $0,003625/M (cache hit)
Harga output	$0,87/M token
Pemanggilan fungsi	Array `tools` yang kompatibel dengan OpenAI dan respons `tool_calls`
Antarmuka lain	Format Pesan Anthropic, API Respons DeepSeek

Setiap baris sesuai dengan masalah agen: jendela 1M token membawa seluruh riwayat hasil alat agen yang panjang, batas output 384K menyisakan ruang untuk payload terstruktur besar, dan caching prefiks membuat ekonomi loop berfungsi. Model ini terdaftar di OpenRouter sebagai deepseek-v4-pro-0813 untuk perbandingan penyedia.

Satu peringatan sebelum kode. Dalam diskusi peluncuran Hacker News, pengembang melaporkan bahwa kinerja pemanggilan alat sangat sensitif terhadap harness: model yang sama mencetak skor lebih baik atau lebih buruk tergantung pada framework, scaffolding prompt, dan gaya skema. Benchmark tidak akan memberi tahu Anda bagaimana model menangani skema alat Anda. Uji dengan definisi Anda yang sebenarnya.

Cara kerja pemanggilan fungsi DeepSeek

Pemanggilan fungsi tidak berarti model mengeksekusi apa pun. Ia merespons dengan permintaan terstruktur, “panggil get_order dengan {"order_id": "ORD-10442"}”, alih-alih prosa. Kode Anda menjalankan fungsi, mengembalikan hasilnya, dan model melanjutkan dengan data nyata. Siklusnya:

Anda mengirim messages ditambah array tools yang menjelaskan setiap fungsi dalam Skema JSON.
Model memutuskan alat diperlukan dan merespons dengan tool_calls dan finish_reason: "tool_calls".
Kode Anda mengurai argumen dan menjalankan fungsi sebenarnya.
Anda menambahkan hasil sebagai pesan role: "tool" yang terkait dengan ID panggilan.
Model akan meminta alat lain atau menghasilkan jawaban akhirnya.

Jika Anda pernah bekerja dengan pemanggilan fungsi OpenAI, ini adalah format kawat yang sama; sebagian besar kode agen dapat di-porting dengan mengubah URL dasar dan nama model. Dokumentasi resmi DeepSeek juga mencakup endpoint Pesan yang kompatibel dengan Anthropic dan API Respons, tetapi panduan ini berpegang pada antarmuka yang kompatibel dengan OpenAI.

Langkah 1: Siapkan klien

Instal SDK dan arahkan ke DeepSeek:

pip install openai
export DEEPSEEK_API_KEY="sk-..."

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["DEEPSEEK_API_KEY"],
    base_url="https://api.deepseek.com",
)

Itulah seluruh pengaturannya. Setiap contoh menggunakan model="deepseek-v4-pro", yang mengacu pada build GA DeepSeek-V4-Pro-0813.

Langkah 2: Definisikan skema alat

Kami akan membangun agen dukungan untuk toko online. Alat pertamanya mencari pesanan. Definisi alat memiliki tiga bagian: nama, deskripsi, dan Skema JSON untuk parameternya.

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_order",
            "description": (
                "Cari pesanan pelanggan berdasarkan ID-nya. Mengembalikan status pesanan, "
                "kurir, nomor pelacakan, dan perkiraan tanggal pengiriman. Gunakan ini "
                "setiap kali pengguna bertanya di mana pesanan berada atau dalam status apa."
            ),
            "parameters": {
                "type": "object",
                "properties": {
                    "order_id": {
                        "type": "string",
                        "description": "ID pesanan, diformat seperti 'ORD-10442'.",
                    }
                },
                "required": ["order_id"],
            },
        },
    }
]

Deskripsi bukanlah hiasan: model memutuskan kapan harus memanggil alat dengan membacanya. Deskripsi yang tidak jelas adalah alasan utama model mengabaikan alat atau memilih yang salah.

Fungsi lokal yang dijelaskan oleh skema, yang dipalsukan untuk layanan pesanan nyata:

def get_order(order_id: str) -> dict:
    """Stub untuk layanan pesanan Anda yang sebenarnya."""
    fake_db = {
        "ORD-10442": {
            "status": "shipped",
            "carrier": "DHL",
            "tracking_number": "4281337005",
            "estimated_delivery": "2026-08-15",
        },
        "ORD-10587": {
            "status": "processing",
            "estimated_ship_date": "2026-08-14",
        },
    }
    return fake_db.get(order_id, {"error": f"Unknown order ID: {order_id}"})

Langkah 3: Lakukan panggilan alat pertama Anda

Kirim pertanyaan yang tidak bisa dijawab model tanpa alat:

messages = [
    {"role": "system", "content": "Anda adalah agen dukungan untuk toko online."},
    {"role": "user", "content": "Di mana pesanan saya ORD-10442?"},
]

response = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=messages,
    tools=tools,
)

message = response.choices[0].message
print(message.tool_calls[0].function.name) # get_order
print(message.tool_calls[0].function.arguments) # {"order_id": "ORD-10442"}

Alih-alih menjawab, model meminta Anda untuk menjalankan get_order. Payload respons mentah terlihat seperti ini:

{
  "id": "chatcmpl-8f3a1c",
  "object": "chat.completion",
  "model": "deepseek-v4-pro",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "",
        "tool_calls": [
          {
            "id": "call_0_f1c29a44",
            "type": "function",
            "function": {
              "name": "get_order",
              "arguments": "{\"order_id\": \"ORD-10442\"}"
            }
          }
        ]
      },
      "finish_reason": "tool_calls"
    }
  ],
  "usage": {
    "prompt_tokens": 312,
    "completion_tokens": 24,
    "total_tokens": 336,
    "prompt_cache_hit_tokens": 0,
    "prompt_cache_miss_tokens": 312
  }
}

Tiga detail penting. finish_reason adalah "tool_calls", yang memberi tahu loop Anda bahwa model ingin eksekusi. Setiap panggilan membawa id yang harus Anda kembalikan dengan hasil. Dan arguments adalah string JSON yang Anda uraikan sendiri, jadi harap maklum jika terkadang salah format.

Langkah 4: Jalankan fungsi dan kembalikan hasilnya

Jalankan fungsi, lalu tambahkan dua pesan: giliran asisten yang berisi tool_calls, dan pesan tool yang membawa hasil Anda.

import json

tool_call = message.tool_calls[0]
args = json.loads(tool_call.function.arguments)
result = get_order(args)

messages.append(message) # giliran asisten yang berisi tool_calls
messages.append({
    "role": "tool",
    "tool_call_id": tool_call.id, # harus cocok dengan id dari respons
    "content": json.dumps(result),
})

final = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=messages,
    tools=tools,
)
print(final.choices[0].message.content)
# Pesanan Anda ORD-10442 dikirim dengan DHL dan diperkirakan tiba
# pada 15 Agustus 2026. Nomor pelacakan: 4281337005.

Tautan tool_call_id sangat ketat: setiap entri tool_calls memerlukan pesan tool yang cocok sebelum giliran model berikutnya, atau permintaan akan gagal.

Langkah 5: Loop agen lengkap

Agen sungguhan merangkai panggilan: mencari pesanan, memeriksa kebijakan pengembalian dana, menyusun email, setiap langkah bergantung pada yang terakhir. Polanya: terus memanggil model dan mengeksekusi apa pun yang diminta sampai model mengembalikan jawaban normal.

TOOLS_BY_NAME = {"get_order": get_order}

def run_agent(client, messages, tools, max_rounds=10):
    """Jalankan model hingga menghasilkan jawaban akhir atau mencapai batas."""
    for _ in range(max_rounds):
        response = client.chat.completions.create(
            model="deepseek-v4-pro",
            messages=messages,
            tools=tools,
        )
        message = response.choices[0].message
        messages.append(message)

        if not message.tool_calls: # tidak ada permintaan alat: kita selesai
            return message.content

        for tool_call in message.tool_calls:
            fn = TOOLS_BY_NAME.get(tool_call.function.name)
            try:
                if fn is None:
                    raise ValueError(f"Unknown tool: {tool_call.function.name}")
                args = json.loads(tool_call.function.arguments)
                result = fn(args)
            except Exception as exc:
                result = {"error": str(exc)} # umpan balik kegagalan ke model
            messages.append({
                "role": "tool",
                "tool_call_id": tool_call.id,
                "content": json.dumps(result),
            })

    raise RuntimeError(f"Agent did not finish within {max_rounds} rounds")

Framework dan SDK agen adalah elaborasi dari loop ini. Batas max_rounds mengubah model yang terjebak mengulang panggilan alat yang gagal menjadi kegagalan yang bersih alih-alih tagihan tanpa batas.

Panggilan alat paralel

Minta dua pencarian, “bandingkan status ORD-10442 dan ORD-10587”, dan V4 Pro seringkali akan menggabungkan keduanya menjadi satu giliran:

"tool_calls": [
  {
    "id": "call_0_a7d1",
    "type": "function",
    "function": { "name": "get_order", "arguments": "{\"order_id\": \"ORD-10442\"}" }
  },
  {
    "id": "call_1_b3e9",
    "type": "function",
    "function": { "name": "get_order", "arguments": "{\"order_id\": \"ORD-10587\"}" }
  }
]

Loop run_agent sudah menangani ini: `for` bagian dalam menjawab setiap panggilan dengan tool_call_id-nya sendiri (setiap panggilan memerlukan hasil yang cocok sebelum giliran berikutnya), dan Anda bebas untuk mengeksekusi batch secara bersamaan. Ini adalah filosofi yang berbeda dari pemanggilan alat terprogram GPT-5.6, di mana model menulis kode orkestrasi dalam sandbox; DeepSeek menjaga eksekusi, dan batas kepercayaan, dalam runtime Anda.

Mode berpikir ditambah alat

V4 Pro dilengkapi dengan tiga mode berpikir, sehingga Anda dapat meningkatkan upaya penalaran untuk giliran perencanaan yang sulit dan melewatkannya untuk pencarian rutin (lihat dokumen resmi untuk nama mode dan default). Dengan mode berpikir diaktifkan, API mengembalikan jejak model sebagai reasoning_content bersama dengan panggilan alat apa pun:

response = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=messages,
    tools=tools,
    extra_body={"thinking": {"type": "enabled"}},
)

message = response.choices[0].message
print(message.reasoning_content) # jejak perencanaan
print(message.tool_calls) # panggilan yang diputuskan

Jejak menunjukkan mengapa model memilih alat, yang biasanya merupakan tempat di mana skema yang buruk terungkap. Hapus reasoning_content sebelum menambahkan giliran asisten ke riwayat, dan gunakan mode berpikir hanya untuk giliran yang membutuhkan banyak perencanaan, karena penalaran akan ditagih sebagai output sebesar $0,87/M.

Penanganan kesalahan: ketika model melakukan panggilan yang salah

Panggilan alat yang salah format jarang terjadi, tetapi loop agen memperkuat setiap mode kegagalan. Pola esensial: jangan pernah crash pada panggilan yang buruk, kembalikan masalah sebagai hasil alat, dan biarkan model mencoba lagi. Ini mencakup argumen yang gagal json.loads serta nilai-nilai yang melanggar aturan bisnis Anda:

from jsonschema import ValidationError, validate

schema = tools[0]["function"]["parameters"]

try:
    args = json.loads(tool_call.function.arguments)
    validate(instance=args, schema=schema)
    result = get_order(**args)
except (json.JSONDecodeError, ValidationError) as exc:
    result = {
        "error": f"Argumen tidak valid: {exc}",
        "hint": "Panggil get_order lagi dengan string order_id seperti 'ORD-10442'.",
    }

Bidang hint itu penting: koreksi satu baris biasanya menghasilkan percobaan ulang yang diperbaiki pada putaran berikutnya. Perlakukan kesalahan agen sebagai insiden keamanan juga. Model yang dibujuk untuk memanggil delete_order dengan argumen yang disediakan penyerang hanya berbahaya sejauh kunci di baliknya, kasus untuk kunci API hak istimewa terendah untuk agen AI. Batasi kredensial sehingga panggilan yang salah tidak dapat menjadi insiden.

Uji dan debug panggilan alat dengan Apidog sebelum Anda meluncurkan

Setiap alat adalah pembungkus tipis di sekitar API, dan model sekarang menjadi konsumen API tersebut. Jika endpoint pendukung ambigu atau tidak stabil, model mewarisi semua itu. Di sinilah Apidog mendapatkan tempatnya dalam loop:

Rancang API pendukung terlebih dahulu. Definisikan GET /orders/{order_id} sebagai spesifikasi di desainer visual Apidog; Skema JSON alat Anda langsung berasal dari spesifikasi, sehingga keduanya tidak dapat menyimpang secara diam-diam.
Mock itu sebelum backend ada. Mock cerdas Apidog menyajikan respons realistis dari skema, sehingga loop agen berjalan melawan get_order sementara layanan nyata masih dibangun.
Periksa payload mentah. Kirim badan messages + tools yang sama ke https://api.deepseek.com dari Apidog dan baca JSON tool_calls mentah secara langsung, `properties` yang salah bersarang atau argumen yang dikodekan ganda akan terlihat dalam satu pemeriksaan.
Ubah percakapan menjadi skenario pengujian. Tegaskan finish_reason dan bentuk argumen, dan jalankan suite pada setiap perubahan skema; mengingat sensitivitas harness yang dilaporkan di Hacker News, suite regresi atas skema nyata Anda adalah benchmark yang memprediksi produksi. Lihat menghubungkan agen AI ke harness pengujian Apidog untuk pola yang lebih dalam.

Unduh Apidog secara gratis untuk mengikuti; server mock dan skenario pengujian termasuk dalam tingkat gratis.

Berapa biaya loop agen (dan mengapa caching menentukannya)

Loop agen membaca ulang seluruh percakapan setiap putaran: pada putaran kesepuluh, prompt sistem Anda, skema alat, dan sembilan putaran hasil ditagih untuk kesepuluh kalinya. Caching prefiks otomatis V4 Pro memecah kurva itu, input setiap putaran adalah input putaran sebelumnya ditambah sedikit lebih banyak, sehingga hampir seluruh prefiks ditagih sebesar $0,003625/M alih-alih $0,435/M. Membaca ulang percakapan 100K token berharga sekitar $0,0435 tanpa cache tetapi sekitar $0,0004 dengan cache; prompt_cache_hit_tokens di blok penggunaan menunjukkan tingkat hit aktual Anda.

Untuk menjaga tingkat itu tetap tinggi, jangan pernah mengubah pesan sebelumnya, dan jaga agar array tools stabil secara byte di seluruh putaran. Pengantar kami tentang apa itu caching prompt mencakup mekanismenya. Dan jika deepseek-v4-flash pada $0,14/$0,28 terlihat menggoda: itu bagus untuk perutean alat sekali pakai, tetapi kinerjanya menurun pada loop yang merangkai 10+ panggilan, sehingga percobaan ulang akan menghabiskan penghematan, Pro adalah default yang lebih aman untuk agen.

Pertanyaan Umum

Apakah definisi alat memakan token?

Ya, array tools adalah input pada setiap permintaan. Jaga agar tetap stabil dan itu akan bergabung dengan prefiks yang di-cache setelah putaran pertama, ditagih dengan tarif cache-hit setelah itu.

Bisakah saya menggabungkan pemanggilan fungsi dengan output terstruktur?

Ya. Pola umum: alat mengambil data perantara, skema output terstruktur memformat jawaban akhir, sehingga kode downstream tidak pernah mengurai prosa.

Kesimpulan

Pemanggilan fungsi pada DeepSeek V4 Pro sengaja tidak menarik untuk diimplementasikan: skema yang kompatibel dengan OpenAI, array tool_calls, pesan tool dengan ID. Loop di Langkah 5 adalah keseluruhan arsitektur, dan harga cache-hit membuatnya lebih murah daripada yang diharapkan sebagian besar tim. Apa yang tidak bisa diberitahukan oleh benchmark adalah bagaimana model berperilaku terhadap skema Anda, rancang API pendukung dengan sengaja, mock sejak awal, dan simpan suite regresi skenario pemanggilan alat di Apidog sehingga perubahan skema tidak dapat secara diam-diam merusak agen Anda.

tombol