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, serta tugas jangka panjang yang merangkai puluhan langkah tanpa kehilangan fokus. Untuk membangun agen seperti ini, fitur API yang paling penting adalah pemanggilan fungsi (function calling)—bukan sekadar penyelesaian obrolan.

Coba Apidog hari ini

Artikel ini menunjukkan cara mendefinisikan skema alat, melakukan panggilan alat pertama dengan SDK Python openai, membangun loop agen penuh, lalu menguji kontraknya di Apidog. Jika Anda belum memiliki kunci API DeepSeek, ikuti panduan cara menggunakan API DeepSeek V4 terlebih dahulu.

Ringkasan

• deepseek-v4-pro (build GA DeepSeek-V4-Pro-0813) mendukung pemanggilan fungsi bergaya OpenAI: kirim array tools, baca tool_calls, lalu kembalikan hasil sebagai pesan berperan tool.
• SDK Python openai dapat digunakan dengan base_url="https://api.deepseek.com".
• Loop agen inti hanya membutuhkan: panggil model → jalankan alat → tambahkan hasil → ulangi sampai model memberi jawaban akhir.
• Panggilan alat paralel dan keluaran terstruktur dapat digunakan dalam alur yang sama.
• Harga cache-hit input sebesar $0,003625 per juta token, dibandingkan $0,435 per juta token untuk cache miss. Cache prefiks sangat penting untuk loop agen yang panjang.
• Kualitas pemanggilan alat bergantung pada skema, prompt, dan harness Anda. Uji endpoint dan definisi alat yang benar-benar akan dipakai di produksi.

Mengapa pemanggilan alat adalah kasus penggunaan utama V4 Pro

DeepSeek membangun V4 Pro untuk alur kerja agen. Spesifikasinya relevan langsung untuk runtime agen:

Spesifikasi	DeepSeek V4 Pro
Arsitektur	Sparse MoE: 1.6T parameter total, 49B aktif per token
Jendela konteks	1M token
Output maksimum	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 kompatibel OpenAI dan respons tool_calls
Antarmuka lain	Format Pesan Anthropic, API Respons DeepSeek

Jendela konteks besar memungkinkan agen membawa riwayat hasil alat yang panjang. Batas output besar memberi ruang bagi payload terstruktur, sedangkan cache prefiks menekan biaya saat percakapan dibaca ulang di setiap putaran. Model ini juga terdaftar di OpenRouter sebagai deepseek-v4-pro-0813 untuk perbandingan penyedia.

Namun, jangan mengandalkan benchmark saja. Dalam diskusi peluncuran di Hacker News, pengembang melaporkan bahwa kualitas pemanggilan alat sensitif terhadap framework, scaffolding prompt, dan bentuk skema. Model yang sama dapat menghasilkan hasil berbeda ketika definisi alat berubah.

Cara kerja pemanggilan fungsi DeepSeek

Pemanggilan fungsi tidak membuat model mengeksekusi kode Anda. Model hanya mengembalikan permintaan terstruktur, misalnya:

{
  "name": "get_order",
  "arguments": "{\"order_id\":\"ORD-10442\"}"
}

Runtime Anda bertanggung jawab untuk menjalankan fungsi, memvalidasi input, dan mengirimkan hasilnya kembali ke model.

Alurnya:

1. Kirim messages dan array tools yang berisi definisi fungsi dalam JSON Schema.
2. Model merespons dengan tool_calls dan biasanya finish_reason: "tool_calls".
3. Parse argumen fungsi dan jalankan implementasi alat Anda.
4. Tambahkan pesan tool yang memuat hasil dan tool_call_id yang sesuai.
5. Kirim percakapan yang diperbarui ke model.
6. Ulangi sampai model tidak lagi meminta alat.

Jika Anda sudah menggunakan pemanggilan fungsi OpenAI, format kawatnya sama. Umumnya, Anda cukup mengganti URL dasar dan nama model. Dokumentasi resmi DeepSeek juga mencakup endpoint Pesan kompatibel Anthropic dan API Respons, tetapi contoh berikut menggunakan antarmuka kompatibel OpenAI.

