Tool-Nutzung mit Claude

„Tool use“ (Tool-Nutzung), auch „function calling“ (Funktionsaufruf) genannt, ermöglicht es Claude, Funktionen aufzurufen, die du definierst oder die Anthropic bereitstellt. Claude entscheidet anhand der Anfrage des Nutzers und der Beschreibung des Tools, wann ein Tool aufgerufen wird. Anschließend gibt Claude einen strukturierten Aufruf zurück, den deine Anwendung ausführt (Client-Tools) oder den Anthropic ausführt (Server-Tools).

Hier ist ein minimales Beispiel mit einem Server-Tool, dem Web-Search-Tool, das Anthropic für dich ausführt:

client = anthropic.Anthropic()
response = client.messages.create(
    model="claude-opus-5-5",
    max_tokens=1024,
    tools=[{"type": "web_search_20260209", "name": "web_search"}],
    messages=[{"role": "user", "content": "What's the latest on the Mars rover?"}],
)
print(response.content)

Claude führt die Suche auf der Infrastruktur von Anthropic aus und gibt die zitierten Ergebnisse in derselben Antwort zurück. Damit Claude eine von dir definierte Funktion aufruft, übergib ein Tool mit einem input_schema und führe den Aufruf aus, wenn Claude einen tool_use-Block zurückgibt. So funktioniert Tool-Nutzung zeigt diesen Round Trip von Anfang bis Ende. Erfahre mehr über das Definieren von Tools und das Verarbeiten von Tool-Aufrufen.

So funktioniert Tool-Nutzung

Tools unterscheiden sich in erster Linie darin, wo der Code ausgeführt wird. Client-Tools (einschließlich benutzerdefinierter Tools und Tools mit von Anthropic definierten Schemas wie bash und text_editor) laufen in deiner Anwendung. Claude antwortet mit stop_reason: "tool_use" und einem oder mehreren tool_use-Blöcken. Dein Code führt die Operation aus und sendet ein tool_result zurück. Server-Tools (wie web_search, web_fetch, code_execution und tool_search) laufen auf der Infrastruktur von Anthropic: Du siehst die Ergebnisse direkt, ohne die Ausführung selbst zu übernehmen, es sei denn, Claude ruft das Tool in derselben Gruppe paralleler Tool-Aufrufe wie eines deiner Client-Tools auf (siehe Stop-Reasons und Fallback).

Hier ist dieser Round Trip vollständig für ein Client-Tool. Die erste Anfrage definiert ein get_weather-Tool, und Claude beantwortet die Frage, indem es dieses aufruft: Die Antwort enthält einen tool_use-Block, dein Code führt die Abfrage aus, und eine zweite Anfrage sendet das Ergebnis in einem tool_result-Block zurück, sodass Claude mit der Antwort reagieren kann.

client = anthropic.Anthropic()

tools = [
    {
        "name": "get_weather",
        "description": "Get the current weather for a given location.",
        "input_schema": {
            "type": "object",
            "properties": {
                "location": {
                    "type": "string",
                    "description": "City and state, e.g. San Francisco, CA",
                }
            },
            "required": ["location"],
        },
    }
]
messages = [{"role": "user", "content": "What's the weather in San Francisco?"}]

# Claude antwortet mit einem tool_use-Block, der das Tool und seine Argumente nennt.
response = client.messages.create(
    model="claude-opus-5-5",
    max_tokens=1024,
    tools=tools,
    # Fordere höchstens einen Tool-Aufruf pro Turn an.
    tool_choice={"type": "auto", "disable_parallel_tool_use": True},
    messages=messages,
)
tool_use = next(block for block in response.content if block.type == "tool_use")
print(f"Claude called {tool_use.name} with {json.dumps(tool_use.input)}")

# Führe das Tool aus und sende das Ergebnis dann in einem tool_result-Block zurück.
weather = "15 degrees Celsius, partly cloudy"  # your weather lookup goes here
messages += [
    {"role": "assistant", "content": response.content},
    {
        "role": "user",
        "content": [
            {"type": "tool_result", "tool_use_id": tool_use.id, "content": weather}
        ],
    },
]
followup = client.messages.create(
    model="claude-opus-5-5",
    max_tokens=1024,
    tools=tools,
    tool_choice={"type": "auto", "disable_parallel_tool_use": True},
    messages=messages,
)

# Claude nutzt das Ergebnis, um die ursprüngliche Frage zu beantworten.
final_text = next(block for block in followup.content if block.type == "text")
print(final_text.text)

Claude called get_weather with {"location": "San Francisco, CA"}
The current weather in San Francisco is 15 degrees Celsius with partly cloudy skies.

Tool-Aufrufe verarbeiten behandelt jeden Schritt im Detail, einschließlich der Formatierung von Ergebnissen und der Signalisierung von Fehlern; Parallele Tool-Nutzung behandelt Antworten, die mehrere Tools gleichzeitig aufrufen. Wenn du diesen Round Trip nicht selbst schreiben möchtest, verwende den Tool Runner: Die SDKs führen deine Tools aus und senden die Ergebnisse automatisch zurück.

Das vollständige konzeptionelle Modell einschließlich der agentischen Schleife und der Frage, wann welcher Ansatz zu wählen ist, findest du unter So funktioniert Tool-Nutzung.

Um dich mit „Model Context Protocol“-Servern, oder MCP-Servern, zu verbinden, siehe den MCP-Connector. Um deinen eigenen MCP-Client zu erstellen, siehe den Model-Context-Protocol-Leitfaden zum Erstellen eines MCP-Clients.

Wann Claude Tools verwendet

