BroadRouter

Mengatur max_tokens untuk model penalaran: metode penganggaran

Oleh tim BroadNet Inference · 6 menit baca · Dipublikasikan

Pada model penalaran, max_tokens membatasi proses berpikir dan jawaban sekaligus, sehingga batas yang ketat bisa menghentikan balasan sebelum ada teks yang terlihat. Ukur total completion token per jenis tugas, atur max_tokens sekitar persentil ke-95 ditambah 20%, pastikan prompt plus max_tokens muat di context window, dan ulangi balasan yang terpotong dengan anggaran dua kali lipat hingga batas keras.

Model penalaran berpikir sebelum menjawab, dan di sebagian besar API kompatibel OpenAI keduanya diambil dari satu anggaran: max_tokens. Jika Anda mengaturnya seperti untuk model non-penalaran, beberapa ratus token untuk jawaban singkat, sebagian balasan akan kembali kosong dengan finish_reason: "length". Perbaikan cepatnya ada di kenapa model penalaran mengembalikan jawaban kosong. Artikel ini membahas metode di balik anggaran yang bisa diandalkan: ukur, tentukan dari persentil, patuhi context window, dan tangani balasan yang masih terpotong.

Untuk biaya penalaran dan cara menguranginya, lihat token penalaran: kenapa Anda membayar output lebih banyak dari yang terlihat.

Kenapa anggaran habis sebelum jawaban keluar?

Model menghasilkan secara berurutan: pertama penalarannya, lalu jawaban yang terlihat. Setiap token dari keduanya dihitung dalam max_tokens. Dokumentasi BroadNet menyatakan ini untuk DeepSeek V4.1 Flash, GLM 5.3, dan Qwen3.8 27B: “the reasoning counts toward max_tokens” (Terjemahan BroadRouter: penalaran dihitung dalam max_tokens), dan dengan batas kecil “the answer comes back empty” (Terjemahan BroadRouter: jawabannya kembali kosong). Referensi Chat Completions OpenAI mendefinisikan max_completion_tokens dengan cara yang sama, sebagai batas atas “including visible output tokens and reasoning tokens” (Terjemahan BroadRouter: termasuk token output yang terlihat dan token penalaran).

Jadi pertanyaannya bukan “seberapa panjang jawaban saya?” melainkan “seberapa panjang penalaran dan jawaban sekaligus, untuk tugas ini, pada effort ini?” Variasinya lebih besar dari yang diperkirakan orang. Panduan OpenAI menyebutkan model-modelnya bisa menghasilkan “anywhere from a few hundred to tens of thousands of reasoning tokens” (Terjemahan BroadRouter: mulai dari beberapa ratus hingga puluhan ribu token penalaran), tergantung masalahnya.

Apakah max_tokens yang lebih besar lebih mahal?

Tidak. Inilah alasan paling umum anggaran diatur terlalu ketat. max_tokens adalah plafon. Anda ditagih untuk token yang benar-benar dihasilkan. Balasan yang butuh 1.800 token biayanya sama, baik plafonnya 4.000 maupun 40.000.

Yang membuat plafon ketat memakan biaya:

Plafon vs kebutuhan Yang Anda bayar Yang Anda dapat
Plafon di atas kebutuhan Token yang dihasilkan Jawabannya
Plafon di bawah kebutuhan Seluruh plafon, semuanya penalaran Tidak ada yang bisa dipakai, plus retry

Ambil ilustrasi. Misalkan seperempat panggilan Anda butuh lebih dari 1.000 token. Dengan max_tokens=1000, setiap panggilan itu menagih 1.000 token output berupa proses berpikir, tidak mengembalikan apa pun, lalu diulang. Itu menambah rata-rata 250 token output terbuang per panggilan di seluruh panggilan, belum termasuk retry-nya sendiri, plus latensi permintaan kedua. Dengan plafon 4.000, tidak ada yang terbuang. Di Qwen3.8 27B, output seharga $2.17 per 1 juta token, jadi pemborosan ini menumpuk pada volume besar.

