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

Wyszukiwanie narzędzi: narzędzia dynamiczne

Lekcja 10 z 25 Zaktualizowano 29 lipca 2026 Programista
Na tej stronie
  1. Wyszukiwanie narzędzi: narzędzia dynamiczne
  2. Problem zbyt wielu narzędzi
  3. Włączanie wyszukiwania narzędzi
  4. Wzorzec: ręczny wybór narzędzi
  5. Wzorzec: dynamiczne narzędzia świadome kontekstu
  6. Optymalizacja opisów narzędzi
  7. Kluczowe wnioski

Wyszukiwanie narzędzi: narzędzia dynamiczne

Agent demonstracyjny świetnie radzi sobie z trzema lub czterema narzędziami. Agent przedsiębiorczy jednak nieuchronnie gromadzi ich dziesiątki, a czasem setki: fakturowanie, HR, CRM, dokumenty, harmonogramy. Na taką skalę wysyłanie całego katalogu do modelu z każdym żądaniem staje się nieefektywne i kosztowne pod względem liczby tokenów. Wyszukiwanie narzędzi (Tool Search) rozwiązuje ten problem, dynamicznie wybierając odpowiednie narzędzia dla każdego żądania.

Problem zbyt wielu narzędzi

Wyobraź sobie agenta z 50 narzędziami. Przy każdym wywołaniu API schematy wszystkich 50 narzędzi są wysyłane w prompcie. Zużywa to tysiące tokenów i może zmylić model: im dłuższa lista, tym bardziej opisy stają się do siebie podobne, a model coraz bardziej waha się między sąsiednimi narzędziami. Koszty rosną, a precyzja spada – to najgorsze możliwe połączenie.

# Problem: zbyt wiele narzędzi
agent = Agent(
    name="Super Agent",
    instructions="Możesz zrobić wszystko.",
    tools=[tool_1, tool_2, tool_3, ... , tool_50],  # 50 narzędzi = dużo tokenów
)

Włączanie wyszukiwania narzędzi

Wyszukiwanie narzędzi wykorzystuje indeks semantyczny do wyboru odpowiednich narzędzi na podstawie żądania. Deklarujesz swoje narzędzia jak zwykle, ale parametr tool_use_behavior="auto" pozwala modelowi wybrać je z katalogu zamiast ładować wszystko z góry. W poniższym przykładzie żądanie wysłania przypomnienia o płatności nie uruchomi narzędzi HR i odwrotnie.

from agents import Agent, Runner, function_tool

# Zdefiniuj wiele narzędzi
@function_tool
def create_invoice(client: str, amount: float) -> str:
    """Tworzy fakturę dla klienta."""
    return f"Faktura utworzona dla {client}: €{amount}"

@function_tool
def send_reminder(invoice_id: str) -> str:
    """Wysyła przypomnienie o płatności za nieopłaconą fakturę."""
    return f"Przypomnienie wysłane dla faktury {invoice_id}"

@function_tool
def generate_hr_report(month: str) -> str:
    """Generuje raport zasobów ludzkich dla danego miesiąca."""
    return f"Raport HR wygenerowany dla {month}"

@function_tool
def schedule_interview(candidate: str, date: str) -> str:
    """Umawia rozmowę kwalifikacyjną z kandydatem."""
    return f"Rozmowa umówiona z {candidate} na dzień {date}"

# Wiele innych narzędzi...

agent = Agent(
    name="Agent przedsiębiorczy",
    instructions="Zarządzasz operacjami firmy.",
    tools=[
        create_invoice,
        send_reminder,
        generate_hr_report,
        schedule_interview,
        # ... 50 innych narzędzi
    ],
    tool_use_behavior="auto",  # Model wybiera dynamicznie
)

Wzorzec: ręczny wybór narzędzi

Jeśli chcesz mieć pełną kontrolę nad wyborem narzędzi, zaimplementuj własną logikę. Zasada jest prosta: mały agent routera odczytuje żądanie i po prostu wskazuje odpowiednią domenę. Następnie budujesz specjalistycznego agenta w locie, używając tylko narzędzi dla tej domeny. Fraza taka jak „wyślij przypomnienie dla faktury F-2026-114“ wychodzi z routera z odpowiedzią accounting, a agent wykonawczy nigdy nie widzi narzędzi HR.

from agents import Agent, Runner, function_tool

# Grupuj narzędzia według domeny
accounting_tools = [create_invoice, send_reminder]
hr_tools = [generate_hr_report, schedule_interview]

# Agent routera wybierający domenę
router = Agent(
    name="Router",
    instructions="""Określ domenę żądania.
    Odpowiedz tylko 'accounting' lub 'hr'.""",
    model="gpt-5.6-terra",  # Szybki i tani do routingu
    output_type=str,
)

