Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Tool Search: Dynamische tools

Les 10 van 25 Bijgewerkt op 29 juli 2026 Ontwikkelaar
Op deze pagina
  1. Tool Search: Dynamische tools
  2. Het probleem met te veel tools
  3. Tool Search inschakelen
  4. Patroon: Handmatige toolselectie
  5. Patroon: Contextbewuste dynamische tools
  6. Tool-beschrijvingen optimaliseren
  7. Belangrijkste punten

Tool Search: Dynamische tools

Een demo-agent komt prima weg met drie of vier tools. Een enterprise-agent verzamelt echter onvermijdelijk tientallen, soms honderden tools: facturatie, HR, CRM, documentbeheer, planning. Op die schaal wordt het inefficiënt en duur in termen van tokens om bij elk verzoek de volledige catalogus naar het model te sturen. Tool Search lost dit probleem op door dynamisch de relevante tools voor elk verzoek te selecteren.

Het probleem met te veel tools

Stel u een agent voor met 50 tools. Bij elke API-call worden de schema’s van alle 50 tools in de prompt meegestuurd. Dit verbruikt duizenden tokens en kan het model in verwarring brengen: hoe langer de lijst, hoe meer de beschrijvingen op elkaar gaan lijken, en hoe meer het model aarzelt tussen vergelijkbare tools. De kosten stijgen terwijl de precisie daalt; de slechtst mogelijke combinatie.

# Probleem: te veel 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
)

Tool Search inschakelen

Tool Search maakt gebruik van een semantische index om relevante tools te selecteren op basis van het verzoek. U declareert uw tools zoals gebruikelijk, maar de parameter tool_use_behavior="auto" laat het model kiezen uit de catalogus in plaats van alles vooraf te laden. In het onderstaande voorbeeld zal een verzoek om een betalingsherinnering te versturen geen HR-tools activeren, en vice versa.

from agents import Agent, Runner, function_tool

# Definieer veel 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}"

# Veel andere 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",  # Het model selecteert dynamisch
)

Patroon: Handmatige toolselectie

Als u totale controle wilt over de toolselectie, implementeer dan uw eigen logica. Het principe is eenvoudig: een kleine router-agent leest het verzoek en noemt alleen het relevante domein. Vervolgens bouwt u de gespecialiseerde agent on-the-fly met alleen de tools voor dat domein. Een zin als “stuur een herinnering voor factuur F-2026-114” komt uit de router met het antwoord accounting, en de uitvoeringsagent ziet de HR-tools nooit.

from agents import Agent, Runner, function_tool

# Groepeer tools per domein
accounting_tools = [create_invoice, send_reminder]
hr_tools = [generate_hr_report, schedule_interview]

# Een router-agent die het domein selecteert
router = Agent(
    name="Router",
    instructions="""Determine the domain of the request.
    Respond only with 'accounting' or 'hr'.""",
    model="gpt-5.6-terra",  # Snel en goedkoop voor routing
    output_type=str,
)

async def handle_request(message: str):
    # Stap 1: Bepaal het domein
    route = await Runner.run(router, message)
    domain = route.final_output.strip().lower()

    # Stap 2: Maak de gespecialiseerde agent met de juiste 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

Het gebruik van gpt-5.6-terra voor zowel routing als uitvoering behoort tot de vorige generatie modellen; de redenering achter het patroon blijft identiek binnen de GPT-5.6-familie, waar instellingen voor inspanning het onderscheid maken tussen de snelle router en de uitvoerder.

Patroon: Contextbewuste dynamische tools

Selectie hangt niet alleen af van de gestelde vraag, maar ook van wie de vraag stelt. U kunt beschikbare tools aanpassen op basis van de ingelogde gebruiker, waarmee u twee vliegen in één klap slaat: er worden minder tokens verzonden en, nog belangrijker, toegangscontroles worden afgedwongen voordat het model überhaupt gaat redeneren. Een verkoopmedewerker krijgt tools voor offertes, maar delete_account bestaat simpelweg niet in diens 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",
    )

Tool-beschrijvingen optimaliseren

Welk selectiemechanisme u ook kiest, het steunt op één materiaal: de tekst van uw beschrijvingen. De kwaliteit van deze beschrijvingen heeft directe invloed op de relevantie van de selectie. Vergelijk de twee declaraties hieronder: de eerste zegt niets over het gebruiksscenario, terwijl de tweede de inputs, de output en het moment van gebruik benoemt.

# Slecht: vaag beschrijving
@function_tool
def process_data(data: str) -> str:
    """Processes data."""
    return "OK"

# Goed: precieze en gecontextualiseerde beschrijving
@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})"

Een goede tool-beschrijving is als een goede docstring: deze legt uit wanneer u de tool moet gebruiken, niet alleen wat deze doet. Neem tien minuten de tijd om de beschrijvingen van uw agent te reviewen en vraag uzelf bij elke beschrijving af of een collega het juiste tool zou kiezen door alleen die zin te lezen. Dat is precies de oefening die het model uitvoert.

Belangrijkste punten

  • Tool Search selecteert dynamisch relevante tools voor elk verzoek
  • Bij veel tools kan een router-agent vooraf het domein bepalen
  • Pas beschikbare tools aan op basis van de rol en context van de gebruiker
  • De kwaliteit van tool-beschrijvingen beïnvloedt de selectienauwkeurigheid
  • Gebruik een lichtgewicht model voor snelle routing en een krachtig model voor uitvoering