Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Værktøjssøgning: Dynamiske værktøjer

Lektion 10 af 25 Opdateret 29. juli 2026 Udvikler
På denne side
  1. Værktøjssøgning: Dynamiske værktøjer
  2. Problemet med for mange værktøjer
  3. Aktivering af værktøjssøgning
  4. Mønster: Manuel værktøjsvalg
  5. Mønster: Kontekstbevidste dynamiske værktøjer
  6. Optimering af værktøjsbeskrivelser
  7. Vigtige pointer

Værktøjssøgning: Dynamiske værktøjer

En demo-agent klarer sig fint med tre eller fire værktøjer. En enterprise-agent ophober derimod uundgåeligt dusinvis, nogle gange hundreder: fakturering, HR, CRM, dokumenter, planlægning. På det skala bliver det ineffektivt og dyrt i forhold til tokens at sende hele kataloget til modellen ved hver anmodning. Værktøjssøgning løser dette problem ved dynamisk at vælge de relevante værktøjer til hver anmodning.

Problemet med for mange værktøjer

Forestil dig en agent med 50 værktøjer. Ved hvert API-kald sendes skemaerne for alle 50 værktøjer i prompten. Dette bruger tusindvis af tokens og kan forvirre modellen: Jo længere listen er, desto mere ens bliver beskrivelserne, og desto mere tøver modellen mellem nærliggende værktøjer. Omkostningerne stiger, mens præcisionen falder – den værst tænkelige kombination.

# Problem: too many tools
agent = Agent(
    name="Super Agent",
    instructions="You can do anything.",
    tools=[tool_1, tool_2, tool_3, ... , tool_50],  # 50 tools = lots of tokens
)

Aktivering af værktøjssøgning

Værktøjssøgning bruger et semantisk indeks til at vælge relevante værktøjer baseret på anmodningen. Du definerer dine værktøjer som sædvanligt, men parameteren tool_use_behavior="auto" lader modellen vælge fra kataloget i stedet for at indlæse alt på forhånd. I eksemplet nedenfor vil en anmodning om at sende en betalingspåmindelse ikke udløse HR-værktøjer, og omvendt.

from agents import Agent, Runner, function_tool

# Define many tools
@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}"

# Many other tools...

agent = Agent(
    name="Enterprise Agent",
    instructions="You manage company operations.",
    tools=[
        create_invoice,
        send_reminder,
        generate_hr_report,
        schedule_interview,
        # ... 50 other tools
    ],
    tool_use_behavior="auto",  # The model selects dynamically
)

Mønster: Manuel værktøjsvalg

Hvis du ønsker fuld kontrol over værktøjsvalget, kan du implementere din egen logik. Princippet er simpelt: En lille router-agent læser anmodningen og navngiver blot det relevante domæne. Derefter bygger du den specialiserede agent on the fly med kun de værktøjer, der hører til det pågældende domæne. En sætning som „send en påmindelse for faktura F-2026-114” kommer ud af routeren med svaret accounting, og eksekveringsagenten ser aldrig HR-værktøjerne.

from agents import Agent, Runner, function_tool

# Group tools by domain
accounting_tools = [create_invoice, send_reminder]
hr_tools = [generate_hr_report, schedule_interview]

# A router agent that selects the domain
router = Agent(
    name="Router",
    instructions="""Determine the domain of the request.
    Respond only with 'accounting' or 'hr'.""",
    model="gpt-5.6-terra",  # Fast and cheap for routing
    output_type=str,
)

async def handle_request(message: str):
    # Step 1: Determine the domain
    route = await Runner.run(router, message)
    domain = route.final_output.strip().lower()

    # Step 2: Create the specialized agent with the right tools
    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

Brug af gpt-5.6-terra til både routing og eksekvering tilhører den tidligere generation af modeller; begrundelsen bag mønsteret forbliver identisk med GPT-5.6-familien, hvor indsatsindstillingerne adskiller den hurtige router fra eksekveringen.

Mønster: Kontekstbevidste dynamiske værktøjer

Valget afhænger ikke kun af det stillede spørgsmål; det afhænger også af, hvem der spørger. Du kan tilpasse de tilgængelige værktøjer baseret på den loggede bruger og dermed slå to fluer med ét smæk: Færre tokens sendes, og vigtigere endnu, adgangskontroller håndhæves, før modellen overhovedet begynder at ræsonnere. En salgsmedarbejder får værktøjer til tilbudsgivning, men delete_account eksisterer slet ikke i deres agent.

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

Optimering af værktøjsbeskrivelser

Uanset hvilken valgmechanisme du vælger, hviler den på ét enkelt materiale: teksten i dine beskrivelser. Kvaliteten af disse beskrivelser påvirker direkte relevansen af valget. Sammenlign de to deklarationer nedenfor: Den første siger intet om brugsscenariet, mens den anden nævner input, output og hvornår det skal bruges.

# Bad: vague description
@function_tool
def process_data(data: str) -> str:
    """Processes data."""
    return "OK"

# Good: precise and contextualized description
@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})"

En god værktøjsbeskrivelse er som en god docstring: Den forklarer hvornår værktøjet skal bruges, ikke bare hvad det gør. Brug ti minutter på at gennemgå din agents beskrivelser, og spørg dig selv for hver enkelt, om en kollega kunne vælge det rigtige værktøj ved kun at læse den sætning. Det er præcis den øvelse, modellen udfører.

Vigtige pointer

  • Værktøjssøgning vælger dynamisk relevante værktøjer til hver anmodning
  • Med mange værktøjer kan en router-agent bestemme domænet på forhånd
  • Tilpas tilgængelige værktøjer baseret på brugerens rolle og kontekst
  • Kvaliteten af værktøjsbeskrivelser påvirker nøjagtigheden af valget
  • Brug en letvægtsmodel til hurtig routing og en kapacitetsstærk model til eksekvering