Lumaktaw sa nilalaman
Function calling

Function calling

Ilarawan ang iyong mga function sa request at sasagot ang model ng mga call na gusto nitong gawin. Pinapatakbo ng iyong code ang mga ito at ipinapadala pabalik ang mga resulta: nagbabalik ng tool call ang API at hindi ito mismo ang nagpapatakbo ng tool.

POST https://api.shannon-ai.com/v1/chat/completions

Gumagamit ng /v1/chat/completions ang mga sample sa pahinang ito. Tumatakbo ang parehong loop sa /v1/responses at /v1/messages; kung saan magkaiba ang baybay ng isang format, ipinapakita ng mga seksyon sa ibaba ang lahat ng tatlo.

import json
from openai import OpenAI

client = OpenAI(api_key="YOUR_API_KEY", base_url="https://api.shannon-ai.com/v1")

tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Get the current weather for a city.",
        "parameters": {
            "type": "object",
            "properties": {
                "city": {"type": "string", "description": "City name, for example Paris"},
                "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]},
            },
            "required": ["city"],
        },
    },
}]

def get_weather(city, unit="celsius"):
    # Your code: ask a weather service here.
    return {"city": city, "temperature": 18, "unit": unit, "conditions": "cloudy"}

messages = [{"role": "user", "content": "What is the weather in Paris right now?"}]
answer = None

for _ in range(5):  # the API sets no limit on rounds: set your own
    response = client.chat.completions.create(
        model="Kimi-K3-3BIT-REAP",
        messages=messages,
        tools=tools,
    )
    choice = response.choices[0]
    if choice.finish_reason != "tool_calls":
        answer = choice.message.content
        break

    messages.append(choice.message)  # the assistant turn with its tool_calls
    for call in choice.message.tool_calls:
        args = json.loads(call.function.arguments)  # arguments is a JSON string
        result = get_weather(**args)
        messages.append({
            "role": "tool",
            "tool_call_id": call.id,
            "content": json.dumps(result),
        })

print(answer)

Hindi sinasagot ng unang reply ang tanong. Humihingi ito ng call:

200 JSON
{
  "id": "chatcmpl-5b0c1d8e7f6a4b3c9d2e1f0a8b7c6d5e",
  "object": "chat.completion",
  "created": 1791590400,
  "model": "Kimi-K3-3BIT-REAP",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": null,
        "reasoning_content": "The user asks for the current weather in Paris. I should call get_weather.",
        "tool_calls": [
          {
            "id": "call_9f1c2ab34d5e4f60a7b8c9d0e1f2a3b4",
            "type": "function",
            "function": {
              "name": "get_weather",
              "arguments": "{\"city\":\"Paris\"}"
            }
          }
        ]
      },
      "finish_reason": "tool_calls"
    }
  ],
  "usage": {
    "prompt_tokens": 312,
    "completion_tokens": 58,
    "total_tokens": 370,
    "prompt_tokens_details": {"cached_tokens": 0},
    "completion_tokens_details": {"reasoning_tokens": 31}
  }
}

Pagkatapos mong ipadala ang resulta, ang susunod na reply ay karaniwang sagot: ang message.content ang may hawak ng text at ang finish_reason ay stop.

Ang loop, hakbang-hakbang

Hakbang Sino Ano ang mangyayari
1 Ikaw Ipadala ang messages kasama ang tools, ang listahan ng mga function na maaaring hilingin ng model.
2 Model May dalang tool_calls at finish_reason: "tool_calls" ang reply. Pinangangalanan ng bawat call ang isang function at ibinibigay ang mga argument nito.
3 Ikaw I-parse ang arguments ng bawat call at patakbuhin ang iyong function.
4 Ikaw I-append ang assistant message at isang tool message kada call sa messages, saka ipadala muli ang request na may parehong tools.
5 Model Sumasagot ang model sa text na may finish_reason: "stop", o humihingi ng higit pang call. Sa kasong iyon, bumalik sa hakbang 3.

Ang isang request ay isang model turn. Walang itinatagong conversation ang API sa pagitan ng mga request at walang itinakdang bilang ng round: hawak ng iyong code ang messages at ito ang nagpapasya kung kailan hihinto.

Pagdedefine ng tools

Ang tools ay isang array na may isang entry kada function. Tinatanggap ito ng bawat model sa catalogue; iniuulat ng GET /v1/models ang capabilities.tools: true para sa bawat id.

Field Type Paglalarawan
type string Palaging function.
function.name string Ang pangalang ginagamit ng model kapag hinihiling nito ang function na ito. Kinakailangan.
function.description string Ano ang ginagawa ng function, sa payak na wika.
function.parameters object Ang mga argument bilang JSON Schema na may type: "object" sa itaas. Tingnan ang Mga schema keyword sa ibaba.

May sariling baybay ng tool ang bawat endpoint. Ipadala ang nabibilang sa endpoint na tinatawag mo:

{
  "type": "function",
  "function": {
    "name": "get_weather",
    "description": "Get the current weather for a city.",
    "parameters": {
      "type": "object",
      "properties": {
        "city": {
          "type": "string",
          "description": "City name, for example Paris"
        },
        "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
      },
      "required": ["city"]
    }
  }
}

