Function Calling: Propojení AI s vašimi systémy
Na této stránce
Function Calling: Propojení AI s vašimi systémy
Function Calling umožňuje modelu vyvolávat vámi definované funkce. Zapamatuj si jedno zásadní pravidlo, protože od něj se odvíjí vše ostatní: model tyto funkce neprovádí. Pouze ti sdělí, kterou funkci zavolat a s jakými argumenty; provedení zajistí tvůj kód a vrátí výsledek. Tvá databáze, pověření ani obchodní logika nikdy neopustí tvou infrastrukturu.
Celý proces krok za krokem
Komunikace probíhá ve čtyřech fázích:
- Deklaruješ dostupné funkce spolu s jejich parametry
- Model analyzuje požadavek a rozhodne se zavolat funkci
- Tvůj kód funkci provede a získá výsledek
- Výsledek odešleš zpět modelu, aby mohl formulovat svou odpověď
Deklarace si zaslouží zvláštní pozornost: description funkce a popis každého parametru jsou jedinou dokumentací, kterou má model k dispozici pro své rozhodnutí. Nejasné popisy vedou k nepřesným voláním. Všimni si také, jak uzavřít smyčku – výsledek se vrací s call_id, které jsi obdržel. To funguje jako potvrzení a umožňuje API spárovat odpověď s požadavkem.
from openai import OpenAI
import json
client = OpenAI()
# Krok 1: Deklarace dostupných funkcí
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"]
}
}]
# Krok 2: Model se rozhodne funkci zavolat
response = client.responses.create(
model="gpt-5.6-terra",
input="What's the weather like in Marseille?",
tools=tools
)
# Krok 3: Provedení funkce
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)
# Tvá skutečná implementace
resultat_meteo = {"temperature": 22, "condition": "sunny"}
# Krok 4: Odeslání výsledku zpět 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}")
# Výsledek:
# Function: get_meteo
# Arguments: {"ville": "Marseille"}
# Response: It is currently 22 C in Marseille with sunny weather.
Nechání modelu vybrat si z více nástrojů
Skutečná hodnota se projeví, když zpřístupníš celý katalog schopností. U asistenta pro e-commerce bys deklaroval vyhledávání produktů, kontrolu skladových zásob a zadávání objednávek a nechal model, aby rozhodl. Při dotazu „Je herní notebook XPS skladem?“ neprovede vyhledávání, ale přímo se zeptá na stav zásob: toto rozhodnutí řídí tvé popisy funkcí, nikoli natvrdo zakódované pravidlo.
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 automaticky vybere správnou funkci
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}")
# Výsledek: Function chosen: verifier_stock
# Arguments: {"produit_id": "xps-gaming"}
Jediný požadavek může také spustit více volání najednou. Porovnání počasí ve dvou městech vygeneruje dvě nezávislá volání: tvůj kód proto musí iterovat přes response.output a zpracovat všechny položky function_call, nejen tu první. Je to také příležitost provést tato volání paralelně a zkrátit latenci na polovinu.
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 provede dvě volání paralelně
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']})")
# Výsledek:
# Number of calls: 2
# - get_meteo(Paris)
# - get_meteo(Lyon)
Smyčka agenta
Jedna výměna informací málokdy stačí: výsledek jedné funkce často vede model k volání další. Proto celou komunikaci zabalíš do smyčky, která běží, dokud odpověď obsahuje volání funkcí, a zastaví se, jakmile žádná neobsahuje – což je signál, že model formuloval svou konečnou odpověď. Toto je kostra každého agenta a setkáš se s ní v různých podobách ve všech frameworkech pro agenty.
def executer_fonction(nom: str, arguments: str) -> str:
"""Execute a function and return the result."""
args = json.loads(arguments)
if nom == "get_meteo":
# Simulace — nahraď svým skutečným API
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
)
# Kontrola volání funkcí
function_calls = [i for i in response.output if i.type == "function_call"]
if not function_calls:
# Žádná volání funkcí = konečná odpověď
return response.output_text
# Provedení každé funkce a přidání výsledků
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
})
# Použití
reponse = agent_loop("What's the weather like in Paris?", tools)
print(reponse)
U tohoto vzoru buď opatrný: smyčka while True nemá žádné ochranné mechanismy. V produkčním prostředí přidej maximální počet iterací; jinak model, který bude donekonečna požadovat stejný nástroj, spálí tvůj rozpočet, aniž by kdy dospěl k závěru.
Uzamčení argumentů pomocí Strict Mode
Strict Mode aplikuje na parametry funkcí stejnou záruku, jakou Structured Output poskytuje u odpovědí: argumenty striktně dodržují deklarované schéma. U funkce, která vytváří uživatele, to zabrání tomu, abys obdržel věk jako řetězec nebo extra pole, které tvůj kód neočekával.
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
}
}]
Klíčové poznatky
- Function Calling propojuje model s tvými systémy bez vystavení tvých dat
- Model rozhoduje, kterou funkci zavolat; tvůj kód ji provádí
- Výsledek vrať pomocí
function_call_outputacall_id - Model může volat více funkcí paralelně
- Pro vícekolové konverzace zahrnující funkce použij smyčku agenta
- Povol
strict: Truepro zajištění souladu argumentů