async def handle_request(message: str):
    # Krok 1: Określ domenę
    route = await Runner.run(router, message)
    domain = route.final_output.strip().lower()

    # Krok 2: Utwórz specjalistycznego agenta z odpowiednimi narzędziami
    if domain == "accounting":
        tools = accounting_tools
        instructions = "Zarządzasz księgowością firmy."
    elif domain == "hr":
        tools = hr_tools
        instructions = "Zarządzasz zasobami ludzkimi."
    else:
        tools = accounting_tools + hr_tools
        instructions = "Zarządzasz operacjami firmy."

    specialized_agent = Agent(
        name=f"{domain.capitalize()} Agent",
        instructions=instructions,
        tools=tools,
        model="gpt-5.6-terra",
    )

    result = await Runner.run(specialized_agent, message)
    return result.final_output

Użycie gpt-5.6-terra zarówno do routingu, jak i wykonania należy do poprzedniej generacji modeli; rozumowanie stojące za tym wzorcem pozostaje identyczne w rodzinie GPT-5.6, gdzie ustawienia wysiłku odróżniają szybki router od wykonawcy.

Wzorzec: dynamiczne narzędzia świadome kontekstu

Wybór nie zależy tylko od zadanego pytania; zależy również od tego, kto pyta. Możesz dostosować dostępne narzędzia na podstawie zalogowanego użytkownika, zabijając dwie pieczenie jednym ogniem: wysyłasz mniej tokenów i, co ważniejsze, wymuszasz kontrole dostępu, zanim model w ogóle zacznie rozumować. Pracownik działu sprzedaży otrzymuje narzędzia do wycen, ale delete_account po prostu nie istnieje w jego agencie.

from dataclasses import dataclass

@dataclass
class UserContext:
    role: str  # "admin", "manager", "employee"
    department: str

def get_tools_for_role(ctx: UserContext) -> list:
    """Zwraca autoryzowane narzędzia na podstawie roli."""
    base_tools = [search_document, view_schedule]

    if ctx.role in ("admin", "manager"):
        base_tools.extend([create_invoice, generate_hr_report])

    if ctx.role == "admin":
        base_tools.extend([modify_permissions, delete_account])

    if ctx.department == "sales":
        base_tools.extend([search_client, create_quote])

    return base_tools

async def create_agent_for_user(ctx: UserContext):
    tools = get_tools_for_role(ctx)
    return Agent(
        name="Niestandardowy agent",
        instructions=f"Pomagasz użytkownikowi z rolą {ctx.role} w dziale {ctx.department}.",
        tools=tools,
        model="gpt-5.6-terra",
    )

Optymalizacja opisów narzędzi

Niezależnie od wybranego mechanizmu wyboru, opiera się on na jednym materiale: tekście twoich opisów. Jakość tych opisów bezpośrednio wpływa na trafność wyboru. Porównaj poniższe dwie deklaracje: pierwsza nie mówi nic o scenariuszu użycia, podczas gdy druga wymienia dane wejściowe, wyjściowe oraz moment, w którym należy jej użyć.

# Źle: niejasny opis
@function_tool
def process_data(data: str) -> str:
    """Przetwarza dane."""
    return "OK"

# Dobrze: precyzyjny i osadzony w kontekście opis
@function_tool
def calculate_gross_margin(revenue: float, production_cost: float) -> str:
    """Oblicza marżę brutto jako procent od przychodu
    i kosztów produkcji. Przydatne do kwartalnej analizy finansowej."""
    margin = ((revenue - production_cost) / revenue) * 100
    return f"Marża brutto: {margin:.1f}% (Przychód: €{revenue}, Koszty: €{production_cost})"

Dobry opis narzędzia jest jak dobry docstring: wyjaśnia kiedy użyć narzędzia, a nie tylko co ono robi. Poświęć dziesięć minut na przegląd opisów swojego agenta, zadając sobie przy każdym z nich pytanie, czy kolega mógłby wybrać właściwe narzędzie, czytając tylko to zdanie. Dokładnie to ćwiczenie wykonuje model.

Kluczowe wnioski

  • Wyszukiwanie narzędzi dynamicznie wybiera odpowiednie narzędzia dla każdego żądania
  • Przy dużej liczbie narzędzi agent routera może wstępnie określić domenę
  • Dostosuj dostępne narzędzia w zależności od roli i kontekstu użytkownika
  • Jakość opisu narzędzia wpływa na dokładność wyboru
  • Używaj lekkiego modelu do szybkiego routingu i wydajnego modelu do wykonania