Werkzeugsuche: Dynamische Werkzeuge

Lektion aktualisiert am 2. November 2026 basierend auf der OpenAI-Dokumentation: Das Code-Interpreter-Werkzeug erfordert nun einen container-Parameter (in allen Beispielen hinzugefügt), Eingabetexte werden als input_text übergeben, und die Websuche verwendet das web_search-Werkzeug (web_search_preview ist nun ein veraltetes Werkzeug ohne Domänenfilter). Generierte Dateien werden über die Funktionen fichiers_generes und telecharger aus Lektion 10 abgerufen. Quellen: Code Interpreter · Websuche.

Wenn Sie Dutzende oder Hunderte von Funktionen haben, wird deren Deklaration in jedem Aufruf kontraproduktiv: Das Modell verliert an Präzision und die Kosten explodieren. Die Werkzeugsuche löst dieses Problem, indem sie dem Modell ermöglicht, das richtige Werkzeug in einem indizierten Katalog nachzuschlagen.

Das Problem mit großen Werkzeugkatalogen

Die Kosten eines großen Werkzeugkatalogs sind auf zwei Arten unsichtbar. Erstens finanziell: Jede Funktionsdefinition wird mit jeder Anfrage gesendet, einschließlich der neunundneunzig, die nicht verwendet werden. Im großen Maßstab übersteigt dies schließlich die Kosten der Antworten selbst. Zweitens, und noch ernster, qualitativ: Jenseits weniger Dutzend Werkzeuge mit überlappenden Bereichen treffen Modelle schlechtere Entscheidungen. Zu viele Optionen verschlechtern die Entscheidungsfindung, hier wie überall.

# 5 Funktionen = ~500 Kontext-Token
# 50 Funktionen = ~5000 Kontext-Token
# 200 Funktionen = ineffizient zu verwalten

# Das Modell verliert an Präzision, wenn zu viele Funktionen vorhanden sind
# Es wählt manchmal die falsche Funktion aus oder halluziniert Parameter

Werkzeugsuche aktivieren

Die Werkzeugsuche kehrt die Logik um: Anstatt dem Modell alles vorzustellen, indizieren Sie den Katalog und zeigen ihm nur das, was der aktuellen Anfrage entspricht. Der Mechanismus beruht auf der semantischen Suche über Beschreibungen – weshalb der nächste Abschnitt nicht nur stilistische Ratschläge ist, sondern eine Voraussetzung für die Funktionsfähigkeit des Systems.

from openai import OpenAI

client = OpenAI()

# Deklaration einer großen Anzahl von Funktionen
all_functions = [
    {
        "type": "function",
        "name": "create_invoice",
        "description": "Erstellen Sie eine neue Rechnung für einen Kunden",
        "parameters": {"type": "object", "properties": {"client_id": {"type": "string"}}, "required": ["client_id"]}
    },
    {
        "type": "function",
        "name": "cancel_invoice",
        "description": "Stornieren Sie eine bestehende Rechnung",
        "parameters": {"type": "object", "properties": {"invoice_id": {"type": "string"}}, "required": ["invoice_id"]}
    },
    # ... Dutzende weitere Funktionen
]

# Verwenden Sie die Werkzeugsuche, damit das Modell die richtige Funktion findet
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Stornieren Sie die Rechnung FAC-2026-0042",
    tools=[{
        "type": "tool_search",
        "tool_search": {
            "tools": all_functions
        }
    }]
)

Das Modell erhält nur die für die Anfrage relevanten Funktionen in seinem Kontext, nicht den gesamten Katalog.

Strukturierung des Funktionskatalogs

Zwei Prinzipien reichen aus, um einen Katalog zu strukturieren, der weiterhin navigierbar bleibt. Benennen Sie Funktionen nach Domänen vor (crm_, billing_, inventory_): Die Auswertung der Ausführungsspur wird sofort ersichtlich, und Namenskollisionen verschwinden. Und geben Sie jeder Funktion einen klaren Bereich – zwei Funktionen, deren Beschreibungen sich überschneiden, führen zu instabilen Entscheidungen, ob ein Mensch oder ein Vektor-Engine den Aufruf tätigt.

crm_catalog = [
    {
        "type": "function",
        "name": "crm_search_customer",
        "description": "Suchen Sie nach einem Kunden im CRM nach Name, E-Mail oder ID. "
                       "Verwenden Sie dies, um Informationen über einen bestehenden Kunden zu finden.",
        "parameters": {
            "type": "object",
            "properties": {
                "term": {"type": "string", "description": "Suchbegriff"},
                "field": {"type": "string", "enum": ["name", "email", "id"]}
            },
            "required": ["term"],
            "additionalProperties": False
        },
        "strict": True
    },
    {
        "type": "function",
        "name": "crm_create_customer",
        "description": "Erstellen Sie einen neuen Kunden im CRM. "
                       "Verwenden Sie dies, wenn ein Kunde noch nicht existiert.",
        "parameters": {
            "type": "object",
            "properties": {
                "name": {"type": "string"},
                "email": {"type": "string"},
                "company": {"type": "string"}
            },
            "required": ["name", "email", "company"],
            "additionalProperties": False
        },
        "strict": True
    }
]

