Claude ist in der Lage, mit externen clientseitigen Werkzeugen und Funktionen zu interagieren, sodass Sie Claude mit Ihren eigenen benutzerdefinierten Werkzeugen ausstatten können, um eine breitere Palette von Aufgaben zu erledigen.

Öffentliche Beta-Version der Werkzeugnutzung

Wir freuen uns, ankündigen zu können, dass die Werkzeugnutzung jetzt in der öffentlichen Beta-Phase ist! Um auf diese Funktion zuzugreifen, müssen Sie den Header anthropic-beta: tools-2024-05-16 in Ihre API-Anfragen aufnehmen.

Streaming, Erzwingen der Werkzeugnutzung und Bilder werden jetzt unterstützt! Weitere Informationen finden Sie in der Beta-Versionshistorie.

Wir werden diese offene Beta in den kommenden Wochen weiterentwickeln und freuen uns über Ihr Feedback. Bitte teilen Sie uns Ihre Ideen und Vorschläge über dieses Formular mit.

Hier ist ein Beispiel, wie man Claude über die Messages API Werkzeuge zur Verfügung stellt:

curl https://api.anthropic.com/v1/messages \
  -H "content-type: application/json" \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: tools-2024-05-16" \
  -d '{
    "model": "claude-3-opus-20240229",
    "max_tokens": 1024,
    "tools": [
      {
        "name": "get_weather",
        "description": "Ruft das aktuelle Wetter für einen bestimmten Ort ab",
        "input_schema": {
          "type": "object",
          "properties": {
            "location": {
              "type": "string",
              "description": "Die Stadt und das Bundesland, z.B. San Francisco, CA"
            }
          },
          "required": ["location"]
        }
      }
    ],
    "messages": [
      {
        "role": "user",
        "content": "Wie ist das Wetter in San Francisco?"
      }
    ]
  }'

Bitte beachten Sie, dass während der Beta-Phase:

  • Obwohl die Funktion produktionsreif ist, können wir vor der endgültigen Freigabe mehrere Beta-Versionen einführen.
  • Die Werkzeugnutzung ist noch nicht auf Plattformen von Drittanbietern wie Vertex AI oder AWS Bedrock verfügbar, wird aber bald kommen. Siehe Legacy-Werkzeugnutzung für Anleitungen, wie Sie die Werkzeugnutzung auf Vertex AI und AWS Bedrock jetzt durchführen können.

Wie die Werkzeugnutzung funktioniert

Die Verwendung von Werkzeugen mit Claude umfasst die folgenden Schritte:

  1. Stellen Sie Claude Werkzeuge und eine Benutzeraufforderung zur Verfügung: (API-Anfrage)
    • Definieren Sie die Werkzeuge, auf die Claude zugreifen soll, einschließlich ihrer Namen, Beschreibungen und Eingabeschemata.
    • Geben Sie eine Benutzeraufforderung an, die möglicherweise die Verwendung eines oder mehrerer dieser Werkzeuge erfordert, um zu antworten, z.B. “Wie ist das Wetter in San Francisco?“.
  2. Claude verwendet ein Werkzeug: (API-Antwort)
    • Claude bewertet die Benutzeraufforderung und entscheidet, ob eines der verfügbaren Werkzeuge bei der Anfrage oder Aufgabe des Benutzers hilfreich wäre. Wenn ja, entscheidet es auch, welche(s) Werkzeug(e) mit welchen Eingaben verwendet werden soll(en).
    • Claude erstellt eine ordnungsgemäß formatierte Werkzeugnutzungsanfrage.
    • Die API-Antwort hat einen stop_reason von tool_use, was darauf hinweist, dass Claude ein externes Werkzeug verwenden möchte.
  3. Extrahieren Sie die Werkzeugeingabe, führen Sie den Code aus und geben Sie die Ergebnisse zurück: (API-Anfrage)
    • Auf der Client-Seite sollten Sie den Werkzeugnamen und die Eingabe aus Claudes Werkzeugnutzungsanfrage extrahieren.
    • Führen Sie den eigentlichen Werkzeugcode auf der Client-Seite aus.
    • Geben Sie die Ergebnisse an Claude zurück, indem Sie die Konversation mit einer neuen user-Nachricht fortsetzen, die einen tool_result-Inhaltsblock enthält.
  4. Claude verwendet das Werkzeugergebnis, um eine Antwort zu formulieren: (API-Antwort)
    • Nach Erhalt der Werkzeugergebnisse verwendet Claude diese Informationen, um seine endgültige Antwort auf die ursprüngliche Benutzeraufforderung zu formulieren.

