Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Tool Search: dinaminiai įrankiai

Paskaita 10 iš 25 Atnaujinta 2026 m. liepos 29 d. Kūrėjas
Šiame puslapyje
  1. Tool Search: dinaminiai įrankiai
  2. Per daug įrankių keliamos problemos
  3. „Tool Search“ įgalinimas
  4. Šablonas: rankinis įrankių pasirinkimas
  5. Šablonas: kontekstui pritaikyti dinaminiai įrankiai
  6. Įrankių aprašymų optimizavimas
  7. Svarbiausi punktai

Tool Search: dinaminiai įrankiai

Demonstracinis agentas puikiai apsieina su trimis ar keturiais įrankiais. Tačiau įmonės agentas neišvengiamai kaupia dešimtis, o kartais ir šimtus įrankių: sąskaitų faktūrų išrašymui, žmogiškiesiems ištekliams, CRM, dokumentams, planavimui. Esant tokiam mastui, visą katalogą modeliui siųsti su kiekvienu užklausimu tampa neefektyvu ir brangu tokenų požiūriu. Tool Search išsprendžia šią problemą dinamiškai parinkdamas tinkamus įrankius kiekvienai užklausai.

Per daug įrankių keliamos problemos

Įsivaizduok agentą su 50 įrankių. Kviečiant API, visų 50 įrankių schemos siunčiamos prompt’e. Tai suvartoja tūkstančius tokenų ir gali suklaidinti modelį: kuo ilgesnis sąrašas, tuo panašesni tampa aprašymai, ir modelis labiau dvejoja tarp gretimų įrankių. Kaštai auga, o tikslumas mažėja – tai blogiausias įmanomas derinys.

# Problema: per daug įrankių
agent = Agent(
    name="Super Agent",
    instructions="You can do anything.",
    tools=[tool_1, tool_2, tool_3, ... , tool_50],  # 50 įrankių = daug tokenų
)

„Tool Search“ įgalinimas

„Tool Search“ naudoja semantinį indeksą, kad pagal užklausą atrinktų tinkamus įrankius. Įrankius deklaruoji įprastai, tačiau parametras tool_use_behavior="auto" leidžia modeliui rinktis iš katalogo, užuot įkrovus viską iš anksto. Toliau pateiktame pavyzdyje prašymas išsiųsti mokėjimo priminimą nesuaktyvins HR įrankių, ir atvirkščiai.

from agents import Agent, Runner, function_tool

# Apibrėžiame daug įrankių
@function_tool
def create_invoice(client: str, amount: float) -> str:
    """Creates an invoice for a client."""
    return f"Invoice created for {client}: €{amount}"

@function_tool
def send_reminder(invoice_id: str) -> str:
    """Sends a payment reminder for an unpaid invoice."""
    return f"Reminder sent for invoice {invoice_id}"

@function_tool
def generate_hr_report(month: str) -> str:
    """Generates a human resources report for a given month."""
    return f"HR report generated for {month}"

@function_tool
def schedule_interview(candidate: str, date: str) -> str:
    """Schedules a job interview with a candidate."""
    return f"Interview scheduled with {candidate} on {date}"

# Daugybė kitų įrankių...

agent = Agent(
    name="Enterprise Agent",
    instructions="You manage company operations.",
    tools=[
        create_invoice,
        send_reminder,
        generate_hr_report,
        schedule_interview,
        # ... dar 50 įrankių
    ],
    tool_use_behavior="auto",  # Modelis renkasi dinamiškai
)

Šablonas: rankinis įrankių pasirinkimas

Jei nori visiškos kontrolės renkantis įrankius, įgyvendink savo logiką. Principas paprastas: mažas maršrutizatoriaus agentas perskaito užklausą ir tiesiog įvardija atitinkamą sritį. Tada realiuoju laiku sukuri specializuotą agentą tik su tos srities įrankiais. Frazė „išsiųsti priminimą dėl sąskaitos F-2026-114“ iš maršrutizatoriaus grįžta su atsakymu accounting, o vykdymo agentas HR įrankių net nemato.

from agents import Agent, Runner, function_tool