Risiko sebenarnya dari plafon tinggi adalah balasan yang lepas kendali: model yang berputar-putar atau berpikir berlebihan dan menghasilkan jauh lebih banyak dari yang dibutuhkan. Batas keras membatasinya. Tentukan batas itu dari data, seperti di bawah.

Bagaimana mengukur kebutuhan sebuah tugas?

Jalankan prompt nyata untuk satu jenis tugas dengan plafon yang longgar, lalu catat completion token dan porsi penalarannya. Jika model melaporkannya, usage.completion_tokens_details.reasoning_tokens memberi bagian penalaran; dokumentasi BroadNet mencantumkan field itu.

import os
from openai import OpenAI

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])
MODEL = "broadnet/qwen3.8-27b"

def measure(prompts, ceiling=16_000, **kw):
    """Run real prompts with a generous ceiling and return per-call token counts."""
    rows = []
    for p in prompts:
        r = client.chat.completions.create(model=MODEL, max_tokens=ceiling,
                                           messages=[{"role": "user", "content": p}], **kw)
        u, d = r.usage, r.usage.completion_tokens_details
        reasoning = (d.reasoning_tokens or 0) if d else 0
        rows.append({"reasoning": reasoning, "answer": u.completion_tokens - reasoning,
                     "finish": r.choices[0].finish_reason})
    return rows

def pct(values, q):
    values = sorted(values)
    return values[min(len(values) - 1, int(q * len(values)))]

def recommend(rows, margin=1.2):
    total = [r["reasoning"] + r["answer"] for r in rows]
    return {"p50": pct(total, 0.5), "p95": pct(total, 0.95), "max": max(total),
            "max_tokens": int(pct(total, 0.95) * margin),
            "cut_off": sum(r["finish"] == "length" for r in rows)}

# print(recommend(measure(my_prompts)))                       # default effort
# print(recommend(measure(my_prompts, reasoning_effort="low")))

Aturan agar angkanya bisa diandalkan:

  1. Satu jenis tugas per run. Klasifikasi, ekstraksi, code review, dan perencanaan punya distribusi yang sangat berbeda. Satu max_tokens global entah membuang uang untuk retry atau meloloskan balasan yang lepas kendali.
  2. 50 atau lebih prompt nyata. Persentil ke-95 dari sepuluh sampel hanyalah sampel terbesar.
  3. Jalankan di setiap tingkat effort yang Anda pakai. reasoning_effort="low" mengubah distribusinya. BroadNet mendokumentasikan low; uji nilai lain sebelum Anda mengandalkannya.
  4. Jika cut_off tidak nol, naikkan plafon dan jalankan lagi. Sampel yang terpotong menyembunyikan panjang sebenarnya.
  5. Jalankan ulang saat model atau prompt berubah. Versi model baru bisa berpikir lebih banyak atau lebih sedikit.

Lalu atur max_tokens per tugas dari recommend(). Persentil ke-95 ditambah 20% membuat sebagian besar panggilan jauh di bawah plafon dan hanya mengirim panggilan panjang yang jarang ke jalur retry di bawah. Alat anggaran token penalaran yang gratis menghitungnya di browser Anda begitu angkanya sudah ada.

Bagaimana context window membatasi anggaran?

Context window menampung prompt dan jawaban sekaligus. Feed harga BroadNet mendefinisikan context_length sebagai “the most tokens one request can hold, prompt and answer together” (Terjemahan BroadRouter: jumlah token terbanyak yang bisa ditampung satu permintaan, prompt dan jawaban sekaligus). Jadi:

max_tokens ≤ panjang context − token prompt

Model Context Ruang untuk max_tokens dengan prompt 200.000 token
GLM 5.3 1.048.576 848.576
DeepSeek V4.1 Flash 1.048.576 848.576
Qwen3.8 27B 262.144 62.144

