Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Meklēšana pēc rīkiem: dinamiski rīki

Nodarbība 10 no 25 Atjaunota 2026. gada 29. jūlijs Programmētājs
Šajā lapā
  1. Meklēšana pēc rīkiem: dinamiski rīki
  2. Problēma ar pārāk daudziem rīkiem
  3. Meklēšanas pēc rīkiem iespējošana
  4. Paradums: manuāla rīku atlase
  5. Paradums: kontekstam pielāgoti dinamiski rīki
  6. Rīku aprakstu optimizēšana
  7. Galvenās atziņas

Meklēšana pēc rīkiem: dinamiski rīki

Demonstrācijas aģents lieliski tiek galā ar trim vai četriem rīkiem. Uzņēmuma līmeņa aģents tomēr neizbēgami uzkrāj desmitiem, reizēm simtiem rīku: rēķinu izrakstīšana, HR, CRM, dokumenti, grafiku plānošana. Šādā mērogā visu kataloga sūtīšana modelim ar katru pieprasījumu kļūst neefektīva un dārga tokenu ziņā. Meklēšana pēc rīkiem (Tool Search) atrisina šo problēmu, dinamiski atlasot atbilstošos rīkus katram pieprasījumam.

Problēma ar pārāk daudziem rīkiem

Iedomājies aģentu ar 50 rīkiem. Katrā API izsaukumā visu 50 rīku shēmas tiek nosūtītas promptā. Tas patērē tūkstošiem tokenu un var mulsināt modeli: jo garāks saraksts, jo līdzīgāki kļūst apraksti un jo vairāk models svārstās starp blakus esošajiem rīkiem. Izmaksas pieaug, bet precizitāte krītas – sliktākā iespējamā kombinācija.

# Problēma: pārāk daudz rīku
agent = Agent(
    name="Super Agent",
    instructions="You can do anything.",
    tools=[tool_1, tool_2, tool_3, ... , tool_50],  # 50 rīki = daudz tokenu
)

Meklēšanas pēc rīkiem iespējošana

Meklēšana pēc rīkiem izmanto semantisko indeksu, lai atlasītu atbilstošos rīkus, balstoties uz pieprasījumu. Tu deklarē savus rīkus kā parasti, taču parametrs tool_use_behavior="auto" ļauj modelim izvēlēties no kataloga, nevis ielādēt visu uzreiz. Tālāk redzamajā piemērā pieprasījums nosūtīt maksājuma atgādinājumu neaktivizēs HR rīkus un otrādi.

from agents import Agent, Runner, function_tool

# Definējam daudz rīku
@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}"

# Daudz citu rīku...

agent = Agent(
    name="Enterprise Agent",
    instructions="You manage company operations.",
    tools=[
        create_invoice,
        send_reminder,
        generate_hr_report,
        schedule_interview,
        # ... 50 citi rīki
    ],
    tool_use_behavior="auto",  # Models atlasa dinamiski
)

Paradums: manuāla rīku atlase

Ja vēlies pilnīgu kontroli pār rīku atlasi, ievies savu loģiku. Princips ir vienkāršs: neliels maršrutētāja aģents nolasa pieprasījumu un vienkārši nosauc atbilstošo domēnu. Pēc tam tu uzreiz izveido specializētu aģentu tikai ar šī domēna rīkiem. Frāze „nosūtīt atgādinājumu par rēķinu F-2026-114” no maršrutētāja iznāk ar atbildi accounting, un izpildes aģents nekad neredz HR rīkus.

from agents import Agent, Runner, function_tool

# Grupējam rīkus pēc domēniem
accounting_tools = [create_invoice, send_reminder]
hr_tools = [generate_hr_report, schedule_interview]

# Maršrutētāja aģents, kas atlasa domēnu
router = Agent(
    name="Router",
    instructions="""Determine the domain of the request.
    Respond only with 'accounting' or 'hr'.""",
    model="gpt-5.6-terra",  # Ātrs un lēts maršrutēšanai
    output_type=str,
)

async def handle_request(message: str):
    # 1. solis: noteikt domēnu
    route = await Runner.run(router, message)
    domain = route.final_output.strip().lower()

    # 2. solis: izveidot specializētu aģentu ar pareizajiem rīkiem
    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

gpt-5.6-terra izmantošana gan maršrutēšanai, gan izpildei pieder iepriekšējai modeļu paaudzei; loģika aiz šī paraduma paliek identiska arī GPT-5.6 saimei, kur iestatījumi par piepūli nošķir ātro maršrutētāju no izpildītāja.

Paradums: kontekstam pielāgoti dinamiski rīki

Atlase nav atkarīga tikai no uzdotā jautājuma; tā ir atkarīga arī no tā, kas jautā. Tu vari pielāgot pieejamos rīkus, balstoties uz pieslēgušos lietotāju, tādējādi nogalinot divus zaķus ar vienu šāvienu: tiek nosūtīts mazāk tokenu un, vēl svarīgāk, piekļuves kontrole tiek nodrošināta jau pirms models sāk spriest. Pārdošanas darbinieks saņem piedāvājumu sagatavošanas rīkus, bet delete_account viņa aģentā vienkārši nepastāv.

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",
    )

Rīku aprakstu optimizēšana

Neatkarīgi no tā, kādu atlases mehānismu izvēlies, tas balstās uz vienu materiālu: taviem aprakstu tekstiem. Šo aprakstu kvalitāte tieši ietekmē atlases atbilstību. Salīdzini abus tālāk redzamos deklarējumus: pirmais nesaka neko par lietojuma scenāriju, kamēr otrais nosauc ievades datus, izvadi un brīdi, kad to lietot.

# Slikti: neskaidrs apraksts
@function_tool
def process_data(data: str) -> str:
    """Processes data."""
    return "OK"

# Labi: precīzs un kontekstualizēts apraksts
@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})"

Labs rīka apraksts ir kā labs docstring: tas izskaidro, kad rīku lietot, ne tikai to, ko tas dara. Velti desmit minūtes, lai pārskatītu sava aģenta aprakstus, jautājot sev par katru no tiem, vai kolēģis varētu izvēlēties pareizo rīku, lasot tikai šo teikumu. Tieši šo uzdevumu veic arī models.

Galvenās atziņas

  • Meklēšana pēc rīkiem dinamiski atlasa atbilstošos rīkus katram pieprasījumam
  • Ar daudziem rīkiem maršrutētāja aģents var iepriekš noteikt domēnu
  • Pielāgo pieejamos rīkus, balstoties uz lietotāja lomu un kontekstu
  • Rīka apraksta kvalitāte ietekmē atlases precizitāti
  • Izmanto vieglu modeli ātrai maršrutēšanai un spēcīgu modeli izpildei