# Sugrupuojame įrankius pagal sritis
accounting_tools = [create_invoice, send_reminder]
hr_tools = [generate_hr_report, schedule_interview]

# Maršrutizatoriaus agentas, kuris pasirenka sritį
router = Agent(
    name="Router",
    instructions="""Determine the domain of the request.
    Respond only with 'accounting' or 'hr'.""",
    model="gpt-5.6-terra",  # Greitas ir pigus maršrutizavimui
    output_type=str,
)

async def handle_request(message: str):
    # 1 žingsnis: nustatyti sritį
    route = await Runner.run(router, message)
    domain = route.final_output.strip().lower()

    # 2 žingsnis: sukurti specializuotą agentą su tinkamais įrankiais
    if domain == "accounting":
        tools = accounting_tools
        instructions = "You manage the company's accounting."
    elif domain == "hr":
        tools = hr_tools
        instructions = "You manage human resources."
    else:
        tools = accounting_tools + hr_tools
        instructions = "You manage company operations."

    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

Naudojant gpt-5.6-terra tiek maršrutizavimui, tiek vykdymui, remiamasi ankstesne modelių karta; tačiau šio šablono logika lieka identiška ir su GPT-5.6 šeima, kur pastangų nustatymai atskiria greitą maršrutizatorių nuo vykdytojo.

Šablonas: kontekstui pritaikyti dinaminiai įrankiai

Pasirinkimas priklauso ne tik nuo užduoto klausimo, bet ir nuo to, kas klausia. Galite pritaikyti galimus įrankius pagal prisijungusį vartotoją, taip nušaudami du zuikius vienu šūviu: siunčiama mažiau tokenų ir, svarbiausia, prieigos kontrolė užtikrinama dar prieš modelio samprotavimus. Pardavimų darbuotojas gauna kainodaros įrankius, tačiau delete_account jo agente tiesiog neegzistuoja.

from dataclasses import dataclass

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

def get_tools_for_role(ctx: UserContext) -> list:
    """Returns authorized tools based on 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="Custom Agent",
        instructions=f"You assist a {ctx.role} in the {ctx.department} department.",
        tools=tools,
        model="gpt-5.6-terra",
    )

Įrankių aprašymų optimizavimas

Nesvarbu, kokį pasirinkimo mechanizmą pasirinksi, jis remiasi viena medžiaga: tavo aprašymų tekstu. Šių aprašymų kokybė tiesiogiai lemia pasirinkimo tikslumą. Palygink du toliau pateiktus apibrėžimus: pirmasis nieko nesako apie naudojimo scenarijų, o antrasis nurodo įvestis, išvestį ir kada jį naudoti.

# Blogai: miglotas aprašymas
@function_tool
def process_data(data: str) -> str:
    """Processes data."""
    return "OK"

# Gerai: tikslus ir kontekstualizuotas aprašymas
@function_tool
def calculate_gross_margin(revenue: float, production_cost: float) -> str:
    """Calculates gross margin as a percentage from revenue
    and production cost. Useful for quarterly financial analysis."""
    margin = ((revenue - production_cost) / revenue) * 100
    return f"Gross margin: {margin:.1f}% (Revenue: €{revenue}, Costs: €{production_cost})"

Geras įrankio aprašymas yra kaip geras docstring: jis paaiškina kada naudoti įrankį, o ne tik ką jis daro. Skirk dešimt minučių peržiūrėti savo agento aprašymus ir kiekvienam jų užduok sau klausimą, ar kolega galėtų pasirinkti tinkamą įrankį perskaitęs tik tą sakinį. Būtent tą pratimą atlieka ir modelis.

Svarbiausi punktai

  • „Tool Search“ dinamiškai parenka tinkamus įrankius kiekvienai užklausai
  • Turint daug įrankių, maršrutizatoriaus agentas gali iš anksto nustatyti sritį
  • Pritaikyk galimus įrankius pagal vartotojo vaidmenį ir kontekstą
  • Įrankio aprašymo kokybė daro įtaką pasirinkimo tikslumui
  • Greitam maršrutizavimui naudok lengvą modelį, o vykdymui – galingesnį modelį