---
title: "max_tokens sa reasoning model: paano mag-budget | BroadRouter"
description: "Bakit walang laman ang sagot ng reasoning model kapag mababa ang max_tokens, at paano itakda ang budget mula sa sinukat na percentile, context window at retry."
url: https://broadrouter.com/fil/blog/reasoning-model-max-tokens-budget/
lang: fil
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Isinalin mula sa Ingles sa tulong ng AI. [Basahin ang orihinal sa Ingles](https://broadrouter.com/blog/reasoning-model-max-tokens-budget/) (na-update noong 2026-11-15).

# Paano itakda ang max\_tokens sa reasoning model: paraan ng pag-budget

Ng BroadNet Inference team · 6 minutong basa · Nailathala 2026-11-15

Sa reasoning model, iisang limit ng max\_tokens ang sumasaklaw sa pag-iisip at sa sagot, kaya puwedeng maputol ang reply bago lumabas ang anumang text. Sukatin ang kabuuang completion token kada uri ng task, itakda ang max\_tokens sa mga 95th percentile dagdag 20%, panatilihin ang prompt at max\_tokens sa loob ng context window, at i-retry ang naputol na reply nang dinobleng budget hanggang sa isang hard cap.

## Mga pangunahing punto

-   Kisame ang max\_tokens, hindi singil. Ang mga token na nabuo ang binabayaran mo, kaya walang gastos ang maluwag na kisame sa mga reply na maagang natapos.
-   Ang masikip na kisame ang may gastos: sinisingil ang pag-iisip ng naputol na reply, walang sagot na bumabalik, at kailangan itong ipadala ulit.
-   Mag-budget kada uri ng task mula sa sarili mong log: ang 95th percentile ng completion token dagdag 20% na margin ay magandang simula.
-   Dapat magkasya sa context window ang prompt token at max\_tokens: 262,144 token sa Qwen3.8 27B, 1,048,576 sa GLM 5.3 at DeepSeek V4.1 Flash.
-   Ituring na senyales ang finish\_reason na "length": i-retry nang dinobleng budget o mas mababang reasoning\_effort, na may hard cap.

**Sa page na ito**

1.  Bakit nauubos ang budget bago ang sagot?
2.  Mas mahal ba kapag mas malaki ang max\_tokens?
3.  Paano sukatin ang kailangan ng isang task?
4.  Paano nililimitahan ng context window ang budget?
5.  Ano ang gagawin kapag naputol pa rin ang reply?
6.  Paano binabago ng streaming ang sitwasyon?
7.  Aling pangalan ng parameter ang dapat mong ipadala?
8.  Saan pumapasok ang BroadNet Inference

Nag-iisip muna ang reasoning model bago sumagot, at sa karamihan ng OpenAI-compatible na API, iisang budget ang pinanggagalingan ng dalawa: `max_tokens`. Kapag itinakda mo ito gaya ng sa non-reasoning model, ilang daang token para sa maikling sagot, may mga reply na babalik nang walang laman at may `finish_reason: "length"`. Nasa [bakit walang laman ang sagot ng reasoning model](https://broadrouter.com/fil/guides/reasoning-tokens-empty-response/) ang mabilis na solusyon. Ang post na ito ang paraan sa likod ng budget na mapagkakatiwalaan mo: sukatin, itakda mula sa percentile, igalang ang context window, at hawakan ang mga reply na naputol pa rin.

Para sa gastos ng reasoning at kung paano ito babawasan, tingnan ang [reasoning token: bakit mas maraming output ang binabayaran mo kaysa nakikita mo](https://broadrouter.com/fil/blog/reasoning-tokens-cost/).

## Bakit nauubos ang budget bago ang sagot?

Sunod-sunod ang pagbuo ng model: una ang reasoning nito, saka ang nakikitang sagot. Bawat token ng dalawa ay kasama sa `max_tokens`. Ito ang sinasabi ng docs ng BroadNet para sa DeepSeek V4.1 Flash, GLM 5.3 at Qwen3.8 27B: “the reasoning counts toward max\_tokens” (salin: kasama ang reasoning sa max\_tokens), at kapag maliit ang limit, “the answer comes back empty” (salin: walang laman ang bumabalik na sagot). Ganoon din ang depinisyon ng reference ng OpenAI Chat Completions sa `max_completion_tokens`, bilang upper bound “including visible output tokens and reasoning tokens” (salin: kasama ang nakikitang output token at reasoning token).

Kaya ang dapat itanong ay hindi “gaano kahaba ang sagot ko?” Ito ay “gaano kahaba ang reasoning at sagot nang magkasama, sa task na ito, sa effort na ito?” Mas pabago-bago iyan kaysa inaasahan ng marami. Sabi ng guide ng OpenAI, puwedeng bumuo ang mga model nito ng “anywhere from a few hundred to tens of thousands of reasoning tokens” (salin: mula ilang daan hanggang sampu-sampung libong reasoning token), depende sa problema.

## Mas mahal ba kapag mas malaki ang max\_tokens?

Hindi. Ito ang pinakakaraniwang dahilan kung bakit masyadong masikip ang itinatakdang budget. Kisame ang [`max_tokens`](https://broadrouter.com/fil/glossary/max-tokens/). Ang talagang nabuong token ang sinisingil sa iyo. Pareho ang gastos ng reply na nangangailangan ng 1,800 token kahit 4,000 o 40,000 ang kisame.

Ito ang talagang gastos ng masikip na kisame:

| Kisame vs kailangan | Binabayaran mo | Nakukuha mo |
| --- | --- | --- |
| Kisame na lampas sa kailangan | Mga token na nabuo | Ang sagot |
| Kisame na kulang sa kailangan | Ang buong kisame, puro reasoning | Walang magagamit, dagdag pa ang retry |

Halimbawa: ipagpalagay na isang-kapat ng mga tawag mo ang nangangailangan ng higit 1,000 token. Sa `max_tokens=1000`, sinisingil ang bawat isa sa mga tawag na iyon ng 1,000 output token ng pag-iisip, walang ibinabalik, at nire-retry. Nagdaragdag iyan ng 250 nasayang na output token kada tawag sa karaniwan sa lahat ng tawag, bago pa ang mga retry mismo, dagdag ang latency ng ikalawang request. Kapag 4,000 ang kisame, walang nasasayang. Sa [Qwen3.8 27B](https://broadrouter.com/fil/models/qwen3.8-27b/), $2.17 kada 1M token ang output, kaya lumalaki ang sayang kapag malaki ang volume.

Ang totoong panganib ng mataas na kisame ay ang runaway na reply: model na umiikot o sobra mag-isip at bumubuo ng higit pa sa kailangan. Hard cap ang pumipigil diyan. Piliin ang cap mula sa data, gaya ng nasa ibaba.

## Paano sukatin ang kailangan ng isang task?

Magpatakbo ng totoong prompt para sa isang uri ng task na may maluwag na kisame, at itala ang completion token at ang bahagi ng reasoning. Kapag iniuulat ito ng model, ibinibigay ng `usage.completion_tokens_details.reasoning_tokens` ang bahagi ng reasoning; nakalista ang field na iyon sa docs ng BroadNet.

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

Mga patakaran para sa numerong mapagkakatiwalaan:

1.  **Isang uri ng task kada run.** Magkakaibang-magkaiba ang distribution ng classification, extraction, code review at planning. Ang iisang pangkalahatang `max_tokens` ay nagsasayang ng pera sa retry o nagpapalusot ng runaway na reply.
2.  **50 o higit pang totoong prompt.** Ang 95th percentile ng sampung sample ay ang pinakamalaki lang sa mga iyon.
3.  **Patakbuhin ito sa bawat effort na ginagamit mo.** Binabago ng `reasoning_effort="low"` ang distribution. `low` ang dinodokumento ng BroadNet; i-test ang ibang value bago umasa sa mga iyon.
4.  **Kung hindi zero ang `cut_off`, itaas ang kisame at patakbuhin ulit.** Itinatago ng naputol na sample ang totoong haba nito.
5.  **Patakbuhin ulit kapag nagbago ang model o prompt.** Puwedeng mas marami o mas kaunti ang pag-iisip ng bagong bersyon ng model.

Pagkatapos, itakda ang `max_tokens` kada task mula sa `recommend()`. Sa 95th percentile dagdag 20%, malayo sa kisame ang karamihan ng tawag, at ang paminsan-minsang mahaba lang ang napupunta sa retry path sa ibaba. Ang libreng [reasoning token budget tool](https://broadrouter.com/tools/reasoning-token-budget/) ang gagawa ng kuwentang ito sa browser mo kapag hawak mo na ang mga numero mo.

## Paano nililimitahan ng context window ang budget?

Magkasama sa context window ang prompt at ang sagot. Ganito ang depinisyon ng price feed ng BroadNet sa `context_length`: “the most tokens one request can hold, prompt and answer together” (salin: ang pinakamaraming token na kayang hawakan ng isang request, prompt at sagot nang magkasama). Kaya:

**max\_tokens ≤ context length − prompt token**

| Model | Context | Puwang para sa max\_tokens kapag 200,000 token ang prompt |
| --- | --- | --- |
| [GLM 5.3](https://broadrouter.com/fil/models/glm-5.3/) | 1,048,576 | 848,576 |
| [DeepSeek V4.1 Flash](https://broadrouter.com/fil/models/deepseek-v4.1-flash/) | 1,048,576 | 848,576 |
| Qwen3.8 27B | 262,144 | 62,144 |

Mahalaga ito sa long-context na trabaho. Ang agent na umabot na sa 250,000 token ang history sa Qwen3.8 27B ay may mga 12,000 token na lang para sa pag-iisip at sagot. Kadalasang mas maraming reasoning din ang kailangan ng long-context na task, kaya tingnan ang natitirang puwang sa mismong oras ng tawag, hindi minsan lang sa startup. Sinasaklaw ng [context window](https://broadrouter.com/fil/glossary/context-window/) at ng [context window calculator](https://broadrouter.com/tools/context-window-calculator/) ang pagkakasya.

## Ano ang gagawin kapag naputol pa rin ang reply?

Tingnan ang `finish_reason` sa bawat tawag. Kung `length` ito, kulang o hindi kumpleto ang sagot, kahit may text ang `content`. Huwag itong i-parse na parang kumpleto; karaniwang pinagmumulan ng error sa susunod na hakbang ang naputol na JSON object ([structured output](https://broadrouter.com/fil/blog/structured-output-json-schema/)).

Mag-retry nang dinobleng budget, sa loob ng puwang na pinapayagan ng context, hanggang sa isang hard cap:

```python
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
```

Dalawang alternatibo sa pagdodoble, depende sa task:

-   **Mag-retry sa `reasoning_effort="low"`** na pareho ang budget. Sa mga simpleng task, madalas sobra mag-isip ang model, at naaayos ito ng mas mababang effort nang hindi kailangan ng mas malaking kisame.
-   **Hatiin ang task.** Kung paulit-ulit na tumatama sa mataas na cap ang isang reply, kadalasang sobra ang hinihingi ng request nang sabay-sabay.

I-log ang bawat pagkaputol kasama ang uri ng task. Kapag tumataas ang rate, may nagbago sa prompt, sa model o sa input data, at kailangang sukatin ulit ang budget. Bagong inference ang mga retry at sinisingil ulit, kaya limitahan ang bilang ng subok, gaya ng sa [long-running agent: timeout at retry](https://broadrouter.com/fil/blog/long-running-agents-timeouts-retries/).

## Paano binabago ng streaming ang sitwasyon?

Sa `stream=True`, nangyayari ang reasoning bago ang unang nakikitang token, kaya puwedeng mukhang natigil ang reasoning model sa simula. Sa chat UI, magpakita ng “thinking” na estado hanggang dumating ang content, at itakda ang client timeout para sa oras ng pag-iisip, hindi lang sa sagot.

May mga server din na nag-i-stream ng mismong reasoning text, sa hiwalay na field. Hindi standard ang pangalan: `reasoning_content` ang gamit ng sariling API ng DeepSeek, at pinalitan ng vLLM ang pangalan ng field nito mula `reasoning_content` tungong `reasoning`, na may babalang ang lumang client code ay “could silently read an empty” field (salin: puwedeng tahimik na makabasa ng walang lamang field). Hindi dinodokumento ng docs ng BroadNet ang isang reasoning text field, kaya huwag bumuo ng feature dito nang hindi tinitingnan ang raw response para sa model mo. Kung babasahin mo ito, basahin nang maingat:

```python
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))
```

Kailangan ng `stream_options={"include_usage": True}` ang usage sa huling chunk, at dinodokumento ito ng BroadNet. Higit pa tungkol sa stream sa [streaming guide](https://broadrouter.com/fil/guides/streaming-chat-completions/) at sa [paliwanag sa SSE](https://broadrouter.com/fil/blog/llm-streaming-sse-explained/).

## Aling pangalan ng parameter ang dapat mong ipadala?

| API | Parameter | Kasama ang reasoning |
| --- | --- | --- |
| OpenAI Chat Completions | `max_completion_tokens` (deprecated ang `max_tokens`) | Oo |
| OpenAI Responses | `max_output_tokens` | Oo |
| BroadNet Inference (Chat Completions) | `max_tokens`, ayon sa docs | Oo |
| Mga vLLM server | `max_tokens`, dagdag ang opsyonal na `thinking_token_budget` | Oo |

Kapag naglilipat ng code sa pagitan ng mga provider, ipadala ang pangalang dinodokumento ng provider, at kumpirmahin sa isang test call na gumagana ang limit. Mukhang ayos ang limit na tahimik na binabalewala hanggang may dumating na runaway na reply. Sinasaklaw ng [migration checklist](https://broadrouter.com/fil/blog/openai-compatible-api-migration-checklist/) ang iba pang parameter na nagbabago.

## Saan pumapasok ang BroadNet Inference

Iniuulat ng tatlong reasoning model ng BroadNet ang reasoning token sa `usage` kapag ibinibigay ito ng model, kaya gumagana ang pagsukat sa itaas gaya ng pagkakasulat. Ang DeepSeek V4.1 Flash at GLM 5.3 ang nagbibigay ng pinakamaraming puwang, na may 1,048,576 token na context. 262,144 ang sa Qwen3.8 27B. Kung hindi mo kailangan ng reasoning para sa isang task, hindi nakalista bilang reasoning model ang [Gemma 4 VL 26B](https://broadrouter.com/fil/models/gemma-4-vl-26b/) at naiiwasan nito ang tanong sa budget. Sa flat na [DeepSeek V4.1 Flash plan](https://broadrouter.com/fil/guides/unlimited-llm-api-sessions/), walang singil kada token ang mga thinking token, pero may gastos pa rin sa oras ang mga naputol na reply, kaya parehong pag-budget ang naaangkop. Hindi dinodokumento ng BroadNet ang hiwalay na limit sa reasoning; kung kailangan mo nito, gumamit ng provider o self-hosted na server na nag-aalok nito.

Mga libreng tool para rito (Ingles)

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[Libreng tools (Ingles)](https://broadrouter.com/tools/)

## Mga termino sa artikulong ito

[Token](https://broadrouter.com/fil/glossary/token/)

Ang token ay ang yunit ng text na binabasa at isinusulat ng isang language model: isang salita, bahagi ng salita, bantas o byte sequence na ginawa ng tokenizer ng model. Sa token binibilang, nililimitahan at kadalasang sinisingil ng mga LLM API ang paggamit.

[Context window](https://broadrouter.com/fil/glossary/context-window/)

Ang context window ay ang pinakamaraming token na kayang hawakan ng isang language model sa iisang request. Sakop nito ang prompt, history ng usapan, tool definitions, mga larawan at ang nabuong output, kasama ang anumang reasoning tokens. Ang hindi kasya ay kailangang bawasan, ibuod o hatiin sa ilang request.

[Reasoning tokens](https://broadrouter.com/fil/glossary/reasoning-tokens/)

Ang reasoning tokens ay mga token na binubuo ng isang reasoning model para pag-isipan ang isang problema bago nito isulat ang nakikitang sagot. Kadalasang sinisingil ang mga ito bilang output token, binibilang sa output limit at sa context window, at puwedeng itago o ibuod ng API.

[Input at output token (input and output tokens)](https://broadrouter.com/fil/glossary/input-and-output-tokens/)

Ang input token ay ang mga token na binabasa ng language model sa isang request, kasama ang system prompt, history ng usapan, tool definitions at mga larawan. Ang output token ay ang mga token na binubuo nito bilang sagot, kasama ang anumang reasoning. Kadalasang magkahiwalay ang presyo ng dalawa, at mas mahal ang output.

[max\_tokens](https://broadrouter.com/fil/glossary/max-tokens/)

Ang max\_tokens ay isang parameter ng LLM API na nagtatakda ng pinakamaraming token na puwedeng isulat ng model sa isang response. Kapag naabot ang limit, humihinto ang pagbuo ng sagot at minamarkahang naputol ang response, halimbawa may finish\_reason na "length".

[Chat Completions API](https://broadrouter.com/fil/glossary/chat-completions-api/)

Ang Chat Completions API ay HTTP endpoint ng OpenAI, POST /v1/chat/completions, na tumatanggap ng pangalan ng model at listahan ng mga message na may role, at ibinabalik ang susunod na message ng model. Ang hugis ng request at response nito ang naging karaniwang format na ginagamit din ng mga OpenAI-compatible na provider at SDK.

[vLLM](https://broadrouter.com/fil/glossary/vllm/)

Ang vLLM ay isang open-source na library para sa LLM inference at serving, na unang binuo sa Sky Computing Lab ng UC Berkeley. Pinamamahalaan nito ang KV cache memory gamit ang PagedAttention, tuloy-tuloy na bina-batch ang mga papasok na request, sumusuporta sa maraming quantization format at may OpenAI-compatible na HTTP server.

[AI agent](https://broadrouter.com/fil/glossary/agent/)

Ang AI agent ay isang system kung saan ang language model mismo ang nagdidirekta ng mga hakbang nito tungo sa isang layunin: pinipili nito kung aling tools ang tatawagin, binabasa ang mga resulta at umuulit hanggang makabuo ng huling sagot o maabot ang limit. Workflow naman ang karaniwang tawag sa fixed na script na tumatawag sa model sa takdang punto.

## Mga tanong

### Bakit walang laman ang response ng reasoning model ko?

Naubos ng model ang buong budget ng max\_tokens sa nakatagong reasoning bago nito naisulat ang sagot. "length" ang finish\_reason sa ganoong kaso. Itaas ang max\_tokens, ibaba ang reasoning\_effort, o pareho. May link sa post na ito sa maikling gabay na may mabilis na solusyon.

### Anong max\_tokens ang dapat kong itakda sa reasoning model?

Sukatin muna. Magpatakbo ng 50 o higit pang totoong prompt na may maluwag na kisame, kunin ang 95th percentile ng completion\_tokens para sa task na iyon, at magdagdag ng mga 20%. 1,000 token o higit pa ang ibinibigay na minimum ng docs ng BroadNet; payo ng OpenAI na magreserba ng 25,000 sa simula sa mga model nito.

### Mas mahal ba kapag mas mataas ang max\_tokens?

Hindi, sa sarili nito. Ang mga token na binuo ng model ang sinisingil, hindi ang kisame. Mas mahal lang ang mas mataas na kisame kapag mapuputol sana ang reply, at sa ganoong kaso, magagastusan ka rin naman ng retry ng naputol na reply.

### Pareho ba ang max\_completion\_tokens at max\_tokens?

Sa OpenAI, pinapalitan ng max\_completion\_tokens ang deprecated na max\_tokens at tahasang kasama rito ang reasoning token. max\_tokens naman ang dinodokumento ng maraming OpenAI-compatible na provider. max\_tokens ang gamit sa docs ng BroadNet at sinasabi nitong kasama rito ang reasoning.

### Puwede ko bang lagyan ng hiwalay na limit ang reasoning at ang sagot?

Kung suportado lang ng server. May thinking\_token\_budget na parameter ang vLLM, at may sarili ang ilang provider. reasoning\_effort na low ang dinodokumento ng BroadNet, hindi hiwalay na limit sa reasoning, kaya i-budget nang magkasama ang dalawa.

## Magbasa pa

-   [Reasoning token: bakit mas maraming output ang binabayaran mo](https://broadrouter.com/fil/blog/reasoning-tokens-cost/)
-   [Paliwanag sa LLM streaming: SSE chunk, delta, usage at cancel](https://broadrouter.com/fil/blog/llm-streaming-sse-explained/)
-   [JSON mode vs json\_schema: structured output na maaasahan](https://broadrouter.com/fil/blog/structured-output-json-schema/)
-   [Matagal na tumatakbong agent: timeout, retry at checkpoint na matibay](https://broadrouter.com/fil/blog/long-running-agents-timeouts-retries/)
-   [Paglipat sa OpenAI-compatible API: checklist sa migration](https://broadrouter.com/fil/blog/openai-compatible-api-migration-checklist/)
-   [GPU hardware at paraan ng serving ng BroadNet, ayon sa BroadNet](https://broadrouter.com/fil/blog/broadnet-gpu-fleet-and-serving/)
-   [I-cache ang LLM API response, makatipid: exact-match cache sa Python](https://broadrouter.com/fil/blog/cache-llm-responses-cut-cost/)
-   [Gabay: Bakit walang laman ang sagot ng isang reasoning model](https://broadrouter.com/fil/guides/reasoning-tokens-empty-response/)
-   [Gabay: Paano mag-stream ng chat completions at ayusin ang naputol na stream](https://broadrouter.com/fil/guides/streaming-chat-completions/)
-   [Gabay: Paano gamitin ang OpenAI Python SDK sa BroadNet Inference](https://broadrouter.com/fil/guides/openai-python-sdk/)

Subukan ito sa totoong workload mo. May US$5 na panimulang credit ang mga bagong account para sa Gemma at transcription. Kailangan ng top-up para sa DeepSeek, GLM, at Qwen3.8.

[Magsimula](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=fil-blog-reasoning-model-max-tokens-budget&utm_content=page-cta) ·

**Mga source**

-   [API reference ng BroadNet Inference: kasama ang reasoning sa max\_tokens, 1,000 token o higit pa, reasoning\_effort low, mga usage field (sinuri noong 2026-11-15) (Ingles)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=fil-blog-reasoning-model-max-tokens-budget&utm_content=sources)
-   [Reference ng mga field ng pricing.json ng BroadNet: magkasama ang prompt at sagot sa context\_length (sinuri noong 2026-11-15) (Ingles)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=fil-blog-reasoning-model-max-tokens-budget&utm_content=sources#pricing-json)
-   [Reasoning guide ng OpenAI: mga hindi kumpletong response, magreserba ng hindi bababa sa 25,000 token sa simula (sinuri noong 2026-11-15)](https://developers.openai.com/api/docs/guides/reasoning)
-   [Reference ng OpenAI Chat Completions: kasama ang reasoning token sa max\_completion\_tokens; deprecated ang max\_tokens (sinuri noong 2026-11-15)](https://developers.openai.com/api/reference/resources/chat/subresources/completions/methods/create)
-   [Docs ng DeepSeek API, thinking mode: reasoning\_content field, mga effort level (sinuri noong 2026-11-15)](https://api-docs.deepseek.com/guides/thinking_mode)
-   [Docs ng vLLM, reasoning outputs: reasoning field (dating reasoning\_content), thinking\_token\_budget (sinuri noong 2026-11-15)](https://docs.vllm.ai/en/latest/features/reasoning_outputs.html)
