KonfigurierenAgentenverhaltenVerfahren

Strukturierte Prozeduren

Eine feste Abfolge typisierter Schritte, die Ihr Agent jedes Mal gleich ausführt

Überblick

Eine strukturierte Prozedur ist eine Prozedur, die eine feste Abfolge von Schritten ausführt. Eine Freiform-Prozedur bietet natürlichsprachliche Anleitungen, die der Agent interpretiert und an die Situation anpasst. Eine strukturierte Prozedur ist eine geordnete Liste typisierter Schritte, die der Agent bei jeder Anwendung der Prozedur der Reihe nach ausführt.

Verwenden Sie eine strukturierte Prozedur, wenn bestimmte Schritte bei jedem Anruf gleich erfolgen müssen: etwa zur Prüfung der Identität eines Anrufers, zur Eskalation eines Tickets oder zur Entgegennahme einer Zahlung. Sie erstellen sie als kurze Liste einfach formulierter Schritte.

Wie jede Prozedur hat auch eine strukturierte Prozedur einen Trigger, der beschreibt, wann sie gilt. Wenn eine Unterhaltung dem Trigger entspricht, führt der Agent die Schritte der Prozedur der Reihe nach aus und kehrt dann zur restlichen Unterhaltung zurück.

Editor für strukturierte Prozeduren

Wann Sie eine strukturierte Prozedur verwenden sollten

Verwenden Sie eine strukturierte Prozedur, wenn bestimmte Schritte jedes Mal gleich ausgeführt werden müssen, Sie sie aber weiterhin schnell als einfache Schritte erstellen möchten. Einen Vergleich mit Freiform-Prozeduren, Workflows und dem System-Prompt finden Sie unter Wann Sie Prozeduren verwenden sollten.

Aufbau einer strukturierten Prozedur

Eine strukturierte Prozedur besteht aus drei Teilen: einem Namen, einem Trigger und einer geordneten Liste von Schritten.

Name

Eine kurze Bezeichnung, die die Prozedur im Dashboard identifiziert. Der Name wird nie an das LLM gesendet und beeinflusst daher nicht das Verhalten des Agenten.

Trigger

Eine einfach formulierte Beschreibung, wann der Agent diese Prozedur ausführen soll, beispielsweise Wenn der Nutzer eine Rückerstattung für eine Bestellung anfordert. Der Agent vergleicht die Absicht des Nutzers mit dem Trigger jeder Prozedur und führt die passende aus. Trigger sollten daher konkret und eindeutig sein. Ein Trigger funktioniert wie bei jeder Prozedur. Siehe Trigger schreiben.

Schritte

Der Prozedurtext ist eine geordnete Liste typisierter Schritte. Es gibt mehrere Schritttypen, die Sie zur Beschreibung der Aufgabe kombinieren.

SchrittFunktion
FragenFordert Informationen vom Nutzer an und wartet auf eine passende Antwort.
MitteilenLässt den Agenten anhand einer Anweisung eine Nachricht in eigenen Worten erstellen.
SagenLässt den Agenten eine exakte Nachricht Wort für Wort sprechen.
ToolRuft ein bestimmtes Tool oder eine API auf.
WennWählt den ersten passenden if/else-if-Zweig oder einen optionalen else-Zweig aus.
UnterprozedurFührt eine weitere strukturierte Prozedur aus und kehrt dann zum nächsten Schritt zurück.
System-ToolFührt eine integrierte Systemaktion aus. Derzeit wird nur das Beenden des Anrufs unterstützt.
WiederholenFührt einen fehlgeschlagenen Tool-Aufruf erneut aus. Nur innerhalb der Fehlerbehandlung verfügbar.

Menü für Schritttypen strukturierter Prozeduren

API-Schrittreferenz

Der content einer strukturierten Prozedur ist ein JSON-codiertes Dokument mit einem steps-Array. Jeder Schritt ist ein Objekt, das durch seinen type identifiziert wird.

Fragen

Ein Ask-Schritt weist den Agenten an, Informationen anzufordern und zu warten, bis der Nutzer eine passende Antwort gibt.

  • API-Typ: ask
  • instruction: Erforderlicher, nicht leerer String.
{
  "type": "ask",
  "instruction": "Ask the user for their order ID."
}