Mit dem Standardwert für tool_choice von {"type": "auto"} entscheidet Claude in jedem Zug, ob ein Tool aufgerufen oder direkt geantwortet wird. Claude ruft ein Tool auf, wenn die Anfrage der beschriebenen Fähigkeit dieses Tools entspricht und die Antwort nicht bereits im Kontext vorhanden ist. Claude antwortet direkt bei stabilem Wissen, kreativen Aufgaben und Gesprächszügen.

Diese Grenze lässt sich über deinen System-Prompt steuern. Wenn Claude keine Tools aufruft, obwohl du es erwartest, erhöht eine leichte Anweisung wie "Use the tools to investigate before responding." die Tool-Nutzung. Eine stärkere Form wie "Always call a tool first before responding." geht noch weiter. Umgekehrt hält "Use your judgment about whether to call a tool or respond directly." das Auslöseverhalten konservativ.

Um einen Tool-Aufruf zu erzwingen, statt dich auf Prompting zu verlassen, setze tool_choice.

Die Seite jedes Server-Tools beschreibt dessen eigene Auslösegrenze ausführlicher.

{
  "type": "tool_use",
  "id": "toolu_01A09q90qw90lq917835lq9",
  "name": "get_weather",
  "input": { "location": "New York, NY", "unit": "fahrenheit" }
}

Ein Tool auswählen

Für type-Strings, Versionen und Beta-Header siehe die Tool-Referenz.

Deine eigenen Tools

Bei Tools, die du definierst, schreibst du das Schema, und deine Anwendung führt jeden Aufruf aus.

Client-Tools mit Anthropic-Schema

Anthropic veröffentlicht das Schema und trainiert Claude darauf. Deine Anwendung führt weiterhin jeden Aufruf aus und gibt das tool_result zurück.

Server-Tools

Server-Tools laufen auf der Infrastruktur von Anthropic, ohne Handler-Code in deiner Anwendung. Siehe Server-Tools für die gemeinsamen Mechanismen.

Preise

Anfragen mit „tool use“ (Tool-Nutzung) werden auf folgender Grundlage abgerechnet:

1. Die Gesamtzahl der an das Modell gesendeten Input-Token (einschließlich derer im Parameter tools)
2. Die Anzahl der generierten Output-Token
3. Bei serverseitigen Tools zusätzliche nutzungsbasierte Preise (zum Beispiel wird bei der Websuche pro durchgeführter Suche abgerechnet)

Clientseitige Tools werden genauso abgerechnet wie jede andere Claude-API-Anfrage, während bei serverseitigen Tools je nach ihrer spezifischen Nutzung zusätzliche Kosten anfallen können.

Die zusätzlichen Token durch Tool-Nutzung stammen aus:

• Dem Parameter tools in API-Anfragen (Tool-Namen, Beschreibungen und Schemas)
• tool_use-Inhaltsblöcken in API-Anfragen und -Antworten
• tool_result-Inhaltsblöcken in API-Anfragen

Wenn du tools verwendest, fügt die API außerdem automatisch einen speziellen „system prompt“ (System-Prompt) für das Modell hinzu, der die Tool-Nutzung ermöglicht. Die Anzahl der für jedes Modell erforderlichen Tool-Nutzungs-Token ist in der folgenden Tabelle aufgeführt (ohne die zuvor genannten zusätzlichen Token). Beachte, dass die Tabelle davon ausgeht, dass mindestens 1 Tool bereitgestellt wird. Wenn keine tools bereitgestellt werden, verbraucht eine Tool-Auswahl von none 0 zusätzliche System-Prompt-Token.

Model	Tool use system prompt tokens
Name	Tool choice	Token count
Claude Opus 5.5For long-running agentic coding and knowledge work	auto, none	286 tokens
Claude Sonnet 5.5The best combination of speed and intelligence	auto, none	286 tokens
Claude Haiku 4.5The fastest model with near-frontier intelligence	auto, none	496 tokens
	any, tool	588 tokens
Additional models
Claude Opus 5	auto, none	286 tokens
	any, tool	406 tokens
Claude Opus 4.8	auto, none	290 tokens
	any, tool	410 tokens
Claude Opus 4.7	auto, none	675 tokens
	any, tool	804 tokens
Claude Opus 4.6	auto, none	497 tokens
	any, tool	589 tokens
Claude Opus 4.5	auto, none	496 tokens
	any, tool	588 tokens
Claude Opus 4.1	auto, none	313 tokens
	any, tool	315 tokens
Claude Opus 4	auto, none	313 tokens
	any, tool	315 tokens
Claude Sonnet 5	auto, none	354 tokens
	any, tool	474 tokens
Claude Sonnet 4.6	auto, none	497 tokens
	any, tool	589 tokens
Claude Sonnet 4.5	auto, none	496 tokens
	any, tool	588 tokens
Claude Sonnet 4	auto, none	313 tokens
	any, tool	315 tokens
Claude Haiku 3.5	auto, none	264 tokens
	any, tool	355 tokens

Diese Token-Anzahlen werden zu deinen normalen Input- und Output-Token addiert, um die Gesamtkosten einer Anfrage zu berechnen.

Die aktuellen Preise pro Modell findest du in der Tabelle der Modellübersicht.

Wenn du einen Tool-Nutzungs-Prompt sendest, enthält die Antwort wie bei jeder anderen API-Anfrage sowohl die Anzahl der Input- als auch der Output-Token in den gemeldeten usage-Metriken.

Einige Server-Tools erheben zusätzlich zu den Token nutzungsbasierte Gebühren: Siehe Web-Search-Tool und Code-Execution-Tool für deren Tarife.

Nächste Schritte