Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Arkitektur för funktionsanrop i Responses API

Lektion 1 av 20 Uppdaterad 2 november 2026 Utvecklare
På denna sida
  1. Arkitektur för funktionsanrop i Responses API
  2. Den grundläggande principen
  3. Anatomin hos ett svar
  4. Den kompletta loopen
  5. Viktiga skillnader jämfört med Chat Completions
  6. När anropar modellen en funktion?
  7. Viktiga punkter

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 typen input_text, och webbsökning använder verktyget web_search (web_search_preview är nu ett föråldrat verktyg utan domänfilter). Genererade filer hämtas med funktionerna fichiers_generes och telecharger frå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_id säkerställer spårbarhet för varje anrop
  • tool_choice låter dig finjustera modellens beteende