Mitteilen

Ein Tell-Schritt weist den Agenten an, eine einzelne Nachricht in eigenen Worten zu erstellen. Anders als bei Ask wartet er nicht auf eine Nutzerantwort, bevor er fortfährt.

  • API-Typ: tell
  • instruction: Erforderlicher, nicht leerer String.
{
  "type": "tell",
  "instruction": "Explain that the refund normally takes five to ten business days."
}

Sagen

Ein Say-Schritt spricht den bereitgestellten Text exakt wie geschrieben.

  • API-Typ: say
  • message: Erforderlicher, nicht leerer String.
{
  "type": "say",
  "message": "Your refund has been submitted."
}

If, else if und else

Ein If-Schritt enthält einen oder mehrere geordnete bedingte Zweige. Der erste passende Zweig wird ausgeführt. Das optionale fallback-Array dient als else-Zweig.

  • API-Typ: branch
  • branches: Erforderliche, nicht leere Liste bedingter Zweige.
  • fallback: Optionale Liste von else-Schritten.
  • Jeder Zweig erfordert eine condition und eine nicht leere steps-Liste.
{
  "type": "branch",
  "branches": [
    {
      "condition": {
        "type": "llm",
        "condition": "The user is on an annual plan."
      },
      "steps": [
        {
          "type": "say",
          "message": "Your annual plan is eligible for a prorated refund."
        }
      ]
    }
  ],
  "fallback": [
    {
      "type": "tell",
      "instruction": "Explain that the account's plan could not be determined."
    }
  ]
}

Dies verhält sich wie if/else-if/else:

  1. Bedingungen werden der Reihe nach ausgewertet.
  2. Der erste passende Zweig wird ausgeführt.
  3. Wenn keine Bedingung zutrifft, wird fallback ausgeführt.
  4. Nach Abschluss eines Zweigs kehrt die Prozedur zur Hauptsequenz zurück.

Das obige Beispiel verwendet eine natürlichsprachliche Bedingung. Bedingungen können auch Workflow-Ausdrücke verwenden:

{
  "type": "expression",
  "expression": {
    "type": "eq_operator",
    "left": {
      "type": "dynamic_variable",
      "name": "plan_tier"
    },
    "right": {
      "type": "string_literal",
      "value": "annual"
    }
  }
}

Alle Zweige in einem If-Schritt müssen denselben Bedingungstyp verwenden: entweder llm oder expression.

Ein If-Schritt kann der erste Prozedurschritt sein. Allerdings gilt:

  • If-Schritte können nicht verschachtelt werden.
  • Zwei If-Schritte können nicht direkt aufeinanderfolgen.
  • Auf einen Ask-Schritt kann nicht direkt eine Ausdrucksbedingung folgen. Verwenden Sie eine LLM-Bedingung, um die Freitextantwort eines Nutzers auszuwerten.

Tool

Ein Tool-Schritt ruft ein bestimmtes Tool auf.

  • API-Typ: tool_call
  • tool_id: Erforderliche, nicht leere Tool-ID.
  • tool_name: Erforderlicher Tool-Name.
  • instruction: Optionale Anweisung, die beschreibt, wie das Tool aufgerufen wird.
  • on_failure: Optionaler Fehlerbehandler.
{
  "type": "tool_call",
  "tool_id": "tool_abc123",
  "tool_name": "lookup_order",
  "instruction": "Look up the order using the order ID provided by the user."
}

Ohne on_failure beendet ein fehlgeschlagener Tool-Aufruf die Prozedur. Fügen Sie on_failure hinzu, um bestimmte Fehler zu behandeln, das Tool erneut auszuführen oder mit Ausweichschritten fortzufahren.

  • branches: Optionale Liste geordneter Bedingungen. Der erste passende Zweig wird ausgeführt.
  • fallback: Erforderliche, nicht leere Liste von Schritten. Sie wird ausgeführt, wenn kein Zweig zutrifft.
{
  "type": "tool_call",
  "tool_id": "tool_abc123",
  "tool_name": "lookup_order",
  "on_failure": {
    "fallback": [
      {
        "type": "tell",
        "instruction": "Explain that the order could not be retrieved and offer to connect the user with support."
      }
    ]
  }
}

