Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Tool Search: Dynamiske værktøjer

Lektion 15 af 20 Opdateret 2. november 2026 Udvikler
På denne side
  1. Tool Search: Dynamiske værktøjer
  2. Problemet med store værktøjskataloger
  3. Aktivering af Tool Search
  4. Organisering af funktionskataloget
  5. Bedste praksis for beskrivelser
  6. Kombination af Tool Search med faste værktøjer
  7. Mønster: System med flere domæner
  8. Vigtige pointer

Lektion opdateret 2. november 2026 baseret på OpenAI-dokumentation: Code Interpreter-værktøjet kræver nu en container-parameter (tilføjet til alle eksempler), inputtekstdele er typet som input_text, og websøgning bruger web_search-værktøjet (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. Kilder: Code Interpreter · Web search.

Tool Search: Dynamiske værktøjer

Når du har dusinvis eller hundredvis af funktioner, bliver det kontraproduktivt at deklarere dem alle i hvert kald: modellen mister præcision, og omkostningerne eksploderer. Tool Search løser dette problem ved at lade modellen slå det rigtige værktøj op i et indekseret katalog.

Problemet med store værktøjskataloger

Omkostningen ved et stort værktøjskatalog er usynlig på to måder. For det første økonomisk: hver funktionsdefinition sendes med hver anmodning, inklusive de otteoghalvfems, der ikke bliver brugt. I stor skala overstiger dette i sidste ende omkostningerne ved selve svarene. For det andet, og mere alvorligt, kvalitativt: ud over et par dusin værktøjer med overlappende ansvarsområder træffer modellen dårligere valg. For mange muligheder forringer beslutningstagningen, her som alle andre steder.

# 5 funktioner = ~500 kontekst-tokens
# 50 funktioner = ~5000 kontekst-tokens
# 200 funktioner = umuligt at håndtere effektivt

# Modellen mister præcision, når der er for mange funktioner
# Den vælger nogle gange den forkerte funktion eller hallucinerer parametre

Tool Search vender logikken på hovedet: I stedet for at præsentere alt for modellen, indekserer du kataloget og viser kun det, der matcher den aktuelle anmodning. Mekanismen afhænger af semantisk søgning i beskrivelser – hvilket er grunden til, at næste afsnit ikke blot er stilråd; det er en forudsætning for, at systemet fungerer.

from openai import OpenAI

client = OpenAI()

# Deklarer et stort antal funktioner
all_functions = [
    {
        "type": "function",
        "name": "create_invoice",
        "description": "Create a new invoice for a customer",
        "parameters": {"type": "object", "properties": {"client_id": {"type": "string"}}, "required": ["client_id"]}
    },
    {
        "type": "function",
        "name": "cancel_invoice",
        "description": "Cancel an existing invoice",
        "parameters": {"type": "object", "properties": {"invoice_id": {"type": "string"}}, "required": ["invoice_id"]}
    },
    # ... dusinvis af andre funktioner
]

# Brug Tool Search til at lade modellen finde den rigtige funktion
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Cancel invoice FAC-2026-0042",
    tools=[{
        "type": "tool_search",
        "tool_search": {
            "tools": all_functions
        }
    }]
)

Modellen modtager kun de funktioner, der er relevante for anmodningen, i sin kontekst, ikke hele kataloget.

Organisering af funktionskataloget

To principper er nok til at strukturere et katalog, der forbliver overskueligt. Sæt præfikser på navne efter domæne (crm_, billing_, inventory_): læsning af eksekveringsspor bliver øjeblikkelig, og navnekonflikter forsvinder. Og giv hver funktion et klart ansvarsområde – to funktioner, hvis beskrivelser overlapper, vil producere ustabile valg, uanset om det er et menneske eller en vektormotor, der træffer beslutningen.

crm_catalog = [
    {
        "type": "function",
        "name": "crm_search_customer",
        "description": "Search for a customer in the CRM by name, email, or ID. "
                       "Use to find information about an existing customer.",
        "parameters": {
            "type": "object",
            "properties": {
                "term": {"type": "string", "description": "Search term"},
                "field": {"type": "string", "enum": ["name", "email", "id"]}
            },
            "required": ["term"],
            "additionalProperties": False
        },
        "strict": True
    },
    {
        "type": "function",
        "name": "crm_create_customer",
        "description": "Create a new customer in the CRM. "
                       "Use when a customer does not yet exist.",
        "parameters": {
            "type": "object",
            "properties": {
                "name": {"type": "string"},
                "email": {"type": "string"},
                "company": {"type": "string"}
            },
            "required": ["name", "email", "company"],
            "additionalProperties": False
        },
        "strict": True
    }
]

