Ang tool calling ang nagpapabago sa isang model para maging agent. Sa mga open model sa OpenAI-compatible na 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?
- Ipinapadala mo ang
messageskasama angtoolslist. May pangalan, description at JSON Schema para sa arguments ang bawat tool. - Sumasagot ang model ng
finish_reason: "tool_calls"attool_callslist. Mayid, pangalan ng function atargumentsbilang JSON string ang bawat entry. - Pinapatakbo ng code mo ang bawat call at nagdadagdag ng isang
role: "tool"na message kada call, na may katugmangtool_call_id. - 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_fileosearch_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.
- 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 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: falseat nasarequiredang bawat field, na maynullbilang type para sa mga optional. Iba-iba kung ipinapatupad ng provider angstrict, 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. Nag-iisip muna bago sumagot ang GLM 5.3 at Qwen3.8 27B, at kasama ang pag-iisip sa max_tokens. Ipinapaliwanag ng kung bakit bumabalik na walang laman o naputol ang sagot kung gaano kalaking puwang ang dapat iwan.
Isang tool loop na nagva-validate at nagre-retry
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:
- 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.
- May hangganan ang loop. Pinapahinto ng
max_stepsang model na paulit-ulit na tumatawag ng tool nang walang usad. - Hiwalay ang transport retry. Ang
max_retriessa client ang humahawak sa 429 at 5xx. Sa loop hinahawakan ang maling arguments. Huwag paghaluin ang dalawa; tingnan ang errors at 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.
Aling mga model ng BroadNet ang sumusuporta sa tool calling?
| Model | Nakalista ang tools | Context | Tala |
|---|---|---|---|
| GLM 5.3 | Oo | 1,048,576 | May structured output din |
| Qwen3.8 27B | Oo | 262,144 | May image input din |
| DeepSeek V4.1 Flash | Hindi nakalista | 1,048,576 | Image input; i-test ang tools bago umasa sa mga ito |
| 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. Kapag kailangang tumugma sa isang hugis ang huling sagot pero walang function na kailangang patakbuhin, mas simple ang structured output 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. Nasa pricing page 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.
