Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Kombinér værktøjer i ét enkelt kald

Lektion 19 af 20 Opdateret 2. november 2026 Udvikler
På denne side
  1. Kombinér værktøjer i ét enkelt kald
  2. Princippet om kombination
  3. Fuldt eksempel: analytisk assistent
  4. Håndtér multi-værktøjs-løkken
  5. Orkestreringsstrategier
  6. Mønster: agent med flere kompetencer
  7. Vigtige pointer

Opdateret 2. november 2026 baseret på OpenAI-dokumentation: Code Interpreter-værktøjet kræver nu en container-parameter (tilføjet til alle eksempler), tekstinput-dele bruger typen input_text, og websøgning bruger værktøjet web_search (web_search_preview er nu et forældet værktøj uden domænefiltre). Genererede filer hentes ved hjælp af funktionerne fichiers_generes og telecharger fra lektion 10. Filer, der er vedhæftet en besked, uploades med formålet user_data, hvilket OpenAI anbefaler til modelinput (File inputs). Kilder: Code Interpreter · Web search.

Kombinér værktøjer i ét enkelt kald

Indtil videre har vi kigget på hvert værktøj isoleret. I produktion tager interessante spørgsmål sjældent den form. Spørgsmålet „hvordan står vores salg i forhold til markedet?” kræver, at du henter et internt tal, et eksternt tal og derefter sammenligner dem. Tre værktøjer, tre kilder, ét kald.

Det, der ændrer sig, er hvem der beslutter rækkefølgen. Du programmerer ikke sekvensen: du erklærer de tilgængelige værktøjer og beskriver det forventede resultat, så etablerer modellen sin egen plan. Det er praktisk, men det er også det punkt, du skal passe på – en implicit plan er en plan, du ikke kan gennemgå. Den sidste del af denne lektion viser, hvordan du genvinder kontrollen, når rækkefølgen virkelig betyder noget.

Princippet om kombination

Alle værktøjer erklæres i samme tools-array, og det er hele mekanismen: der findes intet kompositions-API, kun en liste over tilgængelige funktioner. Modellen læser din anmodning, udleder de nødvendige trin og kalder det, den har brug for, i den rækkefølge, den finder hensigtsmæssig. Et værktøj, der er erklæret, men unødvendigt for opgaven, bliver simpelthen ikke kaldt – det koster ikke andet end de få tokens i dets beskrivelse.

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Sammenlign vores salgsprognoser med markedstendenser, "
          "og opret derefter et sammenligningsdiagram.",
    tools=[
        {"type": "file_search", "vector_store_ids": ["vs_previsions"]},
        {"type": "web_search"},
        {"type": "code_interpreter", "container": {"type": "auto"}}
    ]
)

Modellen vil:

  1. Hente interne prognoser via File Search
  2. Hente markedstendenser via Web Search
  3. Generere et sammenligningsdiagram via Code Interpreter

Fuldt eksempel: analytisk assistent

with open("donnees_ventes.csv", "rb") as f:
    fichier = client.files.create(file=f, purpose="user_data")

tools = [
    # Søg i interne dokumenter
    {
        "type": "file_search",
        "vector_store_ids": ["vs_rapports", "vs_objectifs"],
        "max_num_results": 10
    },
    # Websøgning efter markedskontekst
    {
        "type": "web_search",
        "search_context_size": "medium"
    },
    # Kodekørsel til analyse
    {"type": "code_interpreter", "container": {"type": "auto"}},
    # Funktion til at gemme rapporten
    {
        "type": "function",
        "name": "sauvegarder_rapport",
        "description": "Gem en analyserapport i dokumentsystemet",
        "parameters": {
            "type": "object",
            "properties": {
                "titre": {"type": "string"},
                "contenu": {"type": "string"},
                "categorie": {
                    "type": "string",
                    "enum": ["analyse", "prevision", "audit", "comparaison"]
                },
                "tags": {
                    "type": "array",
                    "items": {"type": "string"}
                }
            },
            "required": ["titre", "contenu", "categorie", "tags"],
            "additionalProperties": False
        },
        "strict": True
    }
]

