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

Kombinera verktyg i ett enda anrop

Lektion 19 av 20 Uppdaterad 2 november 2026 Utvecklare
På denna sida
  1. Kombinera verktyg i ett enda anrop
  2. Principen för kombination
  3. Komplett exempel: analytisk assistent
  4. Hantera flerverktygsloopen
  5. Orkestreringsstrategier
  6. Mönster: agent med flera kompetenser
  7. Viktiga punkter

Uppdaterad 2 november 2026 baserat på OpenAI-dokumentation: Code Interpreter-verktyget kräver nu en container-parameter (lagd till i alla exempel), textinmatningsdelar 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. Filer som bifogas ett meddelande laddas upp med syftet user_data, vilket OpenAI rekommenderar för modellinmatningar (File inputs). Källor: Code Interpreter · Web search.

Kombinera verktyg i ett enda anrop

Hittills har vi tittat på varje verktyg isolerat. I produktion ställs sällan intressanta frågor på det sättet. Att fråga «hur står sig vår försäljning jämfört med marknaden?» kräver att du hämtar en intern siffra, en extern siffra och sedan jämför dem. Tre verktyg, tre källor, ett anrop.

Det som ändras är vem som bestämmer ordningen. Du programmerar inte sekvensen: du deklarerar vilka verktyg som finns tillgängliga och beskriver det önskade resultatet, så bygger modellen sin egen plan. Det är bekvämt, men det är också punkten du måste hålla koll på – en implicit plan är en plan du inte kan granska. Den sista delen av denna lektion visar hur du återtar kontrollen när ordningen verkligen spelar roll.

Principen för kombination

Alla verktyg deklareras i samma tools-array, och det är hela mekanismen: det finns inget compositions-API, bara en lista över tillgängliga funktioner. Modellen läser din begäran, härleder de nödvändiga stegen och anropar det den behöver, i den ordning den bedömer som användbar. Ett verktyg som är deklarerat men onödigt för uppgiften kommer helt enkelt inte att anropas – det kostar inget utöver de få token som beskrivningen tar.

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Compare our sales forecasts with market trends, "
          "then create a comparison chart.",
    tools=[
        {"type": "file_search", "vector_store_ids": ["vs_previsions"]},
        {"type": "web_search"},
        {"type": "code_interpreter", "container": {"type": "auto"}}
    ]
)

Modellen kommer att:

  1. Hämta interna prognoser via File Search
  2. Hämta marknadstrender via Web Search
  3. Generera ett jämförelse-diagram via Code Interpreter

Komplett exempel: analytisk assistent

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

tools = [
    # Sök i interna dokument
    {
        "type": "file_search",
        "vector_store_ids": ["vs_rapports", "vs_objectifs"],
        "max_num_results": 10
    },
    # Webbsökning för marknadskontext
    {
        "type": "web_search",
        "search_context_size": "medium"
    },
    # Kodkörning för analys
    {"type": "code_interpreter", "container": {"type": "auto"}},
    # Funktion för att spara rapporten
    {
        "type": "function",
        "name": "sauvegarder_rapport",
        "description": "Save an analysis report to the document system",
        "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": (
                "Based on this sales file: "
                "1. Analyze trends over the last 12 months "
                "2. Compare with our annual goals (search the docs) "
                "3. Search the web for market trends "
                "4. Generate a comparison chart "
                "5. Write a summary report "
                "6. Save the report"
            )},
            {"type": "input_file", "file_id": fichier.id}
        ]
    }],
    tools=tools,
    instructions=(
        "You are a senior business analyst. "
        "Use all tools at your disposal to produce "
        "a complete, sourced analysis."
    )
)

Hantera flerverktygsloopen

Det finns en asymmetri här som du måste ha i åtanke, eftersom den avgör din kodstruktur. Inbyggda verktyg – Web Search, File Search, Code Interpreter – körs hos OpenAI: modellen anropar dem, får resultatet och fortsätter, allt i en enda tur och retur. Dina egna funktioner körs dock på din sida: modellen kan bara begära att de körs, sedan lämnar den över kontrollen och väntar.

Därför behövs loopen nedan. Så länge svaret innehåller funktionsanrop kör du dem, returnerar resultaten och startar om. Sätt en gräns för maximalt antal iterationer: en modell som i all oändlighet anropar samma verktyg eftersom resultatet inte tillfredsställer den är ett sällsynt men verkligt fall, och utan en säkerhetsgräns kommer den att förbruka din budget tills den är slut.

