Skip to main content
Pemanggilan Alat

Code Interpreter

Aktifkan Python Code Interpreter bawaan saat memanggil model. Model menulis dan menjalankan kode Python dalam sandbox untuk menyelesaikan masalah kompleks seperti perhitungan matematika dan analitik data.

Cara menggunakan

Code Interpreter mendukung tiga metode pemanggilan, masing-masing dengan parameter yang berbeda:
  • OpenAI-compatible - Responses API
  • OpenAI-compatible - Chat Completions API
  • DashScope
Untuk mengaktifkan Code Interpreter, tambahkan tool code_interpreter ke parameter tools.
Untuk hasil terbaik, aktifkan tool code_interpreter, web_search, dan web_extractor secara bersamaan. 
# Impor dependensi dan buat klien...
response = client.responses.create(
    model="qwen3.8-max",
    input="Berapa 123 pangkat 21?",
    tools=[
        {"type": "code_interpreter"},
        {"type": "web_search"},
        {"type": "web_extractor"},
    ],
    extra_body={
        "enable_thinking": True
    }
)

print(response.output_text)
Setelah Code Interpreter diaktifkan, model memproses permintaan dalam tahapan berikut:
  1. Thinking: Model menganalisis permintaan pengguna dan menghasilkan ide serta langkah-langkah untuk menyelesaikan masalah.
  2. Code execution: Model menghasilkan dan mengeksekusi kode Python.
  3. Result integration: Model menerima hasil eksekusi kode dan merencanakan langkah selanjutnya.
  4. Response: Model menghasilkan tanggapan dalam bahasa alami.
Langkah 2 dan 3 dapat berulang beberapa kali.
Bidang yang dikembalikan oleh API berbeda-beda:
  • Responses API: Konten thinking dikembalikan dalam objek dengan type="reasoning" pada output. Eksekusi kode dikembalikan dengan type="code_interpreter_call". Tanggapan dikembalikan dengan type="message".
  • Chat Completions API / DashScope: Konten thinking dikembalikan dalam bidang reasoning_content. Tanggapan dikembalikan dalam bidang content. DashScope juga mendukung pengembalian konten kode dalam bidang tool_info.

Cakupan

Model yang direkomendasikan

  • Responses API
  • Chat Completions API / DashScope
Qwen-Max: seri Qwen3.8-Max, seri Qwen3.7-MaxQwen-Plus: seri Qwen3.7-Plus, seri Qwen3.6-Plus, seri Qwen3.5-PlusDeepSeek: deepseek-v4-flash, deepseek-v4-flash-0731, deepseek-v4-proGLM: glm-5.2seri open source Qwen3.8

Model lainnya

Model-model ini juga mendukung Code Interpreter tetapi mungkin tidak berkinerja sebaik model yang direkomendasikan. Hanya didukung melalui Responses API.
  • Qwen-Flash: seri Qwen3.7-Flash, seri Qwen3.6-Flash, seri Qwen3.5-Flash
  • seri open-source Qwen3.6 (kecuali qwen3.6-27b)
  • seri open source Qwen3.5

Memulai

Contoh berikut menunjukkan cara Code Interpreter menyelesaikan masalah matematika.
  • OpenAI-compatible - Responses API
  • OpenAI-compatible - Chat Completions API
  • DashScope
Untuk hasil terbaik, aktifkan tool code_interpreter, web_search, dan web_extractor secara bersamaan. 
import os
from openai import OpenAI

client = OpenAI(
    # Jika variabel lingkungan tidak dikonfigurasi, ganti baris berikutnya dengan: api_key="sk-xxx", menggunakan kunci API Model Studio Anda.
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    # URL berikut adalah untuk Wilayah Singapura. Ganti {WorkspaceId} dengan ID ruang kerja Anda. URL bervariasi menurut wilayah.
    base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1"
)