Die Schritte (3) und (4) sind optional - für einige Arbeitsabläufe ist die Verwendung des Werkzeugs durch Claude die einzige Information, die Sie benötigen, und Sie müssen möglicherweise keine Werkzeugergebnisse an Claude zurückgeben.

Alle Werkzeuge werden vom Benutzer bereitgestellt

Es ist wichtig zu beachten, dass Claude keinen Zugriff auf integrierte serverseitige Werkzeuge hat. Alle Werkzeuge müssen von Ihnen, dem Benutzer, in jeder API-Anfrage explizit angegeben werden. Dies gibt Ihnen die volle Kontrolle und Flexibilität über die Werkzeuge, die Claude verwenden kann.


Angeben von Werkzeugen

Werkzeuge werden im Parameter tools auf der obersten Ebene der API-Anfrage angegeben. Jede Werkzeugdefinition enthält:

  • name: Der Name des Werkzeugs. Muss dem regulären Ausdruck ^[a-zA-Z0-9_-]{1,64}$ entsprechen.
  • description: Eine detaillierte Klartext-Beschreibung der Funktionsweise des Werkzeugs, wann es verwendet werden sollte und wie es sich verhält.
  • input_schema: Ein JSON-Schema-Objekt, das die erwarteten Parameter für das Werkzeug definiert.

Hier ist ein Beispiel für eine einfache Werkzeugdefinition:

JSON
{
  "name": "get_weather",
  "description": "Ruft das aktuelle Wetter für einen bestimmten Ort ab",
  "input_schema": {
    "type": "object",
    "properties": {
      "location": {
        "type": "string",
        "description": "Die Stadt und das Bundesland, z.B. San Francisco, CA"
      },
      "unit": {
        "type": "string",
        "enum": ["celsius", "fahrenheit"],
        "description": "Die Temperatureinheit, entweder 'celsius' oder 'fahrenheit'"
      }
    },
    "required": ["location"]
  }
}

Dieses Werkzeug mit dem Namen get_weather erwartet ein Eingabeobjekt mit einem erforderlichen location-String und einem optionalen unit-String, der entweder “celsius” oder “fahrenheit” sein muss.

Bewährte Methoden für Werkzeugdefinitionen

Um die beste Leistung von Claude bei der Verwendung von Werkzeugen zu erzielen, befolgen Sie diese Richtlinien:

  • Geben Sie extrem detaillierte Beschreibungen an. Dies ist mit Abstand der wichtigste Faktor für die Leistung des Werkzeugs. Ihre Beschreibungen sollten jedes Detail über das Werkzeug erklären, einschließlich:
    • Was das Werkzeug tut
    • Wann es verwendet werden sollte (und wann nicht)
    • Was jeder Parameter bedeutet und wie er das Verhalten des Werkzeugs beeinflusst
    • Alle wichtigen Vorbehalte oder Einschränkungen, z.B. welche Informationen das Werkzeug nicht zurückgibt, wenn der Werkzeugname unklar ist
      Je mehr Kontext Sie Claude über Ihre Werkzeuge geben können, desto besser kann es entscheiden, wann und wie es sie verwendet. Streben Sie mindestens 3-4 Sätze pro Werkzeugbeschreibung an, mehr, wenn das Werkzeug komplex ist.
  • Priorisieren Sie Beschreibungen gegenüber Beispielen. Obwohl Sie Beispiele für die Verwendung eines Werkzeugs in seiner Beschreibung oder in der begleitenden Aufforderung angeben können, ist dies weniger wichtig als eine klare und umfassende Erklärung des Zwecks und der Parameter des Werkzeugs. Fügen Sie Beispiele erst hinzu, nachdem Sie die Beschreibung vollständig ausgearbeitet haben.

Hier ist ein Beispiel für eine gute Werkzeugbeschreibung:

