Meklēšana pēc rīkiem: dinamiski rīki
Šajā lapā
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