Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Pretraživanje alata: Dinamički alati

Lekcija 10 od 25 Ažurirano 29. srpnja 2026. Programer
Na ovoj stranici
  1. Pretraživanje alata: Dinamički alati
  2. Problem s previše alata
  3. Omogućavanje pretraživanja alata
  4. Uzorak: Ručni odabir alata
  5. Uzorak: Dinamički alati svjesni konteksta
  6. Optimizacija opisa alata
  7. Ključne točke

Pretraživanje alata: Dinamički alati

Demo agent sasvim dobro funkcionira s tri ili četiri alata. Poduzetnički agent, međutim, neizbježno nakuplja desetke, ponekad i stotine alata: naplata, ljudski resursi, CRM, dokumenti, rasporedi. Pri takvom opsegu, slanje cijelog kataloga modelu sa svakim zahtjevom postaje neučinkovito i skupo u smislu tokena. Pretraživanje alata rješava ovaj problem dinamičkim odabirom relevantnih alata za svaki zahtjev.

Problem s previše alata

Zamisli agenta s 50 alata. Pri svakom pozivu API-ja, sheme svih 50 alata šalju se u promptu. To troši tisuće tokena i može zbuniti model: što je popis duži, to opisi postaju sličniji, a model više oklijeva između susjednih alata. Troškovi rastu, a preciznost pada – najgora moguća kombinacija.

# Problem: previše alata
agent = Agent(
    name="Super Agent",
    instructions="Možeš učiniti bilo što.",
    tools=[tool_1, tool_2, tool_3, ... , tool_50],  # 50 alata = puno tokena
)

Omogućavanje pretraživanja alata

Pretraživanje alata koristi semantički indeks za odabir relevantnih alata na temelju zahtjeva. Alate deklariraš kao i obično, ali parametar tool_use_behavior="auto" omogućuje modelu da bira iz kataloga umjesto da učitava sve unaprijed. U primjeru ispod, zahtjev za slanje podsjetnika za plaćanje neće pokrenuti alate za ljudske resurse i obrnuto.

from agents import Agent, Runner, function_tool

# Definiraj mnogo alata
@function_tool
def create_invoice(client: str, amount: float) -> str:
    """Kreira račun za klijenta."""
    return f"Račun kreiran za {client}: €{amount}"

@function_tool
def send_reminder(invoice_id: str) -> str:
    """Šalje podsjetnik za plaćanje neplaćenog računa."""
    return f"Podsjetnik poslan za račun {invoice_id}"

@function_tool
def generate_hr_report(month: str) -> str:
    """Generira izvješće o ljudskim resursima za određeni mjesec."""
    return f"Izvješće o ljudskim resursima generirano za {month}"

@function_tool
def schedule_interview(candidate: str, date: str) -> str:
    """Zakazuje razgovor za posao s kandidatom."""
    return f"Razgovor zakazan s {candidate} dana {date}"

# Mnogi drugi alati...

agent = Agent(
    name="Poduzetnički agent",
    instructions="Upravljaš poslovanjem tvrtke.",
    tools=[
        create_invoice,
        send_reminder,
        generate_hr_report,
        schedule_interview,
        # ... 50 drugih alata
    ],
    tool_use_behavior="auto",  # Model dinamički odabire
)

Uzorak: Ručni odabir alata

Ako želiš potpunu kontrolu nad odabirom alata, implementiraj vlastitu logiku. Princip je jednostavan: mali agent usmjerivač čita zahtjev i jednostavno imenuje relevantnu domenu. Zatim gradiš specijaliziranog agenta u letu samo s alatima za tu domenu. Fraza poput „pošalji podsjetnik za račun F-2026-114“ izlazi iz usmjerivača s odgovorom accounting, a agent za izvršavanje nikada ne vidi alate za ljudske resurse.

from agents import Agent, Runner, function_tool