Zweige des Fehlerbehandlers können Ask-, Tell-, Say-, Unterprozedur-, System-Tool- und Wiederholen-Schritte enthalten. Sie können keine Tool- oder If-Schritte enthalten. Alle bedingten Zweige eines Fehlerbehandlers müssen denselben Bedingungstyp verwenden.

Wiederholen

Ein Wiederholen-Schritt führt den Tool-Schritt erneut aus, dessen Fehlerbehandler ihn enthält.

  • API-Typ: retry
  • max_retries: Optionale Ganzzahl von 1 bis 3. Standardwert ist 1.
  • Der Wert zählt erneute Versuche nach dem ursprünglichen Tool-Aufruf.
  • Wiederholen ist nur innerhalb von on_failure gültig.
  • Wiederholen muss der letzte Schritt in seinem Fehlerbehandler-Zweig sein, da nachfolgende Schritte nicht erreichbar wären.
  • Wenn alle Versuche fehlschlagen, wird die Prozedur beendet.
{
  "type": "retry",
  "max_retries": 2
}

Unterprozedur

Ein Unterprozedur-Schritt führt eine weitere strukturierte Prozedur aus. Nach ihrem Abschluss kehrt die Ausführung zum Schritt nach dem Unterprozedur-Schritt zurück.

  • API-Typ: sub_procedure
  • procedure_id: Erforderliche, nicht leere Prozedur-ID.
  • Das Ziel muss auf demselben Agenten vorhanden sein.
  • Das Ziel muss eine strukturierte Prozedur sein.
  • Eine Prozedur kann sich nicht selbst aufrufen.
{
  "type": "sub_procedure",
  "procedure_id": "agtprc_6qbpwdq8n01bxhk44bgjy6f10ck3"
}

System-Tool

Ein System-Tool-Schritt führt eine integrierte Systemaktion aus.

  • API-Typ: system_tool
  • system_tool_name: Erforderlicher System-Tool-Name.
  • Derzeit wird nur end_call unterstützt. Weitere System-Tools können später hinzugefügt werden.
  • Da end_call final ist, muss es der letzte Schritt in seiner enthaltenden Sequenz oder seinem Zweig sein.
{
  "type": "system_tool",
  "system_tool_name": "end_call"
}

Vollständiges API-Beispiel

Dieses Beispiel verarbeitet eine Bestellstornierung anhand des Versandstatus. Es wiederholt einen fehlgeschlagenen Tool-Aufruf, ruft eine weitere strukturierte Prozedur auf und beendet dann den Anruf.

{
  "trigger": "When the user asks to cancel an order and request a refund.",
  "steps": [
    {
      "type": "ask",
      "instruction": "Ask the user for their order ID."
    },
    {
      "type": "branch",
      "branches": [
        {
          "condition": {
            "type": "llm",
            "condition": "The user says the order has already shipped."
          },
          "steps": [
            {
              "type": "tell",
              "instruction": "Explain that shipped orders must be returned before they can be refunded."
            }
          ]
        },
        {
          "condition": {
            "type": "llm",
            "condition": "The user says the order has not shipped."
          },
          "steps": [
            {
              "type": "tool_call",
              "tool_id": "tool_abc123",
              "tool_name": "cancel_order",
              "instruction": "Cancel the order using the order ID provided by the user.",
              "on_failure": {
                "fallback": [
                  {
                    "type": "retry",
                    "max_retries": 2
                  }
                ]
              }
            }
          ]
        }
      ],
      "fallback": [
        {
          "type": "ask",
          "instruction": "Ask whether the order has already shipped."
        }
      ]
    },
    {
      "type": "sub_procedure",
      "procedure_id": "agtprc_6qbpwdq8n01bxhk44bgjy6f10ck3"
    },
    {
      "type": "say",
      "message": "Thank you for contacting us. Goodbye."
    },
    {
      "type": "system_tool",
      "system_tool_name": "end_call"
    }
  ]
}

Ausführung einer strukturierten Prozedur

Wenn die Anfrage eines Nutzers während einer Unterhaltung dem Trigger einer Prozedur entspricht, tritt der Agent in die Prozedur ein und führt ihre Schritte der Reihe nach aus – jedes Mal auf dieselbe Weise. Innerhalb der Prozedur konzentriert sich der Agent auf diese Schritte. Wenn er das Ende erreicht, kehrt er zu der Stelle in der Unterhaltung zurück, an der er aufgehört hat.

