Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Tool Search: Dynamische Werkzeuge

Lektion 10 von 25 Aktualisiert am 29. Juli 2026 Entwickler
Auf dieser Seite
  1. Tool Search: Dynamische Werkzeuge
  2. Das Problem mit zu vielen Werkzeugen
  3. Tool Search aktivieren
  4. Muster: Manuelle Werkzeugauswahl
  5. Muster: Kontextbewusste dynamische Werkzeuge
  6. Optimierung von Werkzeugbeschreibungen
  7. Kernaussagen

Tool Search: Dynamische Werkzeuge

Ein Demonstrations-Agent kommt mit drei oder vier Werkzeugen gut zurecht. Ein Unternehmensagent hingegen sammelt zwangsläufig Dutzende, manchmal Hunderte von Werkzeugen an: Abrechnung, Personalwesen, CRM, Dokumente, Terminplanung. Bei diesem Umfang wird das Senden des gesamten Katalogs mit jeder Anfrage ineffizient und in Bezug auf Token teuer. Tool Search löst dieses Problem, indem es für jede Anfrage die relevanten Werkzeuge dynamisch auswählt.

Das Problem mit zu vielen Werkzeugen

Stellen Sie sich einen Agenten mit 50 Werkzeugen vor. Bei jedem API-Aufruf werden die Schemata aller 50 Werkzeuge im Prompt gesendet. Dies verbraucht Tausende von Token und kann das Modell verwirren: Je länger die Liste, desto ähnlicher werden die Beschreibungen, und desto mehr zögert das Modell zwischen benachbarten Werkzeugen. Die Kosten steigen, während die Präzision sinkt – die schlechteste mögliche Kombination.

# Problem: zu viele Werkzeuge
agent = Agent(
    name="Super Agent",
    instructions="Sie können alles tun.",
    tools=[tool_1, tool_2, tool_3, ... , tool_50],  # 50 Werkzeuge = viele Token
)

Tool Search aktivieren

Tool Search verwendet einen semantischen Index, um relevante Werkzeuge basierend auf der Anfrage auszuwählen. Sie deklarieren Ihre Werkzeuge wie gewohnt, aber der Parameter tool_use_behavior="auto" ermöglicht es dem Modell, aus dem Katalog auszuwählen, anstatt alles im Voraus zu laden. Im folgenden Beispiel würde eine Anfrage zur Absendung einer Zahlungserinnerung keine Personalwesen-Werkzeuge auslösen, und umgekehrt.

from agents import Agent, Runner, function_tool

# Viele Werkzeuge definieren
@function_tool
def create_invoice(client: str, amount: float) -> str:
    """Erstellt eine Rechnung für einen Kunden."""
    return f"Rechnung erstellt für {client}: €{amount}"

@function_tool
def send_reminder(invoice_id: str) -> str:
    """Sendet eine Zahlungserinnerung für eine offene Rechnung."""
    return f"Erinnerung gesendet für Rechnung {invoice_id}"

@function_tool
def generate_hr_report(month: str) -> str:
    """Erstellt einen Personalwesen-Bericht für einen bestimmten Monat."""
    return f"Personalwesen-Bericht erstellt für {month}"

@function_tool
def schedule_interview(candidate: str, date: str) -> str:
    """Plant ein Vorstellungsgespräch mit einem Kandidaten."""
    return f"Gespräch geplant mit {candidate} am {date}"

# Viele weitere Werkzeuge...

agent = Agent(
    name="Enterprise Agent",
    instructions="Sie verwalten die Unternehmensabläufe.",
    tools=[
        create_invoice,
        send_reminder,
        generate_hr_report,
        schedule_interview,
        # ... 50 weitere Werkzeuge
    ],
    tool_use_behavior="auto",  # Das Modell wählt dynamisch aus
)

Muster: Manuelle Werkzeugauswahl

Wenn Sie die vollständige Kontrolle über die Werkzeugauswahl wünschen, implementieren Sie Ihre eigene Logik. Das Prinzip ist einfach: Ein kleiner Router-Agent liest die Anfrage und benennt einfach den relevanten Bereich. Sie bauen dann den spezialisierten Agenten auf der Stelle nur mit den Werkzeugen für diesen Bereich auf. Ein Satz wie “Senden Sie eine Erinnerung für die Rechnung F-2026-114” kommt aus dem Router mit der Antwort accounting, und der Ausführungssagent sieht die Personalwesen-Werkzeuge nie.

from agents import Agent, Runner, function_tool

# Werkzeuge nach Bereich gruppieren
accounting_tools = [create_invoice, send_reminder]
hr_tools = [generate_hr_report, schedule_interview]

