Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Meklēšana pēc rīkiem: dinamiski rīki

Nodarbība 15 no 20 Atjaunota 2026. gada 2. novembris Programmētājs
Šajā lapā
  1. Meklēšana pēc rīkiem: dinamiski rīki
  2. Lielu rīku katalogu radītās problēmas
  3. Meklēšanas pēc rīkiem iespējošana
  4. Funkciju kataloga organizēšana
  5. Labākā prakse aprakstu veidošanā
  6. Meklēšanas pēc rīkiem kombinēšana ar fiksētiem rīkiem
  7. Paraugs: vairāku domēnu sistēma
  8. Galvenās atziņas

Nodarbība atjaunināta 2026. gada 2. novembrī, balstoties uz OpenAI dokumentāciju: Code Interpreter rīkam tagad ir nepieciešams container parametrs (pievienots visiem piemēriem), ievades teksta daļas ir tipētas kā input_text, un tīmekļa meklēšana izmanto web_search rīku (web_search_preview tagad ir novecojis rīks bez domēna filtriem). Ģenerētie faili tiek iegūti, izmantojot fichiers_generes un telecharger funkcijas no 10. nodarbības. Avoti: Code Interpreter · Web search.

Meklēšana pēc rīkiem: dinamiski rīki

Ja tev ir desmitiem vai simtiem funkciju, to visu deklarēšana katrā izsaukumā kļūst kontrproduktīva: modelis zaudē precizitāti, un izmaksas strauji pieaug. Meklēšana pēc rīkiem (Tool Search) atrisina šo problēmu, ļaujot modelim atrast pareizo rīku indeksētā katalogā.

Lielu rīku katalogu radītās problēmas

Lielu rīku katalogu radītās izmaksas ir neredzamas divos veidos. Pirmkārt, finansiāli: katra funkcijas definīcija tiek nosūtīta kopā ar katru pieprasījumu, tostarp deviņdesmit astoņas, kas netiks izmantotas. Liela mēroga gadījumā tas galu galā pārsniedz pašu atbilžu izmaksas. Otrkārt, un kas ir vēl nopietnāk, kvalitatīvi: pārsniedzot dažus desmitus rīku ar pārklājošām darbības jomām, modelis pieņem sliktākus lēmumus. Pārāk daudz opciju pasliktina lēmumu pieņemšanu – gan šeit, gan citur.

# 5 funkcijas = ~500 konteksta tokeni
# 50 funkcijas = ~5000 konteksta tokeni
# 200 funkcijas = neiespējami efektīvi pārvaldīt

# Modelis zaudē precizitāti, ja funkciju ir pārāk daudz
# Tas dažreiz izvēlas nepareizu funkciju vai halucinē parametrus

Meklēšanas pēc rīkiem iespējošana

Meklēšana pēc rīkiem maina loģiku: tā vietā, lai modelim parādītu visu, tu indeksē katalogu un rādi tikai to, kas atbilst konkrētajam pieprasījumam. Mehānisms balstās uz semantisko meklēšanu aprakstos – tieši tāpēc nākamā sadaļa nav tikai stila ieteikums, bet gan sistēmas darbības priekšnosacījums.

from openai import OpenAI

client = OpenAI()

# Deklarē lielu skaitu funkciju
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"]}
    },
    # ... desmitiem citu funkciju
]

# Izmanto meklēšanu pēc rīkiem, lai modelis atrastu pareizo funkciju
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Cancel invoice FAC-2026-0042",
    tools=[{
        "type": "tool_search",
        "tool_search": {
            "tools": all_functions
        }
    }]
)

Modelis savā kontekstā saņem tikai pieprasījumam atbilstošās funkcijas, nevis visu katalogu.

Funkciju kataloga organizēšana

Lai izveidotu navigējamu katalogu, pietiek ar diviem principiem. Piešķir nosaukumiem prefiksus pēc domēna (crm_, billing_, inventory_): izpildes žurnālu lasīšana kļūst acumirklīga, un nosaukumu konflikti pazūd. Turklāt piešķir katrai funkcijai skaidru darbības jomu – divas funkcijas, kuru apraksti pārklājas, radīs nestabilu izvēli, neatkarīgi no tā, vai lēmumu pieņem cilvēks vai vektoru dzinējs.

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

# Apvieno visus katalogus
full_catalog = crm_catalog + billing_catalog

Labākā prakse aprakstu veidošanā

Raksti aprakstus meklēšanai, nevis dokumentācijai. „Iegūt klienta datus” nekad netiks atrasts, meklējot „pasūtījumu vēsturi” vai „rēķinu kontaktinformāciju”: indeksētajā tekstā ir jābūt vārdiem, kurus tavi lietotāji faktiski ieraksta. Noderīgs apraksts nosauc lietojumgadījumus un uzņēmējdarbības vokabulāru, nevis ieviešanas detaļas.

# Slikti: pārāk vispārīgi
{"name": "get_data", "description": "Retrieve data"}

# Labi: specifiski ar lietojuma kontekstu
{
    "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."
}

# Labi: ar sinonīmiem meklēšanas uzlabošanai
{
    "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."
}

Meklēšanas pēc rīkiem kombinēšana ar fiksētiem rīkiem

Jauktais režīms ir standarta darbības veids ražošanas vidē. Daži vispārīgi rīki – laiks, pašreizējais lietotājs, dokumentu meklēšana – paliek deklarēti pastāvīgi, jo tie noder gandrīz katram pieprasījumam, savukārt uzņēmējdarbības katalogs paliek dinamisks. Tas uztur kontekstu vieglu, neliekot modelim katru reizi meklēt to, kas tam nepieciešams.

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Search the web for this month's sales and create the corresponding invoice",
    tools=[
        # Vienmēr pieejami rīki
        {"type": "web_search"},
        {"type": "code_interpreter", "container": {"type": "auto"}},
        # Dinamisks katalogs
        {
            "type": "tool_search",
            "tool_search": {
                "tools": full_catalog  # 200+ funkcijas
            }
        }
    ]
)

Paraugs: vairāku domēnu sistēma

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

    def register_domain(self, name: str, functions: list[dict]):
        """Reģistrē funkciju katalogu konkrētam domēnam."""
        self.catalogs[name] = functions

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

    def execute(self, query: str) -> str:
        """Izpilda vaicājumu, izmantojot meklēšanu pēc rīkiem visos domēnos."""
        response = self.client.responses.create(
            model="gpt-5.6-terra",
            input=query,
            tools=[{
                "type": "tool_search",
                "tool_search": {
                    "tools": self.full_catalog()
                }
            }]
        )

        # Apstrādā funkciju izsaukumus
        for item in response.output:
            if item.type == "function_call":
                result = self.dispatcher(item.name, item.arguments)
                # ... funkciju izsaukumu cikls

        return response.output_text

    def dispatcher(self, name: str, arguments: str):
        """Novirza izsaukumu uz pareizo servisu."""
        # Tava maršrutēšanas loģika
        pass

# Lietojums
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)

# Modelis automātiski atrod pareizo funkciju
# starp simtiem iespēju
result = system.execute("How many vacation days does Marie Dupont have left?")

Galvenās atziņas

  • Meklēšana pēc rīkiem atrisina lielu funkciju katalogu problēmu
  • Modelis savā kontekstā saņem tikai atbilstošās funkcijas
  • Bagātīgi un specifiski apraksti ir būtiski precizitātei
  • Piešķir funkciju nosaukumiem prefiksus pēc domēna lasāmības nodrošināšanai
  • Kombinē meklēšanu pēc rīkiem ar vienmēr pieejamiem iebūvētiem rīkiem