tool_choice

Sinasabi ng tool_choice kung maaari, o dapat, tumawag ng tool ang model. Binabasa lamang ito kasama ng tools.

Value Paglalarawan Ina-apply ng
"auto" Nagpapasya ang model kung sasagot ito sa text o tatawag ng tool. Ito ang default. Lahat ng model
"required" Tumatawag ang reply ng kahit isang tool. Mga hosted open-weight model
{"type": "function", "function": {"name": "get_weather"}} Tinatawag ng reply ang function na ito. Dapat isa ang pangalan sa mga function sa tools. Ang mga call sa ibang function ay inaalis sa reply. Mga hosted open-weight model

Nagpapasya ang mga Shannon model (shannon-*) sa bawat request, tulad ng auto.

Gamit ang required o isang pinangalanang function, basahin ang finish_reason bago ang tool_calls. Kapag walang nabuong call ang model, ang reply ay sagot na text na may finish_reason: "stop".

Kahulugan /v1/chat/completions /v1/responses /v1/messages
Nagpapasya ang model "auto" "auto" {"type": "auto"}
Tumawag ng kahit isang tool "required" "required" {"type": "any"}
Tumawag ng isang pinangalanang function {"type": "function", "function": {"name": "get_weather"}} {"type": "function", "name": "get_weather"} {"type": "tool", "name": "get_weather"}

Tinatanggap para sa compatibility: tool_choice: "none" at parallel_tool_calls. Para sa turn na walang tool call, ipadala ang request nang walang tools.

Mga tool call sa reply

Field Type Paglalarawan
finish_reason string tool_calls kapag may dalang kahit isang call ang reply.
message.tool_calls array Isang entry kada call. Naroroon lamang ang field kapag humiling ng call ang model.
tool_calls[].id string call_ na sinusundan ng 32 hexadecimal na character. Ipadala ito pabalik bilang tool_call_id kasama ang resulta.
tool_calls[].type string Palaging function.
tool_calls[].function.name string Ang function na papatakbuhin.
tool_calls[].function.arguments string Ang mga argument bilang JSON string, "{}" kapag wala. I-parse ito bago gamitin.
message.content string | null null kapag mga call lang ang laman ng reply. Maaaring magbalik ang mga hosted open-weight model ng text katabi ng mga call; null ang ibinabalik ng mga Shannon model.

Ang parehong call sa bawat format. Sa /v1/responses, ito ay isang function_call item ng output, na ang arguments ay JSON string. Sa /v1/messages, ito ay isang tool_use content block na ang input ay JSON object, ang id nito ay nagsisimula sa toolu_, at ang stop_reason ay tool_use.

{
  "finish_reason": "tool_calls",
  "message": {
    "role": "assistant",
    "content": null,
    "tool_calls": [
      {
        "id": "call_9f1c2ab34d5e4f60a7b8c9d0e1f2a3b4",
        "type": "function",
        "function": {
          "name": "get_weather",
          "arguments": "{\"city\":\"Paris\"}"
        }
      }
    ]
  }
}

Ilang call sa isang turn

Maaaring magdala ang reply ng ilang call. Patakbuhin ang bawat isa at magpadala ng isang resulta kada call, bawat isa ay may sariling tool_call_id, sa susunod na request.

Ibinabalik ng mga hosted open-weight model ang bawat natatanging call nang isang beses: ang dalawang call na magkapareho ang pangalan at argument ay dumarating bilang isa.

Mga naka-stream na tool call

Gamit ang stream: true, dumarating nang buo ang isang call: hawak ng chunk ang kumpletong arguments string, kaya walang pira-pirasong pagdudugtungin. Binibilang ng index ang mga call ng turn mula 0.

data: isang chunk, naka-format
{
  "id": "chatcmpl-5b0c1d8e7f6a4b3c9d2e1f0a8b7c6d5e",
  "object": "chat.completion.chunk",
  "created": 1791590400,
  "model": "Kimi-K3-3BIT-REAP",
  "choices": [
    {
      "index": 0,
      "delta": {
        "tool_calls": [
          {
            "index": 0,
            "id": "call_9f1c2ab34d5e4f60a7b8c9d0e1f2a3b4",
            "type": "function",
            "function": {
              "name": "get_weather",
              "arguments": "{\"city\":\"Paris\"}"
            }
          }
        ]
      },
      "finish_reason": null
    }
  ]
}
Endpoint Ano ang dumarating
/v1/chat/completions Isang chat.completion.chunk kada call, na ang call ay nasa delta.tool_calls[0]. Ang huling chunk ay may finish_reason: "tool_calls" at usage.
/v1/responses Kada call: response.output_item.added (isang function_call item na may walang lamang arguments), response.function_call_arguments.delta (ang buong string), response.function_call_arguments.done, response.output_item.done.
/v1/messages Kada call: content_block_start (isang tool_use block na may walang lamang input), isang content_block_delta na ang input_json_delta.partial_json ay ang buong text ng mga argument, content_block_stop. Dala na pagkatapos ng message_delta ang stop_reason: "tool_use".

