Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Arhitektuur funktsioonide kutsumiseks vastuste API-s

Õppetund 1 / 20 Värskendatud 2. november 2026 Arendajatele
Sellel lehel
  1. Arhitektuur funktsioonide kutsumiseks vastuste API-s
  2. Põhimõte
  3. Vastuse anatoomia
  4. Täielik tsükkel
  5. Põhilised erinevused vestluse lõpetamistega (Chat Completions)
  6. Millal mudel funktsiooni kutsub?
  7. Peamised punktid

Uuendatud 2. novembril 2026 OpenAI dokumentatsiooni põhjal: Code Interpreteri tööriist nõuab nüüd parameetrit container (lisatud kõigile näidetele), sisendteksti osad kasutavad tüüpi input_text ja veebiotsing kasutab tööriista web_search (web_search_preview on nüüd aegunud tööriist ilma domeenifiltriteta). Genereeritud failid laaditakse alla, kasutades 10. õppetükist pärit funktsioone fichiers_generes ja telecharger. Allikad: Code Interpreter · Veebiotsing.

Arhitektuur funktsioonide kutsumiseks vastuste API-s

Funktsioonide kutsumine on põhimehhanism, mis võimaldab OpenAI mudelitel välismaailmaga suhelda. Vastuste API-s on see mehhanism ümber kujundatud, et olla töökindlam, ennustatavam ja loomupäraselt integreeritud sisseehitatud tööriistadega, nagu veebiotsing ja Code Interpreter.

Põhimõte

Mudel ei tee kunagi midagi otse. See väljastab struktureeritud kavatsused, mida sinu kood peab kinni ja täidab. Nii öeldes võib see kõlada tehnilise piiranguna; tegelikult on see disainivalik, mis teeb võimalikuks kõik muu.

Mõtle alternatiivile. Kui mudel täidaks tegevusi ise, peaksid sa loovutama oma andmebaasi kasutajaandmed, API võtmed ja kirjutamisõigused – ning sul poleks ühtegi punkti, kus midagi kontrollida. Lahutamise korral liigub iga kavatsus läbi sinu koodi: sa valideerid argumendid, rakendad ärireegleid ja keeldud vajadusel. Mudel teeb ettepaneku, sinu kood otsustab, ja just see piir võimaldab sul viia funktsioonide kutsumine tootmiskeskkonda ilma kontrolli kaotamata.

from openai import OpenAI

client = OpenAI()

# Deklareeri kohandatud tööriist
tools = [{
    "type": "function",
    "name": "rechercher_client",
    "description": "Search for a client in the CRM by name or email",
    "parameters": {
        "type": "object",
        "properties": {
            "terme": {
                "type": "string",
                "description": "Client name, email, or ID"
            },
            "champ": {
                "type": "string",
                "enum": ["nom", "email", "id"],
                "description": "Field to search in"
            }
        },
        "required": ["terme"]
    }
}]

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Find the client Jean Dupont",
    tools=tools
)

Vastuse anatoomia

Vastus ei sisalda kas teksti või tööriistakutsunguid: output on heterogeenne loend, mis võib mõlemat segada. Harjumus, mille peaksid oma esimesest koodireast peale kujundama, on iteratsioon selle loendi üle, mitte output[0] lugemine – mudel, mis selgitab oma arutluskäiku enne funktsiooni kutsumist, toodab täpselt sellise juhtumi, ja kood, mis loeb esimest elementi, läheb katki päeval, kui see hakkab kommentaare lisama.

for item in response.output:
    if item.type == "function_call":
        print(f"Call ID  : {item.call_id}")
        print(f"Function : {item.name}")
        print(f"Args     : {item.arguments}")

call_id on hädavajalik: see seob kutse selle tulemusega, kui saadad vastuse mudelile tagasi. Ühe kutse puhul sa seda vaevalt märkad; kolme paralleelse kutse puhul on see ainus asi, mis takistab sul omistamast Lyoni ilmateadet Marseilli puudutavale päringule. Tagasta tulemus alati selle call_id-ga, mille said, mitte kunagi ID-ga, mille ise rekonstrueerid.