response = client.responses.create(
    model="gpt-5.6-terra",
    input=[{
        "role": "user",
        "content": [
            {"type": "input_text", "text": (
                "Baseret på denne salgsfil: "
                "1. Analyser tendenser over de sidste 12 måneder "
                "2. Sammenlign med vores årlige mål (søg i dokumenterne) "
                "3. Søg på nettet efter markedstendenser "
                "4. Generer et sammenligningsdiagram "
                "5. Skriv en sammenfattende rapport "
                "6. Gem rapporten"
            )},
            {"type": "input_file", "file_id": fichier.id}
        ]
    }],
    tools=tools,
    instructions=(
        "Du er en senior forretningsanalytiker. "
        "Brug alle værktøjer til din rådighed til at producere "
        "en komplet, kildehenvisende analyse."
    )
)

Håndtér multi-værktøjs-løkken

Der er en asymmetri her, som du skal holde for øje, fordi den bestemmer din kodestruktur. Indbyggede værktøjer – Web Search, File Search, Code Interpreter – kører hos OpenAI: modellen kalder dem, får resultatet og fortsætter, alt i én enkelt rundtur. Dine egne funktioner kører derimod på din side: modellen kan kun anmode om deres udførelse, hvorefter den afgiver kontrollen og venter.

Derfor løkken nedenfor. Så længe svaret indeholder funktionskald, udfører du dem, returnerer resultaterne og starter forfra. Sæt et maksimum antal iterationer: en model, der uendeligt genkalder samme værktøj, fordi resultatet ikke tilfredsstiller den, er et sjældent, men reelt tilfælde, og uden en sikkerhedsforanstaltning vil den opbruge dit budget, indtil det er tømt.

import json

def boucle_multi_outils(prompt, tools, fichiers=None, max_tours=15):
    """Funktionskaldsløkke med understøttelse af flere værktøjer."""
    content = [{"type": "input_text", "text": prompt}]
    if fichiers:
        for fid in fichiers:
            content.append({"type": "input_file", "file_id": fid})

    messages = [{"role": "user", "content": content}]

    for tour in range(max_tours):
        response = client.responses.create(
            model="gpt-5.6-terra",
            input=messages,
            tools=tools,
            instructions="Brug de nødvendige værktøjer til at besvare spørgsmålet fuldstændigt."
        )

        # Indbyggede værktøjer (web_search, file_search, code_interpreter)
        # udføres automatisk på serversiden.
        # Vi håndterer kun custom function_call-elementer.
        appels_custom = [
            item for item in response.output
            if item.type == "function_call"
        ]

        if not appels_custom:
            # Intet custom kald: modellen er færdig
            return {
                "reponse": response.output_text,
                "tours": tour + 1,
                "tokens": response.usage.total_tokens
            }

        # Udfør custom funktioner
        resultats = []
        for appel in appels_custom:
            resultat = dispatcher_fonctions(appel.name, appel.arguments)
            resultats.append({
                "type": "function_call_output",
                "call_id": appel.call_id,
                "output": json.dumps(resultat)
            })

        # Forbered næste runde
        messages = response.output + resultats

    return {"reponse": "Grænse for antal runder nået", "tours": max_tours}

Orkestreringsstrategier

Guid værktøjsrækkefølgen

Automatisk orkestrering fungerer fint, så længe rækkefølgen ikke betyder noget. Den holder op med at fungere, når ét trin skal informere det næste: at søge i dine dokumenter før nettet, for eksempel, fordi det interne ordforråd betinger relevansen af den eksterne forespørgsel. Systemprompten er løftestangen – ikke som en teknisk begrænsning, men som en metodisk instruktion, som modellen følger desto bedre, når den er begrundet.

# Strategi 1: søg først, handl senere
instructions_recherche_dabord = (
    "Før enhver handling skal du først søge efter de nødvendige oplysninger "
    "i interne dokumenter og på nettet. "
    "Foreslå ikke handlinger, før du har indsamlet alle data."
)

# Strategi 2: dataanalyse derefter berigelse
instructions_analyse_dabord = (
    "Start med at analysere dataene med Code Interpreter. "
    "Berig derefter dine konklusioner med websøgninger. "
    "Sammenlign til sidst med interne dokumenter."
)

