---
title: Использование инструментов с Claude
url: https://platform.claude.com/docs/ru/agents-and-tools/tool-use/overview
description: Подключите Claude к внешним инструментам и API. Узнайте, где выполняются инструменты, когда Claude их вызывает и какой инструмент подходит для вашей задачи.
---

«Tool use» (использование инструментов), также называемое «function calling» (вызов функций), позволяет Claude вызывать функции, которые определяете вы или предоставляет Anthropic. Claude решает, когда вызвать инструмент, исходя из запроса пользователя и описания инструмента. Затем он возвращает структурированный вызов, который выполняет ваше приложение («client tools», клиентские инструменты) или Anthropic («server tools», серверные инструменты).

Вот минимальный пример с серверным инструментом — [инструментом веб-поиска](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/web-search-tool), который Anthropic выполняет за вас:

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "content-type: application/json" \
    -d '{
      "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?"}]
    }'
  ```

  ```bash CLI
  ant messages create --transform content --format yaml \
    --model claude-opus-5-5 \
    --max-tokens 1024 \
    --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=1024,
      tools=[{"type": "web_search_20260209", "name": "web_search"}],
      messages=[{"role": "user", "content": "What's 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: 1024,
    tools: [{ type: "web_search_20260209", name: "web_search" }],
    messages: [{ role: "user", content: "What's the latest on the Mars rover?" }]
  });
  console.log(response.content);
  ```

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

  var parameters = new MessageCreateParams
  {
      Model = Model.ClaudeOpus5_5,
      MaxTokens = 1024,
      Tools = [new ToolUnion(new WebSearchTool20260209())],
      Messages = [new() { Role = Role.User, Content = "What's 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: 1024,
  	Tools: []anthropic.ToolUnionParam{
  		{OfWebSearchTool20260209: &anthropic.WebSearchTool20260209Param{}},
  	},
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock("What's 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(1024L)
          .addTool(WebSearchTool20260209.builder().build())
          .addUserMessage("What's 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: 1024,
      tools: [
          ['type' => 'web_search_20260209', 'name' => 'web_search'],
      ],
      messages: [
          ['role' => 'user', 'content' => "What's the latest on the Mars rover?"],
      ],
  );

  echo $message;
  ```

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

  message = 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?" }]
  )
  puts message.content
  ```
</CodeGroup>

Claude выполняет поиск в инфраструктуре Anthropic и возвращает результаты с цитатами в том же ответе. Чтобы Claude вызвал функцию, которую определяете вы, передайте инструмент с `input_schema`, а затем выполните вызов, когда Claude вернёт блок `tool_use`. В разделе [Как работает использование инструментов](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/overview#how-tool-use-works) этот полный цикл обмена показан от начала до конца. Узнайте больше об [определении инструментов](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/define-tools) и [обработке вызовов инструментов](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/handle-tool-calls).

## Как работает использование инструментов

Инструменты различаются прежде всего тем, где выполняется код. **Клиентские инструменты** (включая пользовательские инструменты и инструменты со схемами, определёнными Anthropic, такие как `bash` и `text_editor`) выполняются в вашем приложении. Claude отвечает с `stop_reason: "tool_use"` и одним или несколькими блоками `tool_use`. Ваш код выполняет операцию и отправляет обратно `tool_result`. **Серверные инструменты** (такие как `web_search`, `web_fetch`, `code_execution` и `tool_search`) выполняются в инфраструктуре Anthropic: вы получаете результаты напрямую, не занимаясь выполнением, если только Claude не вызывает инструмент в той же группе параллельных вызовов инструментов, что и один из ваших клиентских инструментов (см. [Причины остановки и резервные варианты](https://platform.claude.com/docs/ru/build-with-claude/handling-stop-reasons#tool-use)).

Вот этот цикл обмена целиком для клиентского инструмента. Первый запрос определяет инструмент `get_weather`, и Claude отвечает на вопрос, вызывая его: ответ содержит блок `tool_use`, ваш код выполняет поиск данных, а второй запрос отправляет результат обратно в блоке `tool_result`, чтобы Claude мог дать ответ.

<CodeGroup>
  ```bash cURL
  # Claude отвечает блоком tool_use с именем инструмента и его аргументами.
  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"]
      }
    }
  ]'
  USER_MSG="What's the weather in San Francisco?"
  RESPONSE=$(curl -s https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "content-type: application/json" \
    -d "$(jq -n --argjson tools "$TOOLS" --arg msg "$USER_MSG" '{
      model: "claude-opus-5-5",
      max_tokens: 1024,
      tools: $tools,
      # Запрашивайте не более одного вызова инструмента за ход.
      tool_choice: {type: "auto", disable_parallel_tool_use: true},
      messages: [{role: "user", content: $msg}]
    }')")
  TOOL_USE=$(echo "$RESPONSE" | jq '.content[] | select(.type == "tool_use")')
  echo "Claude called $(echo "$TOOL_USE" | jq -r '.name') with $(echo "$TOOL_USE" | jq -c '.input')"

  # Выполните инструмент, затем отправьте результат обратно в блоке tool_result.
  # Claude использует результат, чтобы ответить на исходный вопрос.
  WEATHER="15 degrees Celsius, partly cloudy"
  curl -s https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "content-type: application/json" \
    -d "$(jq -n \
      --argjson tools "$TOOLS" \
      --arg msg "$USER_MSG" \
      --argjson assistant "$(echo "$RESPONSE" | jq '.content')" \
      --arg tool_use_id "$(echo "$TOOL_USE" | jq -r '.id')" \
      --arg weather "$WEATHER" \
      '{
        model: "claude-opus-5-5",
        max_tokens: 1024,
        tools: $tools,
        tool_choice: {type: "auto", disable_parallel_tool_use: true},
        messages: [
          {role: "user", content: $msg},
          {role: "assistant", content: $assistant},
          {role: "user", content: [
            {type: "tool_result", tool_use_id: $tool_use_id, content: $weather}
          ]}
        ]
      }')"
  ```

  ```bash CLI
  # ant читает тело запроса в формате YAML из stdin; jq переносит состояние
  # диалога во второй запрос.
  USER_MSG="What's the weather in San Francisco?"
  MESSAGES=$(jq -n --arg msg "$USER_MSG" '[{role: "user", content: $msg}]')
  call_api() {
    {
      cat <<'YAML'
  model: claude-opus-5-5
  max_tokens: 1024
  # Запрашиваем не более одного вызова инструмента за ход.
  tool_choice: {type: auto, disable_parallel_tool_use: true}
  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]
  YAML
      printf 'messages: %s\n' "$MESSAGES"
    } | ant messages create --format json
  }

  # Claude отвечает блоком tool_use с именем инструмента и его аргументами.
  RESPONSE=$(call_api)
  TOOL_USE=$(jq '.content[] | select(.type == "tool_use")' <<<"$RESPONSE")
  echo "Claude called $(jq -r '.name' <<<"$TOOL_USE") with $(jq -c '.input' <<<"$TOOL_USE")"

  # Выполните инструмент, затем отправьте результат обратно в блоке tool_result.
  WEATHER="15 degrees Celsius, partly cloudy"
  MESSAGES=$(jq \
    --argjson assistant "$(jq '.content' <<<"$RESPONSE")" \
    --arg tool_use_id "$(jq -r '.id' <<<"$TOOL_USE")" \
    --arg weather "$WEATHER" \
    '. + [
      {role: "assistant", content: $assistant},
      {role: "user", content: [
        {type: "tool_result", tool_use_id: $tool_use_id, content: $weather}
      ]}
    ]' <<<"$MESSAGES")

  # Claude использует результат, чтобы ответить на исходный вопрос.
  call_api
  ```

  ```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 отвечает блоком tool_use с именем инструмента и его аргументами.
  response = client.messages.create(
      model="claude-opus-5-5",
      max_tokens=1024,
      tools=tools,
      # Запрашивайте не более одного вызова инструмента за ход.
      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)}")

  # Выполните инструмент, затем отправьте результат обратно в блоке tool_result.
  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 использует результат, чтобы ответить на исходный вопрос.
  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 отвечает блоком tool_use с именем инструмента и его аргументами.
  const response = await client.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 1024,
    tools,
    // Запрашивайте не более одного вызова инструмента за ход.
    tool_choice: { type: "auto", disable_parallel_tool_use: true },
    messages
  });
  const toolUse = response.content.find(
    (block): block is Anthropic.ToolUseBlock => block.type === "tool_use"
  )!;
  console.log(`Claude called ${toolUse.name} with ${JSON.stringify(toolUse.input)}`);

  // Выполните инструмент, затем отправьте результат обратно в блоке tool_result.
  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 использует результат, чтобы ответить на исходный вопрос.
  const finalText = followup.content.find(
    (block): block is Anthropic.TextBlock => 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"],
          },
      }),
  ];

  // Запрашивайте не более одного вызова инструмента за ход.
  var toolChoice = new ToolChoice(new ToolChoiceAuto { DisableParallelToolUse = true });

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

  // Claude отвечает блоком tool_use с именем инструмента и его аргументами.
  var response = await client.Messages.Create(new MessageCreateParams
  {
      Model = Model.ClaudeOpus5_5,
      MaxTokens = 1024,
      Tools = tools,
      ToolChoice = toolChoice,
      Messages = [new() { Role = Role.User, 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)}");

  // Выполните инструмент, затем отправьте результат обратно в блоке tool_result.
  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() { Role = Role.User, Content = userPrompt },
          new() { Role = Role.Assistant, Content = response.Content.Select(block => new ContentBlockParam(block.Json)).ToList() },
          new() { Role = Role.User, Content = new MessageParamContent(toolResults) },
      ],
  });

  // Claude использует результат, чтобы ответить на исходный вопрос.
  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"},
  		},
  	}},
  }
  // Запрашивайте не более одного вызова инструмента за ход.
  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 отвечает блоком tool_use с именем инструмента и его аргументами.
  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))

  // Выполните инструмент, затем отправьте результат обратно в блоке tool_result.
  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 использует результат, чтобы ответить на исходный вопрос.
  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();

      // Запрашивайте не более одного вызова инструмента за ход.
      ToolChoiceAuto toolChoice = ToolChoiceAuto.builder()
          .disableParallelToolUse(true)
          .build();

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

      // Claude отвечает блоком tool_use с именем инструмента и его аргументами.
      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());

      // Выполните инструмент, затем отправьте результат обратно в блоке tool_result.
      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)
          .addUserMessageOfBlockParams(List.of(ContentBlockParam.ofToolResult(
              ToolResultBlockParam.builder()
                  .toolUseId(toolUse.id())
                  .content(weather)
                  .build())))
          .build());

      // Claude использует результат, чтобы ответить на исходный вопрос.
      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?"];

  // Запрашивайте не более одного вызова инструмента за ход.
  $toolChoice = ToolChoiceAuto::with(disableParallelToolUse: true);

  // Claude отвечает блоком tool_use с именем инструмента и его аргументами.
  $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));

  // Выполните инструмент, затем отправьте результат обратно в блоке tool_result.
  $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 использует результат, чтобы ответить на исходный вопрос.
  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 отвечает блоком tool_use с именем инструмента и его аргументами.
  response = client.messages.create(
    model: "claude-opus-5-5",
    max_tokens: 1024,
    tools: tools,
    # Запрашивайте не более одного вызова инструмента за ход.
    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)}"

  # Выполните инструмент, затем отправьте результат обратно в блоке tool_result.
  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: "claude-opus-5-5",
    max_tokens: 1024,
    tools: tools,
    tool_choice: {type: "auto", disable_parallel_tool_use: true},
    messages: messages
  )

  # Claude использует результат, чтобы ответить на исходный вопрос.
  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.