Ini penting untuk pekerjaan konteks panjang. Agent yang riwayatnya sudah tumbuh hingga 250.000 token di Qwen3.8 27B hanya punya sekitar 12.000 token tersisa untuk berpikir dan menjawab. Tugas konteks panjang juga cenderung butuh penalaran lebih banyak, jadi periksa sisa ruangnya saat panggilan dilakukan, bukan sekali saat startup. Context window dan kalkulator context window membahas soal muat tidaknya.

Apa yang harus dilakukan jika balasan masih terpotong?

Periksa finish_reason di setiap panggilan. Jika nilainya length, jawabannya hilang atau tidak lengkap, meskipun content berisi sedikit teks. Jangan mem-parse-nya seolah lengkap; objek JSON yang terpotong adalah sumber error hilir yang umum (output terstruktur).

Ulangi dengan anggaran dua kali lipat, dalam ruang yang diizinkan context, hingga batas keras:

import json, urllib.request

FEED = json.load(urllib.request.urlopen("https://inference.broadnet.ai/pricing.json"))
CONTEXT = {m["id"]: m.get("context_length") for m in FEED["models"]}

def ask(model, messages, budget=4_000, hard_cap=32_000, **kw):
    """Retry a cut-off reply with a doubled budget, never past the cap or the context window."""
    while True:
        r = client.chat.completions.create(model=model, messages=messages,
                                           max_tokens=budget, **kw)
        if r.choices[0].finish_reason != "length":
            return r
        room = CONTEXT[model] - r.usage.prompt_tokens        # context holds prompt + answer
        nxt = min(budget * 2, hard_cap, room)
        if nxt <= budget:
            raise RuntimeError(f"still cut off at max_tokens={budget}")
        print(f"cut off at {budget}, retrying with {nxt}")
        budget = nxt

Dua alternatif selain menggandakan, tergantung tugasnya:

  • Ulangi dengan reasoning_effort="low" pada anggaran yang sama. Untuk tugas sederhana, model sering berpikir berlebihan, dan effort yang lebih rendah menyelesaikannya tanpa plafon yang lebih besar.
  • Pecah tugasnya. Jika sebuah balasan terus menabrak batas yang tinggi, biasanya permintaannya meminta terlalu banyak sekaligus.

Catat setiap pemotongan beserta jenis tugasnya di log. Tingkat yang naik berarti prompt, model, atau data input berubah, dan anggarannya perlu diukur ulang. Retry adalah inferensi baru dan ditagih lagi, jadi batasi jumlah percobaannya, seperti di agent yang berjalan lama: timeout dan retry.

Bagaimana streaming mengubah gambarannya?

Dengan stream=True, penalaran terjadi sebelum token pertama yang terlihat, sehingga model penalaran bisa tampak macet di awal. Di UI chat, tampilkan status “sedang berpikir” sampai konten tiba, dan atur timeout klien untuk waktu berpikir, bukan hanya untuk jawabannya.

Beberapa server juga men-stream teks penalaran itu sendiri, di field terpisah. Namanya tidak standar: API DeepSeek sendiri memakai reasoning_content, dan vLLM mengganti nama field-nya dari reasoning_content menjadi reasoning, dengan peringatan bahwa kode klien lama “could silently read an empty” (Terjemahan BroadRouter: bisa diam-diam membaca field kosong). Dokumentasi BroadNet tidak mendokumentasikan field teks penalaran, jadi jangan membangun fitur di atasnya tanpa memeriksa respons mentah untuk model Anda. Jika Anda membacanya, baca secara defensif:

for chunk in stream:
    if chunk.choices:
        delta = chunk.choices[0].delta
        thinking = getattr(delta, "reasoning", None) or getattr(delta, "reasoning_content", None)
        # log or display `thinking` only if your provider actually sends it
        if delta.content:
            print(delta.content, end="")
    elif chunk.usage:                                  # last chunk, with include_usage
        print("\nreasoning tokens:", getattr(chunk.usage.completion_tokens_details, "reasoning_tokens", None))