# Ein Router-Agent, der den Bereich auswählt
router = Agent(
    name="Router",
    instructions="""Bestimmen Sie den Bereich der Anfrage.
    Antworten Sie nur mit 'accounting' oder 'hr'.""",
    model="gpt-5.6-terra",  # Schnell und günstig für die Routierung
    output_type=str,
)

async def handle_request(message: str):
    # Schritt 1: Den Bereich bestimmen
    route = await Runner.run(router, message)
    domain = route.final_output.strip().lower()

    # Schritt 2: Den spezialisierten Agenten mit den richtigen Werkzeugen erstellen
    if domain == "accounting":
        tools = accounting_tools
        instructions = "Sie verwalten die Buchhaltung des Unternehmens."
    elif domain == "hr":
        tools = hr_tools
        instructions = "Sie verwalten das Personalwesen."
    else:
        tools = accounting_tools + hr_tools
        instructions = "Sie verwalten die Unternehmensabläufe."

    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

Die Verwendung von gpt-5.6-terra sowohl für die Routierung als auch für die Ausführung gehört zur vorherigen Modellgeneration; die Begründung hinter dem Muster bleibt mit der GPT-5.6-Familie identisch, wobei die Einstellungseinstellungen den schnellen Router vom Ausführer unterscheiden.

Muster: Kontextbewusste dynamische Werkzeuge

Die Auswahl hängt nicht nur von der gestellten Frage ab, sondern auch davon, wer fragt. Sie können verfügbare Werkzeuge basierend auf dem angemeldeten Benutzer anpassen und zwei Fliegen mit einer Klappe schlagen: weniger gesendete Token und, noch wichtiger, Zugriffskontrollen, die noch bevor das Modell überhaupt nachdenkt, erzwungen werden. Ein Vertriebsmitarbeiter erhält Angebotswerkzeuge, aber delete_account existiert in seinem Agenten schlichtweg nicht.

from dataclasses import dataclass

@dataclass
class UserContext:
    role: str  # "admin", "manager", "employee"
    department: str

def get_tools_for_role(ctx: UserContext) -> list:
    """Gibt autorisierte Werkzeuge basierend auf der Rolle zurück."""
    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"Sie unterstützen einen {ctx.role} in der {ctx.department}-Abteilung.",
        tools=tools,
        model="gpt-5.6-terra",
    )

Optimierung von Werkzeugbeschreibungen

Welches Auswahlmechanismus Sie auch immer wählen, er stützt sich auf ein einziges Material: den Text Ihrer Beschreibungen. Die Qualität dieser Beschreibungen wirkt sich direkt auf die Relevanz der Auswahl aus. Vergleichen Sie die beiden Deklarationen unten: Die erste sagt nichts über die Nutzungssituation aus, während die zweite die Eingaben, die Ausgabe und den Zeitpunkt der Verwendung benennt.

# Schlecht: vage Beschreibung
@function_tool
def process_data(data: str) -> str:
    """Verarbeitet Daten."""
    return "OK"

# Gut: präzise und kontextualisierte Beschreibung
@function_tool
def calculate_gross_margin(revenue: float, production_cost: float) -> str:
    """Berechnet die Bruttomarge als Prozentsatz aus Umsatz
    und Produktionskosten. Nützlich für die vierteljährliche Finanzanalyse."""
    margin = ((revenue - production_cost) / revenue) * 100
    return f"Bruttomarge: {margin:.1f}% (Umsatz: €{revenue}, Kosten: €{production_cost})"

Eine gute Werkzeugbeschreibung ist wie eine gute Docstring: Sie erklärt, wann das Werkzeug verwendet werden soll, nicht nur, was es tut. Nehmen Sie sich zehn Minuten Zeit, um die Beschreibungen Ihres Agenten zu überprüfen und für jedes zu fragen, ob ein Kollege das richtige Werkzeug auswählen könnte, indem er nur diesen Satz liest. Genau dies ist die Übung, die das Modell durchführt.

Kernaussagen

  • Tool Search wählt dynamisch relevante Werkzeuge für jede Anfrage aus
  • Bei vielen Werkzeugen kann ein Router-Agent den Bereich im Voraus bestimmen
  • Verfügbare Werkzeuge basierend auf der Rolle und dem Kontext des Benutzers anpassen
  • Die Qualität der Werkzeugbeschreibung wirkt sich auf die Auswahlgenauigkeit aus
  • Verwenden Sie ein leichtes Modell für schnelle Routierung und ein leistungsfähiges Modell für die Ausführung