```

В разделе [Обработка вызовов инструментов](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/handle-tool-calls) подробно описан каждый шаг, включая форматирование результатов и сигнализацию об ошибках; в разделе [Параллельное использование инструментов](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/parallel-tool-use) описаны ответы, вызывающие несколько инструментов одновременно. Чтобы не писать этот цикл самостоятельно, используйте [Tool Runner](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/tool-runner): SDK выполняет ваши инструменты и автоматически отправляет результаты обратно.

Полную концептуальную модель, включая «agentic loop» (агентный цикл) и рекомендации по выбору каждого подхода, см. в разделе [Как работает использование инструментов](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/how-tool-use-works).

Чтобы подключиться к серверам «Model Context Protocol», или MCP, см. [коннектор MCP](https://platform.claude.com/docs/ru/agents-and-tools/mcp-connector). Чтобы создать собственный клиент MCP, см. руководство Model Context Protocol по [созданию клиента MCP](https://modelcontextprotocol.io/docs/develop/build-client).

## Когда Claude использует инструменты

При значении `tool_choice` по умолчанию `{"type": "auto"}` Claude на каждом ходе определяет, вызвать ли инструмент или ответить напрямую. Он вызывает инструмент, когда запрос соответствует описанной возможности этого инструмента, а ответа ещё нет в контексте. Он отвечает напрямую в случае устойчивых знаний, творческих задач и разговорных реплик.

Эту границу можно регулировать через вашу «system prompt» (системную подсказку). Если Claude не вызывает инструменты, когда вы этого ожидаете, лёгкая инструкция вроде `"Use the tools to investigate before responding."` увеличивает использование инструментов. Более сильная форма, например `"Always call a tool first before responding."`, действует ещё настойчивее. И наоборот, `"Use your judgment about whether to call a tool or respond directly."` сохраняет поведение срабатывания консервативным.

Чтобы потребовать вызов инструмента, а не полагаться на подсказки, задайте [`tool_choice`](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/define-tools#forcing-tool-use).

<Tip>
  **Гарантируйте соответствие схеме с помощью строгого использования инструментов**

  Добавьте `strict: true` в определения ваших пользовательских инструментов, чтобы вызовы инструментов Claude всегда точно соответствовали вашей схеме. См. [Строгое использование инструментов](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/strict-tool-use).
</Tip>

Страница каждого серверного инструмента более подробно описывает его собственную границу срабатывания.

<Accordion title="Когда отсутствуют обязательные параметры">
  Если подсказка пользователя не содержит достаточно информации для заполнения всех обязательных параметров инструмента, Claude Opus с гораздо большей вероятностью распознает, что параметр отсутствует, и запросит его. Claude Sonnet может спросить, особенно если ему предложено подумать перед выводом запроса инструмента. Но он также может вывести разумное значение самостоятельно.

  Например, при наличии инструмента `get_weather`, требующего параметр `location`, если вы спросите Claude «Какая погода?», не указав местоположение, Claude (особенно Claude Sonnet) может угадать значения, которые вы не предоставили:

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

  Такое поведение не гарантируется, особенно для более неоднозначных подсказок и менее способных моделей.
</Accordion>

## Выбор инструмента

Строки `type`, версии и бета-заголовки см. в [Справочнике по инструментам](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/tool-reference).

### Ваши собственные инструменты

Для инструментов, которые определяете вы, вы пишете схему, а ваше приложение выполняет каждый вызов.

<CardGroup cols={2}>
  <Card title="Определение инструментов" icon="hammer" href="https://platform.claude.com/docs/ru/agents-and-tools/tool-use/define-tools">
    Задавайте схемы инструментов, пишите описания и управляйте тем, когда Claude вызывает ваши инструменты.
  </Card>

  <Card title="Обработка вызовов инструментов" icon="arrows-left-right" href="https://platform.claude.com/docs/ru/agents-and-tools/tool-use/handle-tool-calls">
    Разбирайте блоки `tool_use`, форматируйте ответы `tool_result` и обрабатывайте ошибки.
  </Card>
</CardGroup>

### Клиентские инструменты со схемой Anthropic

Anthropic публикует схему и обучает Claude на ней. Ваше приложение по-прежнему выполняет каждый вызов и возвращает `tool_result`.

<CardGroup cols={2}>
  <Card title="Инструмент памяти" icon="brain" href="https://platform.claude.com/docs/ru/agents-and-tools/tool-use/memory-tool">
    Сохраняйте и извлекайте информацию между разговорами в файлах, которые вы контролируете.
  </Card>

  <Card title="Инструмент Bash" icon="terminal" href="https://platform.claude.com/docs/ru/agents-and-tools/tool-use/bash-tool">
    Выполняйте команды оболочки в постоянном сеансе, сохраняющем состояние.
  </Card>

  <Card title="Инструмент текстового редактора" icon="edit" href="https://platform.claude.com/docs/ru/agents-and-tools/tool-use/text-editor-tool">
    Просматривайте и изменяйте текстовые файлы для отладки, исправления и улучшения кода.
  </Card>

  <Card title="Инструмент использования компьютера" icon="computer" href="https://platform.claude.com/docs/ru/agents-and-tools/tool-use/computer-use-tool">
    Делайте снимки экрана и управляйте мышью и клавиатурой в среде рабочего стола.
  </Card>

  <Card title="Инструмент использования браузера" icon="browser" href="https://platform.claude.com/docs/ru/agents-and-tools/tool-use/browser-use-tool">
    Перемещайтесь по веб-страницам, читайте их и взаимодействуйте с ними в вашей собственной браузерной среде.
  </Card>
</CardGroup>

### Серверные инструменты

Серверные инструменты выполняются на инфраструктуре Anthropic без кода обработчиков в вашем приложении. Общие для них механизмы см. в разделе [Серверные инструменты](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/server-tools).

<CardGroup cols={2}>
  <Card title="Инструмент веб-поиска" icon="magnifying-glass" href="https://platform.claude.com/docs/ru/agents-and-tools/tool-use/web-search-tool">
    Ищите в интернете информацию за пределами даты отсечения знаний, с цитируемыми источниками.
  </Card>

  <Card title="Инструмент веб-загрузки" icon="download" href="https://platform.claude.com/docs/ru/agents-and-tools/tool-use/web-fetch-tool">
    Получайте полное содержимое указанных веб-страниц и PDF-документов.
  </Card>

  <Card title="Инструмент выполнения кода" icon="code" href="https://platform.claude.com/docs/ru/agents-and-tools/tool-use/code-execution-tool">
    Выполняйте код Python и bash в изолированном контейнере для анализа данных и создания файлов.
  </Card>

  <Card title="Инструмент советника" icon="lightbulb" href="https://platform.claude.com/docs/ru/agents-and-tools/tool-use/advisor-tool">
    Позвольте более быстрой модели-исполнителю консультироваться с более интеллектуальной моделью-советником в процессе генерации.
  </Card>

  <Card title="Инструмент поиска инструментов" icon="library" href="https://platform.claude.com/docs/ru/agents-and-tools/tool-use/tool-search-tool">
    Работайте с тысячами инструментов, обнаруживая и загружая их по требованию.
  </Card>

  <Card title="Коннектор MCP" icon="link" href="https://platform.claude.com/docs/ru/agents-and-tools/mcp-connector">
    Подключайтесь к удалённым серверам MCP из Messages API без отдельного клиента MCP.
  </Card>
</CardGroup>

<Note>
  [Claude Managed Agents](https://platform.claude.com/docs/ru/managed-agents/overview) предоставляет встроенный набор инструментов, который Claude использует автономно в рамках сеанса. Об этом наборе инструментов и способе добавления пользовательских инструментов в Managed Agents см. страницу [Инструменты](https://platform.claude.com/docs/ru/managed-agents/tools).
</Note>

## Цены

Запросы с использованием инструментов (tool use) тарифицируются на основе:

1. Общего количества входных токенов, отправленных модели (включая параметр `tools`)
2. Количества сгенерированных выходных токенов
3. Для серверных инструментов — дополнительной тарификации на основе использования (например, веб-поиск взимает плату за каждый выполненный поиск)

Клиентские инструменты тарифицируются так же, как и любой другой запрос к Claude API, хотя серверные инструменты могут повлечь дополнительные расходы в зависимости от их конкретного использования.

Дополнительные токены при использовании инструментов возникают из:

* Параметра `tools` в запросах API (имена инструментов, описания и схемы)
* Блоков содержимого `tool_use` в запросах и ответах API
* Блоков содержимого `tool_result` в запросах API

Когда вы используете `tools`, API также автоматически включает специальную системную подсказку (system prompt) для модели, которая обеспечивает использование инструментов. Количество токенов использования инструментов, необходимое для каждой модели, указано в следующей таблице (без учёта дополнительных токенов, перечисленных выше). Обратите внимание, что таблица предполагает, что предоставлен как минимум 1 инструмент. Если `tools` не предоставлены, то выбор инструмента `none` использует 0 дополнительных токенов системной подсказки.

| 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 Bedrock and Google Cloud](https://platform.claude.com/docs/ru/about-claude/model-deprecations)) | 313 tokens                                | 315 tokens                               |
| Claude Opus 4 ([retired, except on Google Cloud](https://platform.claude.com/docs/ru/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 Bedrock and Google Cloud](https://platform.claude.com/docs/ru/about-claude/model-deprecations)) | 313 tokens                                | 315 tokens                               |
| Claude Haiku 5.5                                                                                                                     | 286 tokens                                | 406 tokens                               |
| Claude Haiku 4.5                                                                                                                     | 496 tokens                                | 588 tokens                               |
| Claude Haiku 3.5 ([retired, except on Google Cloud](https://platform.claude.com/docs/ru/about-claude/model-deprecations))            | 264 tokens                                | 355 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/ru/about-claude/model-deprecations) for more.

Эти количества токенов добавляются к вашим обычным входным и выходным токенам для расчёта общей стоимости запроса.

Актуальные цены по моделям см. в таблице [Обзор моделей](https://platform.claude.com/docs/ru/models/overview#latest-models-comparison).

Когда вы отправляете подсказку с использованием инструментов, как и при любом другом запросе API, ответ включает количество как входных, так и выходных токенов в сообщаемых метриках `usage`.

Некоторые серверные инструменты добавляют плату на основе использования сверх токенов: их тарифы см. в разделах [Инструмент веб-поиска](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/web-search-tool#usage-and-pricing) и [Инструмент выполнения кода](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/code-execution-tool#usage-and-pricing).

## Следующие шаги

<CardGroup cols={3}>
  <Card href="https://platform.claude.com/docs/ru/agents-and-tools/tool-use/how-tool-use-works" title="Как работает использование инструментов" icon="compass">
    Разберитесь в цикле использования инструментов, где выполняются инструменты и когда использовать инструменты вместо текста.
  </Card>

  <Card href="https://platform.claude.com/docs/ru/agents-and-tools/tool-use/build-a-tool-using-agent" title="Руководство: создание агента, использующего инструменты" icon="graduation-cap">
    Пошаговое руководство от одного вызова инструмента до готового к продакшену агентного цикла.
  </Card>

  <Card href="https://platform.claude.com/docs/ru/agents-and-tools/tool-use/tool-reference" title="Справочник по инструментам" icon="book">
    Каталог инструментов, предоставляемых Anthropic, и справочник по необязательным свойствам определения инструментов.
  </Card>
</CardGroup>