JSON
{
  "name": "get_stock_price",
  "description": "Ruft den aktuellen Aktienkurs für ein bestimmtes Tickersymbol ab. Das Tickersymbol muss ein gültiges Symbol für ein börsennotiertes Unternehmen an einer großen US-Börse wie NYSE oder NASDAQ sein. Das Werkzeug gibt den letzten Handelspreis in USD zurück. Es sollte verwendet werden, wenn der Benutzer nach dem aktuellen oder jüngsten Preis einer bestimmten Aktie fragt. Es liefert keine weiteren Informationen über die Aktie oder das Unternehmen.",
  "input_schema": {
    "type": "object",
    "properties": {
      "ticker": {
        "type": "string",
        "description": "Das Aktientickersymbol, z.B. AAPL für Apple Inc."
      }
    },
    "required": ["ticker"]
  }
}

Im Gegensatz dazu ist hier ein Beispiel für eine schlechte Werkzeugbeschreibung:

JSON
{
  "name": "get_stock_price",
  "description": "Ruft den Aktienkurs für ein Tickersymbol ab.",
  "input_schema": {
    "type": "object",
    "properties": {
      "ticker": {
        "type": "string"
      }
    },
    "required": ["ticker"]
  }
}

Die gute Beschreibung erklärt deutlich, was das Werkzeug tut, wann es verwendet werden soll, welche Daten es zurückgibt und was der Parameter ticker bedeutet. Die schlechte Beschreibung ist zu kurz und lässt Claude mit vielen offenen Fragen über das Verhalten und die Verwendung des Werkzeugs zurück.


Werkzeugnutzung und Werkzeugergebnis-Inhaltsblöcke

Wenn Claude sich entscheidet, eines der von Ihnen bereitgestellten Werkzeuge zu verwenden, gibt es eine Antwort mit einem stop_reason von tool_use und einem oder mehreren tool_use-Inhaltsblöcken in der API-Antwort zurück, die Folgendes enthalten:

  • id: Eine eindeutige Kennung für diesen speziellen Werkzeugnutzungsblock. Diese wird später verwendet, um die Werkzeugergebnisse zuzuordnen.
  • name: Der Name des verwendeten Werkzeugs.
  • input: Ein Objekt, das die an das Werkzeug übergebene Eingabe enthält und dem input_schema des Werkzeugs entspricht.

Hier ist ein Beispiel für eine API-Antwort mit einem tool_use-Inhaltsblock:

JSON
{
  "id": "msg_01Aq9w938a90dw8q",
  "model": "claude-3-opus-20240229",
  "stop_reason": "tool_use",
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "<thinking>Ich muss get_weather verwenden, und der Benutzer möchte SF, was wahrscheinlich San Francisco, CA ist.</thinking>"
    },
    {
      "type": "tool_use",
      "id": "toolu_01A09q90qw90lq917835lq9",
      "name": "get_weather",
      "input": {"location": "San Francisco, CA", "unit": "celsius"}
    }
  ]
}

Wenn Sie eine Werkzeugnutzungsantwort erhalten, sollten Sie:

  1. Extrahieren Sie name, id und input aus dem tool_use-Block.
  2. Führen Sie das tatsächliche Werkzeug in Ihrem Codebase aus, das diesem Werkzeugnamen entspricht, und übergeben Sie die Werkzeug-input.
  3. [optional] Setzen Sie die Konversation fort, indem Sie eine neue Nachricht mit der role user und einem content-Block senden, der den tool_result-Typ und die folgenden Informationen enthält:
    • tool_use_id: Die id der Werkzeugnutzungsanfrage, für die dies ein Ergebnis ist.
    • content: Das Ergebnis des Werkzeugs als String (z.B. "content": "15 Grad") oder als Liste von verschachtelten Inhaltsblöcken (z.B. "content": [{"type": "text", "text": "15 Grad"}]). Diese Inhaltsblöcke können die Typen text oder image verwenden.
    • is_error (optional): Auf true setzen, wenn die Werkzeugausführung zu einem Fehler geführt hat.

Hier ist ein Beispiel für die Rückgabe eines erfolgreichen Werkzeugergebnisses:

JSON
{
  "role": "user",
  "content": [
    {
      "type": "tool_result",
      "tool_use_id": "toolu_01A09q90qw90lq917835lq9",
      "content": "15 Grad"
    }
  ]
}