# Grupiraj alate po domeni
accounting_tools = [create_invoice, send_reminder]
hr_tools = [generate_hr_report, schedule_interview]

# Agent usmjerivač koji odabire domenu
router = Agent(
    name="Usmjerivač",
    instructions="""Odredi domenu zahtjeva.
    Odgovori samo s 'accounting' ili 'hr'.""",
    model="gpt-5.6-terra",  # Brz i jeftin za usmjeravanje
    output_type=str,
)

async def handle_request(message: str):
    # Korak 1: Odredi domenu
    route = await Runner.run(router, message)
    domain = route.final_output.strip().lower()

    # Korak 2: Kreiraj specijaliziranog agenta s pravim alatima
    if domain == "accounting":
        tools = accounting_tools
        instructions = "Upravljaš računovodstvom tvrtke."
    elif domain == "hr":
        tools = hr_tools
        instructions = "Upravljaš ljudskim resursima."
    else:
        tools = accounting_tools + hr_tools
        instructions = "Upravljaš poslovanjem tvrtke."

    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

Korištenje modela gpt-5.6-terra i za usmjeravanje i za izvršavanje pripada prethodnoj generaciji modela; logika iza ovog uzorka ostaje identična s obitelji GPT-5.6, gdje postavke napora razlikuju brzi usmjerivač od izvršitelja.

Uzorak: Dinamički alati svjesni konteksta

Odabir ne ovisi samo o postavljenom pitanju; ovisi i o tome tko pita. Dostupne alate možeš prilagoditi na temelju prijavljenog korisnika, ubivši tako dvije muhe jednim udarcem: šalješ manje tokena i, što je još važnije, provodiš kontrole pristupa prije nego što model uopće počne razmišljati. Prodajni djelatnik dobiva alate za izradu ponuda, ali delete_account jednostavno ne postoji u njegovom agentu.

from dataclasses import dataclass

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

def get_tools_for_role(ctx: UserContext) -> list:
    """Vraća autorizirane alate na temelju uloge."""
    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="Prilagođeni agent",
        instructions=f"Pomažeš {ctx.role} u odjelu {ctx.department}.",
        tools=tools,
        model="gpt-5.6-terra",
    )

Optimizacija opisa alata

Bez obzira na mehanizam odabira koji odabereš, on se oslanja na jedan materijal: tekst tvojih opisa. Kvaliteta tih opisa izravno utječe na relevantnost odabira. Usporedi dvije deklaracije u nastavku: prva ne govori ništa o scenariju upotrebe, dok druga imenuje ulaze, izlaz i kada ga koristiti.

# Loše: nejasan opis
@function_tool
def process_data(data: str) -> str:
    """Obrađuje podatke."""
    return "OK"

# Dobro: precizan i kontekstualiziran opis
@function_tool
def calculate_gross_margin(revenue: float, production_cost: float) -> str:
    """Izračunava bruto maržu kao postotak od prihoda
    i troškova proizvodnje. Korisno za kvartalnu financijsku analizu."""
    margin = ((revenue - production_cost) / revenue) * 100
    return f"Bruto marža: {margin:.1f}% (Prihodi: €{revenue}, Troškovi: €{production_cost})"

Dobar opis alata poput je dobrog docstringa: objašnjava kada koristiti alat, a ne samo što radi. Odvoji deset minuta da pregledaš opise svog agenta, pitajući se za svaki od njih bi li kolega mogao odabrati pravi alat čitajući samo tu rečenicu. To je točno vježba koju model izvodi.

Ključne točke

  • Pretraživanje alata dinamički odabire relevantne alate za svaki zahtjev
  • S mnogo alata, agent usmjerivač može unaprijed odrediti domenu
  • Prilagodi dostupne alate na temelju uloge i konteksta korisnika
  • Kvaliteta opisa alata utječe na točnost odabira
  • Koristi lagani model za brzo usmjeravanje i sposoban model za izvršavanje