Function Calling : yhdistä tekoäly järjestelmiisi
Tällä sivulla
Function Calling : yhdistä tekoäly järjestelmiisi
Function Callingin avulla malli voi kutsua määrittelemiäsi funktioita. Pidä yksi sääntö mielessäsi kaiken perustana, sillä kaikki muu seuraa siitä: malli ei suorita funktioita. Se kertoo sinulle, mikä funktio tulee kutsua ja millä argumenteilla; sinun koodisi hoitaa suorituksen ja palauttaa tuloksen. Tietokantasi, tunnistetietosi ja liiketoimintalogiikkasi eivät koskaan poistu infrastruktuuristasi.
Koko prosessi vaihe vaiheelta
Viestintä etenee neljässä vaiheessa:
- Määrittelet käytettävissä olevat funktiot ja niiden parametrit
- Malli analysoi pyynnön ja päättää kutsua funktion
- Koodisi suorittaa funktion ja hankkii tuloksen
- Lähetät tuloksen takaisin mallille, jotta se voi muotoilla vastauksensa
Määrittely vaatii erityistä huolellisuutta: funktion description ja kunkin parametrin kuvaus ovat ainoat dokumentit, joiden perusteella malli tekee päätöksensä. Epämääräiset kuvaukset johtavat epätarkkoihin kutsuihin. Huomaa myös, miten silmukka suljetaan: tulos lähetetään takaisin käyttämällä vastaanottamaasi call_id:tä, joka toimii kuittauksena ja antaa rajapinnan yhdistää vastauksen pyyntöön.
from openai import OpenAI
import json
client = OpenAI()
# Vaihe 1: Määrittele käytettävissä olevat funktiot
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"]
}
}]
# Vaihe 2: Malli päättää kutsua funktion
response = client.responses.create(
model="gpt-5.6-terra",
input="What's the weather like in Marseille?",
tools=tools
)
# Vaihe 3: Suorita funktio
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)
# Todellinen toteutuksesi
resultat_meteo = {"temperature": 22, "condition": "sunny"}
# Vaihe 4: Lähetä tulos takaisin mallille
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}")
# Tulos:
# Function: get_meteo
# Arguments: {"ville": "Marseille"}
# Response: It is currently 22 C in Marseille with sunny weather.
Anna mallin valita useista työkaluista
Todellinen arvo paljastuu, kun tarjoat käyttöön koko katalogin ominaisuuksia. Verkkokauppa-assistentissa määrittelisit tuotuhaun, varaston tarkistuksen ja tilauksen tekemisen, ja antaisit mallin tehdä valinnat. Kun se kohtaa kysymyksen “Onko XPS-pelikannettava saatavilla?”, se ei suorita hakua, vaan kysyy suoraan varastotilannetta: valinnan ohjasivat funktion kuvaukset, ei kovakoodattu sääntö.
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"]
}
}
]
# Malli valitsee automaattisesti oikean funktion
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}")
# Tulos: Function chosen: verifier_stock
# Arguments: {"produit_id": "xps-gaming"}
Yksi pyyntö voi laukaista myös useita kutsuja samanaikaisesti. Kahden kaupungin sään vertailu tuottaa kaksi erillistä kutsua: koodisi täytyy siksi iteroida response.output läpi ja käsitellä kaikki function_call-kohteet, ei vain ensimmäistä. Tämä on myös tilaisuus suorittaa nämä kutsut rinnakkain ja puolittaa viive.
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"]
}
}]
)
# Malli tekee kaksi kutsua rinnakkain
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']})")
# Tulos:
# Number of calls: 2
# - get_meteo(Paris)
# - get_meteo(Lyon)
Agenttisilmukka
Yksi edestakainen viesti harvoin riittää: yhden funktion tulos saa usein mallin kutsumaan toista funktion. Siksi käärit viestinnän silmukkaan, joka pyörii niin kauan kuin vastaus sisältää funktiokutsuja, ja pysähtyy heti kun niitä ei enää ole – tämä merkitsee, että malli on muotoillut lopullisen vastauksensa. Tämä on jokaisen agentin runko, ja näet sen eri muodoissa kaikissa agenttikehyksissä.
def executer_fonction(nom: str, arguments: str) -> str:
"""Execute a function and return the result."""
args = json.loads(arguments)
if nom == "get_meteo":
# Simulaatio – korvaa omalla APIllasi
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
)
# Tarkista funktiokutsut
function_calls = [i for i in response.output if i.type == "function_call"]
if not function_calls:
# Ei funktiokutsuja = lopullinen vastaus
return response.output_text
# Suorita jokainen funktio ja lisää tulokset
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
})
# Käyttö
reponse = agent_loop("What's the weather like in Paris?", tools)
print(reponse)
Varoitus tähän malliin liittyen: while True -silmukassa ei ole turvavälejä. Tuotantoympäristössä lisää maksimikierroslaskuri; muuten malli, joka pyytää samaa työkalua loputtomiin, polttaa budjettisi tekemättä koskaan johtopäätöstä.
Lukitse argumentit tiukalla tilalla
Strict mode (tiukka tila) tarjoaa funktioparametreille saman takuun kuin Structured Output vastauksille: argumentit noudattavat tarkasti määriteltyä skeemaa. Funktiolle, joka luo käyttäjän, tämä estää tilanteen, jossa vastaanotat iän merkkijonona tai ylimääräisen kentän, jota koodisi ei odottanut.
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
}
}]
Keskeiset asiat
- Function Calling yhdistää mallin järjestelmiisi paljastamatta dataasi
- Malli päättää, mikä funktio kutsutaan; koodisi suorittaa sen
- Palauta tulos käyttämällä
function_call_outputjacall_id - Malli voi kutsua useita funktioita rinnakkain
- Käytä agenttisilmukkaa monivaiheisiin keskusteluihin, jotka sisältävät funktioita
- Ota käyttöön
strict: Truevarmistaaksesi argumenttien yhteensopivuuden