Bilder werden in content ebenfalls unterstützt:

JSON
{
  "role": "user",
  "content": [
    {
      "type": "tool_result",
      "tool_use_id": "toolu_01A09q90qw90lq917835lq9",
      "content": [
        {"type": "text", "text": "15 Grad"},
        {
          "type": "image",
          "source": {
            "type": "base64",
            "media_type": "image/jpeg",
            "data": "/9j/4AAQSkZJRg...",
          }
        }
      ]
    }
  ]
}

Und hier ist ein Beispiel für die Rückgabe eines Fehlerergebnisses:

JSON
{
  "role": "user",
  "content": [
    {
      "type": "tool_result",
      "tool_use_id": "toolu_01A09q90qw90lq917835lq9",
      "content": "ConnectionError: Der Wetterdienst-API ist nicht verfügbar (HTTP 500)",
      "is_error": true
    }
  ]
}

Nach Erhalt des Werkzeugergebnisses verwendet Claude diese Informationen, um eine Antwort auf die ursprüngliche Benutzeraufforderung zu generieren.

Sie können auch ein nicht fehlerhaftes Werkzeugergebnis mit leerem content zurückgeben, was darauf hinweist, dass das Werkzeug erfolgreich ausgeführt wurde, ohne eine Ausgabe zu erzeugen:

JSON
{
  "role": "user",
  "content": [
    {
      "type": "tool_result",
      "tool_use_id": "toolu_01A09q90qw90lq917835lq9",
    }
  ]
}

Unterschiede zu anderen APIs

Möglicherweise kennen Sie andere APIs, die die Werkzeugnutzung getrennt von der primären Ausgabe des Modells zurückgeben oder die eine spezielle tool- oder function-Nachrichten-role verwenden.

Im Gegensatz dazu basieren die Modelle und die API von Anthropic auf alternierenden user- und assistant-Nachrichten, wobei jede Nachricht ein Array von umfangreichen Inhaltsblöcken ist: text, image, tool_use und tool_result.

In diesem Format repräsentieren user-Nachrichten clientseitige und von Benutzern/Menschen verwaltete Inhalte, während assistant-Nachrichten serverseitige und von der KI verwaltete Inhalte darstellen. Daher gibt es keine spezielle tool- oder function-Nachrichten-role, und Sie sollten tool_result-Blöcke im content Ihrer user-Nachrichten einschließen.


Erzwingen der Werkzeugnutzung

In einigen Fällen möchten Sie vielleicht, dass Claude ein bestimmtes Werkzeug verwendet, um die Frage des Benutzers zu beantworten, auch wenn Claude der Meinung ist, dass es eine Antwort ohne Verwendung eines Werkzeugs geben kann. Sie können dies tun, indem Sie das Werkzeug im Feld tool_choice wie folgt angeben:

tool_choice = {"type": "tool", "name": "get_weather"}

Indem Sie Claude explizit anweisen, das Werkzeug get_weather zu verwenden, können Sie es dazu ermutigen, das von Ihnen gewünschte Werkzeug zu nutzen. Diese Technik kann nützlich sein, um Ihre Werkzeugintegrationen zu testen und zu debuggen oder wenn Sie wissen, dass das Werkzeug immer verwendet werden sollte, unabhängig von der Eingabe.

Sie können Claude auch anweisen, eines der bereitgestellten Werkzeuge über {"type": "any"} zu verwenden. Die Standardeinstellung für tool_choice ist {"type": "auto"}, was Claude die Entscheidung überlässt, ob ein Werkzeug verwendet werden soll oder nicht.

Beachten Sie, dass wir bei tool_choice als any oder tool die Assistentennachricht vorfüllen, um die Verwendung eines Werkzeugs zu erzwingen. Das bedeutet, dass die Modelle keinen Gedankengang-text-Inhaltsblock vor tool_use-Inhaltsblöcken ausgeben, auch wenn dies explizit gefordert wird. Unsere Tests haben gezeigt, dass dies die Leistung nicht beeinträchtigen sollte. Wenn Sie den Gedankengang (insbesondere bei Opus) beibehalten möchten und gleichzeitig die Verwendung eines bestimmten Werkzeugs anfordern, können Sie {"type": "auto"} für tool_choice (Standardeinstellung) verwenden und explizite Anweisungen in einer user-Nachricht hinzufügen. Zum Beispiel: Wie ist das Wetter in London? Verwenden Sie in Ihrer Antwort das Werkzeug get_weather.