Täielik tsükkel

See neljaastmeline tsükkel on muutumatu: see kehtib ühe funktsiooni või kahekümne kohta, lihtsa kutse või agenti kohta, mis aheldab kümmet tööriista. Kogu keerukus, millega hiljem kokku puutud – paralleelsus, vead, varuplaanid – seisneb selle tsükli instrumenteerimises, mitte selle asendamises.

import json

# 1. Esimene kutse deklareeritud tööriistadega
response = client.responses.create(
    model="gpt-5.6-terra",
    input="What is the balance for client [email protected]?",
    tools=tools
)

# 2. Tuvasta ja täida funktsioonikutsungid
resultats = []
for item in response.output:
    if item.type == "function_call":
        if item.name == "rechercher_client":
            args = json.loads(item.arguments)
            resultat = votre_crm.rechercher(args["terme"])
            resultats.append({
                "type": "function_call_output",
                "call_id": item.call_id,
                "output": json.dumps(resultat)
            })

# 3. Saada tulemused mudelile tagasi
response_finale = client.responses.create(
    model="gpt-5.6-terra",
    input=response.output + resultats,
    tools=tools
)

# 4. Mudel formuleerib oma loomuliku vastuse
print(response_finale.output_text)

Põhilised erinevused vestluse lõpetamistega (Chat Completions)

Vastuste API toob kaasa mitmeid arhitektuurseid täiustusi.

Sisseehitatud tööriistade loomupärane haldamine

Sisseehitatud tööriistad deklareeritakse täpselt nagu sinu funktsioonid, kuid need täidetakse OpenAI poolt. Praktiline tulemus on meeldiv: sa ei pea nende jaoks ühtegi tsüklit kirjutama. Mudel kutsub, saab tulemuse ja jätkab, kõik ühes voorus. Eespool kirjeldatud tsükkel puudutab ainult sinu funktsioone – neid, mis jooksevad sinu masinas.

# Sega sisseehitatud ja kohandatud tööriistu
tools = [
    {"type": "web_search"},
    {"type": "code_interpreter", "container": {"type": "auto"}},
    {
        "type": "function",
        "name": "ma_fonction",
        "description": "My custom function",
        "parameters": {"type": "object", "properties": {}}
    }
]

Stabiilsed kutse identifikaatorid

Iga funktsioonikutse saab unikaalse call_id, mis võimaldab täpselt jälgida, milline tulemus vastab millisele kutsele, isegi paralleelsete kutsete korral.

Lihtsustatud voog

Pole vaja käsitsi hallata sõnumites rolle assistant ja tool. Väli input aktsepteerib otseselt eelmiste väljundite liitmist funktsioonitulemustega.

Millal mudel funktsiooni kutsub?

Mudel otsustab funktsiooni kutsuda, kui kasutaja päring nõuab teavet, mida tal endal pole, kui funktsiooni kirjeldus vastab tuvastatud vajadusele ja kui nõutavad parameetrid saab kontekstist tuletada.

Seega peavad samaaegselt olema täidetud kolm tingimust ja see on silumisel kasulik: kui funktsiooni ei kutsuta, kuigi seda peaks, on põhjus peaaegu alati teine – kirjeldus, mis ei kata viisi, kuidas kasutaja oma päringu sõnastas. Parameeter tool_choice võimaldab sundida käitumist, kui kirjeldusest ei piisa:

# Lase mudelil otsustada
tool_choice = "auto"

# Sunni kutsuma kindlat funktsiooni
tool_choice = {"type": "function", "name": "rechercher_client"}

# Keela kõik funktsioonikutsungid
tool_choice = "none"

# Nõua vähemalt üht kutset täpsustamata, millist
tool_choice = "required"

Peamised punktid

  • Funktsioonide kutsumine on kavatsuste protokoll, mitte täitmise protokoll
  • Kutse-täitmine-tagastamine tsükkel on fundamentaalne muster
  • Sisseehitatud ja kohandatud tööriistad eksisteerivad samas tools massiivis
  • call_id tagab iga kutse jälgitavuse
  • tool_choice võimaldab mudeli käitumist peenelt juhtida