Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Iskanje orodij: Dinamična orodja

Lekcija 10 od 25 Posodobljeno 29. julij 2026 Razvijalec
Na tej strani
  1. Iskanje orodij: Dinamična orodja
  2. Težava s prevelikim številom orodij
  3. Omogočanje iskanja orodij
  4. Vzorec: Ročni izbor orodij
  5. Vzorec: Dinamična orodja, odvisna od konteksta
  6. Optimizacija opisov orodij
  7. Ključne ugotovitve

Iskanje orodij: Dinamična orodja

Demo agent brez težav deluje s tremi ali štirimi orodji. Podjetniški agent pa neizogibno nabere ducat, včasih celo sto orodij: fakturiranje, kadri, CRM, dokumenti, načrtovanje. Pri takem obsegu pošiljanje celotnega kataloga modelu z vsako zahtevo postane neučinkovito in drago glede na porabo žetonov. Iskanje orodij (Tool Search) reši ta problem z dinamičnim izbiranjem ustreznih orodij za vsako zahtevo.

Težava s prevelikim številom orodij

Predstavljaj si agenta s 50 orodji. Ob vsakem klicu API-ja so v poziv vključene sheme vseh 50 orodij. To porabi na tisoče žetonov in lahko zmede model: daljši kot je seznam, bolj si opisi postajajo podobni in model bolj okleva med sosednjimi orodji. Stroški rastejo, natančnost pa pada – najslabša možna kombinacija.

# Težava: preveč orodij
agent = Agent(
    name="Super Agent",
    instructions="Lahko narediš karkoli.",
    tools=[tool_1, tool_2, tool_3, ... , tool_50],  # 50 orodij = veliko žetonov
)

Omogočanje iskanja orodij

Iskanje orodij uporablja semantični indeks za izbiro ustreznih orodij na podlagi zahteve. Orodja deklariraš kot običajno, vendar parameter tool_use_behavior="auto" modelu omogoči, da izbira iz kataloga, namesto da bi vse naložil vnaprej. V spodnjem primeru zahteva za pošiljanje opomnika za plačilo ne bo sprožila kadrovskih orodij in obratno.

from agents import Agent, Runner, function_tool

# Definiraj veliko orodij
@function_tool
def create_invoice(client: str, amount: float) -> str:
    """Ustvari račun za stranko."""
    return f"Račun ustvarjen za {client}: €{amount}"

@function_tool
def send_reminder(invoice_id: str) -> str:
    """Pošlje opomnik za plačilo neplačanega računa."""
    return f"Opomnik poslan za račun {invoice_id}"

@function_tool
def generate_hr_report(month: str) -> str:
    """Generira kadrovsko poročilo za določen mesec."""
    return f"Kadrovsko poročilo generirano za {month}"

@function_tool
def schedule_interview(candidate: str, date: str) -> str:
    """Načrtuje delovni razgovor s kandidatom."""
    return f"Razgovor načrtovan s {candidate} dne {date}"

# Številna druga orodja...

agent = Agent(
    name="Podjetniški agent",
    instructions="Upravljaš poslovanje podjetja.",
    tools=[
        create_invoice,
        send_reminder,
        generate_hr_report,
        schedule_interview,
        # ... 50 drugih orodij
    ],
    tool_use_behavior="auto",  # Model dinamično izbira
)

Vzorec: Ročni izbor orodij

Če želiš popoln nadzor nad izbiro orodij, implementiraj svojo logiko. Načelo je preprosto: majhen usmerjevalni agent prebere zahtevo in preprosto poimenuje ustrezno domeno. Nato sproti zgradiš specializiranega agenta le z orodji za to domeno. Stavek, kot je „pošlji opomnik za račun F-2026-114”, iz usmerjevalnika pride z odgovorom accounting (računovodstvo), izvršilni agent pa kadrovskih orodij nikoli ne vidi.

from agents import Agent, Runner, function_tool