billing_catalog = [
    {
        "type": "function",
        "name": "bill_create_invoice",
        "description": "Erstellen Sie eine Rechnung. Erfordert einen bestehenden Kunden.",
        "parameters": {
            "type": "object",
            "properties": {
                "client_id": {"type": "string"},
                "lines": {"type": "array", "items": {"type": "object", "properties": {
                    "description": {"type": "string"},
                    "amount": {"type": "number"}
                }}}
            },
            "required": ["client_id", "lines"],
            "additionalProperties": False
        },
        "strict": True
    }
]

# Alle Kataloge zusammenführen
full_catalog = crm_catalog + billing_catalog

Best Practices für Beschreibungen

Schreiben Sie Beschreibungen für die Suche, nicht für die Dokumentation. „Rufen Sie Kundendaten ab” wird niemals durch eine Abfrage zu „Bestellhistorie” oder „Rechnungs-Kontaktinformationen” gefunden: Die Wörter, die Ihre Benutzer tatsächlich eingeben, müssen im indizierten Text erscheinen. Eine nützliche Beschreibung nennt Anwendungsfälle und Geschäftsvokabular, nicht Implementierungsdetails.

# Schlecht: zu allgemein
{"name": "get_data", "description": "Daten abrufen"}

# Gut: spezifisch mit Nutzungskontext
{
    "name": "hr_check_leave_balance",
    "description": "Prüfen Sie den Urlaubssaldo eines Mitarbeiters (Urlaub, Freizeit, Krankheitsurlaub). "
                   "Gibt verbleibende Tage pro Urlaubstyp zurück. "
                   "Verwenden Sie dies, wenn ein Mitarbeiter fragt, wie viele Tage ihm noch verbleiben."
}

# Gut: mit Synonymen zur Verbesserung der Suche
{
    "name": "acct_reconcile_bank",
    "description": "Bankabstimmung: Vergleichen Sie Buchungsbelege "
                   "mit Banktransaktionen. Kontenabstimmung. "
                   "Verwenden Sie dies, um die Konsistenz zwischen Buchungsunterlagen "
                   "und Bankauszügen zu überprüfen."
}

Kombination von Werkzeugsuche mit festen Werkzeugen

Die Mischung ist der Standardbetriebsmodus in der Produktion. Ein paar querschnittliche Werkzeuge – Zeit, aktueller Benutzer, Dokumentensuche – bleiben dauerhaft deklariert, da sie fast jeder Anfrage dienen, während der Geschäftskatalog dynamisch bleibt. Dies hält den Kontext leicht, ohne dass das Modell jedes Mal nach dem suchen muss, was es benötigt.

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Suchen Sie im Web nach den Verkäufen dieses Monats und erstellen Sie die entsprechende Rechnung",
    tools=[
        # Immer verfügbare Werkzeuge
        {"type": "web_search"},
        {"type": "code_interpreter", "container": {"type": "auto"}},
        # Dynamischer Katalog
        {
            "type": "tool_search",
            "tool_search": {
                "tools": full_catalog  # 200+ Funktionen
            }
        }
    ]
)

Muster: Mehrdomänensystem

class MultiDomainSystem:
    def __init__(self):
        self.client = OpenAI()
        self.catalogs = {}

    def register_domain(self, name: str, functions: list[dict]):
        """Registrieren Sie einen Funktionskatalog für eine Domäne."""
        self.catalogs[name] = functions

    def full_catalog(self) -> list[dict]:
        """Führen Sie alle Kataloge zusammen."""
        result = []
        for functions in self.catalogs.values():
            result.extend(functions)
        return result

    def execute(self, query: str) -> str:
        """Führen Sie eine Abfrage mit Werkzeugsuche über alle Domänen aus."""
        response = self.client.responses.create(
            model="gpt-5.6-terra",
            input=query,
            tools=[{
                "type": "tool_search",
                "tool_search": {
                    "tools": self.full_catalog()
                }
            }]
        )

        # Verarbeiten Sie Funktionsaufrufe
        for item in response.output:
            if item.type == "function_call":
                result = self.dispatcher(item.name, item.arguments)
                # ... Funktionsaufruf-Loop

        return response.output_text

    def dispatcher(self, name: str, arguments: str):
        """Leiten Sie den Aufruf an den richtigen Dienst weiter."""
        # Ihre Routing-Logik
        pass

# Nutzung
system = MultiDomainSystem()
system.register_domain("crm", crm_catalog)
system.register_domain("billing", billing_catalog)
system.register_domain("hr", hr_catalog)
system.register_domain("support", support_catalog)

# Das Modell findet automatisch die richtige Funktion
# unter Hunderten von Möglichkeiten
result = system.execute("Wie viele Urlaubstage hat Marie Dupont noch?")

Kernaussagen

Die Werkzeugsuche löst das Problem großer Funktionskataloge.
Das Modell erhält nur relevante Funktionen in seinem Kontext.
Reichhaltige, spezifische Beschreibungen sind für die Präzision unerlässlich.
Benennen Sie Funktionsnamen nach Domänen für bessere Lesbarkeit.
Kombinieren Sie die Werkzeugsuche mit immer verfügbaren integrierten Werkzeugen.