Sa shannon-1.6-lite, shannon-1.6-pro, shannon-2-lite, shannon-2-pro at shannon-coder-1, ang naka-stream na request na may dalang tools ay naghahatid ng text ng sagot nito sa isang content delta sa dulo ng turn. Pag‑stream

Pagpapadala pabalik ng mga resulta

Inuulit ng ikalawang request ang conversation at nagdaragdag ng dalawang bagay: ang assistant turn na humiling ng mga call, at isang resulta kada call.

{
  "messages": [
    {"role": "user", "content": "What is the weather in Paris right now?"},
    {
      "role": "assistant",
      "content": null,
      "tool_calls": [
        {
          "id": "call_9f1c2ab34d5e4f60a7b8c9d0e1f2a3b4",
          "type": "function",
          "function": {
            "name": "get_weather",
            "arguments": "{\"city\":\"Paris\"}"
          }
        }
      ]
    },
    {
      "role": "tool",
      "tool_call_id": "call_9f1c2ab34d5e4f60a7b8c9d0e1f2a3b4",
      "content": "{\"city\":\"Paris\",\"temperature\":18,\"unit\":\"celsius\",\"conditions\":\"cloudy\"}"
    }
  ]
}
  • Ipadala pabalik ang assistant turn kung paano mo ito natanggap, bago ang mga resulta. Itinutugma ang bawat resulta sa call nito gamit ang id: tool_call_id sa /v1/chat/completions, call_id sa /v1/responses, tool_use_id sa /v1/messages.
  • Text ang resulta. I-serialize ang object sa JSON string para sa content (output sa /v1/responses). Sa /v1/messages, ang content ng tool_result block ay string o listahan ng mga text block.
  • Sa assistant turn, nananatiling JSON string ang function.arguments, eksakto kung paano ito dumating.
  • Maaaring magtapos ang conversation sa tool result. Hindi kailangan ng bagong user message: nagpapatuloy ang model mula sa resulta.
  • Kapag nabigo ang iyong function, ipadala ang pagkabigo bilang text ng resulta. Maaari itong iulat ng model o humingi ng ibang call.

Mga schema keyword

Ang parameters (input_schema sa /v1/messages) ay isang JSON Schema. Natatanggap ito ng pamilyang Shannon 3 (shannon-3, shannon-3-pro, shannon-3.1, shannon-3.1-pro) at ng mga hosted open-weight model ayon sa pagkakapadala mo.

Natatanggap ng shannon-1.6-lite, shannon-1.6-pro, shannon-2-lite, shannon-2-pro at shannon-coder-1 ang subset na ito, sa lahat ng tatlong endpoint:

Pagtrato Mga keyword
Binabasa ayon sa pagkakapadala Bawat keyword na hindi nakapangalan sa mga row sa ibaba, halimbawa type, properties, required, items, enum, description, minimum, maximum, anyOf at allOf, sa bawat antas ng schema.
format Binabasa para sa mga value na int32, int64, float, double, byte, date, date-time at enum.
oneOf Binabasa bilang anyOf.
Hindi bahagi ng schemang natatanggap ng mga model na ito $schema, $id, $ref, $defs, $comment, definitions, additionalProperties, unevaluatedProperties, patternProperties, propertyNames, examples, default, title, const, not, if, then, else, contains, minContains, maxContains, dependentRequired, dependentSchemas, dependencies, readOnly, writeOnly, deprecated, contentEncoding, contentMediaType, contentSchema, multipleOf, uniqueItems; exclusiveMinimum at exclusiveMaximum kapag mga numero ang mga ito; ibang value ng format.

Gawi at mga limitasyon

  • Walang itinakdang pinakamataas na bilang ng tools at pinakamataas na bilang ng round ang API.
  • Maaaring umabot sa 32 MiB ang request body, at dapat kasya ang conversation kasama ang mga resulta nito sa context window ng model.
  • Kapag may dalang tools ang request, gumagamit ang shannon-1.6-lite, shannon-1.6-pro, shannon-2-lite at shannon-2-pro ng default na temperature na 0.2. Ipadala ang temperature para magtakda ng ibang value.
  • Sariling request ang bawat round: kumukuha ito sa iyong balance at binibilang sa flood protection tulad ng anumang request. Mga limitasyon at balance

Mga error

Ang tool call ay karaniwang reply na may status 200. Ang mga error na ito ay tungkol sa mismong request:

Status Type Mensahe Kailan
400 invalid_request_error unknown model: <id> Hindi id sa inilathalang listahan ang model.
422 invalid_request_error Failed to deserialize the JSON body into the target type: … Hindi array ang tools, o mali ang JSON type ng ibang field.
413 invalid_request_error Failed to buffer the request body: … Mas malaki sa 32 MiB ang request body. Dala ng error ang code: "request_too_large".

Ang model ang sumusulat ng mga argument. Suriin ang mga ito laban sa iyong schema bago patakbuhin ang function, tulad ng pagsusuri sa anumang input mula sa labas.

Pareho ng sa bawat request ang mga error sa authentication, balance at server. Paghawak ng Error