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

Function Calling: ühenda tehisintellekt oma süsteemidega

Õppetund 10 / 22 Värskendatud 29. juuli 2026 Arendajatele
Sellel lehel
  1. Function Calling: ühenda tehisintellekt oma süsteemidega
  2. Kogu voog samm-sammult
  3. Lase mudelil valida mitme tööriista hulgast
  4. Agendi tsükkel
  5. Lukusta argumendid range režiimiga
  6. Peamised punktid

Function Calling: ühenda tehisintellekt oma süsteemidega

Function calling võimaldab mudelil kutsuda sinu defineeritud funktsioone. Pea meeles üht reeglit, sest kõik muu tuleneb sellest: mudel ei täida neid funktsioone ise. See teatab sulle, millist funktsiooni ja milliste argumentidega kutsuda; sinu kood teostab käivitamise ja tagastab tulemuse. Sinu andmebaas, mandaadid ja äriloogika ei lahku kunagi sinu taristust.

Kogu voog samm-sammult

Vahetus toimub neljas etapis:

  1. Sa deklareerid olemasolevad funktsioonid koos nende parameetritega
  2. Mudel analüüsib päringut ja otsustab kutsuda funktsiooni
  3. Sinu kood käivitab funktsiooni ja saab tulemuse
  4. Sa saadad tulemuse mudelile tagasi, et see saaks vormistada oma vastuse

Deklaratsioon nõuab erilist hoolt: funktsiooni description ja iga parameetri kirjeldus on ainus dokumentatsioon, mille põhjal mudel oma otsuse teeb. Ebamäärased kirjeldused viivad ligikaudsete kutseteni. Pane tähele ka seda, kuidas tsükkel sulgeda – tulemus saadetakse tagasi koos sinu saadud call_id-ga, mis toimib kinnitusena ja võimaldab API-l vastuse päringuga sobitada.

from openai import OpenAI
import json

client = OpenAI()

# 1. samm: deklareeri olemasolevad funktsioonid
tools = [{
    "type": "function",
    "name": "get_meteo",
    "description": "Get the current weather for a city",
    "parameters": {
        "type": "object",
        "properties": {
            "ville": {
                "type": "string",
                "description": "The name of the city"
            },
            "unite": {
                "type": "string",
                "enum": ["celsius", "fahrenheit"],
                "description": "Temperature unit"
            }
        },
        "required": ["ville"]
    }
}]

# 2. samm: mudel otsustab funktsiooni kutsuda
response = client.responses.create(
    model="gpt-5.6-terra",
    input="What's the weather like in Marseille?",
    tools=tools
)

# 3. samm: käivita funktsioon
for item in response.output:
    if item.type == "function_call":
        print(f"Function: {item.name}")
        print(f"Arguments: {item.arguments}")
        args = json.loads(item.arguments)

        # Sinu tegelik implementatsioon
        resultat_meteo = {"temperature": 22, "condition": "sunny"}

        # 4. samm: saada tulemus mudelile tagasi
        final = client.responses.create(
            model="gpt-5.6-terra",
            input=[
                {"role": "user", "content": "What's the weather like in Marseille?"},
                {
                    "type": "function_call_output",
                    "call_id": item.call_id,
                    "output": json.dumps(resultat_meteo)
                }
            ],
            tools=tools
        )
        print(f"Response: {final.output_text}")

# Tulemus:
# Function: get_meteo
# Arguments: {"ville": "Marseille"}
# Response: It is currently 22 C in Marseille with sunny weather.

Lase mudelil valida mitme tööriista hulgast

Tegelik väärtus ilmneb siis, kui avalikustad terve võimekuste kataloogi. E-kaubanduse assistendis deklareeriksid tooteotsingu, laoseisu kontrolli ja tellimuse esitamise, jättes otsustamise mudeli hooleks. Küsimusele „Kas XPS-i mängusülearvuti on saadaval?“ ei käivita see otsingut, vaid pärib otse laoseisu: selle valiku tegid sinu funktsioonide kirjeldused, mitte kõvakodeeritud reegel.

tools = [
    {
        "type": "function",
        "name": "rechercher_produit",
        "description": "Search for a product in the catalog",
        "parameters": {
            "type": "object",
            "properties": {
                "requête": {"type": "string", "description": "Search terms"},
                "categorie": {"type": "string", "description": "Category (optional)"}
            },
            "required": ["requête"]
        }
    },
    {
        "type": "function",
        "name": "verifier_stock",
        "description": "Check product availability",
        "parameters": {
            "type": "object",
            "properties": {
                "produit_id": {"type": "string", "description": "Product ID"}
            },
            "required": ["produit_id"]
        }
    },
    {
        "type": "function",
        "name": "passer_commande",
        "description": "Place an order for a product",
        "parameters": {
            "type": "object",
            "properties": {
                "produit_id": {"type": "string"},
                "quantite": {"type": "integer", "description": "Number of units"}
            },
            "required": ["produit_id", "quantite"]
        }
    }
]

