Arkitektur för funktionsanrop i Responses API
På denna sida
Uppdaterat den 2 november 2026 baserat på OpenAIs dokumentation: verktyget Code Interpreter kräver nu en parameter
container(lagts till i alla exempel), textdelar för inmatning använder typeninput_text, och webbsökning använder verktygetweb_search(web_search_previewär nu ett föråldrat verktyg utan domänfilter). Genererade filer hämtas med funktionernafichiers_generesochtelechargerfrån lektion 10. Källor: Code Interpreter · Web search.
Arkitektur för funktionsanrop i Responses API
Funktionsanrop är den centrala mekanism som låter OpenAIs modeller interagera med omvärlden. I Responses API har denna mekanism omarbetats för att bli mer robust, mer förutsägbar och native integrerad med inbyggda verktyg som Web Search och Code Interpreter.
Den grundläggande principen
Modellen gör aldrig något direkt. Den emitterar strukturerade avsikter som din kod fångar upp och exekuterar. Uttryckt så kan det låta som en teknisk begränsning; i verkligheten är det designvalet som möjliggör allt annat.
Tänk på alternativet. Om modellen exekverade åtgärder själv skulle du behöva lämna ut dina databasuppgifter, API-nycklar och skrivrättigheter – och du skulle inte ha någon punkt där du kunde verifiera något. Med avkoppling passerar varje avsikt genom din kod: du validerar argument, tillämpar affärsregler och vägrar vid behov. Modellen föreslår, din kod disponerar, och det är den gränsen som låter dig ta funktionsanrop till produktion utan att tappa kontrollen.
from openai import OpenAI
client = OpenAI()
# Deklarera ett anpassat verktyg
tools = [{
"type": "function",
"name": "rechercher_client",
"description": "Search for a client in the CRM by name or email",
"parameters": {
"type": "object",
"properties": {
"terme": {
"type": "string",
"description": "Client name, email, or ID"
},
"champ": {
"type": "string",
"enum": ["nom", "email", "id"],
"description": "Field to search in"
}
},
"required": ["terme"]
}
}]
response = client.responses.create(
model="gpt-5.6-terra",
input="Find the client Jean Dupont",
tools=tools
)
Anatomin hos ett svar
Ett svar innehåller inte antingen text eller verktygsanrop: output är en heterogen lista som kan blanda båda. Vanan du måste bygga från din första kodrad är att iterera över denna lista snarare än att läsa output[0] – en modell som förklarar sitt resonemang innan den anropar en funktion producerar exakt det fallet, och kod som läser det första elementet kommer att krascha den dag den börjar lägga till kommentarer.
for item in response.output:
if item.type == "function_call":
print(f"Call ID : {item.call_id}")
print(f"Function : {item.name}")
print(f"Args : {item.arguments}")
call_id är avgörande: den länkar anropet till dess resultat när du skickar tillbaka svaret till modellen. Vid ett enda anrop märker du knappt av det; vid tre parallella anrop är det det enda som hindrar dig från att tillskriva vädret i Lyon till förfrågan om Marseille. Returnera alltid resultatet med det call_id du fick, aldrig med ett ID du rekonstruerar på din sida.
Den kompletta loopen
Denna fyrstegscykel är invariant: den gäller för en funktion eller tjugo, för ett enkelt anrop eller en agent som kedjar tio verktyg. All komplexitet du stöter på senare – parallellism, fel, reservlösningar – består i att instrumentera denna loop, aldrig att ersätta den.
import json
# 1. Första anropet med deklarerade verktyg
response = client.responses.create(
model="gpt-5.6-terra",
input="What is the balance for client [email protected]?",
tools=tools
)
# 2. Upptäck och exekvera funktionsanrop
resultats = []
for item in response.output:
if item.type == "function_call":
if item.name == "rechercher_client":
args = json.loads(item.arguments)
resultat = votre_crm.rechercher(args["terme"])
resultats.append({
"type": "function_call_output",
"call_id": item.call_id,
"output": json.dumps(resultat)
})
# 3. Skicka tillbaka resultaten till modellen
response_finale = client.responses.create(
model="gpt-5.6-terra",
input=response.output + resultats,
tools=tools
)
# 4. Modellen formulerar sitt naturliga svar
print(response_finale.output_text)
Viktiga skillnader jämfört med Chat Completions
Responses API medför flera arkitektoniska förbättringar.
Native hantering av inbyggda verktyg
Inbyggda verktyg deklareras exakt som dina funktioner, men de exekveras på OpenAIs sida. Den praktiska konsekvensen är behaglig: du skriver ingen loop för dem. Modellen anropar, får resultatet och fortsätter, allt i en enda omgång. Loopen som beskrivs ovan gäller endast dina funktioner – de som körs på din maskin.
# Blanda inbyggda och anpassade verktyg
tools = [
{"type": "web_search"},
{"type": "code_interpreter", "container": {"type": "auto"}},
{
"type": "function",
"name": "ma_fonction",
"description": "My custom function",
"parameters": {"type": "object", "properties": {}}
}
]
Stabila anropsidentifikatorer
Varje funktionsanrop får en unik call_id som låter dig spåra exakt vilket resultat som motsvarar vilket anrop, även vid parallella anrop.
Förenklat flöde
Inget behov av att manuellt hantera rollerna assistant och tool i meddelanden. Fältet input accepterar direkt att konkatenera tidigare utdata med funktionsresultat.
När anropar modellen en funktion?
Modellen beslutar att anropa en funktion när användarens förfrågan kräver information den inte har, när funktionens beskrivning matchar det identifierade behovet, och när de erforderliga parametrarna kan härledas ur kontexten.
Tre villkor måste alltså uppfyllas samtidigt, och det är användbart för felsökning: när en funktion inte anropas trots att den borde det, är orsaken nästan alltid den andra – en beskrivning som inte täcker sättet användaren formulerade sin förfrågan på. Parametern tool_choice låter dig tvinga fram beteende när beskrivningen inte räcker:
# Låt modellen besluta
tool_choice = "auto"
# Tvinga ett anrop till en specifik funktion
tool_choice = {"type": "function", "name": "rechercher_client"}
# Förbjud alla funktionsanrop
tool_choice = "none"
# Kräv minst ett anrop utan att specificera vilket
tool_choice = "required"
Viktiga punkter
- Funktionsanrop är ett avsiktsprotokoll, inte ett exekveringsprotokoll
- Loopen anropa-exekvera-returnera är det grundläggande mönstret
- Inbyggda och anpassade verktyg samexisterar i samma
tools-array call_idsäkerställer spårbarhet för varje anroptool_choicelåter dig finjustera modellens beteende