Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Iskanje orodij: dinamična orodja

Lekcija 15 od 20 Posodobljeno 2. november 2026 Razvijalec
Na tej strani
  1. Iskanje orodij: dinamična orodja
  2. Težava z velikimi katalogi orodij
  3. Omogočanje iskanja orodij
  4. Organizacija kataloga funkcij
  5. Najboljše prakse za opise
  6. Kombiniranje iskanja orodij s fiksnimi orodji
  7. Vzorec: sistem z več domenami
  8. Ključne ugotovitve

Lekcija posodobljena 2. novembra 2026 na podlagi dokumentacije OpenAI: orodje Code Interpreter zdaj zahteva parameter container (dodan vsem primerom), vhodni deli besedila so tipizirani kot input_text, spletno iskanje pa uporablja orodje web_search (web_search_preview je zdaj zastarelo orodje brez filtrov domen). Ustvarjene datoteke se pridobijo z uporabo funkcij fichiers_generes in telecharger iz lekcije 10. Viri: Code Interpreter · Web search.

Iskanje orodij: dinamična orodja

Ko imaš na desetine ali stotine funkcij, postane njihovo deklariranje pri vsakem klicu kontraproduktivno: model izgubi natančnost, stroški pa eksplodirajo. Iskanje orodij (Tool Search) reši ta problem tako, da modelu omogoči iskanje pravega orodja v indeksiranem katalogu.

Težava z velikimi katalogi orodij

Strošek velikega kataloga orodij je neviden na dva načina. Prvič, finančno: definicija vsake funkcije se pošlje z vsako zahtevo, vključno s tistimi devetindevetdesetimi, ki ne bodo uporabljene. V velikem obsegu to sčasoma preseže strošek samih odgovorov. Drugič, kar je resneje, kvalitativno: pri več kot nekaj deset orodjih s prekrivajočimi se področji model sprejema slabše odločitve. Preveč možnosti poslabša odločanje, tukaj kot drugje.

# 5 funkcij = ~500 žetonov konteksta
# 50 funkcij = ~5000 žetonov konteksta
# 200 funkcij = nemogoče učinkovito upravljati

# Model izgubi natančnost, ko je funkcij preveč
# Včasih izbere napačno funkcijo ali halucinira parametre

Omogočanje iskanja orodij

Iskanje orodij obrne logiko: namesto da modelu predstaviš vse, katalog indeksiraš in mu pokažeš le tisto, kar ustreza trenutni zahtevi. Mehanizem temelji na semantičnem iskanju po opisih – zato naslednji razdelek ni le nasvet o slogu, temveč zahteva za delovanje sistema.

from openai import OpenAI

client = OpenAI()

# Deklariraj veliko število funkcij
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"]}
    },
    # ... ducat drugih funkcij
]

# Uporabi Tool Search, da model najde pravo funkcijo
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 v svojem kontekstu prejme le funkcije, ki so relevantne za zahtevo, ne celotnega kataloga.

Organizacija kataloga funkcij

Za strukturiranje kataloga, ki ostane pregleden, zadostujeta dva principa. Imenom dodaj predpone po domenah (crm_, billing_, inventory_): branje sledi izvajanja postane takojšnje, trki imen pa izginejo. In vsaki funkciji dodeli jasno področje – dve funkciji s prekrivajočima se opisoma bosta povzročili nestabilne izbire, ne glede na to, ali klic opravi človek ali vektorski pogon.

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

# Združi vse kataloge
full_catalog = crm_catalog + billing_catalog

Najboljše prakse za opise

Opise piši za iskanje, ne za dokumentacijo. „Pridobi podatke o stranki” nikoli ne bo najdeno z poizvedbo o „zgodovini naročil” ali „podrobnostih za stik glede plačil”: besede, ki jih tvoji uporabniki dejansko vtipkajo, se morajo pojaviti v indeksiranem besedilu. Uporaben opis imenuje primere uporabe in poslovni besednjak, ne podrobnosti implementacije.

# Slabo: preveč splošno
{"name": "get_data", "description": "Retrieve data"}

# Dobro: specifično s kontekstom uporabe
{
    "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."
}

# Dobro: s sopomenkami za izboljšanje iskanja
{
    "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."
}

Kombiniranje iskanja orodij s fiksnimi orodji

Mešanje je standardni način delovanja v proizvodnem okolju. Nekaj prečnih orodij – čas, trenutni uporabnik, iskanje dokumentov – ostane trajno deklariranih, ker služijo skoraj vsaki zahtevi, medtem ko poslovni katalog ostane dinamičen. To ohranja kontekst lahek, ne da bi moral model vsakič iskati tisto, kar potrebuje.

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Search the web for this month's sales and create the corresponding invoice",
    tools=[
        # Orodja, ki so vedno na voljo
        {"type": "web_search"},
        {"type": "code_interpreter", "container": {"type": "auto"}},
        # Dinamični katalog
        {
            "type": "tool_search",
            "tool_search": {
                "tools": full_catalog  # 200+ funkcij
            }
        }
    ]
)

Vzorec: sistem z več domenami

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?")

Ključne ugotovitve

  • Iskanje orodij rešuje problem velikih katalogov funkcij
  • Model v svojem kontekstu prejme le relevantne funkcije
  • Bogati, specifični opisi so ključni za natančnost
  • Imenom funkcij dodaj predpone po domenah zaradi berljivosti
  • Iskanje orodij kombiniraj z vgrajenimi orodji, ki so vedno na voljo