Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Function Calling: Poveži AI sa svojim sustavima

Lekcija 10 od 22 Ažurirano 29. srpnja 2026. Programer
Na ovoj stranici
  1. Function Calling: Poveži AI sa svojim sustavima
  2. Cijeli tijek, korak po korak
  3. Dopuštanje modelu da bira između više alata
  4. Petlja agenta
  5. Osiguraj argumente strogim načinom rada (Strict Mode)
  6. Ključne točke

Function Calling: Poveži AI sa svojim sustavima

Function calling omogućuje modelu da pozove funkcije koje ti definiraš. Zapamti jedno ključno pravilo jer sve ostalo proizlazi iz njega: model ne izvršava te funkcije. On ti samo javlja koju funkciju trebaš pozvati i s kojim argumentima; tvoj kod obavlja izvršavanje i vraća rezultat. Tvoja baza podataka, vjerodajnice i poslovna logika nikada ne napuštaju tvoju infrastrukturu.

Cijeli tijek, korak po korak

Razmjena se odvija u četiri faze:

  1. Deklariraš dostupne funkcije zajedno s njihovim parametrima
  2. Model analizira zahtjev i odluči pozvati funkciju
  3. Tvoj kod izvršava funkciju i dobiva rezultat
  4. Šalješ rezultat natrag modelu kako bi on mogao formulirati svoj odgovor

Deklaracija zaslužuje posebnu pažnju: description funkcije i opis svakog parametra jedina su dokumentacija koju model ima za donošenje odluke. Nejasni opisi dovode do približnih poziva. Također, obrati pažnju na to kako zatvoriti petlju – rezultat se vraća s call_id koji si primio, a koji služi kao potvrda i omogućuje API-ju da poveže odgovor sa zahtjevom.

from openai import OpenAI
import json

client = OpenAI()

# Korak 1: Deklariraj dostupne funkcije
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"]
    }
}]

# Korak 2: Model odluči pozvati funkciju
response = client.responses.create(
    model="gpt-5.6-terra",
    input="What's the weather like in Marseille?",
    tools=tools
)

# Korak 3: Izvrši funkciju
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 stvarna implementacija
        resultat_meteo = {"temperature": 22, "condition": "sunny"}

        # Korak 4: Pošalji rezultat natrag 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.

Dopuštanje modelu da bira između više alata

Prava vrijednost dolazi do izražaja kada izložiš cijeli katalog mogućnosti. U asistentu za e-trgovinu deklarirao bi pretraživanje proizvoda, provjeru zaliha i kreiranje narudžbe, a zatim prepustio modelu da arbitriraju. Suočen s upitom „Je li XPS gaming laptop dostupan?“, neće pokrenuti pretraživanje, već će izravno upitati zalihe: tvoji opisi funkcija, a ne unaprijed definirano pravilo, upravljali su tim izborom.

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 automatski bira ispravnu funkciju
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"}

Jedan zahtjev može istovremeno pokrenuti i više poziva. Usporedba vremena u dva grada rezultirat će s dva neovisna poziva: tvoj kod stoga mora iterirati kroz response.output i obraditi sve stavke function_call, a ne samo prvu. Ovo je također prilika da te pozive izvršiš paralelno i prepoloviš kašnjenje.

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 izvršava dva poziva paralelno
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)

Petlja agenta

Jedan krug razmjene rijetko je dovoljan: rezultat jedne funkcije često navodi model da pozove drugu. Zato omotaš razmjenu u petlju koja se vrti sve dok odgovor sadrži pozive funkcija, a staje čim ih više nema – što je znak da je model formulirao svoj konačni odgovor. To je kostur svakog agenta i vidjet ćeš ga u raznim oblicima u svim okvirima 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 — zamijeni svojim stvarnim 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
        )

        # Provjeri postoje li pozivi funkcija
        function_calls = [i for i in response.output if i.type == "function_call"]

        if not function_calls:
            # Nema poziva funkcija = konačni odgovor
            return response.output_text

        # Izvrši svaku funkciju i 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
            })

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

Jedno upozorenje vezano uz ovaj obrazac: petlja while True nema sigurnosne ograničenja. U proizvodnji dodaj brojač maksimalnog broja iteracija; u suprotnom, model koji beskonačno traži isti alat potrošit će tvoj budžet, a da nikada ne zaključi zadatak.

Osiguraj argumente strogim načinom rada (Strict Mode)

Strogi način rada (Strict mode) primjenjuje isto jamstvo na parametre funkcije koje Structured Output primjenjuje na odgovore: argumenti se strogo pridržavaju deklarirane sheme. Za funkciju koja stvara korisnika, to sprječava da dobiješ dob kao niz znakova ili dodatno polje koje tvoj kod nije očekivao.

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 točke

  • Function calling povezuje model s tvojim sustavima bez izlaganja tvojih podataka
  • Model odlučuje koju funkciju pozvati; tvoj kod je izvršava
  • Vrati rezultat koristeći function_call_output i call_id
  • Model može paralelno pozvati više funkcija
  • Koristi petlju agenta za višekratne razgovore koji uključuju funkcije
  • Omogući strict: True kako bi zajamčio usklađenost argumenata