Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Function Calling: Poveži umetno inteligenco s svojimi sistemi

Lekcija 10 od 22 Posodobljeno 29. julij 2026 Razvijalec
Na tej strani
  1. Function Calling: Poveži umetno inteligenco s svojimi sistemi
  2. Celoten potek, korak za korakom
  3. Modelu dovoli izbiro med več orodji
  4. Zanka agenta
  5. Zakleni argumente s strogim načinom (Strict Mode)
  6. Ključne ugotovitve

Function Calling: Poveži umetno inteligenco s svojimi sistemi

Function calling modelu omogoča, da prikliče funkcije, ki jih definiraš ti. Zapomni si eno ključno pravilo, saj vse ostalo izhaja iz njega: model teh funkcij ne izvaja. Le pove ti, katero funkcijo naj pokliče in s katerimi argumenti; tvoja koda opravi izvedbo in vrne rezultat. Tvoja baza podatkov, poverilnice in poslovna logika nikoli ne zapustijo tvoje infrastrukture.

Celoten potek, korak za korakom

Izmenjava poteka v štirih fazah:

  1. Deklariraš razpoložljive funkcije skupaj z njihovimi parametri
  2. Model analizira zahtevo in se odloči za klic funkcije
  3. Tvoja koda izvede funkcijo in pridobi rezultat
  4. Rezultat pošlješ nazaj modelu, da lahko oblikuje svoj odgovor

Deklaracija zahteva posebno pozornost: opis funkcije (description) in opis vsakega parametra sta edina dokumentacija, na podlagi katere model sprejme odločitev. Nejasni opisi vodijo v približne klice. Prav tako bodi pozoren na zaključevanje zanke – rezultat se vrne z call_id, ki si ga prejel; ta deluje kot potrdilo in omogoča API-ju, da odgovor poveže z zahtevo.

from openai import OpenAI
import json

client = OpenAI()

# 1. korak: Deklaracija razpoložljivih funkcij
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. korak: Model se odloči za klic funkcije
response = client.responses.create(
    model="gpt-5.6-terra",
    input="What's the weather like in Marseille?",
    tools=tools
)

# 3. korak: Izvedba funkcije
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)

        # Tvoja dejanska implementacija
        resultat_meteo = {"temperature": 22, "condition": "sunny"}

        # 4. korak: Pošlji rezultat nazaj modelu
        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}")

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

Modelu dovoli izbiro med več orodji

Prava vrednost se pokaže, ko razkriješ celoten katalog zmožnosti. Pri pomočniku za e-trgovino bi deklariral iskanje izdelkov, preverjanje zalog in oddajo naročil, nato pa prepustil modelu, da arbitrirá. Ko se sooči z vprašanjem „Ali je prenosni računalnik XPS gaming na voljo?”, ne bo izvedel iskanja, temveč bo neposredno poizvedel po zalogi: to odločitev so usmerili tvoji opisi funkcij, ne pa vnaprej določeno pravilo.

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"]
        }
    }
]

# Model samodejno izbere pravo funkcijo
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}")

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

Ena sama zahteva lahko sproži tudi več klicev hkrati. Primerjava vremena v dveh mestih ustvari dva neodvisna klica: tvoja koda mora zato iterirati skozi response.output in obdelati vse elemente function_call, nikoli le prvega. To je tudi priložnost za vzporedno izvajanje teh klicev in prepolovitev zakasnitve.

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"]
        }
    }]
)

# Model opravi dva klica vzporedno
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']})")

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

Zanka agenta

En sam povratni krog redko zadostuje: rezultat ene funkcije pogosto vodi model do klica druge. Zato izmenjavo oviješ v zanko, ki teče, dokler odgovor vsebuje klice funkcij, in se ustavi, ko jih ne vsebuje več – kar je znak, da je model oblikoval svoj končni odgovor. To je ogrodje vsakega agenta in ga boš v različnih preoblekah videl v vseh ogrodjih za agente.

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

    if nom == "get_meteo":
        # Simulacija — zamenjaj s svojim pravim API-jem
        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
        )

        # Preveri klice funkcij
        function_calls = [i for i in response.output if i.type == "function_call"]

        if not function_calls:
            # Ni klicev funkcij = končni odgovor
            return response.output_text

        # Izvedi vsako funkcijo in dodaj rezultate
        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
            })

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

Opozorilo glede tega vzorca: zanka while True nima varoval. V produkcijskem okolju dodaj števec največjega števila iteracij; sicer bo model, ki neskončno zahteva isto orodje, porabil tvoj proračun, ne da bi kdaj zaključil.

Zakleni argumente s strogim načinom (Strict Mode)

Strogi način (Strict Mode) za parametre funkcij zagotavlja isto garancijo kot strukturirani izhod (Structured Output) za odgovore: argumenti strogo sledijo deklarirani shemi. Pri funkciji, ki ustvarja uporabnika, to prepreči, da bi starost prejel kot niz ali dodatno polje, ki ga tvoja koda ni pričakovala.

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
    }
}]

Ključne ugotovitve

  • Function calling poveže model s tvojimi sistemi, ne da bi razkril tvoje podatke
  • Model odloči, katero funkcijo poklicati; tvoja koda jo izvede
  • Rezultat vrni z uporabo function_call_output in call_id
  • Model lahko vzporedno pokliče več funkcij
  • Za večkratne pogovore, ki vključujejo funkcije, uporabi zanko agenta
  • Omogoči strict: True za zagotovilo skladnosti argumentov