JSON-Ausgabe

Werkzeuge müssen nicht unbedingt clientseitige Funktionen sein - Sie können Werkzeuge jederzeit verwenden, wenn Sie möchten, dass das Modell JSON-Ausgaben zurückgibt, die einem bereitgestellten Schema entsprechen. Beispielsweise könnten Sie ein Werkzeug record_summary mit einem bestimmten Schema verwenden. Ein vollständiges funktionierendes Beispiel finden Sie unter Beispiele für die Werkzeugnutzung.


Fehlerbehandlung

Bei der Verwendung von Werkzeugen mit Claude können verschiedene Arten von Fehlern auftreten:

Fehler bei der Werkzeugausführung

Wenn das Werkzeug selbst während der Ausführung einen Fehler auslöst (z.B. einen Netzwerkfehler beim Abrufen von Wetterdaten), können Sie die Fehlermeldung im content zusammen mit "is_error": true zurückgeben:

JSON
{
  "role": "user",
  "content": [
    {
      "type": "tool_result",
      "tool_use_id": "toolu_01A09q90qw90lq917835lq9",
      "content": "ConnectionError: Der Wetterdienst-API ist nicht verfügbar (HTTP 500)",
      "is_error": true
    }
  ]
}

Claude wird diesen Fehler dann in seine Antwort an den Benutzer einbeziehen, z.B. “Es tut mir leid, ich konnte das aktuelle Wetter nicht abrufen, weil der Wetterdienst-API nicht verfügbar ist. Bitte versuchen Sie es später noch einmal.”

Maximale Anzahl von Token überschritten

Wenn Claudes Antwort aufgrund des Erreichens des Grenzwerts max_tokens abgeschnitten wird und die gekürzte Antwort einen unvollständigen Werkzeugnutzungsblock enthält, müssen Sie die Anfrage mit einem höheren Wert für max_tokens wiederholen, um die vollständige Werkzeugnutzung zu erhalten.

Ungültige Werkzeugnutzung

Wenn Claudes versuchte Verwendung eines Werkzeugs ungültig ist (z.B. fehlende erforderliche Parameter), bedeutet dies normalerweise, dass nicht genügend Informationen vorhanden waren, damit Claude das Werkzeug korrekt verwenden konnte. Während der Entwicklung ist es am besten, die Anfrage mit detaillierteren description-Werten in Ihren Werkzeugdefinitionen erneut zu stellen.

Sie können die Konversation jedoch auch mit einem tool_result fortsetzen, der den Fehler anzeigt, und Claude wird versuchen, das Werkzeug erneut zu verwenden, wobei die fehlenden Informationen ergänzt werden:

JSON
{
  "role": "user",
  "content": [
    {
      "type": "tool_result",
      "tool_use_id": "toolu_01A09q90qw90lq917835lq9",
      "content": "Fehler: Erforderlicher Parameter 'location' fehlt",
      "is_error": true
    }
  ]
}

Gedankengang bei der Werkzeugnutzung

Bei der Verwendung von Werkzeugen zeigt Claude oft seinen “Gedankengang”, d.h. die schrittweise Argumentation, die es verwendet, um das Problem zu zerlegen und zu entscheiden, welche Werkzeuge verwendet werden sollen. Das Modell Claude 3 Opus tut dies, wenn tool_choice auf auto gesetzt ist (dies ist der Standardwert, siehe Erzwingen der Werkzeugnutzung), und Sonnet und Haiku können dazu aufgefordert werden.

Beispielsweise könnte Claude bei der Aufforderung “Wie ist das Wetter gerade in San Francisco und wie spät ist es dort?” wie folgt antworten:

JSON
{
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "<thinking>Um diese Frage zu beantworten, werde ich: 1. Das Werkzeug get_weather verwenden, um das aktuelle Wetter in San Francisco zu erhalten. 2. Das Werkzeug get_time verwenden, um die aktuelle Uhrzeit in der Zeitzone America/Los_Angeles zu erhalten, die San Francisco, CA abdeckt.</thinking>"
    },
    {
      "type": "tool_use",
      "id": "toolu_01A09q90qw90lq917835lq9",
      "name": "get_weather",
      "input": {"location": "San Francisco, CA"}
    }
  ]
}

