---
title: Tool-Nutzung mit Claude
url: https://platform.claude.com/docs/de/agents-and-tools/tool-use/overview
description: Verbinde Claude mit externen Tools und APIs. Erfahre, wo Tools ausgeführt werden, wann Claude sie aufruft und welches Tool zu deiner Aufgabe passt.
---

„Tool use“ (Tool-Nutzung), auch „function calling“ (Funktionsaufrufe) 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](https://platform.claude.com/docs/de/agents-and-tools/tool-use/web-search-tool), das Anthropic für dich ausführt:

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "content-type: application/json" \
    -d '{
      "model": "claude-opus-5-5",
      "max_tokens": 4096,
      "tools": [{"type": "web_search_20260209", "name": "web_search"}],
      "messages": [{"role": "user", "content": "What is the latest on the Mars rover?"}]
    }'
  ```

  ```bash CLI
  ant messages create \
    --model claude-opus-5-5 \
    --max-tokens 4096 \
    --tool '{type: web_search_20260209, name: web_search}' \
    --message '{role: user, content: "What is the latest on the Mars rover?"}'
  ```

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

  ```typescript TypeScript
  const client = new Anthropic();
  const response = await client.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 4096,
    tools: [{ type: "web_search_20260209", name: "web_search" }],
    messages: [{ role: "user", content: "What is the latest on the Mars rover?" }]
  });
  console.log(response.content);
  ```

  ```csharp C#
  AnthropicClient client = new();

  var parameters = new MessageCreateParams
  {
      Model = Model.ClaudeOpus5_5,
      MaxTokens = 4096,
      Tools = [new ToolUnion(new WebSearchTool20260209())],
      Messages = [new UserMessageParam { Content = "What is the latest on the Mars rover?" }]
  };

  var message = await client.Messages.Create(parameters);
  Console.WriteLine(message.Content);
  ```

  ```go Go
  client := anthropic.NewClient()

  response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeOpus5_5,
  	MaxTokens: 4096,
  	Tools: []anthropic.ToolUnionParam{
  		{OfWebSearchTool20260209: &anthropic.WebSearchTool20260209Param{}},
  	},
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock("What is the latest on the Mars rover?")),
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }
  fmt.Println(response.Content)
  ```

  ```java Java
  import com.anthropic.models.messages.WebSearchTool20260209;

  void main() {
      AnthropicClient client = AnthropicOkHttpClient.fromEnv();

      MessageCreateParams params = MessageCreateParams.builder()
          .model(Model.CLAUDE_OPUS_5_5)
          .maxTokens(4096L)
          .addTool(WebSearchTool20260209.builder().build())
          .addUserMessage("What is the latest on the Mars rover?")
          .build();

      Message response = client.messages().create(params);
      IO.println(response.content());
  }
  ```

  ```php PHP
  $client = new Client();

  $message = $client->messages->create(
      model: 'claude-opus-5-5',
      maxTokens: 4096,
      tools: [
          ['type' => 'web_search_20260209', 'name' => 'web_search'],
      ],
      messages: [
          ['role' => 'user', 'content' => 'What is the latest on the Mars rover?'],
      ],
  );

  echo $message;
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  message = client.messages.create(
    model: Anthropic::Model::CLAUDE_OPUS_5_5,
    max_tokens: 4096,
    tools: [{ type: "web_search_20260209", name: "web_search" }],
    messages: [{ role: "user", content: "What is the latest on the Mars rover?" }]
  )
  puts message.content
  ```
</CodeGroup>

Claude führt die Suche auf der Infrastruktur von Anthropic aus und gibt die zitierten Ergebnisse in derselben Antwort zurück. Damit Claude eine Funktion aufruft, die du definierst, übergib ein Tool mit einem `input_schema` und führe den Aufruf aus, wenn Claude einen `tool_use`-Block zurückgibt. Das [Client-Tool-Beispiel](https://platform.claude.com/docs/de/agents-and-tools/tool-use/overview#how-tool-use-works) zeigt diesen Ablauf von Anfang bis Ende. Erfahre mehr über das [Definieren von Tools](https://platform.claude.com/docs/de/agents-and-tools/tool-use/define-tools) und das [Verarbeiten von Tool-Aufrufen](https://platform.claude.com/docs/de/agents-and-tools/tool-use/handle-tool-calls).

## So funktioniert Tool-Nutzung

Tools unterscheiden sich vor allem 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 auf wie eines deiner Client-Tools (siehe [Stop-Gründe und Fallback](https://platform.claude.com/docs/de/build-with-claude/handling-stop-reasons#tool-use)).

Hier ist dieser Roundtrip 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.

<CodeGroup exclude="shell:cURL, shell:CLI">
  <CodeGroupItem language="cURL">
    Dieser Workflow erfordert mehr Logik als ein einzelner Shell-Befehl. Verwende das [Anthropic SDK](https://platform.claude.com/docs/de/cli-sdks-libraries/overview), um ihn auszuführen.
  </CodeGroupItem>

  <CodeGroupItem language="CLI">
    Dieser Workflow erfordert mehr Logik als ein einzelner Shell-Befehl. Verwende das [Anthropic SDK](https://platform.claude.com/docs/de/cli-sdks-libraries/overview), um ihn auszuführen.
  </CodeGroupItem>

  ```python Python
  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 pro Turn höchstens einen Tool-Aufruf 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)
  ```

  ```typescript TypeScript
  const client = new Anthropic();

  const tools: Anthropic.Tool[] = [
    {
      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"]
      }
    }
  ];
  const messages: Anthropic.MessageParam[] = [
    { role: "user", content: "What's the weather in San Francisco?" }
  ];

  // Claude antwortet mit einem tool_use-Block, der das Tool und seine Argumente nennt.
  const response = await client.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 1024,
    tools,
    // Fordere höchstens einen Tool-Aufruf pro Turn an.
    tool_choice: { type: "auto", disable_parallel_tool_use: true },
    messages
  });
  const toolUse = response.content.find((block) => block.type === "tool_use")!;
  console.log(`Claude called ${toolUse.name} with ${JSON.stringify(toolUse.input)}`);

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

  // Claude nutzt das Ergebnis, um die ursprüngliche Frage zu beantworten.
  const finalText = followup.content.find((block) => block.type === "text")!;
  console.log(finalText.text);
  ```

  ```csharp C#
  AnthropicClient client = new();

  List<ToolUnion> tools =
  [
      new ToolUnion(new Tool()
      {
          Name = "get_weather",
          Description = "Get the current weather for a given location.",
          InputSchema = new InputSchema()
          {
              Properties = new Dictionary<string, JsonElement>
              {
                  ["location"] = JsonSerializer.SerializeToElement(new
                  {
                      type = "string",
                      description = "City and state, e.g. San Francisco, CA",
                  }),
              },
              Required = ["location"],
          },
      }),
  ];

  // Fordere pro Turn höchstens einen Tool-Aufruf an.
  var toolChoice = new ToolChoice(new ToolChoiceAuto { DisableParallelToolUse = true });

  const string userPrompt = "What's the weather in San Francisco?";

  // Claude antwortet mit einem tool_use-Block, der das Tool und seine Argumente nennt.
  var response = await client.Messages.Create(new MessageCreateParams
  {
      Model = Model.ClaudeOpus5_5,
      MaxTokens = 1024,
      Tools = tools,
      ToolChoice = toolChoice,
      Messages = [new UserMessageParam { Content = userPrompt }],
  });
  ToolUseBlock? toolUse = null;
  foreach (var block in response.Content)
  {
      if (block.TryPickToolUse(out var picked))
      {
          toolUse = picked;
          break;
      }
  }
  Console.WriteLine($"Claude called {toolUse!.Name} with {JsonSerializer.Serialize(toolUse.Input)}");

  // Führe das Tool aus und sende das Ergebnis in einem tool_result-Block zurück.
  var weather = "15 degrees Celsius, partly cloudy";
  List<ContentBlockParam> toolResults =
  [
      new ContentBlockParam(new ToolResultBlockParam()
      {
          ToolUseID = toolUse.ID,
          Content = weather,
      }),
  ];
  var followup = await client.Messages.Create(new MessageCreateParams
  {
      Model = Model.ClaudeOpus5_5,
      MaxTokens = 1024,
      Tools = tools,
      ToolChoice = toolChoice,
      Messages =
      [
          new UserMessageParam { Content = userPrompt },
          new AssistantMessageParam { Content = response.Content.Select(block => new ContentBlockParam(block.Json)).ToList() },
          new UserMessageParam { Content = toolResults },
      ],
  });

  // Claude nutzt das Ergebnis, um die ursprüngliche Frage zu beantworten.
  foreach (var block in followup.Content)
  {
      if (block.TryPickText(out var text))
      {
          Console.WriteLine(text.Text);
      }
  }
  ```

  ```go Go
  client := anthropic.NewClient()
  ctx := context.Background()

  tools := []anthropic.ToolUnionParam{
  	{OfTool: &anthropic.ToolParam{
  		Name:        "get_weather",
  		Description: anthropic.String("Get the current weather for a given location."),
  		InputSchema: anthropic.ToolInputSchemaParam{
  			Properties: map[string]any{
  				"location": map[string]any{
  					"type":        "string",
  					"description": "City and state, e.g. San Francisco, CA",
  				},
  			},
  			Required: []string{"location"},
  		},
  	}},
  }
  // Fordere pro Turn höchstens einen Tool-Aufruf an.
  toolChoice := anthropic.ToolChoiceUnionParam{
  	OfAuto: &anthropic.ToolChoiceAutoParam{DisableParallelToolUse: anthropic.Bool(true)},
  }
  messages := []anthropic.MessageParam{
  	anthropic.NewUserMessage(anthropic.NewTextBlock("What's the weather in San Francisco?")),
  }

  // Claude antwortet mit einem tool_use-Block, der das Tool und seine Argumente nennt.
  response, err := client.Messages.New(ctx, anthropic.MessageNewParams{
  	Model:      anthropic.ModelClaudeOpus5_5,
  	MaxTokens:  1024,
  	Tools:      tools,
  	ToolChoice: toolChoice,
  	Messages:   messages,
  })
  if err != nil {
  	log.Fatal(err)
  }
  var toolUse anthropic.ContentBlockUnion
  for _, block := range response.Content {
  	if block.Type == "tool_use" {
  		toolUse = block
  		break
  	}
  }
  fmt.Printf("Claude called %s with %s\n", toolUse.Name, string(toolUse.Input))

  // Führe das Tool aus und sende das Ergebnis dann in einem tool_result-Block zurück.
  weather := "15 degrees Celsius, partly cloudy"
  var assistantContent []anthropic.ContentBlockParamUnion
  for _, block := range response.Content {
  	assistantContent = append(assistantContent, block.ToParam())
  }
  messages = append(messages,
  	anthropic.NewAssistantMessage(assistantContent...),
  	anthropic.NewUserMessage(anthropic.NewToolResultBlock(toolUse.ID, weather, false)),
  )
  followup, err := client.Messages.New(ctx, anthropic.MessageNewParams{
  	Model:      anthropic.ModelClaudeOpus5_5,
  	MaxTokens:  1024,
  	Tools:      tools,
  	ToolChoice: toolChoice,
  	Messages:   messages,
  })
  if err != nil {
  	log.Fatal(err)
  }

  // Claude nutzt das Ergebnis, um die ursprüngliche Frage zu beantworten.
  for _, block := range followup.Content {
  	if block.Type == "text" {
  		fmt.Println(block.Text)
  	}
  }
  ```

  ```java Java
  import com.anthropic.core.JsonValue;
  import com.anthropic.models.messages.ContentBlockParam;
  // ...
  import com.anthropic.models.messages.Tool;
  import com.anthropic.models.messages.Tool.InputSchema;
  import com.anthropic.models.messages.ToolChoiceAuto;
  import com.anthropic.models.messages.ToolResultBlockParam;
  import com.anthropic.models.messages.ToolUseBlock;
  // ...

  void main() {
      AnthropicClient client = AnthropicOkHttpClient.fromEnv();

      Tool weatherTool = Tool.builder()
          .name("get_weather")
          .description("Get the current weather for a given location.")
          .inputSchema(InputSchema.builder()
              .properties(JsonValue.from(Map.of(
                  "location", Map.of(
                      "type", "string",
                      "description", "City and state, e.g. San Francisco, CA"
                  )
              )))
              .required(List.of("location"))
              .build())
          .build();

      // Fordere pro Turn höchstens einen Tool-Aufruf an.
      ToolChoiceAuto toolChoice = ToolChoiceAuto.builder()
          .disableParallelToolUse(true)
          .build();

      String userPrompt = "What's the weather in San Francisco?";

      // Claude antwortet mit einem tool_use-Block, der das Tool und seine Argumente nennt.
      Message response = client.messages().create(MessageCreateParams.builder()
          .model(Model.CLAUDE_OPUS_5_5)
          .maxTokens(1024L)
          .addTool(weatherTool)
          .toolChoice(toolChoice)
          .addUserMessage(userPrompt)
          .build());
      ToolUseBlock toolUse = response.content().stream()
          .flatMap(block -> block.toolUse().stream())
          .findFirst()
          .orElseThrow();
      IO.println("Claude called " + toolUse.name() + " with " + toolUse._input());

      // Führe das Tool aus und sende das Ergebnis dann in einem tool_result-Block zurück.
      String weather = "15 degrees Celsius, partly cloudy";
      Message followup = client.messages().create(MessageCreateParams.builder()
          .model(Model.CLAUDE_OPUS_5_5)
          .maxTokens(1024L)
          .addTool(weatherTool)
          .toolChoice(toolChoice)
          .addUserMessage(userPrompt)
          .addMessage(response)
          .addUserMessageOfContentBlockParams(List.of(ContentBlockParam.ofToolResult(
              ToolResultBlockParam.builder()
                  .toolUseId(toolUse.id())
                  .content(weather)
                  .build())))
          .build());

      // Claude nutzt das Ergebnis, um die ursprüngliche Frage zu beantworten.
      followup.content().stream()
          .flatMap(block -> block.text().stream())
          .forEach(textBlock -> IO.println(textBlock.text()));
  }
  ```

  ```php PHP
  use Anthropic\Messages\ToolChoiceAuto;

  $client = new Client();

  $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'],
          ],
      ],
  ];
  $userMessage = ['role' => 'user', 'content' => "What's the weather in San Francisco?"];

  // Fordere pro Turn höchstens einen Tool-Aufruf an.
  $toolChoice = ToolChoiceAuto::with(disableParallelToolUse: true);

  // Claude antwortet mit einem tool_use-Block, der das Tool und seine Argumente nennt.
  $response = $client->messages->create(
      model: 'claude-opus-5-5',
      maxTokens: 1024,
      tools: $tools,
      toolChoice: $toolChoice,
      messages: [$userMessage],
  );
  $toolUse = null;
  foreach ($response->content as $block) {
      if ($block->type === 'tool_use') {
          $toolUse = $block;
          break;
      }
  }
  printf("Claude called %s with %s\n", $toolUse->name, json_encode($toolUse->input));

  // Führe das Tool aus und sende das Ergebnis dann in einem tool_result-Block zurück.
  $weather = '15 degrees Celsius, partly cloudy';
  $followup = $client->messages->create(
      model: 'claude-opus-5-5',
      maxTokens: 1024,
      tools: $tools,
      toolChoice: $toolChoice,
      messages: [
          $userMessage,
          ['role' => 'assistant', 'content' => $response->content],
          [
              'role' => 'user',
              'content' => [
                  [
                      'type' => 'tool_result',
                      'tool_use_id' => $toolUse->id,
                      'content' => $weather,
                  ],
              ],
          ],
      ],
  );

  // Claude nutzt das Ergebnis, um die ursprüngliche Frage zu beantworten.
  foreach ($followup->content as $block) {
      if ($block->type === 'text') {
          echo $block->text, "\n";
      }
  }
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  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: Anthropic::Model::CLAUDE_OPUS_5_5,
    max_tokens: 1024,
    tools: tools,
    # Fordere pro Turn höchstens einen Tool-Aufruf an.
    tool_choice: {type: "auto", disable_parallel_tool_use: true},
    messages: messages
  )
  tool_use = response.content.find { |block| block.type == :tool_use }
  puts "Claude called #{tool_use.name} with #{JSON.generate(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"
  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: Anthropic::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 = followup.content.find { |block| block.type == :text }
  puts final_text.text
  ```
</CodeGroup>

```text Output wrap
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](https://platform.claude.com/docs/de/agents-and-tools/tool-use/handle-tool-calls) behandelt jeden Schritt im Detail, einschließlich der Formatierung von Ergebnissen und der Signalisierung von Fehlern; [Parallele Tool-Nutzung](https://platform.claude.com/docs/de/agents-and-tools/tool-use/parallel-tool-use) behandelt Antworten, die mehrere Tools gleichzeitig aufrufen. Wenn du diesen Ablauf nicht selbst schreiben möchtest, verwende den [Tool Runner](https://platform.claude.com/docs/de/agents-and-tools/tool-use/tool-runner): Das SDK führt deine Tools aus und sendet 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](https://platform.claude.com/docs/de/agents-and-tools/tool-use/how-tool-use-works).

Um dich mit „Model Context Protocol“-Servern, oder MCP-Servern, zu verbinden, siehe den [MCP-Connector](https://platform.claude.com/docs/de/agents-and-tools/mcp-connector). Um deinen eigenen MCP-Client zu erstellen, siehe den Model Context Protocol-Leitfaden zum [Erstellen eines MCP-Clients](https://modelcontextprotocol.io/docs/develop/build-client).

## 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`](https://platform.claude.com/docs/de/agents-and-tools/tool-use/define-tools#forcing-tool-use).

<Tip>
  **Schema-Konformität mit strikter Tool-Nutzung garantieren**

  Füge `strict: true` zu deinen benutzerdefinierten Tool-Definitionen hinzu, um sicherzustellen, dass Claudes Tool-Aufrufe immer exakt deinem Schema entsprechen. Siehe [Strikte Tool-Nutzung](https://platform.claude.com/docs/de/agents-and-tools/tool-use/strict-tool-use).
</Tip>

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

<Accordion title="Wenn erforderliche Parameter fehlen">
  Wenn der Prompt des Nutzers nicht genügend Informationen enthält, um alle erforderlichen Parameter eines Tools zu füllen, erkennt Claude Opus mit deutlich höherer Wahrscheinlichkeit, dass ein Parameter fehlt, und fragt danach. Claude Sonnet fragt möglicherweise nach, insbesondere wenn es aufgefordert wird, vor der Ausgabe einer Tool-Anfrage nachzudenken. Es kann aber auch einen plausiblen Wert ableiten.

  Wenn du beispielsweise bei einem `get_weather`-Tool, das einen `location`-Parameter erfordert, Claude fragst „Wie ist das Wetter?“, ohne einen Ort anzugeben, könnte Claude (insbesondere Claude Sonnet) Werte raten, die du nicht angegeben hast:

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

  Dieses Verhalten ist nicht garantiert, insbesondere bei mehrdeutigeren Prompts und bei weniger leistungsfähigen Modellen.
</Accordion>

## Ein Tool auswählen

Für `type`-Strings, Versionen und Beta-Header siehe die [Tool-Referenz](https://platform.claude.com/docs/de/agents-and-tools/tool-use/tool-reference).

### Deine eigenen Tools

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

<CardGroup cols={2}>
  <Card title="Tools definieren" icon="hammer" href="https://platform.claude.com/docs/de/agents-and-tools/tool-use/define-tools">
    Lege Tool-Schemas fest, schreibe Beschreibungen und steuere, wann Claude deine Tools aufruft.
  </Card>

  <Card title="Tool-Aufrufe verarbeiten" icon="arrows-left-right" href="https://platform.claude.com/docs/de/agents-and-tools/tool-use/handle-tool-calls">
    Parse `tool_use`-Blöcke, formatiere `tool_result`-Antworten und behandle Fehler.
  </Card>
</CardGroup>

### 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.

<CardGroup cols={2}>
  <Card title="Memory-Tool" icon="brain" href="https://platform.claude.com/docs/de/agents-and-tools/tool-use/memory-tool">
    Speichere und rufe Informationen über Gespräche hinweg in Dateien ab, die du kontrollierst.
  </Card>

  <Card title="Bash-Tool" icon="terminal" href="https://platform.claude.com/docs/de/agents-and-tools/tool-use/bash-tool">
    Führe Shell-Befehle in einer persistenten Sitzung aus, die den Zustand beibehält.
  </Card>

  <Card title="Text-Editor-Tool" icon="edit" href="https://platform.claude.com/docs/de/agents-and-tools/tool-use/text-editor-tool">
    Zeige Textdateien an und bearbeite sie, um Code zu debuggen, zu korrigieren und zu verbessern.
  </Card>

  <Card title="Computer-Use-Tool" icon="computer" href="https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool">
    Erstelle Screenshots und steuere Maus und Tastatur in einer Desktop-Umgebung.
  </Card>

  <Card title="Browser-Use-Tool" icon="browser" href="https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-tool">
    Navigiere, lies und interagiere mit Webseiten in deiner eigenen Browser-Umgebung.
  </Card>
</CardGroup>

### Server-Tools

Server-Tools laufen auf der Infrastruktur von Anthropic, ohne Handler-Code in deiner Anwendung. Siehe [Server-Tools](https://platform.claude.com/docs/de/agents-and-tools/tool-use/server-tools) für die gemeinsamen Mechanismen.

<CardGroup cols={2}>
  <Card title="Web-Search-Tool" icon="magnifying-glass" href="https://platform.claude.com/docs/de/agents-and-tools/tool-use/web-search-tool">
    Durchsuche das Web nach Informationen jenseits des Wissensstichtags, mit zitierten Quellen.
  </Card>

  <Card title="Web-Fetch-Tool" icon="download" href="https://platform.claude.com/docs/de/agents-and-tools/tool-use/web-fetch-tool">
    Rufe den vollständigen Inhalt bestimmter Webseiten und PDF-Dokumente ab.
  </Card>

  <Card title="Code-Execution-Tool" icon="code" href="https://platform.claude.com/docs/de/agents-and-tools/tool-use/code-execution-tool">
    Führe Python- und Bash-Code in einem Sandbox-Container aus, um Daten zu analysieren und Dateien zu erzeugen.
  </Card>

  <Card title="Advisor-Tool" icon="lightbulb" href="https://platform.claude.com/docs/de/agents-and-tools/tool-use/advisor-tool">
    Lass ein schnelleres Executor-Modell während der Generierung ein intelligenteres Advisor-Modell konsultieren.
  </Card>

  <Card title="Tool-Search-Tool" icon="library" href="https://platform.claude.com/docs/de/agents-and-tools/tool-use/tool-search-tool">
    Arbeite mit Tausenden von Tools, indem du sie bei Bedarf entdeckst und lädst.
  </Card>

  <Card title="MCP-Connector" icon="link" href="https://platform.claude.com/docs/de/agents-and-tools/mcp-connector">
    Verbinde dich über die Messages API mit entfernten MCP-Servern, ohne einen separaten MCP-Client.
  </Card>
</CardGroup>

<Note>
  [Claude Managed Agents](https://platform.claude.com/docs/de/managed-agents/overview) stellt ein integriertes Toolset bereit, das Claude innerhalb einer Sitzung autonom verwendet. Für dieses Toolset und die Managed-Agents-Methode zum Hinzufügen benutzerdefinierter Tools siehe die zugehörige Seite [Tools](https://platform.claude.com/docs/de/managed-agents/tools).
</Note>

## 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 folgende Tabelle listet die Anzahl der Tool-Nutzungs-Token auf, die jedes Modell benötigt (ohne die zuvor genannten zusätzlichen Token). Die Tabelle geht davon aus, dass du mindestens ein Tool bereitstellst. Wenn du keine `tools` bereitstellst, verbraucht eine Tool-Auswahl von `none` 0 zusätzliche System-Prompt-Token.

| Model                                                                                                                                                                  | Tool use system prompt tokens: auto, none | Tool use system prompt tokens: any, tool |
| :--------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :---------------------------------------- | :--------------------------------------- |
| Claude Opus 5.5                                                                                                                                                        | 286 tokens                                |                                          |
| Claude Opus 5                                                                                                                                                          | 286 tokens                                | 406 tokens                               |
| Claude Opus 4.8                                                                                                                                                        | 290 tokens                                | 410 tokens                               |
| Claude Opus 4.7                                                                                                                                                        | 675 tokens                                | 804 tokens                               |
| Claude Opus 4.6                                                                                                                                                        | 497 tokens                                | 589 tokens                               |
| Claude Opus 4.5                                                                                                                                                        | 496 tokens                                | 588 tokens                               |
| Claude Opus 4.1 ([retired, except on Claude Models on Google Cloud (Google managed) and Bedrock](https://platform.claude.com/docs/de/about-claude/model-deprecations)) | 313 tokens                                | 315 tokens                               |
| Claude Opus 4 ([retired, except on Claude Models on Google Cloud (Google managed)](https://platform.claude.com/docs/de/about-claude/model-deprecations))               | 313 tokens                                | 315 tokens                               |
| Claude Sonnet 5.5                                                                                                                                                      | 286 tokens                                |                                          |
| Claude Sonnet 5                                                                                                                                                        | 354 tokens                                | 474 tokens                               |
| Claude Sonnet 4.6                                                                                                                                                      | 497 tokens                                | 589 tokens                               |
| Claude Sonnet 4.5                                                                                                                                                      | 496 tokens                                | 588 tokens                               |
| Claude Sonnet 4 ([retired, except on Claude Models on Google Cloud (Google managed) and Bedrock](https://platform.claude.com/docs/de/about-claude/model-deprecations)) | 313 tokens                                | 315 tokens                               |
| Claude Haiku 5.5                                                                                                                                                       | 286 tokens                                | 406 tokens                               |
| Claude Haiku 4.5                                                                                                                                                       | 496 tokens                                | 588 tokens                               |

* **auto, none:** The count when tool\_choice is auto or none.
* **any, tool:** The count when tool\_choice is any or tool.
* **Retired:** May still be available on other cloud platforms. See [Model deprecations](https://platform.claude.com/docs/de/about-claude/model-deprecations) for more.

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

Die aktuellen Preise pro Modell findest du in der Tabelle [Alle Modelle](https://platform.claude.com/docs/de/models/overview#all-models).

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

Einige Server-Tools berechnen zusätzlich zu den Token nutzungsbasierte Gebühren: Siehe [Nutzung und Preise des Web-Search-Tools](https://platform.claude.com/docs/de/agents-and-tools/tool-use/web-search-tool#usage-and-pricing) und [Nutzung und Preise des Code-Execution-Tools](https://platform.claude.com/docs/de/agents-and-tools/tool-use/code-execution-tool#usage-and-pricing) für deren Tarife.

## Nächste Schritte

<CardGroup cols={3}>
  <Card href="https://platform.claude.com/docs/de/agents-and-tools/tool-use/how-tool-use-works" title="So funktioniert Tool-Nutzung" icon="compass">
    Verstehe die Tool-Nutzungsschleife, wo Tools ausgeführt werden und wann du Tools statt Fließtext verwenden solltest.
  </Card>

  <Card href="https://platform.claude.com/docs/de/agents-and-tools/tool-use/build-a-tool-using-agent" title="Tutorial: Einen Tool-nutzenden Agenten erstellen" icon="graduation-cap">
    Eine geführte Anleitung von einem einzelnen Tool-Aufruf bis zu einer produktionsreifen agentischen Schleife.
  </Card>

  <Card href="https://platform.claude.com/docs/de/agents-and-tools/tool-use/tool-reference" title="Tool-Referenz" icon="book">
    Verzeichnis der von Anthropic bereitgestellten Tools und Referenz für optionale Eigenschaften von Tool-Definitionen.
  </Card>
</CardGroup>
