Function Calling: Anslut AI till dina system
På denna sida
Function Calling: Anslut AI till dina system
Function calling låter modellen anropa funktioner som du definierar. Kom ihåg en grundregel framför allt annat, för allt annat följer av den: modellen exekverar dem inte. Den berättar vilken funktion du ska anropa och med vilka argument; din kod utför exekveringen och returnerar resultatet. Din databas, dina inloggningsuppgifter och din affärslogik lämnar aldrig din infrastruktur.
Hela flödet, steg för steg
Utbytet sker i fyra steg:
- Du deklarerar tillgängliga funktioner tillsammans med deras parametrar
- Modellen analyserar förfrågan och beslutar att anropa en funktion
- Din kod exekverar funktionen och hämtar resultatet
- Du skickar tillbaka resultatet till modellen så att den kan formulera sitt svar
Deklarationen förtjänar särskild omsorg: funktionens description och varje parameters beskrivning är den enda dokumentation modellen har för att fatta sitt beslut. Otydliga beskrivningar leder till ungefärliga anrop. Lägg också märke till hur du sluter loopen – resultatet skickas tillbaka med det call_id du fick, vilket fungerar som en bekräftelse och låter API:t matcha svaret med begäran.
from openai import OpenAI
import json
client = OpenAI()
# Steg 1: Deklarera tillgängliga funktioner
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"]
}
}]
# Steg 2: Modellen beslutar att anropa funktionen
response = client.responses.create(
model="gpt-5.6-terra",
input="What's the weather like in Marseille?",
tools=tools
)
# Steg 3: Exekvera funktionen
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)
# Din faktiska implementation
resultat_meteo = {"temperature": 22, "condition": "sunny"}
# Steg 4: Skicka tillbaka resultatet till modellen
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}")
# Resultat:
# Function: get_meteo
# Arguments: {"ville": "Marseille"}
# Response: It is currently 22 C in Marseille with sunny weather.
Låt modellen välja mellan flera verktyg
Det verkliga värdet visar sig när du exponerar en hel katalog av möjligheter. I en e-handelsassistent skulle du deklarera produktsökning, lagerkontroll och orderläggning, och sedan låta modellen avgöra. Konfronterad med frågan «Is the XPS gaming laptop available?» kommer den inte att köra en sökning utan istället fråga lagret direkt: det är dina funktionsbeskrivningar, inte en hårdkodad regel, som styr detta val.
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"]
}
}
]
# Modellen väljer automatiskt rätt 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}")
# Resultat: Function chosen: verifier_stock
# Arguments: {"produit_id": "xps-gaming"}
En enda förfrågan kan också utlösa flera anrop samtidigt. Att jämföra vädret i två städer genererar två oberoende anrop: din kod måste därför iterera genom response.output och hantera alla function_call-objekt, aldrig bara det första. Detta är också ett tillfälle att exekvera dessa anrop parallellt och halvera latensen.
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"]
}
}]
)
# Modellen gör två anrop parallellt
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']})")
# Resultat:
# Number of calls: 2
# - get_meteo(Paris)
# - get_meteo(Lyon)
Agentloopen
En enda tur och retur räcker sällan: resultatet från en funktion leder ofta modellen till att anropa en annan. Därför kapslar du utbytet i en loop som körs så länge svaret innehåller funktionsanrop och stoppar så snart det inte gör det – ett tecken på att modellen har formulerat sitt slutgiltiga svar. Detta är skelettet i varje agent, och du kommer att se det i olika skepnader i alla agent-ramverk.
def executer_fonction(nom: str, arguments: str) -> str:
"""Execute a function and return the result."""
args = json.loads(arguments)
if nom == "get_meteo":
# Simulation — replace with your real 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
)
# Kontrollera efter funktionsanrop
function_calls = [i for i in response.output if i.type == "function_call"]
if not function_calls:
# Inga funktionsanrop = slutgiltigt svar
return response.output_text
# Exekvera varje funktion och lägg till resultat
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
})
# Användning
reponse = agent_loop("What's the weather like in Paris?", tools)
print(reponse)
En varning för detta mönster: while True-loopen har inga skyddsräcken. I produktion måste du lägga till en räknare för maximalt antal iterationer; annars kommer en modell som oändligt begär samma verktyg att bränna igenom din budget utan att någonsin avsluta.
Lås argumenten med strikt läge
Strikt läge applicerar samma garanti på funktionsparametrar som Structured Output gör på svar: argument följer strikt det deklarerade schemat. För en funktion som skapar en användare förhindrar detta att du får en ålder som en sträng, eller ett extra fält som din kod inte förväntade sig.
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
}
}]
Viktiga punkter
- Function calling kopplar modellen till dina system utan att exponera dina data
- Modellen beslutar vilken funktion som ska anropas; din kod exekverar den
- Returnera resultatet med
function_call_outputochcall_id - Modellen kan anropa flera funktioner parallellt
- Använd en agentloop för konversationer över flera steg som involverar funktioner
- Aktivera
strict: Trueför att garantera att argumenten följer schemat