Tool Search: Dynamiske værktøjer
På denne side
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 sominput_text, og websøgning brugerweb_search-værktøjet (web_search_previewer nu et forældet værktøj uden domænefiltre). Genererede filer hentes ved hjælp af funktionernefichiers_generesogtelechargerfra 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
Aktivering af Tool Search
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