response = client.responses.create(
    model="qwen3.8-max",
    input="12 to the power of 3",
    tools=[
        {
            "type": "code_interpreter"
        },
        {
            "type": "web_search"
        },
        {
            "type": "web_extractor"
        }
    ],
    extra_body = {
        "enable_thinking": True
    }
)
# Hapus tanda komentar pada baris berikut untuk melihat output proses perantara
# print(response.output)
print("="*20+"Konten Tanggapan"+"="*20)
print(response.output_text)
print("="*20+"Konsumsi Token dan Panggilan Alat"+"="*20)
print(response.usage)
Contoh tanggapan 
====================Konten Tanggapan====================
12 pangkat 3 adalah **1728**.

Proses perhitungan:
12³ = 12 × 12 × 12 = 144 × 12 = 1728
====================Konsumsi Token dan Pemanggilan Tool====================
ResponseUsage(input_tokens=1160, input_tokens_details=InputTokensDetails(cached_tokens=0), output_tokens=195, output_tokens_details=OutputTokensDetails(reasoning_tokens=105), total_tokens=1355, x_tools={'code_interpreter': {'count': 1}})

Mengurai respons

  • OpenAI-compatible - Responses API
  • DashScope
Contoh berikut menggunakan OpenAI Python SDK untuk menunjukkan cara mengurai respons streaming.
import os
from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    # URL berikut digunakan untuk wilayah Singapura. Ganti {WorkspaceId} dengan ID ruang kerja Anda yang sebenarnya. URL bervariasi tergantung wilayah.
    base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1"
)

response = client.responses.create(
    model="qwen3.8-max",
    input="12 to the power of 3",
    tools=[
        {"type": "code_interpreter"}
    ],
    extra_body={
        "enable_thinking": True
    },
    stream=True
)

def print_section(title):
    print(f"\n{'=' * 20}{title}{'=' * 20}")

current_section = None
final_response = None

for event in response:
    # Output inkremental dari proses berpikir
    if event.type == "response.reasoning_summary_text.delta":
        if current_section != "reasoning":
            print_section("Thinking Process")
            current_section = "reasoning"
        print(event.delta, end="", flush=True)

    # Pemanggilan Code Interpreter selesai
    elif event.type == "response.output_item.done" and hasattr(event.item, "code"):
        print_section("Code Execution")
        print(f"Code:\n{event.item.code}")
        if event.item.outputs:
            print(f"Result: {event.item.outputs[0].logs}")
        current_section = "code"

    # Output inkremental dari respons akhir
    elif event.type == "response.output_text.delta":
        if current_section != "answer":
            print_section("Complete Response")
            current_section = "answer"
        print(event.delta, end="", flush=True)

    # Respons selesai, simpan hasil akhir untuk mendapatkan penggunaan
    elif event.type == "response.completed":
        final_response = event.response

# Tampilkan konsumsi token dan jumlah pemanggilan tool
if final_response and final_response.usage:
    print_section("Token Consumption and Tool Calls")
    usage = final_response.usage
    print(f"Input Tokens: {usage.input_tokens}")
    print(f"Output Tokens: {usage.output_tokens}")
    print(f"Thinking Tokens: {usage.output_tokens_details.reasoning_tokens}")
    # Jika model tidak benar-benar memanggil code interpreter (misalnya pertanyaan sederhana dijawab langsung), respons tidak memiliki field x_tools
    if hasattr(usage, 'x_tools'):
        print(f"Code Interpreter calls: {usage.x_tools.get('code_interpreter', {}).get('count', 0)}")
    else:
        print("Code Interpreter calls: 0")

Catatan

  • Code Interpreter dan Function calling bersifat saling eksklusif.
    Mengaktifkan keduanya dalam satu permintaan yang sama akan menyebabkan error.
  • Ketika Code Interpreter diaktifkan, satu permintaan dapat memicu multiple inferensi model. Bidang usage merangkum total konsumsi token untuk semua panggilan dalam permintaan tersebut.

Billing

Code Interpreter gratis untuk waktu terbatas tetapi meningkatkan konsumsi token.
Memulai
Billing
Rencana Token (Team Edition)
Model playground
Klien dan Alat Pengembang
Inferensi Model
Fine-tuning Model
Deployment
Evaluasi
Statistik dan Pemantauan
Asset Center
Keamanan dan Kepatuhan
Praktik terbaik
Dukungan layanan
Log Perubahan