Wyszukiwanie narzędzi: narzędzia dynamiczne
Na tej stronie
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