Function Calling: Poveži umetno inteligenco s svojimi sistemi
Na tej strani
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:
- Deklariraš razpoložljive funkcije skupaj z njihovimi parametri
- Model analizira zahtevo in se odloči za klic funkcije
- Tvoja koda izvede funkcijo in pridobi rezultat
- 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_outputincall_id - Model lahko vzporedno pokliče več funkcij
- Za večkratne pogovore, ki vključujejo funkcije, uporabi zanko agenta
- Omogoči
strict: Trueza zagotovilo skladnosti argumentov