---
title: "Tool calling sa open model: schema, retry at code | BroadRouter"
description: "Function calling sa OpenAI-compatible na open model: tips sa schema, parallel tool call, limang paraan ng pagpalya, at Python loop na nagva-validate at nagre-retry."
url: https://broadrouter.com/fil/blog/tool-calling-open-models/
lang: fil
updated: 2026-11-14
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/tool-calling-open-models/) (na-update noong 2026-11-16).

# Tool calling sa open model: schema, parallel call, retry

Ng BroadNet Inference team · 4 minutong basa · Nailathala 2026-11-14 · Na-update 2026-11-16

Parehong tools at tool\_calls format ng OpenAI ang gamit ng mga open model sa OpenAI-compatible na API. Panatilihing maliit at flat ang schema, i-parse ang arguments bilang JSON string, i-validate bago magpatakbo ng kahit ano, at ibalik ang error sa model bilang tool result para makapag-retry ito. Lagyan ng limit ang mga hakbang. Sa BroadNet, GLM 5.3 at Qwen3.8 27B ang may nakalistang tool support.

## Mga pangunahing punto

-   Pareho ang wire format sa OpenAI: tools list ang papasok, tool\_calls ang lalabas, saka isang role tool na message kada tool\_call\_id.
-   Dumarating ang arguments bilang JSON string. Babala ng docs ng vLLM, kapag kinukuha nito ang tool call mula sa raw text, "may occasionally be malformed or violate the function's parameter schema" (salin: paminsan-minsang sira o lumalabag sa parameter schema ng function).
-   I-validate ang bawat call, ibalik ang error bilang tool result, at lagyan ng limit ang retry at kabuuang bilang ng hakbang.
-   Mas gumagana ang mas kaunti at mas flat na tool. Mungkahi ng OpenAI na wala pang 20 function sa simula ng isang turn.
-   Sa BroadNet Inference, gamitin ang GLM 5.3 o Qwen3.8 27B para sa tool calling; i-test ang DeepSeek V4.1 Flash bago umasa rito.

**Sa page na ito**

1.  Paano gumagana ang tool calling sa OpenAI-compatible na API?
2.  Paano dapat isulat ang tool schema?
3.  Paano naman ang parallel tool call?
4.  Bakit pumapalya ang mga tool call?
5.  Isang tool loop na nagva-validate at nagre-retry
6.  Aling mga model ng BroadNet ang sumusuporta sa tool calling?
7.  Saan bagay ang BroadNet Inference

