Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Vyhledávání nástrojů: Dynamické nástroje

Lekce 10 z 25 Aktualizováno 29. července 2026 Vývojář
Na této stránce
  1. Vyhledávání nástrojů: Dynamické nástroje
  2. Problém s příliš mnoha nástroji
  3. Aktivace vyhledávání nástrojů
  4. Vzor: Ruční výběr nástrojů
  5. Vzor: Dynamické nástroje závislé na kontextu
  6. Optimalizace popisů nástrojů
  7. Klíčové poznatky

Vyhledávání nástrojů: Dynamické nástroje

Demo agent si bez problémů vystačí se třemi nebo čtyřmi nástroji. Podnikový agent však nevyhnutelně nabírá desítky, někdy i stovky nástrojů: fakturace, HR, CRM, dokumenty, plánování. V takovém měřítku se posílání celého katalogu modelu s každým požadavkem stává neefektivní a drahé z hlediska tokenů. Vyhledávání nástrojů (Tool Search) tento problém řeší dynamickým výběrem relevantních nástrojů pro každý požadavek.

Problém s příliš mnoha nástroji

Představ si agenta s 50 nástroji. Při každém volání API se do promptu odešlou schémata všech 50 nástrojů. To spotřebuje tisíce tokenů a může model zmást: čím delší je seznam, tím více si popisy připomínají a model více váhá mezi sousedními nástroji. Náklady rostou, zatímco přesnost klesá – to je ta nejhorší možná kombinace.

# Problém: příliš mnoho nástrojů
agent = Agent(
    name="Super Agent",
    instructions="Můžeš dělat cokoliv.",
    tools=[tool_1, tool_2, tool_3, ... , tool_50],  # 50 nástrojů = spousta tokenů
)

Aktivace vyhledávání nástrojů

Vyhledávání nástrojů využívá sémantický index k výběru relevantních nástrojů na základě požadavku. Nástroje deklaruješ jako obvykle, ale parametr tool_use_behavior="auto" umožní modelu vybrat si z katalogu místo toho, aby se vše načítalo předem. V níže uvedeném příkladu požadavek na odeslání upomínky k platbě nespustí HR nástroje a naopak.

from agents import Agent, Runner, function_tool

# Definice mnoha nástrojů
@function_tool
def create_invoice(client: str, amount: float) -> str:
    """Vytvoří fakturu pro klienta."""
    return f"Faktura vytvořena pro {client}: €{amount}"

@function_tool
def send_reminder(invoice_id: str) -> str:
    """Odešle upomínku k platbě za nezaplacenou fakturu."""
    return f"Upomínka odeslána pro fakturu {invoice_id}"

@function_tool
def generate_hr_report(month: str) -> str:
    """Vygeneruje report lidských zdrojů pro daný měsíc."""
    return f"HR report vygenerován pro {month}"

@function_tool
def schedule_interview(candidate: str, date: str) -> str:
    """Naplánuje pracovní pohovor s kandidátem."""
    return f"Pohovor naplánován s {candidate} na {date}"

# Mnoho dalších nástrojů...

agent = Agent(
    name="Podnikový agent",
    instructions="Spravuješ chod společnosti.",
    tools=[
        create_invoice,
        send_reminder,
        generate_hr_report,
        schedule_interview,
        # ... 50 dalších nástrojů
    ],
    tool_use_behavior="auto",  # Model vybírá dynamicky
)

Vzor: Ruční výběr nástrojů

Pokud chceš mít nad výběrem nástrojů úplnou kontrolu, implementuj vlastní logiku. Princip je jednoduchý: malý agent-směrovač (router) přečte požadavek a pouze pojmenuje relevantní doménu. Následně za běhu vytvoříš specializovaného agenta pouze s nástroji pro tuto doménu. Věta jako „pošli upomínku pro fakturu F-2026-114“ vyjde ze směrovače s odpovědí accounting a vykonávající agent nikdy neuvidí HR nástroje.