Langkah 1: Siapkan klien

Instal SDK dan ekspor kunci API:

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

Buat klien yang mengarah ke endpoint DeepSeek:

import os
from openai import OpenAI

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

Contoh berikut menggunakan model="deepseek-v4-pro", yang mengacu pada build GA DeepSeek-V4-Pro-0813.

Langkah 2: Definisikan skema alat

Contoh ini membangun agen dukungan toko online. Alat pertama mengambil data pesanan berdasarkan ID.

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 alat ini "
                "saat pengguna bertanya lokasi atau status pesanan."
            ),
            "parameters": {
                "type": "object",
                "properties": {
                    "order_id": {
                        "type": "string",
                        "description": "ID pesanan dengan format seperti 'ORD-10442'.",
                    }
                },
                "required": ["order_id"],
                "additionalProperties": False,
            },
        },
    }
]

Deskripsi alat adalah bagian dari instruksi untuk model. Buat deskripsi yang menjawab tiga pertanyaan:

• Kapan alat harus digunakan?
• Data apa yang dikembalikan?
• Parameter apa yang diperlukan?

Selanjutnya, buat implementasi lokal. Dalam produksi, fungsi ini biasanya memanggil API atau database internal.

def get_order(order_id: str) -> dict:
    """Contoh pengganti untuk layanan pesanan nyata."""
    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

Kirim pertanyaan yang membutuhkan data eksternal:

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 langsung, model meminta runtime Anda menjalankan get_order.

Respons mentah akan berbentuk seperti berikut:

{
  "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
  }
}

Perhatikan tiga hal:

1. finish_reason: "tool_calls" berarti model menunggu eksekusi alat.
2. Setiap panggilan memiliki id unik.
3. arguments adalah string JSON, bukan dictionary Python. Parse dan validasi nilainya sebelum digunakan.

Langkah 4: Jalankan fungsi dan kembalikan hasilnya

Tambahkan pesan asisten yang berisi tool_calls, lalu tambahkan satu pesan tool untuk setiap panggilan.

import json

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

result = get_order(**args)

messages.append(message)

messages.append({
    "role": "tool",
    "tool_call_id": tool_call.id,
    "content": json.dumps(result),
})

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

print(final.choices[0].message.content)

Contoh jawaban akhir:

Pesanan Anda ORD-10442 dikirim dengan DHL dan diperkirakan tiba
pada 15 Agustus 2026. Nomor pelacakan: 4281337005.

tool_call_id wajib cocok dengan ID panggilan alat sebelumnya. Jika respons alat tidak tersedia untuk setiap entri tool_calls, permintaan lanjutan dapat gagal.

Langkah 5: Bangun loop agen lengkap

Agen nyata biasanya memanggil lebih dari satu alat. Misalnya:

1. Ambil status pesanan.
2. Periksa kebijakan pengembalian dana.
3. Buat draf email dukungan.
4. Berikan jawaban akhir kepada pengguna.

Gunakan loop berikut sebagai fondasi runtime:

import json

TOOLS_BY_NAME = {
    "get_order": get_order,
}

def run_agent(client, messages, tools, max_rounds=10):
    """Jalankan agen sampai model menghasilkan jawaban akhir."""
    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)

        # Tidak ada tool_calls berarti model sudah memberi jawaban akhir.
        if not message.tool_calls:
            return message.content

        for tool_call in message.tool_calls:
            try:
                fn = TOOLS_BY_NAME.get(tool_call.function.name)

                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:
                # Kirim kegagalan ke model agar ia dapat memperbaiki langkahnya.
                result = {
                    "error": str(exc),
                }

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

Gunakan batas max_rounds. Tanpa batas, agen yang terus mengulang panggilan gagal dapat menghasilkan biaya dan log yang tidak terkendali.

Contoh penggunaan:

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

print(answer)

Panggilan alat paralel

Untuk permintaan seperti:

Bandingkan status ORD-10442 dan ORD-10587.

Model dapat meminta dua panggilan dalam satu respons:

"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 sebelumnya sudah mendukung pola ini karena ia memproses seluruh message.tool_calls. Untuk API I/O-bound, Anda dapat menjalankan fungsi secara paralel menggunakan asyncio, thread pool, atau worker queue.

Yang penting: setiap panggilan tetap harus menerima pesan tool dengan tool_call_id yang cocok sebelum Anda mengirim giliran berikutnya ke model.

Ini berbeda dari pemanggilan alat terprogram GPT-5.6, ketika model menulis kode orkestrasi dalam sandbox. Pada DeepSeek, eksekusi dan batas kepercayaan tetap berada di runtime Anda.

Mode berpikir dan alat

V4 Pro memiliki tiga mode berpikir. Anda dapat mengaktifkan mode berpikir pada langkah perencanaan yang kompleks, lalu menggunakannya secara terbatas untuk pencarian rutin. Lihat nama mode dan default pada dokumentasi resmi DeepSeek.

Contoh aktivasi:

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)
print(message.tool_calls)

Dengan mode berpikir aktif, API mengembalikan reasoning_content bersama panggilan alat yang dipilih model.

Jangan menambahkan reasoning_content ke riwayat percakapan saat meneruskan pesan asisten ke putaran berikutnya. Gunakan juga mode ini secara selektif karena token penalaran ditagihkan sebagai output sebesar $0,87/M token.

Tangani argumen alat yang tidak valid

Jangan menganggap argumen model selalu valid. Validasi dua hal sebelum memanggil layanan Anda:

• Apakah arguments dapat diparse sebagai JSON?
• Apakah hasilnya sesuai dengan JSON Schema dan aturan bisnis?

Instal validator:

pip install jsonschema

Lalu gunakan validasi sebelum eksekusi:

import json
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'."
        ),
    }

Field hint membantu model memperbaiki percobaan berikutnya. Selain validasi skema, tambahkan validasi domain, misalnya:

• Pastikan pengguna memiliki hak akses ke pesanan.
• Tolak ID pesanan yang tidak sesuai tenant.
• Batasi kuantitas, rentang tanggal, atau tindakan sensitif.
• Terapkan timeout dan retry di lapisan integrasi.

Perlakukan kesalahan alat sebagai masalah keamanan. Model yang dibujuk memanggil delete_order hanya akan berbahaya jika kredensial di balik alat tersebut terlalu luas. Gunakan kunci API dengan hak istimewa terendah untuk agen AI agar panggilan yang salah tidak berubah menjadi insiden.

Uji dan debug panggilan alat dengan Apidog sebelum rilis

Setiap alat pada akhirnya adalah pembungkus di atas API, dan model menjadi konsumen API tersebut. Jika endpoint ambigu, responsnya tidak konsisten, atau skemanya berubah diam-diam, agen Anda akan mewarisi masalah itu.

Gunakan Apidog untuk menguji kontrak API dan perilaku alat:

1. Rancang API pendukung terlebih dahulu
   
   Definisikan endpoint seperti GET /orders/{order_id} dalam spesifikasi API. Buat parameter, respons sukses, dan respons error eksplisit agar implementasi alat serta kontrak backend tetap selaras.

2. Mock endpoint sebelum backend selesai
   
   Gunakan mock berbasis skema untuk menguji get_order ketika layanan produksi belum tersedia. Dengan begitu, Anda dapat menguji loop agen, pesan error, dan format hasil alat lebih awal.

3. Inspeksi payload API mentah
   
   Kirim payload messages dan tools yang sama ke https://api.deepseek.com dari Apidog. Periksa JSON tool_calls secara langsung untuk menemukan masalah seperti properties yang salah bersarang, tipe parameter yang keliru, atau argumen JSON yang dikodekan ganda.