# Mudel valib automaatselt õige funktsiooni
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Is the XPS gaming laptop available?",
    tools=tools
)

for item in response.output:
    if item.type == "function_call":
        print(f"Function chosen: {item.name}")
        print(f"Arguments: {item.arguments}")

# Tulemus: Function chosen: verifier_stock
# Arguments: {"produit_id": "xps-gaming"}

Üks päring võib käivitada ka mitu kutset korraga. Kahe linna ilma võrdlemine tekitab kaks sõltumatut kutset: sinu kood peab seetõttu iteratsiooniga läbima response.output ja töötlema kõiki function_call elemendid, mitte kunagi ainult esimest. See on ka võimalus need kutsed käivitada paralleelselt ja lühendada latentsust poole võrra.

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Compare the weather between Paris and Lyon.",
    tools=[{
        "type": "function",
        "name": "get_meteo",
        "description": "Get the weather for a city",
        "parameters": {
            "type": "object",
            "properties": {
                "ville": {"type": "string"}
            },
            "required": ["ville"]
        }
    }]
)

# Mudel teeb kaks paralleelset kutset
function_calls = [item for item in response.output if item.type == "function_call"]
print(f"Number of calls: {len(function_calls)}")
for call in function_calls:
    args = json.loads(call.arguments)
    print(f"  - get_meteo({args['ville']})")

# Tulemus:
# Number of calls: 2
#   - get_meteo(Paris)
#   - get_meteo(Lyon)

Agendi tsükkel

Ühest edasi-tagasi vahetusest harva ei piisa: ühe funktsiooni tulemus viib mudeli sageli teise funktsiooni kutsumiseni. Seega pakid vahetuse tsüklisse, mis jookseb seni, kuni vastus sisaldab funktsioonikutseid, ja peatub kohe, kui neid enam ei ole – see on märk, et mudel on vormistanud oma lõpliku vastuse. See on iga agendi luustik ja sa kohtad seda erinevates kehastustes kõigis agentuuride raamistikes.

def executer_fonction(nom: str, arguments: str) -> str:
    """Execute a function and return the result."""
    args = json.loads(arguments)

    if nom == "get_meteo":
        # Simulatsioon – asenda oma tegeliku API-ga
        return json.dumps({"temp": 18, "condition": "cloudy"})
    elif nom == "get_heure":
        return json.dumps({"heure": "14:30", "timezone": "CET"})

    return json.dumps({"error": "Unknown function"})

def agent_loop(question: str, tools: list) -> str:
    """Agent loop: call functions until the final response."""
    input_messages = [{"role": "user", "content": question}]

    while True:
        response = client.responses.create(
            model="gpt-5.6-terra",
            input=input_messages,
            tools=tools
        )

        # Kontrolli funktsioonikutseid
        function_calls = [i for i in response.output if i.type == "function_call"]

        if not function_calls:
            # Funktsioonikutseid pole = lõplik vastus
            return response.output_text

        # Käivita iga funktsioon ja lisa tulemused
        for call in function_calls:
            resultat = executer_fonction(call.name, call.arguments)
            input_messages.append({
                "type": "function_call_output",
                "call_id": call.call_id,
                "output": resultat
            })

# Kasutamine
reponse = agent_loop("What's the weather like in Paris?", tools)
print(reponse)

Selle mustri puhul üks hoiatus: while True tsüklil puuduvad piirangud. Tootmiskeskkonnas lisa maksimaalne iteratsiooniloendur; vastasel juhul kulutab mudel, mis küsib lõputult sama tööriista, sinu eelarve ära, jõudmata kunagi järelduseni.

Lukusta argumendid range režiimiga

Range režiim (strict mode) rakendab funktsiooniparameetritele sama garantii, mida struktureeritud väljund (Structured Output) pakub vastuste jaoks: argumendid järgivad rangelt deklareeritud skeemi. Funktsiooni puhul, mis loob kasutaja, hoiab see ära olukorra, kus saad vanuse stringina või täiendava välja, mida sinu kood ei oodanud.

tools = [{
    "type": "function",
    "name": "creer_utilisateur",
    "description": "Create a new user",
    "strict": True,
    "parameters": {
        "type": "object",
        "properties": {
            "nom": {"type": "string"},
            "email": {"type": "string"},
            "age": {"type": "integer"}
        },
        "required": ["nom", "email", "age"],
        "additionalProperties": False
    }
}]

Peamised punktid

  • Function calling ühendab mudeli sinu süsteemidega, paljastamata sinu andmeid
  • Mudel otsustab, millist funktsiooni kutsuda; sinu kood täidab selle
  • Tagasta tulemus, kasutades function_call_output ja call_id
  • Mudel saab kutsuda mitut funktsiooni paralleelselt
  • Kasuta agendi tsüklit mitmekäiguliste vestluste jaoks, mis hõlmavad funktsioone
  • Luba strict: True, et garanteerida argumentide vastavus