from agents import Agent, Runner, function_tool

# Seskupení nástrojů podle domény
accounting_tools = [create_invoice, send_reminder]
hr_tools = [generate_hr_report, schedule_interview]

# Agent-směrovač, který vybírá doménu
router = Agent(
    name="Směrovač",
    instructions="""Urči doménu požadavku.
    Odpověz pouze 'accounting' nebo 'hr'.""",
    model="gpt-5.6-terra",  # Rychlý a levný pro směrování
    output_type=str,
)

async def handle_request(message: str):
    # Krok 1: Určení domény
    route = await Runner.run(router, message)
    domain = route.final_output.strip().lower()

    # Krok 2: Vytvoření specializovaného agenta se správnými nástroji
    if domain == "accounting":
        tools = accounting_tools
        instructions = "Spravuješ účetnictví společnosti."
    elif domain == "hr":
        tools = hr_tools
        instructions = "Spravuješ lidské zdroje."
    else:
        tools = accounting_tools + hr_tools
        instructions = "Spravuješ chod společnosti."

    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

Použití gpt-5.6-terra jak pro směrování, tak pro vykonávání patří k předchozí generaci modelů; logika tohoto vzoru zůstává identická i u rodiny GPT-5.6, kde nastavení úsilí odlišuje rychlý směrovač od vykonavatele.

Vzor: Dynamické nástroje závislé na kontextu

Výběr nezávisí pouze na položené otázce, ale také na tom, kdo se ptá. Dostupné nástroje můžeš přizpůsobit přihlášenému uživateli, čímž zabiješ dvě mouchy jednou ranou: odešle se méně tokenů a co je důležitější, kontrola přístupu je vynucena ještě předtím, než model začne uvažovat. Obchodní zaměstnanec dostane nástroje pro tvorbu nabídek, ale delete_account v jeho agentovi jednoduše neexistuje.

from dataclasses import dataclass

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

def get_tools_for_role(ctx: UserContext) -> list:
    """Vrátí autorizované nástroje na základě role."""
    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="Vlastní agent",
        instructions=f"Pomáháš {ctx.role} na oddělení {ctx.department}.",
        tools=tools,
        model="gpt-5.6-terra",
    )

Optimalizace popisů nástrojů

Ať už zvolíš jakýkoli mechanismus výběru, spoléhá na jediný materiál: text tvých popisů. Kvalita těchto popisů přímo ovlivňuje relevanci výběru. Porovnej níže uvedená dvě prohlášení: první nic neříká o scénáři použití, zatímco druhé pojmenovává vstupy, výstup a kdy jej použít.

# Špatně: vágní popis
@function_tool
def process_data(data: str) -> str:
    """Zpracovává data."""
    return "OK"

# Dobře: přesný a kontextualizovaný popis
@function_tool
def calculate_gross_margin(revenue: float, production_cost: float) -> str:
    """Vypočítá hrubou marži v procentech z tržeb
    a výrobních nákladů. Užitečné pro čtvrtletní finanční analýzu."""
    margin = ((revenue - production_cost) / revenue) * 100
    return f"Hrubá marže: {margin:.1f}% (Tržby: €{revenue}, Náklady: €{production_cost})"

Dobrý popis nástroje je jako dobrý docstring: vysvětluje, kdy nástroj použít, nejen co dělá. Věnuj deset minut revizi popisů svého agenta a u každého se zeptej, zda by kolega dokázal vybrat správný nástroj pouze na základě přečtení této věty. Přesně toto cvičení provádí model.

Klíčové poznatky

  • Vyhledávání nástrojů dynamicky vybírá relevantní nástroje pro každý požadavek
  • Při velkém množství nástrojů může agent-směrovač předem určit doménu
  • Přizpůsob dostupné nástroje na základě role a kontextu uživatele
  • Kvalita popisu nástroje ovlivňuje přesnost výběru
  • Pro rychlé směrování použij lehký model a pro vykonávání výkonný model