import json

def boucle_multi_outils(prompt, tools, fichiers=None, max_tours=15):
    """Function calling loop with multi-tool support."""
    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="Use the necessary tools to answer completely."
        )

        # Built-in tools (web_search, file_search, code_interpreter)
        # are executed automatically on the server side.
        # We only handle custom function_call items.
        appels_custom = [
            item for item in response.output
            if item.type == "function_call"
        ]

        if not appels_custom:
            # No custom call: the model is finished
            return {
                "reponse": response.output_text,
                "tours": tour + 1,
                "tokens": response.usage.total_tokens
            }

        # Execute custom functions
        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)
            })

        # Prepare the next turn
        messages = response.output + resultats

    return {"reponse": "Turn limit reached", "tours": max_tours}

Orkestreringsstrategier

Styra verktygsordningen

Automatisk orkestrering fungerar bra så länge ordningen inte spelar roll. Den slutar fungera när ett steg måste informera nästa: att söka i dina dokument innan webben, till exempel, eftersom det interna ordförrådet avgör relevansen i den externa frågan. Systemprompten är hävstången – inte som en teknisk begränsning, utan som en metodisk instruktion som modellen följer desto bättre när den är motiverad.

# Strategi 1: sök först, agera senare
instructions_recherche_dabord = (
    "Before any action, first search for the necessary information "
    "in internal documents and on the web. "
    "Do not propose actions until you have gathered all data."
)

# Strategi 2: dataanalys sedan berikning
instructions_analyse_dabord = (
    "Start by analyzing the data with Code Interpreter. "
    "Then enrich your conclusions with web searches. "
    "Finally, compare with internal documents."
)

# Strategi 3: korsverifiering
instructions_verification = (
    "For each important piece of information, verify it in at least two sources: "
    "internal documents AND web search. Report any contradictions."
)

Begränsa verktyg per steg

Den motsatta approachen är att ta bort valet. Istället för ett enda anrop med hela verktygslådan delar du upp arbetsflödet i flera anrop, där varje anrop endast deklarerar verktyget för sitt specifika steg. Du förlorar den automatiska orkestreringen men vinner tre saker som betyder något i produktion: garanterad ordning, förutsägbara kostnader och isolerbara fel. För ett kritiskt flöde är detta nästan alltid rätt avvägning.

# Steg 1: datainsamling (ingen kod)
response_collecte = client.responses.create(
    model="gpt-5.6-terra",
    input="Gather information on Project Alpha",
    tools=[
        {"type": "file_search", "vector_store_ids": ["vs_projets"]},
        {"type": "web_search"}
    ]
)

# Steg 2: analys med insamlad data
response_analyse = client.responses.create(
    model="gpt-5.6-terra",
    input=f"Analyze this information and generate charts:\n"
          f"{response_collecte.output_text}",
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)

Mönster: agent med flera kompetenser

Detta sista exempel kombinerar båda approacherna: en router väljer verktygskonfigurationen baserat på begärans natur, och låter sedan modellen orkestrera inom det begränsade omfånget. Det är kompromissen som håller i användning – tillräckligt med frihet för att absorbera variationen i begäranden, tillräckligt med struktur för att hålla kostnader och beteende förutsägbara.

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)

# Instansiera agenten
agent = AgentMultiCompetences(
    vector_stores=["vs_docs", "vs_contrats"],
    fonctions=[
        {
            "type": "function",
            "name": "envoyer_email",
            "description": "Send a notification email",
            "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": "Create a task in the project manager",
            "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öka i dokument
# - Söka på webben
# - Analysera data
# - Skicka e-post
# - Skapa uppgifter
resultat = agent.traiter(
    "Analyze Q1 sales, compare with goals, "
    "and create a task for the sales director if we are behind."
)

Viktiga punkter

  • Alla verktyg samexisterar i samma tools-array
  • Inbyggda verktyg körs på serversidan, egna funktioner körs på clientsidan
  • Modellen orkestrerar automatiskt ordningen på anropen
  • Styr orkestreringsstrategin via systemprompten
  • Implementera en loop för att hantera egna funktionsanrop