Wenn ein Tool-Schritt fehlschlägt und kein on_failure definiert ist, wird die Prozedur beendet, ohne die verbleibenden Schritte auszuführen. Wenn on_failure konfiguriert ist, führt die Prozedur den ersten passenden Fehlerzweig oder dessen erforderlichen Fallback aus. Nach einem behandelten Fehler wird mit dem nächsten Prozedurschritt fortgefahren, sofern der ausgewählte Behandler das Tool nicht erneut ausführt, den Anruf beendet oder einen anderen finalen Pfad aufruft.

Strukturierte Prozedur verwalten

Öffnen Sie Ihren Agenten im Dashboard und wählen Sie Prozeduren. Verwenden Sie +, um eine strukturierte Prozedur zu erstellen. Fügen Sie einen Auslöser hinzu, wählen Sie für jeden Schritt einen Typ aus und veröffentlichen Sie die Änderungen am Agenten.

Best Practices

Jeder Schritttyp erzwingt bereits sein eigenes Verhalten, daher müssen Sie es selten ausdrücklich festlegen. Beschreiben Sie die Absicht jedes Schritts und überlassen Sie den Rest dem Schritttyp. Die folgenden Hinweise behandeln die Fälle, bei denen es wichtig ist, sie richtig umzusetzen.

Schritte formulieren

Ein Ask-Schritt wird erst fortgesetzt, nachdem er Ihre Frage gestellt und eine passende Antwort erhalten hat. Sie benötigen keinen Folgeschritt, um zu prüfen, ob die Informationen erfasst wurden. Der Ask- Schritt garantiert dies, bevor er fortfährt.

Ein Tool-Schritt führt nur das Tool aus. Der Agent kann währenddessen weder sprechen noch eine Entscheidung treffen. Um mit dem Nutzer zu sprechen oder basierend auf der Tool-Rückgabe zu verzweigen, verwenden Sie dafür einen separaten Schritt vor oder nach dem Tool-Schritt.

Verwenden Sie einen Tell-Schritt, wenn der Agent die Nachricht selbst formulieren soll, und einen Say-Schritt, wenn der Wortlaut exakt sein muss. Beide senden genau eine Nachricht, daher müssen Sie einem Schritt nicht mitteilen, dass er nur eine Nachricht senden soll.

Prozeduren zusammenstellen

Die allgemeinen Hinweise zum Zusammenstellen von Prozeduren gelten auch für strukturierte Prozeduren. Siehe dazu Prozeduren zusammenstellen auf der Seite zu Freiform-Prozeduren.

Ein Muster gilt speziell für die Kombination von Typen: Eine Freiform-Prozedur kann auf eine strukturierte Prozedur verweisen. Behalten Sie die offene Bearbeitung in einer Freiform-Prozedur bei und delegieren Sie Teile, die jedes Mal gleich ausgeführt werden müssen, etwa die Identitätsprüfung oder Eskalation, an eine strukturierte Prozedur.

Einschränkungen

  • If-Schritte können nicht verschachtelt werden, und zwei If-Schritte können nicht direkt hintereinander platziert werden.

Unterstützung durch Modellanbieter

Strukturierte Prozeduren erzwingen interne Tool-Aufrufe beim Eintritt in eine Unterprozedur und beim Abschluss einer Prozedur. Die wichtigsten Modellfamilien von OpenAI, Anthropic, Gemini und Grok unterstützen die erzwungene Tool-Auswahl. Andere Modelle oder benutzerdefinierte Anbieter garantieren dies möglicherweise nicht, wodurch Übergänge zu Unterprozeduren oder der Abschluss von Prozeduren weniger zuverlässig sein können. Prüfen Sie die Unterstützung der erzwungenen Tool-Auswahl, wenn Sie einen anderen Modellanbieter verwenden.

Unter Prozeduren finden Sie Einschränkungen, die für alle Prozeduren gelten, einschließlich der Größenbegrenzung für Inhalte und der Unterschiede zwischen strukturierten und Freiform-Prozeduren.