Function Calling: Poveži AI sa svojim sustavima
Na ovoj stranici
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:
- Deklariraš dostupne funkcije zajedno s njihovim parametrima
- Model analizira zahtjev i odluči pozvati funkciju
- Tvoj kod izvršava funkciju i dobiva rezultat
- Š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_outputicall_id - Model može paralelno pozvati više funkcija
- Koristi petlju agenta za višekratne razgovore koji uključuju funkcije
- Omogući
strict: Truekako bi zajamčio usklađenost argumenata