Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Tools und Funktionsaufrufe in der Sprachausgabe

Lektion 5 von 14 Aktualisiert am 29. Juli 2026 Mittelstufe
Auf dieser Seite
  1. Ein Agent, der handelt, nicht nur spricht
  2. Die fünf Arten von Tools
  3. Der vollständige Zyklus eines Funktionsaufrufs
  4. Wenn mehrere Funktionen gleichzeitig ausgeführt werden
  5. Spezifische Einschränkungen für die Sprachausgabe
  6. Kernaussagen

Ein Agent, der handelt, nicht nur spricht

Ein Sprachassistent, der nur chatten kann, stößt schnell an seine Grenzen: Er antwortet höflich auf die Frage „Wo ist meine Bestellung?”, ohne jedoch die geringste Ahnung zu haben. Der wahre Wert des Sprachagents liegt in seiner Fähigkeit, mitten in einem Gespräch Handlungen auszuführen (Datenbankabfrage, Web-Suche, Aufruf einer Business-API, Verbindung zu einem MCP-Server) und das Ergebnis so vorzulesen, als wäre nichts geschehen.

Die fünf Arten von Tools

Die Web-Suche in ihrer einfachsten Form benötigt keine Parameter:

{ "type": "web_search" }

Der Agent führt dann eine Live-Suche im Web durch, was faktische Fragen, Nachrichten und alle Daten abdeckt, die sich zu oft ändern, um in einem Prompt gespeichert zu werden.

Die X-Suche funktioniert auf die gleiche Weise, mit der Option, sie auf bestimmte Konten zu beschränken:

{
  "type": "x_search",
  "allowed_x_handles": ["corsen_ai"]
}

Der Parameter allowed_x_handles ist optional, verändert aber die Funktion des Tools. Ohne ihn sucht der Agent die gesamte Plattform ab; mit ihm wird der Agent zu einem Sprecher, der nur Ihre offiziellen Beiträge zitiert.

Die Dateisuche abfragt Sammlungen von vektorisierten Dokumenten, wie z. B. Ihre Handbücher, Verfahrensanweisungen und Produktdokumentationen:

{
  "type": "file_search",
  "vector_store_ids": ["vs_abc123"],
  "max_num_results": 10
}

Benutzerdefinierte Funktionen öffnen die Tür zu Ihren eigenen Systemen. Dies ist die Art von Tool, die Sie am häufigsten verwenden werden, und sie lohnt es sich, sorgfältig zu deklarieren:

{
  "type": "function",
  "name": "check_order",
  "description": "Überprüft den Status einer Kundenbestellung",
  "parameters": {
    "type": "object",
    "properties": {
      "order_number": {
        "type": "string",
        "description": "Die Bestellnummer im Format CMD-XXXX"
      }
    },
    "required": ["order_number"]
  }
}

Sie können auf dieselbe Weise ein CRM, ein ERP, einen Kalender oder eine interne Datenbank verbinden. Schließlich bieten MCP-Server Zugriff auf standardisierte Tools über das Model Context Protocol, sodass Sie für jeden Dienst keine Integration neu schreiben müssen:

{
  "type": "mcp",
  "server_url": "https://mcp.example.com/sse",
  "server_label": "Mein MCP-Server"
}

Der vollständige Zyklus eines Funktionsaufrufs

Wenn der Agent beschließt, eine Funktion aufzurufen, führt er sie nicht aus: Er bittet Sie darum, und Ihre Anwendung erledigt die Arbeit. Die Argumente strömen zunächst über response.function_call_arguments.delta ein. Das Event response.function_call_arguments.done markiert das Ende der Anfrage und liefert Ihnen die call_id sowie die vollständigen Argumente. Es liegt an Ihnen, die Funktion auszuführen und das Ergebnis als conversation.item.create vom Typ function_call_output zurückzugeben:

{
  "type": "conversation.item.create",
  "item": {
    "type": "function_call_output",
    "call_id": "call_abc123",
    "output": "{\"status\": \"shipped\", \"delivery_date\": \"2026-04-05\"}"
  }
}

Ein letzter Schritt ist essenziell und wird oft vergessen: Senden Sie response.create, damit der Agent das Ergebnis in seine gesprochene Antwort einarbeitet. Ohne dies erreicht das Ergebnis zwar die Konversation, aber es passiert nichts. Der Nutzer hört Stille, und Sie suchen fälschlicherweise nach einem Fehler im Code.

Wenn mehrere Funktionen gleichzeitig ausgeführt werden

Das Modell kann beschließen, zwei oder drei Funktionen gleichzeitig aufzurufen, beispielsweise um eine Bestellung zu prüfen und den Lieferplan nachzuschlagen. Sie erhalten dann mehrere function_call_arguments.done-Events, jedes mit einer eigenen call_id. Führen Sie alle aus, parallel, wenn möglich, damit sich die Latenzen nicht summieren. Geben Sie jedes Ergebnis in seinem eigenen conversation.item.create ein und senden Sie am Ende eine einzige response.create. Eine response.create pro Funktion würde so viele konkurrierende Sprachantworten auslösen, und der Agent würde beginnen, sich selbst zu überstimmen.

// Empfangen und ausführen aller Funktionen
const results = await Promise.all(
  pendingCalls.map(call => executeFunction(call))
);

// Einreichen aller Ergebnisse
for (const result of results) {
  ws.send(JSON.stringify({
    type: "conversation.item.create",
    item: {
      type: "function_call_output",
      call_id: result.callId,
      output: JSON.stringify(result.data)
    }
  }));
}

// Antwort auslösen
ws.send(JSON.stringify({ type: "response.create" }));

Spezifische Einschränkungen für die Sprachausgabe

Was in einer Textoberfläche unbemerkt bleibt, fällt in der Sprache sofort ins Auge, beginnend mit der Zeit. Niemand wartet mitten in einem Gespräch länger als drei bis fünf Sekunden. Darüber hinaus denken Nutzer, die Leitung sei abgehängt, und beginnen zu sprechen. Wenn Ihre Funktion ein langsames System abfragt, sollte der Agent während des Aufrufs eine Wartephase aussprechen, anstatt eine leere Zeit zu lassen.

Die Größe der Ergebnisse ist ebenso wichtig. Der Agent muss das, was Sie ihm geben, laut zusammenfassen, und eine Liste von vierzig Bestellungen führt entweder zu einem endlosen Vortrag oder zu einer groben Zusammenfassung. Geben Sie strukturierte Daten zurück, beschränken Sie sie aber auf das Wesentliche. Achten Sie auch auf die Beschreibung jeder Funktion, da dies die einzige Information ist, auf die sich das Modell verlässt, um zu wählen: Eine vage Beschreibung wie „behandelt Bestellungen” lässt es zögern oder das falsche Tool auswählen. Und planen Sie für Fehlerfälle. Wenn eine Funktion abstürzt, geben Sie eine explizite Fehlermeldung im output zurück, anstatt nichts, sonst wird der Agent eine Antwort improvisieren, ohne zu wissen, dass der Aufruf fehlgeschlagen ist.

Kernaussagen

  • Der Sprachagent unterstützt fünf Arten von Tools: Web-Suche, X-Suche, Dateisuche, Funktionen und MCP
  • Ein Funktionsaufruf durchläuft vier Schritte: Argumente empfangen, Funktion ausführen, Ergebnis zurückgeben und Antwort auslösen
  • Parallele Aufrufe sind möglich: Alles ausführen, alles einreichen, dann eine einzige response.create senden
  • In der Sprachausgabe ist die Reaktionszeit von Funktionen kritisch: Streben Sie eine Zeit von unter 3 Sekunden an