# Združi orodja po domenah
accounting_tools = [create_invoice, send_reminder]
hr_tools = [generate_hr_report, schedule_interview]

# Usmerjevalni agent, ki izbere domeno
router = Agent(
    name="Usmerjevalnik",
    instructions="""Določi domeno zahteve.
    Odgovori samo z 'accounting' ali 'hr'.""",
    model="gpt-5.6-terra",  # Hiter in poceni za usmerjanje
    output_type=str,
)

async def handle_request(message: str):
    # 1. korak: Določi domeno
    route = await Runner.run(router, message)
    domain = route.final_output.strip().lower()

    # 2. korak: Ustvari specializiranega agenta s pravimi orodji
    if domain == "accounting":
        tools = accounting_tools
        instructions = "Upravljaš računovodstvo podjetja."
    elif domain == "hr":
        tools = hr_tools
        instructions = "Upravljaš človeške vire."
    else:
        tools = accounting_tools + hr_tools
        instructions = "Upravljaš poslovanje podjetja."

    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

Uporaba modela gpt-5.6-terra tako za usmerjanje kot za izvrševanje spada v prejšnjo generacijo modelov; logika vzorca ostaja enaka pri družini GPT-5.6, kjer nastavitve napora ločijo hitri usmerjevalnik od izvršilca.

Vzorec: Dinamična orodja, odvisna od konteksta

Izbira ni odvisna le od postavljenega vprašanja, temveč tudi od tega, kdo sprašuje. Razpoložljiva orodja lahko prilagodiš glede na prijavljenega uporabnika in s tem ubiješ dve muhi na en mah: pošlješ manj žetonov in, kar je še pomembneje, uveljaviš nadzor dostopa, preden model sploh začne razmišljati. Prodajni uslužbenec dobi orodja za pripravo ponudb, delete_account (izbris računa) pa v njegovem agentu preprosto ne obstaja.

from dataclasses import dataclass

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

def get_tools_for_role(ctx: UserContext) -> list:
    """Vrne avtorizirana orodja glede na vlogo."""
    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="Osebni agent",
        instructions=f"Pomagaš {ctx.role} v oddelku {ctx.department}.",
        tools=tools,
        model="gpt-5.6-terra",
    )

Optimizacija opisov orodij

Ne glede na izbrani mehanizem izbire ta temelji na enem samem materialu: besedilu tvojih opisov. Kakovost teh opisov neposredno vpliva na ustreznost izbire. Primerjaj spodnji dve deklaraciji: prva ne pove ničesar o scenariju uporabe, medtem ko druga imenuje vhode, izhod in kdaj jo uporabiti.

# Slabo: nejasen opis
@function_tool
def process_data(data: str) -> str:
    """Obdela podatke."""
    return "OK"

# Dobro: natančen in umешčen v kontekst
@function_tool
def calculate_gross_margin(revenue: float, production_cost: float) -> str:
    """Izračuna bruto maržo v odstotkih iz prihodkov
    in proizvodnih stroškov. Uporabno za četrtletno finančno analizo."""
    margin = ((revenue - production_cost) / revenue) * 100
    return f"Bruto marža: {margin:.1f}% (Prihodki: €{revenue}, Stroški: €{production_cost})"

Dober opis orodja je kot dober docstring: pojasni kdaj uporabiti orodje, ne le kaj počne. Vzemi si deset minut za pregled opisov svojega agenta in se pri vsakem vprašaj, ali bi sodelavec lahko izbral pravo orodje samo z branjem tega stavka. Točno to vajo opravlja model.

Ključne ugotovitve

  • Iskanje orodij dinamično izbere ustrezna orodja za vsako zahtevo
  • Pri velikem številu orodij lahko usmerjevalni agent vnaprej določi domeno
  • Prilagodi razpoložljiva orodja glede na vlogo in kontekst uporabnika
  • Kakovost opisa orodja vpliva na natančnost izbire
  • Za hitro usmerjanje uporabi lahek model, za izvrševanje pa zmogljivega