billing_catalog = [
    {
        "type": "function",
        "name": "bill_create_invoice",
        "description": "Create an invoice. Requires an existing customer.",
        "parameters": {
            "type": "object",
            "properties": {
                "client_id": {"type": "string"},
                "lines": {"type": "array", "items": {"type": "object", "properties": {
                    "description": {"type": "string"},
                    "amount": {"type": "number"}
                }}}
            },
            "required": ["client_id", "lines"],
            "additionalProperties": False
        },
        "strict": True
    }
]

# Saml alle kataloger
full_catalog = crm_catalog + billing_catalog

Bedste praksis for beskrivelser

Skriv beskrivelser til søgning, ikke til dokumentation. „Hent kundeoplysninger” vil aldrig blive fundet ved en forespørgsel om „ordrehistorik” eller „faktureringskontaktoplysninger”: de ord, dine brugere faktisk skriver, skal forekomme i den indekserede tekst. En nyttig beskrivelse nævner brugstilfælde og fagsprog, ikke implementeringsdetaljer.

# Dårligt: for generisk
{"name": "get_data", "description": "Retrieve data"}

# Godt: specifikt med brugskontekst
{
    "name": "hr_check_leave_balance",
    "description": "Check an employee's leave balance (vacation, personal time, sick leave). "
                   "Returns remaining days by leave type. "
                   "Use when an employee asks how many days they have left."
}

# Godt: med synonymer for at forbedre søgningen
{
    "name": "acct_reconcile_bank",
    "description": "Bank reconciliation: compare accounting entries "
                   "with bank transactions. Account reconciliation. "
                   "Use to verify consistency between accounting records "
                   "and bank statements."
}

Kombination af Tool Search med faste værktøjer

Blanding er standardtilstanden i produktion. Et par tværgående værktøjer – tid, nuværende bruger, dokumentsøgning – forbliver deklareret permanent, fordi de tjener næsten enhver anmodning, mens forretningskataloget forbliver dynamisk. Dette holder konteksten let uden at tvinge modellen til at søge efter det, den har brug for, hver gang.

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Search the web for this month's sales and create the corresponding invoice",
    tools=[
        # Altid tilgængelige værktøjer
        {"type": "web_search"},
        {"type": "code_interpreter", "container": {"type": "auto"}},
        # Dynamisk katalog
        {
            "type": "tool_search",
            "tool_search": {
                "tools": full_catalog  # 200+ funktioner
            }
        }
    ]
)

Mønster: System med flere domæner

class MultiDomainSystem:
    def __init__(self):
        self.client = OpenAI()
        self.catalogs = {}

    def register_domain(self, name: str, functions: list[dict]):
        """Register a function catalog for a domain."""
        self.catalogs[name] = functions

    def full_catalog(self) -> list[dict]:
        """Merge all catalogs."""
        result = []
        for functions in self.catalogs.values():
            result.extend(functions)
        return result

    def execute(self, query: str) -> str:
        """Execute a query with Tool Search across all domains."""
        response = self.client.responses.create(
            model="gpt-5.6-terra",
            input=query,
            tools=[{
                "type": "tool_search",
                "tool_search": {
                    "tools": self.full_catalog()
                }
            }]
        )

        # Process function calls
        for item in response.output:
            if item.type == "function_call":
                result = self.dispatcher(item.name, item.arguments)
                # ... function calling loop

        return response.output_text

    def dispatcher(self, name: str, arguments: str):
        """Route the call to the correct service."""
        # Your routing logic
        pass

# Usage
system = MultiDomainSystem()
system.register_domain("crm", crm_catalog)
system.register_domain("billing", billing_catalog)
system.register_domain("hr", hr_catalog)
system.register_domain("support", support_catalog)

# The model automatically finds the right function
# among hundreds of possibilities
result = system.execute("How many vacation days does Marie Dupont have left?")

Vigtige pointer

  • Tool Search løser problemet med store funktionskataloger
  • Modellen modtager kun relevante funktioner i sin kontekst
  • Rige, specifikke beskrivelser er afgørende for præcision
  • Sæt præfikser på funktionsnavne efter domæne for læsbarhed
  • Kombiner Tool Search med altid tilgængelige indbyggede værktøjer