Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Function Calling: Forbind AI med dine systemer

Lektion 10 af 22 Opdateret 29. juli 2026 Udvikler
På denne side
  1. Function Calling: Forbind AI med dine systemer
  2. Hele forløbet trin for trin
  3. Lad modellen vælge mellem flere værktøjer
  4. Agent-løkken
  5. Lås argumenter med Strict Mode
  6. Vigtige pointer

Function Calling: Forbind AI med dine systemer

Function Calling lader modellen kalde funktioner, som du definerer. Husk én grundregel frem for alt, for alt andet udspringer af den: Modellen udfører dem ikke. Den fortæller dig, hvilken funktion der skal kaldes, og med hvilke argumenter; din kode står for selve udførelsen og returnerer resultatet. Din database, dine legitimationsoplysninger og din forretningslogik forlader aldrig din egen infrastruktur.

Hele forløbet trin for trin

Udvekslingen foregår i fire faser:

  1. Du deklarerer tilgængelige funktioner sammen med deres parametre
  2. Modellen analyserer forespørgslen og beslutter at kalde en funktion
  3. Din kode udfører funktionen og indhenter resultatet
  4. Du sender resultatet tilbage til modellen, så den kan formulere sit svar

Deklarationen fortjener særlig omhu: Funktionens description og beskrivelsen af hver enkelt parameter er den eneste dokumentation, modellen har til rådighed for at træffe sin beslutning. Vage beskrivelser fører til upræcise kald. Bemærk også, hvordan du lukker sløjfen: Resultatet sendes tilbage med det call_id, du modtog, hvilket fungerer som en kvittering og gør det muligt for API’et at matche svaret med anmodningen.

from openai import OpenAI
import json

client = OpenAI()

# Trin 1: Deklarer tilgængelige 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"]
    }
}]

# Trin 2: Modellen beslutter at kalde funktionen
response = client.responses.create(
    model="gpt-5.6-terra",
    input="What's the weather like in Marseille?",
    tools=tools
)

# Trin 3: Udfør 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 faktiske implementering
        resultat_meteo = {"temperature": 22, "condition": "sunny"}

        # Trin 4: Send resultatet tilbage til 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.

Lad modellen vælge mellem flere værktøjer

Den virkelige værdi viser sig, når du stiller en hel katalog af muligheder til rådighed. I en e-commerce-assistent ville du deklarere produktsøgning, lagerbekræftelse og ordreoprettelse og derefter lade modellen træffe valget. Konfronteret med spørgsmålet „Er XPS gaming-laptoppen på lager?” vil den ikke køre en søgning, men direkte spørge til lagerstatus: Det er dine funktionsbeskrivelser – ikke en hårdkodet regel – der styrer dette valg.

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ælger automatisk den rigtige 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 enkelt anmodning kan også udløse flere kald på én gang. En sammenligning af vejret i to byer producerer to uafhængige kald: Din kode skal derfor iterere gennem response.output og håndtere alle function_call-elementer, aldrig kun det første. Dette er også en mulighed for at udføre disse kald parallelt og dermed halvere ventetiden.

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 foretager to kald parallelt
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)

Agent-løkken

Én tur-retur er sjældent nok: Resultatet af én funktion får ofte modellen til at kalde en anden. Derfor pakker du udvekslingen ind i en løkke, der kører, så længe svaret indeholder funktionskald, og stopper, så snart det ikke gør – et tegn på, at modellen har formuleret sit endelige svar. Dette er skelettet i enhver agent, og du vil se det i forskellige former i alle agent-frameworks.

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
        )

        # Tjek for funktionskald
        function_calls = [i for i in response.output if i.type == "function_call"]

        if not function_calls:
            # Ingen funktionskald = endeligt svar
            return response.output_text

        # Udfør hver funktion og tilføj resultater
        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
            })

# Brug
reponse = agent_loop("What's the weather like in Paris?", tools)
print(reponse)

Et ord af advarsel om dette mønster: while True-løkken har ingen sikkerhedsnet. I produktion skal du tilføje en tæller for maksimalt antal iterationer; ellers vil en model, der uendeligt anmoder om det samme værktøj, brænde dit budget af uden nogensinde at konkludere.

Lås argumenter med Strict Mode

Strict Mode giver den samme garanti for funktionsparametre, som Structured Output giver for svar: Argumenterne overholder strengt det deklarerede skema. For en funktion, der opretter en bruger, forhindrer dette, at du modtager en alder som en streng eller et ekstra felt, som din kode ikke forventede.

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
    }
}]

Vigtige pointer

  • Function Calling forbinder modellen med dine systemer uden at afsløre dine data
  • Modellen beslutter, hvilken funktion der skal kaldes; din kode udfører den
  • Returner resultatet ved hjælp af function_call_output og call_id
  • Modellen kan kalde flere funktioner parallelt
  • Brug en agent-løkke til samtaler over flere omgange, der involverer funktioner
  • Aktiver strict: True for at garantere overholdelse af argumenter