Usage di chunk terakhir memerlukan stream_options={"include_usage": True}, yang didokumentasikan BroadNet. Lebih lanjut tentang stream ada di panduan streaming dan penjelasan SSE.

Nama parameter mana yang harus dikirim?

API Parameter Termasuk penalaran
OpenAI Chat Completions max_completion_tokens (max_tokens deprecated) Ya
OpenAI Responses max_output_tokens Ya
BroadNet Inference (Chat Completions) max_tokens, sesuai dokumentasi Ya
Server vLLM max_tokens, plus thinking_token_budget opsional Ya

Saat memindahkan kode antarpenyedia, kirim nama yang didokumentasikan penyedia, dan pastikan dengan satu panggilan uji bahwa batasnya berlaku. Batas yang diam-diam diabaikan terlihat baik-baik saja sampai balasan yang lepas kendali muncul. Checklist migrasi membahas parameter lain yang berubah.

Di mana posisi BroadNet Inference?

Tiga model penalaran BroadNet melaporkan token penalaran di usage jika model menyediakannya, sehingga pengukuran di atas berjalan sebagaimana tertulis. DeepSeek V4.1 Flash dan GLM 5.3 memberi ruang paling besar, dengan context 1.048.576 token. Qwen3.8 27B punya 262.144. Jika Anda tidak butuh penalaran untuk suatu tugas, Gemma 4 VL 26B tidak tercantum sebagai model penalaran dan menghindari persoalan anggaran ini sama sekali. Pada paket DeepSeek V4.1 Flash harga tetap, token berpikir tidak dikenai biaya per token, tetapi balasan yang terpotong tetap membuang waktu, jadi penganggaran yang sama tetap berlaku. BroadNet tidak mendokumentasikan batas penalaran terpisah; jika Anda membutuhkannya, gunakan penyedia atau server self-hosted yang menawarkannya.

Pertanyaan umum

Kenapa model penalaran saya mengembalikan respons kosong?

Model menghabiskan seluruh anggaran max_tokens untuk penalaran tersembunyi sebelum sempat menulis jawaban. finish_reason-nya lalu "length". Naikkan max_tokens, turunkan reasoning_effort, atau keduanya. Panduan singkat berisi perbaikan cepatnya ditautkan dari artikel ini.

Berapa max_tokens yang sebaiknya untuk model penalaran?

Ukur dulu. Jalankan 50 atau lebih prompt nyata dengan plafon yang longgar, ambil persentil ke-95 completion_tokens untuk tugas itu, lalu tambahkan sekitar 20%. Dokumentasi BroadNet memberi 1.000 token atau lebih sebagai batas bawah; OpenAI menyarankan menyisihkan 25.000 saat mulai memakai model-modelnya.

Apakah max_tokens yang lebih tinggi lebih mahal?

Tidak dengan sendirinya. Anda ditagih untuk token yang dihasilkan model, bukan untuk plafonnya. Plafon yang lebih tinggi hanya lebih mahal jika balasan itu sebenarnya akan terpotong, dan dalam kasus itu balasan terpotong tetap akan membuat Anda membayar retry.

Apakah max_completion_tokens sama dengan max_tokens?

Di OpenAI, max_completion_tokens menggantikan max_tokens yang sudah deprecated dan secara eksplisit mencakup token penalaran. Banyak penyedia kompatibel OpenAI justru mendokumentasikan max_tokens. Dokumentasi BroadNet memakai max_tokens dan menyatakan penalaran dihitung di dalamnya.

Bisakah saya membatasi penalaran terpisah dari jawaban?

Hanya jika server mendukungnya. vLLM punya parameter thinking_token_budget, dan beberapa penyedia punya parameter sendiri. BroadNet mendokumentasikan reasoning_effort yang diatur ke low, bukan batas penalaran terpisah, jadi anggarkan keduanya bersama.

Baca sebagai MarkdownTanya ChatGPTTanya ClaudeTanya Perplexity