Dieser Gedankengang gibt Einblick in Claudes Argumentationsprozess und kann Ihnen helfen, unerwartetes Verhalten zu debuggen.

Beim Modell Claude 3 Sonnet ist der Gedankengang standardmäßig weniger häufig, aber Sie können Claude auffordern, seine Argumentation zu zeigen, indem Sie etwas wie “Erklären Sie vor der Beantwortung Ihre Argumentation Schritt für Schritt in Tags.” zur Benutzernachricht oder Systemaufforderung hinzufügen. Ein ausführlicheres Beispiel finden Sie unter Beispiel für den Gedankengang bei der Werkzeugnutzung.

Es ist wichtig zu beachten, dass die <thinking>-Tags zwar eine gängige Konvention sind, die Claude verwendet, um seinen Gedankengang zu kennzeichnen, sich das genaue Format (z.B. wie dieser XML-Tag benannt ist) jedoch im Laufe der Zeit ändern kann. Ihr Code sollte den Gedankengang wie jeden anderen vom Assistenten generierten Text behandeln und sich nicht auf das Vorhandensein oder das spezifische Format der <thinking>-Tags verlassen.


Bewährte Methoden und Einschränkungen bei der Werkzeugnutzung

Beachten Sie bei der Verwendung von Werkzeugen mit Claude die folgenden Einschränkungen und bewährten Methoden:

  • Verwenden Sie Claude 3 Opus für die Navigation in komplexen Werkzeugnutzungen, Haiku für unkomplizierte Werkzeuge: Opus kann die meisten gleichzeitigen Werkzeuge verarbeiten und ist besser darin, fehlende Argumente zu erkennen als andere Modelle. Es wird eher nach Klarstellung in mehrdeutigen Fällen fragen, in denen ein Argument nicht explizit angegeben wird oder ein Werkzeug möglicherweise nicht erforderlich ist, um die Benutzeranfrage zu erfüllen. Haiku versucht standardmäßig, Werkzeuge häufiger zu verwenden (auch wenn sie nicht für die Abfrage relevant sind) und leitet fehlende Parameter ab, wenn sie nicht explizit angegeben werden.
  • Anzahl der Werkzeuge: Alle Claude 3-Modelle können auch bei der Arbeit mit Hunderten von einfachen Werkzeugen und einer kleineren Anzahl komplexer Werkzeuge eine Genauigkeit von über 90% beibehalten. Ein “komplexes” Werkzeug wäre eines mit einer großen Anzahl von Parametern oder Parametern mit komplexen Schemata (z.B. verschachtelte Objekte).
  • Komplexe und tief verschachtelte Werkzeuge: Genau wie ein Mensch kann Claude besser mit einfacheren Schnittstellen und einfacheren Werkzeugen arbeiten. Wenn Claude Schwierigkeiten hat, Ihr Werkzeug korrekt zu verwenden, versuchen Sie, das Eingabeschema von tief verschachtelten JSON-Objekten abzuflachen und die Anzahl der Eingaben zu reduzieren.
  • Sequenzielle Werkzeugnutzung: Claude bevorzugt im Allgemeinen die Verwendung eines Werkzeugs nach dem anderen und verwendet dann die Ausgabe dieses Werkzeugs, um seine nächste Aktion zu bestimmen. Während Sie Claude durch sorgfältiges Entwerfen Ihrer Aufforderung und Werkzeuge dazu bringen können, mehrere Werkzeuge parallel zu verwenden, kann dies dazu führen, dass Claude Dummy-Werte für Parameter einfügt, die von den Ergebnissen früherer Werkzeugnutzungen abhängen. Für optimale Ergebnisse sollten Sie Ihren Workflow und Ihre Werkzeuge so gestalten, dass sie eine Reihe von sequenziellen Werkzeugnutzungen von Claude hervorrufen und damit arbeiten.
  • Wiederholungen: Wenn Claudes Werkzeugnutzungsanfrage ungültig ist oder erforderliche Parameter fehlen, können Sie eine Fehlerantwort zurückgeben und Claude wird die Anfrage in der Regel mit den fehlenden Informationen erneut stellen. Nach 2-3 fehlgeschlagenen Versuchen kann Claude jedoch aufgeben und stattdessen eine Entschuldigung an den Benutzer zurückgeben, anstatt es weiter zu versuchen.
  • Debugging: Achten Sie beim Debuggen von unerwartetem Verhalten bei der Werkzeugnutzung auf Claudes Gedankengang-Ausgabe (falls vorhanden), um zu verstehen, warum es die Entscheidungen trifft, die es trifft. Sie können Claude auch auffordern, ein bestimmtes Werkzeug zu verwenden, um zu sehen, ob dies zum erwarteten Verhalten führt. Wenn Claude ein Werkzeug falsch verwendet, überprüfen Sie, ob Ihre Werkzeugbeschreibungen und -schemata klar und eindeutig sind.
  • <search_quality_reflection>-Tags: Manchmal, wenn Suchwerkzeuge verwendet werden, kann das Modell in seiner Antwort <search_quality_reflection>-XML-Tags und eine Suchqualitätsbewertung zurückgeben. Um zu verhindern, dass das Modell dies tut, fügen Sie den Satz “Reflektieren Sie in Ihrer Antwort nicht über die Qualität der zurückgegebenen Suchergebnisse.” am Ende Ihrer Aufforderung hinzu.