4. Ubah percakapan menjadi skenario regresi
   
   Buat pengujian untuk pertanyaan penting, misalnya:

   • “Di mana pesanan saya ORD-10442?”
   • “Bandingkan ORD-10442 dan ORD-10587.”
   • “Batalkan pesanan saya” tanpa izin yang diperlukan.
   • ID pesanan yang tidak valid.
   • Respons backend dengan timeout atau error.

Tegaskan finish_reason, nama alat, dan bentuk argumen yang dihasilkan. Jalankan suite pada setiap perubahan skema.

Untuk pola yang lebih lengkap, lihat panduan menghubungkan agen AI ke harness pengujian Apidog.

Unduh Apidog secara gratis untuk mengikuti contoh; server mock dan skenario pengujian tersedia pada tingkat gratis.

Berapa biaya loop agen?

Loop agen mengirim ulang riwayat percakapan pada setiap putaran. Pada putaran kesepuluh, prompt sistem, definisi alat, dan hasil dari sembilan putaran sebelumnya kembali menjadi bagian input.

Caching prefiks otomatis V4 Pro mengubah biaya pola ini:

• Input cache miss: $0,435/M token
• Input cache hit: $0,003625/M token

Misalnya, membaca ulang percakapan 100K token kira-kira berbiaya:

• Sekitar $0,0435 tanpa cache
• Sekitar $0,0004 dengan cache

Periksa field berikut pada respons untuk mengukur cache Anda:

{
  "prompt_cache_hit_tokens": 95000,
  "prompt_cache_miss_tokens": 5000
}

Untuk mempertahankan cache-hit yang tinggi:

1. Jangan mengubah pesan sebelumnya.
2. Pertahankan urutan pesan.
3. Jaga array tools stabil secara byte di setiap putaran.
4. Hindari menyisipkan metadata dinamis ke prompt sistem.
5. Tambahkan hasil baru hanya di akhir riwayat.

Baca pengantar apa itu caching prompt untuk memahami mekanismenya.

deepseek-v4-flash pada $0,14/$0,28 dapat menarik untuk perutean alat satu kali. Namun, untuk loop yang merangkai 10+ panggilan, percobaan ulang akibat kualitas perencanaan yang menurun dapat menghabiskan penghematan tersebut. Untuk agen multi-langkah, Pro adalah default yang lebih aman.

Pertanyaan umum

Apakah definisi alat memakan token?

Ya. Array tools adalah bagian input pada setiap permintaan. Karena itu, pertahankan definisi alat tetap stabil agar dapat menjadi bagian dari prefiks cache setelah putaran pertama.

Bisakah pemanggilan fungsi digabungkan dengan output terstruktur?

Ya. Pola umumnya:

1. Alat mengambil data perantara.
2. Model menyusun jawaban akhir dalam format terstruktur.
3. Kode downstream menerima JSON yang tervalidasi, bukan prosa yang perlu diparse.

Apakah saya harus mengeksekusi alat yang diminta model?

Tidak. Runtime Anda harus tetap menjadi pengambil keputusan. Anda dapat menolak alat yang tidak dikenal, memvalidasi argumen, menerapkan otorisasi, dan mengembalikan error terstruktur ke model.

Kesimpulan

Pemanggilan fungsi DeepSeek V4 Pro menggunakan pola yang sederhana: definisi tools kompatibel OpenAI, respons tool_calls, lalu pesan tool yang menyertakan ID panggilan terkait.

Bagian paling penting bukan SDK-nya, melainkan implementasi runtime:

• Definisikan skema yang spesifik.
• Validasi setiap argumen.
• Batasi jumlah putaran.
• Kembalikan error sebagai hasil alat.
• Gunakan kredensial dengan hak minimum.
• Uji skenario alat nyata terhadap API dan skema nyata Anda.

Benchmark tidak dapat menunjukkan bagaimana model akan berperilaku terhadap kontrak API Anda. Rancang endpoint pendukung dengan sengaja, mock sejak awal, dan pertahankan suite regresi pemanggilan alat di Apidog agar perubahan skema tidak merusak agen secara diam-diam.