Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Työkaluhaku: Dynaamiset työkalut

Oppitunti 10 / 25 Päivitetty 29. heinäkuuta 2026 Kehittäjä
Tällä sivulla
  1. Työkaluhaku: Dynaamiset työkalut
  2. Ongelma: liian monta työkalua
  3. Työkaluhaun käyttöönotto
  4. Malli: Manuaalinen työkalujen valinta
  5. Malli: Kontekstitietoiset dynaamiset työkalut
  6. Työkalukuvausten optimointi
  7. Keskeiset asiat

Työkaluhaku: Dynaamiset työkalut

Demo-agentti pärjää hyvin kolmella tai neljällä työkalulla. Yritystason agentti kuitenkin kerää väistämättä kymmeniä, joskus satoja työkaluja: laskutus, HR, CRM, asiakirjat, aikataulutus. Tässä mittakaavassa koko luettelon lähettäminen mallille jokaisen pyynnön mukana muuttuu tehottomaksi ja kallista tokenien kulutuksen kannalta. Työkaluhaku ratkaisee tämän ongelman valitsemalla dynaamisesti kunkin pyynnön kannalta merkitykselliset työkalut.

Ongelma: liian monta työkalua

Kuvittele agentti, jolla on 50 työkalua. Jokaisella API-kutsulla kaikkien 50 työkalun skeemat lähetetään kehotteessa. Tämä kuluttaa tuhansia tokeneita ja voi hämmentää mallia: mitä pidempi lista on, sitä samankaltaisemmiksi kuvaukset muuttuvat, ja malli epäröi enemmän vierekkäisten työkalujen välillä. Kustannukset nousevat samalla kun tarkkuus laskee – pahin mahdollinen yhdistelmä.

# Ongelma: liian monta työkalua
agent = Agent(
    name="Super Agent",
    instructions="You can do anything.",
    tools=[tool_1, tool_2, tool_3, ... , tool_50],  # 50 työkalua = paljon tokeneita
)

Työkaluhaun käyttöönotto

Työkaluhaku käyttää semanttista indeksiä valitakseen pyynnön perusteella merkitykselliset työkalut. Määrittelet työkalusi kuten tavallista, mutta parametri tool_use_behavior="auto" antaa mallin valita luettelosta sen sijaan, että kaikki ladattaisiin etukäteen. Alla olevassa esimerkissä maksumuistutuksen lähettämistä koskeva pyyntö ei käynnistä HR-työkaluja, eikä päinvastoin.

from agents import Agent, Runner, function_tool

# Määrittele monta työkalua
@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}"

# Monia muita työkaluja...

agent = Agent(
    name="Enterprise Agent",
    instructions="You manage company operations.",
    tools=[
        create_invoice,
        send_reminder,
        generate_hr_report,
        schedule_interview,
        # ... 50 muuta työkalua
    ],
    tool_use_behavior="auto",  # Malli valitsee dynaamisesti
)

Malli: Manuaalinen työkalujen valinta

Jos haluat täyden hallinnan työkalujen valintaan, toteuta oma logiikkasi. Periaate on yksinkertainen: pieni reititin-agentti lukee pyynnön ja nimeää vain asiaankuuluvan toimialueen. Tämän jälkeen rakennat erikoistuneen agentin lennossa käyttämällä vain kyseisen toimialueen työkaluja. Lause kuten “lähetä muistutus laskusta F-2026-114” palauttaa reitittimeltä vastauksen accounting, eikä suoritusagentti näe koskaan HR-työkaluja.

from agents import Agent, Runner, function_tool

# Ryhmittele työkalut toimialueittain
accounting_tools = [create_invoice, send_reminder]
hr_tools = [generate_hr_report, schedule_interview]

# Reititin-agentti, joka valitsee toimialueen
router = Agent(
    name="Router",
    instructions="""Determine the domain of the request.
    Respond only with 'accounting' or 'hr'.""",
    model="gpt-5.6-terra",  # Nopea ja halpa reititykseen
    output_type=str,
)

async def handle_request(message: str):
    # Vaihe 1: Määritä toimialue
    route = await Runner.run(router, message)
    domain = route.final_output.strip().lower()

    # Vaihe 2: Luo erikoistunut agentti oikeilla työkaluilla
    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

Mallin gpt-5.6-terra käyttäminen sekä reititykseen että suorittamiseen kuuluu edelliseen mallisukupolveen; kuvion taustalla oleva logiikka pysyy kuitenkin identtisenä GPT-5.6 -perheen kanssa, jossa ponnisteluasetukset erottavat nopean reitittimen suorittajasta.

Malli: Kontekstitietoiset dynaamiset työkalut

Valinta ei riipu vain kysymyksestä, vaan myös siitä, kuka kysyy. Voit mukauttaa käytettävissä olevia työkaluja kirjautuneen käyttäjän perusteella, tappaen kaksi kärpästä yhdellä iskulla: lähetettäviä tokeneita on vähemmän, ja mikä tärkeämpää, käyttöoikeuksien valvonta toteutetaan ennen kuin malli edes aloittaa päättelyn. Myyntityöntekijä saa tarjoustyökalut, mutta delete_account ei yksinkertaisesti ole olemassa hänen agentissaan.

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

Työkalukuvausten optimointi

Riippumatta siitä, mitä valintamekanismia käytät, se nojaa yhteen raaka-aineeseen: kuvaustesi tekstiin. Näiden kuvausten laatu vaikuttaa suoraan valinnan osuvuuteen. Vertaa alla olevia kahta määrittelyä: ensimmäinen ei kerro mitään käyttötilanteesta, kun taas toinen nimeää syötteet, tulosteen ja sen, milloin työkalua kannattaa käyttää.

# Huono: epämääräinen kuvaus
@function_tool
def process_data(data: str) -> str:
    """Processes data."""
    return "OK"

# Hyvä: tarkka ja kontekstualisoitu kuvaus
@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})"

Hyvä työkalukuvaus on kuin hyvä docstring: se selittää, milloin työkalua tulee käyttää, ei vain sitä, mitä se tekee. Käytä kymmenen minuuttia agenttisi kuvausten läpikäymiseen ja kysy itseltäsi jokaisen kohdalla, voisiko kollega valita oikean työkalun lukemalla vain kyseisen lauseen. Juuri tämän harjoituksen malli suorittaa.

Keskeiset asiat

  • Työkaluhaku valitsee dynaamisesti merkitykselliset työkalut kullekin pyynnölle
  • Kun työkaluja on paljon, reititin-agentti voi määrittää toimialueen etukäteen
  • Mukauta käytettävissä olevia työkaluja käyttäjän roolin ja kontekstin perusteella
  • Työkalukuvausten laatu vaikuttaa valinnan tarkkuuteen
  • Käytä kevyttä mallia nopeaan reititykseen ja tehokasta mallia suorittamiseen