Indem Sie diese Einschränkungen und Richtlinien berücksichtigen, können Sie effektive Werkzeuge und agentische Orchestrierungen entwerfen, die Claudes Fähigkeiten zur Bewältigung einer Vielzahl von Aufgaben erheblich erweitern.


Beta-Versionshistorie

  • tools-2024-05-16
    • Änderung der Systemaufforderung für Opus, um Szenarien besser zu handhaben, in denen möglicherweise mehrere Werkzeugnutzungen in einem einzigen Durchgang erforderlich sind
  • tools-2024-04-04: Erste Beta-Version für die Werkzeugnutzung

Nächste Schritte

Die Werkzeugnutzung ist eine leistungsstarke Technik zur Erweiterung der Fähigkeiten von Claude, indem es mit externen Datenquellen und Funktionen verbunden wird. Mit einem gut gestalteten Satz von Werkzeugen können Sie Claude in die Lage versetzen, eine Vielzahl von Aufgaben zu bewältigen, die mit seinem Basiswissen allein unmöglich wären.

Einige mögliche nächste Schritte zum Erkunden:

  • Durchsuchen Sie unsere Werkzeugnutzungs-Kochbücher: Erkunden Sie unser Repository mit sofort einsetzbaren Codebeispielen zur Werkzeugnutzung, wie z.B:
  • Verbessern Sie die Qualität und Zuverlässigkeit der Werkzeugnutzung: Iterieren und verbessern Sie Ihre Werkzeugbeschreibungen und Aufforderungen, um eine zuverlässigere und genauere Werkzeugnutzung von Claude zu erreichen
  • Erweitern Sie Claudes Fähigkeiten:
    • Experimentieren Sie mit verschiedenen Werkzeugen und Schemata, um zu sehen, wie Claude mit verschiedenen Eingabe- und Ausgabeformaten umgeht.
    • Verketten Sie mehrere Werkzeuge, um komplexe Aufgaben in eine Reihe einfacherer Schritte zu zerlegen.
    • Erstellen Sie agentische Orchestrierungen, bei denen Claude eine Vielzahl von Aufgaben von Anfang bis Ende erledigen kann, als wäre es ein Assistent.
    • Erforschen Sie komplexe Architekturen für die Werkzeugnutzung, z.B. indem Sie Claude Werkzeuge für die RAG-Suche oder für den Aufruf kleinerer Modell-Subagenten wie Haiku zur Verfügung stellen, damit diese in seinem Auftrag Aufgaben ausführen können

Während Sie mit der Werkzeugnutzung arbeiten, würden wir gerne Ihr Feedback hören und sehen, was Sie erstellen! Treten Sie unserem Entwickler-Discord bei, um Ihre Projekte zu teilen und Tipps und Techniken mit anderen Entwicklern zu diskutieren.

Wir sind gespannt darauf, wie Sie die Werkzeugnutzung einsetzen, um die Grenzen des Möglichen mit Claude zu erweitern. Viel Spaß beim Entwickeln!