Przejdź do głównej treści
Polski— Wybierz język
Menu

Tool Search: Narzędzia dynamiczne

Lekcja 15 z 20 Zaktualizowano 2 listopada 2026 Programista
Na tej stronie
  1. Tool Search: Narzędzia dynamiczne
  2. Problem z dużymi katalogami narzędzi
  3. Włączanie Tool Search
  4. Organizacja katalogu funkcji
  5. Najlepsze praktyki dotyczące opisów
  6. Łączenie Tool Search z narzędziami stałymi
  7. Wzorzec: System wielodomenowy
  8. Kluczowe wnioski

Lekcja zaktualizowana 2 listopada 2026 r. na podstawie dokumentacji OpenAI: narzędzie Code Interpreter wymaga teraz parametru container (dodanego do wszystkich przykładów), części tekstowe wejścia są typowane jako input_text, a wyszukiwanie w sieci korzysta z narzędzia web_search (web_search_preview to obecnie przestarzałe narzędzie bez filtrów domenowych). Wygenerowane pliki pobiera się za pomocą funkcji fichiers_generes i telecharger z Lekcji 10. Źródła: Code Interpreter · Wyszukiwanie w sieci.

Tool Search: Narzędzia dynamiczne

Gdy masz do dyspozycji dziesiątki lub setki funkcji, deklarowanie ich wszystkich przy każdym wywołaniu staje się kontrproduktywne: model traci precyzję, a koszty drastycznie rosną. Tool Search rozwiązuje ten problem, pozwalając modelowi wyszukać odpowiednie narzędzie w indeksowanym katalogu.

Problem z dużymi katalogami narzędzi

Koszt obsługi dużego katalogu narzędzi jest niewidoczny na dwa sposoby. Po pierwsze, finansowo: definicja każdej funkcji jest wysyłana z każdym żądaniem, w tym dziewięćdziesięciu ośmiu, które nie zostaną użyte. Na dużą skalę koszt ten w końcu przekracza koszt samych odpowiedzi. Po drugie, co poważniejsze, jakościowo: przy więcej niż kilkudziesięciu narzędziach o nakładających się zakresach działania model podejmuje gorsze decyzje. Zbyt wiele opcji pogarsza proces decyzyjny, tutaj tak samo jak gdzie indziej.

# 5 funkcji = ~500 tokenów kontekstu
# 50 funkcji = ~5000 tokenów kontekstu
# 200 funkcji = niemożliwe do efektywnego zarządzania

# Model traci precyzję, gdy jest zbyt wiele funkcji
# Czasami wybiera niewłaściwą funkcję lub halucynuje parametry

Tool Search odwraca logikę działania: zamiast przedstawiać modelowi wszystko, indeksujesz katalog i pokazujesz mu tylko to, co pasuje do bieżącego żądania. Mechanizm ten opiera się na wyszukiwaniu semantycznym opisów – dlatego następna sekcja to nie tylko rada stylistyczna, ale wymóg konieczny do działania systemu.

from openai import OpenAI

client = OpenAI()

# Zdeklaruj dużą liczbę funkcji
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"]}
    },
    # ... dziesiątki innych funkcji
]

# Użyj Tool Search, aby model znalazł właściwą funkcję
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 otrzymuje w swoim kontekście tylko funkcje istotne dla danego żądania, a nie cały katalog.

Organizacja katalogu funkcji

Dwa zasady wystarczą, aby zorganizować katalog, który pozostanie przejrzysty. Prefiksuj nazwy według domeny (crm_, billing_, inventory_): odczyt śladu wykonania staje się natychmiastowy, a kolizje nazw znikają. Nadaj też każdej funkcji jasny zakres – dwie funkcje, których opisy się pokrywają, będą generować niestabilne wybory, niezależnie od tego, czy decyzję podejmuje człowiek, czy silnik wektorowy.

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

# Połącz wszystkie katalogi
full_catalog = crm_catalog + billing_catalog

Najlepsze praktyki dotyczące opisów

Pisz opisy pod kątem wyszukiwania, a nie dokumentacji. Fraza „Pobierz dane klienta“ nigdy nie zostanie znaleziona przez zapytanie dotyczące „historii zamówień“ lub „danych kontaktowych do faktury“: słowa, które Twoi użytkownicy faktycznie wpisują, muszą pojawić się w zindeksowanym tekście. Przydatny opis wymienia przypadki użycia i słownictwo biznesowe, a nie szczegóły implementacji.

# Źle: zbyt ogólnie
{"name": "get_data", "description": "Retrieve data"}

# Dobrze: konkretnie z kontekstem użycia
{
    "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."
}

# Dobrze: z synonimami poprawiającymi wyszukiwanie
{
    "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."
}

Łączenie Tool Search z narzędziami stałymi

Mieszanie trybów to standardowy sposób działania w środowisku produkcyjnym. Kilka narzędzi przekrojowych – czas, bieżący użytkownik, wyszukiwanie dokumentów – pozostaje zadeklarowanych na stałe, ponieważ służą prawie każdemu żądaniu, podczas gdy katalog biznesowy pozostaje dynamiczny. Dzięki temu kontekst pozostaje lekki, a model nie musi za każdym razem szukać tego, czego potrzebuje.

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Search the web for this month's sales and create the corresponding invoice",
    tools=[
        # Narzędzia zawsze dostępne
        {"type": "web_search"},
        {"type": "code_interpreter", "container": {"type": "auto"}},
        # Katalog dynamiczny
        {
            "type": "tool_search",
            "tool_search": {
                "tools": full_catalog  # ponad 200 funkcji
            }
        }
    ]
)

Wzorzec: System wielodomenowy

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

    def register_domain(self, name: str, functions: list[dict]):
        """Zarejestruj katalog funkcji dla domeny."""
        self.catalogs[name] = functions

    def full_catalog(self) -> list[dict]:
        """Połącz wszystkie katalogi."""
        result = []
        for functions in self.catalogs.values():
            result.extend(functions)
        return result

    def execute(self, query: str) -> str:
        """Wykonaj zapytanie z Tool Search we wszystkich domenach."""
        response = self.client.responses.create(
            model="gpt-5.6-terra",
            input=query,
            tools=[{
                "type": "tool_search",
                "tool_search": {
                    "tools": self.full_catalog()
                }
            }]
        )

        # Przetwarzaj wywołania funkcji
        for item in response.output:
            if item.type == "function_call":
                result = self.dispatcher(item.name, item.arguments)
                # ... pętla wywoływania funkcji

        return response.output_text

    def dispatcher(self, name: str, arguments: str):
        """Przekieruj wywołanie do właściwej usługi."""
        # Twoja logika routingu
        pass

# Użycie
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 automatycznie znajduje właściwą funkcję
# spośród setek możliwości
result = system.execute("How many vacation days does Marie Dupont have left?")

Kluczowe wnioski

  • Tool Search rozwiązuje problem dużych katalogów funkcji
  • Model otrzymuje w kontekście tylko odpowiednie funkcje
  • Bogate, specyficzne opisy są niezbędne dla precyzji
  • Prefiksuj nazwy funkcji według domeny dla czytelności
  • Łącz Tool Search z wbudowanymi narzędziami zawsze dostępnymi