Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Tool Search: Nástroje dynamického vyhledávání

Lekce 15 z 20 Aktualizováno 2. listopadu 2026 Vývojář
Na této stránce
  1. Tool Search: Nástroje dynamického vyhledávání
  2. Problém s velkými katalogy nástrojů
  3. Aktivace Tool Search
  4. Organizace katalogu funkcí
  5. Osvědčené postupy pro popisy
  6. Kombinace Tool Search s pevnými nástroji
  7. Vzor: Systém pro více domén
  8. Klíčové poznatky

Lekce aktualizována 2. listopadu 2026 na základě dokumentace OpenAI: nástroj Code Interpreter nyní vyžaduje parametr container (doplněn ve všech příkladech), vstupní textové části jsou typovány jako input_text a webové vyhledávání používá nástroj web_search (web_search_preview je nyní zastaralý nástroj bez filtrů domén). Vygenerované soubory se získávají pomocí funkcí fichiers_generes a telecharger z Lekce 10. Zdroje: Code Interpreter · Web search.

Tool Search: Nástroje dynamického vyhledávání

Když máš k dispozici desítky nebo stovky funkcí, jejich deklarace při každém volání se stává kontraproduktivní: model ztrácí přesnost a náklady prudce rostou. Tool Search tento problém řeší tím, že umožňuje modelu vyhledat správný nástroj v indexovaném katalogu.

Problém s velkými katalogy nástrojů

Náklady na velký katalog nástrojů jsou neviditelné dvěma způsoby. Zaprvé finančně: definice každé funkce se odesílá s každým požadavkem, včetně těch devadesáti osmi, které se nepoužijí. Ve velkém měřítku to nakonec převýší náklady na samotné odpovědi. Zadruhé, a co je vážnější, kvalitativně: při více než několika desítkách nástrojů s překrývajícími se rozsahy dělá model horší rozhodnutí. Příliš mnoho možností degraduje rozhodování, zde i jinde.

# 5 funkcí = ~500 tokenů kontextu
# 50 funkcí = ~5000 tokenů kontextu
# 200 funkcí = nemožné efektivně spravovat

# Model ztrácí přesnost, když je funkcí příliš mnoho
# Někdy vybere špatnou funkci nebo halucinuje parametry

Tool Search obrací logiku: místo abys modelu předložil vše, indexuješ katalog a zobrazíš mu pouze to, co odpovídá aktuálnímu požadavku. Mechanismus spoléhá na sémantické vyhledávání v popisech – proto následující sekce není jen radou ohledně stylu; je to podmínka fungování systému.

from openai import OpenAI

client = OpenAI()

# Deklaruj velké množství funkcí
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"]}
    },
    # ... desítky dalších funkcí
]

# Použij Tool Search, aby model našel správnou funkci
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Cancel invoice FAC-2026-0042",
    tools=[{
        "type": "tool_search",
        "tool_search": {
            "tools": all_functions
        }
    }]
)

Model obdrží ve svém kontextu pouze funkce relevantní pro daný požadavek, nikoliv celý katalog.

Organizace katalogu funkcí

Ke strukturování katalogu, který zůstane přehledný, stačí dva principy. Prefixuj názvy podle domény (crm_, billing_, inventory_): čtení tras provedení se stane okamžitým a kolize názvů zmizí. A každé funkci přiřaď jasný rozsah – dvě funkce s překrývajícími se popisy povedou k nestabilním volbám, ať už volbu provádí člověk, nebo vektorový engine.

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

# Slouč všechny katalogy
full_catalog = crm_catalog + billing_catalog

Osvědčené postupy pro popisy

Piš popisy pro vyhledávání, ne pro dokumentaci. „Získat data zákazníka“ nikdy nenajde dotaz týkající se „historie objednávek“ nebo „kontaktních údajů pro fakturaci“: slova, která tvoji uživatelé skutečně zadávají, se musí objevit v indexovaném textu. Užitečný popis pojmenovává případy použití a obchodní slovník, nikoliv implementační detaily.

# Špatně: příliš obecné
{"name": "get_data", "description": "Retrieve data"}

# Dobře: specifické s kontextem použití
{
    "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."
}

# Dobře: se synonymy pro zlepšení vyhledávání
{
    "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."
}

Kombinace Tool Search s pevnými nástroji

Míchání je standardním režimem provozu v produkci. Několik průřezových nástrojů – čas, aktuální uživatel, vyhledávání dokumentů – zůstává deklarováno trvale, protože slouží téměř každému požadavku, zatímco obchodní katalog zůstává dynamický. To udržuje kontext lehký, aniž by model musel pokaždé hledat to, co potřebuje.

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Search the web for this month's sales and create the corresponding invoice",
    tools=[
        # Nástroje vždy dostupné
        {"type": "web_search"},
        {"type": "code_interpreter", "container": {"type": "auto"}},
        # Dynamický katalog
        {
            "type": "tool_search",
            "tool_search": {
                "tools": full_catalog  # 200+ funkcí
            }
        }
    ]
)

Vzor: Systém pro více domén

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

        # Zpracuj volání funkcí
        for item in response.output:
            if item.type == "function_call":
                result = self.dispatcher(item.name, item.arguments)
                # ... smyčka volání funkcí

        return response.output_text

    def dispatcher(self, name: str, arguments: str):
        """Route the call to the correct service."""
        # Tvá logika směrování
        pass

# Použití
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)

# Model automaticky najde správnou funkci
# mezi stovkami možností
result = system.execute("How many vacation days does Marie Dupont have left?")

Klíčové poznatky

  • Tool Search řeší problém velkých katalogů funkcí
  • Model obdrží ve svém kontextu pouze relevantní funkce
  • Bohaté a specifické popisy jsou zásadní pro přesnost
  • Prefixuj názvy funkcí podle domény pro lepší čitelnost
  • Kombinuj Tool Search s vestavěnými nástroji, které jsou vždy dostupné