# Strategi 3: krydsverifikation
instructions_verification = (
    "For hvert vigtigt informationspunkt skal du verificere det i mindst to kilder: "
    "interne dokumenter OG websøgning. Rapporter eventuelle modsigelser."
)

Begræns værktøjer pr. trin

Den modsatte tilgang er at fjerne valgfriheden. I stedet for ét enkelt kald med hele værktøjssættet opdeler du arbejdsgangen i flere kald, hvor hvert kald kun erklærer værktøjet til sit specifikke trin. Du mister den automatiske orkestrering, men vinder tre ting, der betyder noget i produktion: garanteret rækkefølge, forudsigelige omkostninger og isolerbare fejl. For et kritisk flow er dette næsten altid den rigtige afvejning.

# Trin 1: dataindsamling (ingen kode)
response_collecte = client.responses.create(
    model="gpt-5.6-terra",
    input="Indsaml oplysninger om Projekt Alpha",
    tools=[
        {"type": "file_search", "vector_store_ids": ["vs_projets"]},
        {"type": "web_search"}
    ]
)

# Trin 2: analyse med indsamlede data
response_analyse = client.responses.create(
    model="gpt-5.6-terra",
    input=f"Analyser disse oplysninger og generer diagrammer:\n"
          f"{response_collecte.output_text}",
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)

Mønster: agent med flere kompetencer

Dette sidste eksempel kombinerer begge tilgange: en router vælger værktøjskonfigurationen baseret på forespørgslens art og lader derefter modellen orkestrere inden for dette begrænsede omfang. Det er det kompromis, der holder i brug – nok frihed til at absorbere variationen i forespørgsler, nok struktur til at holde omkostninger og adfærd forudsigelige.

class AgentMultiCompetences:
    def __init__(self, vector_stores: list[str], fonctions: list[dict]):
        self.client = OpenAI()
        self.tools = [
            {"type": "file_search", "vector_store_ids": vector_stores},
            {"type": "web_search", "search_context_size": "medium"},
            {"type": "code_interpreter", "container": {"type": "auto"}},
        ] + fonctions

    def traiter(self, requete: str, fichiers: list[str] = None) -> dict:
        return boucle_multi_outils(requete, self.tools, fichiers)

# Instantiér agenten
agent = AgentMultiCompetences(
    vector_stores=["vs_docs", "vs_contrats"],
    fonctions=[
        {
            "type": "function",
            "name": "envoyer_email",
            "description": "Send en notifikations-e-mail",
            "parameters": {
                "type": "object",
                "properties": {
                    "destinataire": {"type": "string"},
                    "sujet": {"type": "string"},
                    "corps": {"type": "string"}
                },
                "required": ["destinataire", "sujet", "corps"],
                "additionalProperties": False
            },
            "strict": True
        },
        {
            "type": "function",
            "name": "creer_tache",
            "description": "Opret en opgave i projektlederen",
            "parameters": {
                "type": "object",
                "properties": {
                    "titre": {"type": "string"},
                    "assignee": {"type": "string"},
                    "priorite": {"type": "string", "enum": ["basse", "moyenne", "haute"]},
                    "echeance": {"type": "string"}
                },
                "required": ["titre", "assignee", "priorite"],
                "additionalProperties": False
            },
            "strict": True
        }
    ]
)

# Agenten kan nu:
# - Søge i dokumenter
# - Søge på nettet
# - Analysere data
# - Sende e-mails
# - Oprette opgaver
resultat = agent.traiter(
    "Analyser salget i 1. kvartal, sammenlign med målene, "
    "og opret en opgave til salgsdirektøren, hvis vi bagefter."
)

Vigtige pointer

  • Alle værktøjer sameksisterer i samme tools-array
  • Indbyggede værktøjer kører på serversiden, custom funktioner kører på clientsiden
  • Modellen orkestrerer automatisk rækkefølgen af kald
  • Guid orkestreringsstrategien via systemprompten
  • Implementér en løkke til at håndtere custom funktionskald