Ang [tool calling](https://broadrouter.com/fil/glossary/tool-calling/) ang nagpapabago sa isang model para maging agent. Sa mga open model sa [OpenAI-compatible na API](https://broadrouter.com/fil/glossary/openai-compatible-api/), pareho ang request format sa gagamitin mo sa OpenAI. Ang nagkakaiba ay kung gaano kadalas may nagkakamali at kung ano ang ginagawa ng server para pigilan ito. Tinatalakay ng post na ito ang format, kung paano sumulat ng schema na kayang hawakan nang maayos ng mga open model, ang parallel call, ang limang palyang talagang makikita mo, at isang Python loop na nakakalusot sa mga ito.

## Paano gumagana ang tool calling sa OpenAI-compatible na API?

1.  Ipinapadala mo ang `messages` kasama ang `tools` list. May pangalan, description at JSON Schema para sa arguments ang bawat tool.
2.  Sumasagot ang model ng `finish_reason: "tool_calls"` at `tool_calls` list. May `id`, pangalan ng function at `arguments` bilang **JSON string** ang bawat entry.
3.  Pinapatakbo ng code mo ang bawat call at nagdadagdag ng isang `role: "tool"` na message kada call, na may katugmang `tool_call_id`.
4.  Tinatawag mo ulit ang API. Sasagot ang model o hihingi ng iba pang tool.

Hindi kailanman nagpapatakbo ng anuman ang model. Ang code mo ang nagpapasya kung ano ang ie-execute.

## Paano dapat isulat ang tool schema?

Mas maaasahang sinusunod ng mga open model ang mga simpleng schema. Galing ang mga patakarang ito sa gabay ng OpenAI at sa mga karaniwang nasisira:

-   **Pangalanan ang tool ayon sa aksyon**, gaya ng `read_file` o `search_code`, at sabihin sa description _kung kailan_ gagamitin ang bawat isa.
-   **Panatilihing maikli ang listahan.** Tinatawag ng gabay ng OpenAI na soft suggestion ang wala pang 20 function sa simula ng isang turn. Ipinapadala rin ang bawat schema sa bawat call; tingnan ang [token budget ng agent](https://broadrouter.com/fil/blog/agent-token-budget/).
-   **Mas piliin ang flat na arguments.** String, number, boolean at enum. Iwasan ang malalim na nesting at free-form na object.
-   **Gumamit ng enum** para sa mga nakapirming pagpipilian, para hindi makaimbento ng value ang model. Ginagawa ng [JSON schema generator](https://broadrouter.com/tools/json-schema-generator/) na flat na schema ang isang sample na arguments object na puwede mong i-paste sa `parameters`.
-   **Markahan ang mga required na field.** Kailangan ng strict mode ng OpenAI ang `additionalProperties: false` at nasa `required` ang bawat field, na may `null` bilang type para sa mga optional. Iba-iba kung ipinapatupad ng provider ang `strict`, kaya mag-validate pa rin.

## Paano naman ang parallel tool call?

Puwedeng magbalik ang model ng ilang entry sa `tool_calls` sa iisang turn, halimbawa tatlong file read. Patakbuhin nang sabay ang magkakahiwalay na call at magbalik ng isang result kada `tool_call_id`, kahit anong pagkakasunod. Kung may side effect ang mga tool mo na nakadepende sa isa’t isa, itakda ang `parallel_tool_calls: false`; sabi ng gabay ng OpenAI, nililimitahan nito ang model sa zero o isang call kada turn. I-test kung sinusunod ito ng provider mo.

## Bakit pumapalya ang mga tool call?

| Palya | Ang nakikita mo | Ayos |
| --- | --- | --- |
| Sirang arguments | Nagra-raise ang `json.loads` | Ibalik ang parse error bilang tool result; i-retry |
| Hindi tugma sa schema | Kulang na field, maling type, inimbentong enum | Mag-validate; ibalik ang validation error |
| Hindi kilalang tool | Pangalang hindi mo kailanman dinepina | Ibalik ang “unknown tool, available: …” |
| Walang call kahit kailangan | Text na sagot ang dumating | `tool_choice: "required"` o isang pinangalanang function |
| Naputol na call | `finish_reason: "length"` | Taasan ang `max_tokens`; kahati nito ang reasoning |

Inaasahan ang unang dalawa, hindi bihira. Sabi ng tool-calling docs ng vLLM, sa `auto` mode, maliban kung may tool na nagtatakda ng `strict: true` (o nagpapatupad ang server ng minimum na strictness) at sinusuportahan ng parser ng model ang constraints, “vLLM extracts tool calls from raw text, so arguments may occasionally be malformed or violate the function’s parameter schema.” (salin: kinukuha ng vLLM ang tool call mula sa raw text, kaya paminsan-minsang sira ang arguments o lumalabag sa parameter schema ng function.) Ang pinangalanang function ay gumagamit ng structured-outputs backend ng vLLM. Puwedeng iba ang paraan ng pag-serve ng provider mo, kaya ituring na sapilitan ang validation.

Ang huling row ang humuhuli sa mga gumagamit ng [reasoning model](https://broadrouter.com/fil/glossary/reasoning-tokens/). Nag-iisip muna bago sumagot ang GLM 5.3 at Qwen3.8 27B, at kasama ang pag-iisip sa [`max_tokens`](https://broadrouter.com/fil/glossary/max-tokens/). Ipinapaliwanag ng [kung bakit bumabalik na walang laman o naputol ang sagot](https://broadrouter.com/fil/guides/reasoning-tokens-empty-response/) kung gaano kalaking puwang ang dapat iwan.

## Isang tool loop na nagva-validate at nagre-retry

```python
import json, os
from openai import OpenAI
from jsonschema import validate, ValidationError

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"], max_retries=4)
MODEL = "broadnet/glm-5.3"

TOOLS = [{"type": "function", "function": {
    "name": "get_order_status",
    "description": "Look up one order by its ID. Use when the user asks where an order is.",
    "parameters": {"type": "object",
                   "properties": {"order_id": {"type": "string"}},
                   "required": ["order_id"], "additionalProperties": False}}}]
SCHEMAS = {t["function"]["name"]: t["function"]["parameters"] for t in TOOLS}
IMPL = {"get_order_status": lambda order_id: f"Order {order_id}: shipped"}

def run_call(call):
    name = call.function.name
    if name not in IMPL:
        return f"Error: unknown tool {name}. Available: {', '.join(IMPL)}"
    try:
        args = json.loads(call.function.arguments or "{}")
        validate(args, SCHEMAS[name])
    except (json.JSONDecodeError, ValidationError) as e:
        return f"Error: invalid arguments ({e}). Send the call again with valid JSON."
    return str(IMPL[name](**args))

def agent(messages, max_steps=8):
    for _ in range(max_steps):
        r = client.chat.completions.create(model=MODEL, messages=messages,
                                           tools=TOOLS, max_tokens=4000)
        msg = r.choices[0].message
        if r.choices[0].finish_reason == "length":
            raise RuntimeError("Output limit reached; raise max_tokens")
        messages.append(msg.model_dump(exclude_none=True))
        if not msg.tool_calls:
            return msg.content
        for call in msg.tool_calls:
            messages.append({"role": "tool", "tool_call_id": call.id,
                             "content": run_call(call)})
    raise RuntimeError("Step limit reached")
```

Tatlong desisyon sa disenyo ang mahalaga rito:

1.  **Bumabalik sa model ang mga error bilang tool result.** Nakikita ng model kung ano ang mali at kadalasang naitatama ito sa susunod na turn. Kapag nag-raise ka ng exception, nasasayang ang pagkakataong iyon.
2.  **May hangganan ang loop.** Pinapahinto ng `max_steps` ang model na paulit-ulit na tumatawag ng tool nang walang usad.
3.  **Hiwalay ang transport retry.** Ang `max_retries` sa client ang humahawak sa 429 at 5xx. Sa loop hinahawakan ang maling arguments. Huwag paghaluin ang dalawa; tingnan ang [errors at retries](https://broadrouter.com/fil/guides/errors-and-retries/).

Para sa mga tool na may side effect, gaya ng pagpapadala ng email, magdagdag ng idempotency key para hindi dalawang beses kumilos ang inulit na hakbang. Tinatalakay ito sa [long-running na agent](https://broadrouter.com/fil/blog/long-running-agents-timeouts-retries/).

## Aling mga model ng BroadNet ang sumusuporta sa tool calling?

| Model | Nakalista ang tools | Context | Tala |
| --- | --- | --- | --- |
| [GLM 5.3](https://broadrouter.com/fil/models/glm-5.3/) | Oo | 1,048,576 | May structured output din |
| [Qwen3.8 27B](https://broadrouter.com/fil/models/qwen3.8-27b/) | Oo | 262,144 | May image input din |
| [DeepSeek V4.1 Flash](https://broadrouter.com/fil/models/deepseek-v4.1-flash/) | Hindi nakalista | 1,048,576 | Image input; i-test ang tools bago umasa sa mga ito |
| [Gemma 4 VL 26B](https://broadrouter.com/fil/models/gemma-4-vl-26b/) | Hindi nakalista | 32,768 | Hindi para sa tool loop |

Para pumili sa dalawang model na may tool support, tingnan ang [GLM 5.3 vs Qwen3.8 27B](https://broadrouter.com/compare/glm-5.3-vs-qwen3.8-27b/). Kapag kailangang tumugma sa isang hugis ang huling sagot pero walang function na kailangang patakbuhin, mas simple ang [structured output](https://broadrouter.com/fil/blog/structured-output-json-schema/) kaysa sa tool.

## Saan bagay ang BroadNet Inference

Sine-serve ng BroadNet Inference ang GLM 5.3 at Qwen3.8 27B na may nakalistang tool calling, sa pamamagitan ng standard na chat-completions format, kaya tumatakbo nang walang pagbabago ang loop sa itaas gamit ang [OpenAI Python SDK](https://broadrouter.com/fil/guides/openai-python-sdk/). Nasa [pricing page](https://broadrouter.com/fil/pricing/) ang presyo kada token. Hindi ito nagho-host ng server-side na tool gaya ng web search o code execution, at hindi nakalista sa docs nito ang tool calling para sa DeepSeek V4.1 Flash, ang model sa mga unlimited na plan. Para sa agent na mabigat sa tools, gamitin ang GLM 5.3 o Qwen3.8 27B kada token. Kung gusto mo pa rin ang flat plan, tingnan sa isang $1 na Meteor hour kung maaasahang tinatawag ng DeepSeek V4.1 Flash ang mga tool mo bago bumili ng isang buwan.

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

[Tool calling (function calling)](https://broadrouter.com/fil/glossary/tool-calling/)

Ang tool calling, tinatawag ding function calling, ay feature ng LLM API kung saan nagbabalik ang model ng structured na request para magpatakbo ng function na tinukoy ng developer, kasama ang JSON arguments. Ang application ang nagpapatakbo ng function at nagpapadala pabalik ng resulta; hindi kailanman nagpapatakbo ng code ang model mismo.

[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.

[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.

[Open-weight model](https://broadrouter.com/fil/glossary/open-weight-model/)

Ang open-weight model ay machine learning model na inilathala ang trained weights para i-download at patakbuhin ng kahit sino, kadalasan sa ilalim ng lisensyang may kondisyon. Iba ito sa ganap na open-source AI, na naglalabas din ng training code at detalyadong impormasyon tungkol sa training data para mapag-aralan at ma-reproduce ng iba ang model.

[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.

[Flat-rate LLM plan (unlimited na plan)](https://broadrouter.com/fil/glossary/flat-rate-llm-plan/)

Ang flat-rate LLM plan ay naniningil ng fixed na presyo para sa isang period, gaya ng isang buwan, para sa access sa language model API sa halip na maningil kada token. Kadalasang may ibang nililimitahan ang ganitong plan, gaya ng concurrency, bilis, mga model o usage window, kaya kasinghalaga ng presyo ang mga limit.

[JSON Schema](https://broadrouter.com/fil/glossary/json-schema/)

Ang JSON Schema ay isang vocabulary, nakasulat sa JSON, para ilarawan at i-validate ang istruktura ng JSON data: mga type, required na field, pinapayagang value at nesting. 2020-12 ang kasalukuyang bersyon. Ginagamit ito ng mga LLM API para tukuyin ang tool parameters at ang eksaktong hugis na dapat sundin ng structured output.

[Structured output](https://broadrouter.com/fil/glossary/structured-output/)

Ang structured output ay feature ng LLM API na naglilimita sa sagot ng model sa format na itinakda ng developer, kadalasang JSON Schema, para maaasahang ma-parse ito ng code. Mas mahigpit ito kaysa sa JSON mode, na gumagarantiya ng valid na JSON pero hindi ng partikular na hugis.

## Mga tanong

### Sumusuporta ba sa function calling ang mga open model?

Marami, pero depende ang suporta sa model at sa paraan ng pag-serve ng provider. Sa BroadNet Inference, nakalista sa docs ang tool calling para sa GLM 5.3 at Qwen3.8 27B. Hindi ito nakalista para sa DeepSeek V4.1 Flash o Gemma 4 VL 26B.

### Bakit invalid JSON ang arguments ng tool call ko?

Maliban kung kinokontrol ng server ang decoding, ginagawa ang arguments bilang text at pina-parse pagkatapos. Sabi ng docs ng vLLM, puwedeng paminsan-minsang sira ang arguments na kinuha mula sa raw text. Saluhin ang parse error at ibalik ito bilang tool result para maitama ng model ang sarili.

### Paano ko io-off ang parallel tool call?

Sa OpenAI format, itakda ang parallel\_tool\_calls sa false. Nililimitahan nito ang model sa zero o isang tool call kada turn. I-check kung sinusunod ng provider mo ang field.

### Bakit text ang sagot ng model sa halip na tumawag ng tool?

Sa tool\_choice na auto, ang model ang nagpapasya. Itakda ang tool\_choice sa required, o sa isang tiyak na function, kapag sapilitan ang call. I-check din kung sinasabi ng description ng tool kung kailan ito gagamitin.

### Bakit naputol ang tool call ko?

Sa mga reasoning model, kasama sa max\_tokens ang pag-iisip. Puwedeng matapos sa gitna ng arguments ang sagot kapag maliit ang limit. Tingnan ang finish\_reason at taasan ang max\_tokens.

## Magbasa pa

-   [OpenClaw at Hermes Agent sa murang model: setup at token math](https://broadrouter.com/fil/blog/openclaw-hermes-agent-cheap-model/)
-   [JSON mode vs json\_schema: structured output na maaasahan](https://broadrouter.com/fil/blog/structured-output-json-schema/)
-   [Paano gamitin ang MCP server sa OpenAI-compatible na model](https://broadrouter.com/fil/blog/mcp-with-openai-compatible-models/)
-   [Matagal na tumatakbong agent: timeout, retry at checkpoint na matibay](https://broadrouter.com/fil/blog/long-running-agents-timeouts-retries/)
-   [Token budget ng agent: saan napupunta ang token ng agent loop](https://broadrouter.com/fil/blog/agent-token-budget/)
-   [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: Paano gamitin ang OpenAI Python SDK sa BroadNet Inference](https://broadrouter.com/fil/guides/openai-python-sdk/)
-   [Gabay: Patakbuhin ang OpenAI Agents SDK sa BroadNet Inference](https://broadrouter.com/fil/guides/openai-agents-sdk-custom-provider/)
-   [Gabay: Bakit walang laman ang sagot ng isang reasoning model](https://broadrouter.com/fil/guides/reasoning-tokens-empty-response/)
-   [Gabay: Mga error code ng BroadNet Inference at kailan dapat mag-retry](https://broadrouter.com/fil/guides/errors-and-retries/)

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-tool-calling-open-models&utm_content=page-cta) ·

**Mga source**

-   [OpenAI, gabay sa function calling (sinuri noong 2026-11-14)](https://developers.openai.com/api/docs/guides/function-calling)
-   [Docs ng vLLM, tool calling (sinuri noong 2026-11-14)](https://docs.vllm.ai/en/latest/features/tool_calling/)
-   [API reference ng BroadNet Inference, mga model (Ingles)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=fil-blog-tool-calling-open-models&utm_content=sources#models)
