---
title: Utilisation d'outils avec Claude
url: https://platform.claude.com/docs/fr/agents-and-tools/tool-use/overview
description: Connectez Claude à des outils et API externes. Découvrez où les outils s'exécutent, quand Claude les appelle et quel outil convient à votre tâche.
---

Le « tool use » (utilisation d'outils), également appelé « function calling » (appel de fonctions), permet à Claude d'appeler des fonctions que vous définissez ou qu'Anthropic fournit. Claude détermine quand appeler un outil en fonction de la demande de l'utilisateur et de la description de l'outil. Il renvoie ensuite un appel structuré que votre application exécute (outils client) ou qu'Anthropic exécute (outils serveur).

Voici un exemple minimal utilisant un outil serveur, l'[outil de recherche web](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/web-search-tool), qu'Anthropic exécute pour vous :

<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 exécute la recherche sur l'infrastructure d'Anthropic et renvoie les résultats cités dans la même réponse. Pour que Claude appelle une fonction que vous définissez, transmettez un outil avec un `input_schema`, puis exécutez l'appel lorsque Claude renvoie un bloc `tool_use`. La section [Fonctionnement de l'utilisation d'outils](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/overview#how-tool-use-works) montre cet aller-retour de bout en bout. Apprenez-en davantage sur la [définition des outils](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/define-tools) et la [gestion des appels d'outils](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/handle-tool-calls).

## Fonctionnement de l'utilisation d'outils

Les outils diffèrent principalement par l'endroit où le code s'exécute. Les **outils client** (y compris les outils définis par l'utilisateur et les outils dont le schéma est défini par Anthropic, tels que `bash` et `text_editor`) s'exécutent dans votre application. Claude répond avec `stop_reason: "tool_use"` et un ou plusieurs blocs `tool_use`. Votre code exécute l'opération et renvoie un `tool_result`. Les **outils serveur** (tels que `web_search`, `web_fetch`, `code_execution` et `tool_search`) s'exécutent sur l'infrastructure d'Anthropic : vous voyez les résultats directement sans gérer l'exécution, sauf si Claude appelle l'outil dans le même groupe d'appels d'outils parallèles que l'un de vos outils client (voir [Raisons d'arrêt et solution de repli](https://platform.claude.com/docs/fr/build-with-claude/handling-stop-reasons#tool-use)).

Voici cet aller-retour complet pour un outil client. La première requête définit un outil `get_weather`, et Claude répond à la question en l'appelant : la réponse contient un bloc `tool_use`, votre code effectue la recherche, et une seconde requête renvoie le résultat dans un bloc `tool_result` afin que Claude puisse répondre avec la réponse.

<CodeGroup>
  ```bash cURL
  # Claude répond avec un bloc tool_use nommant l'outil et ses arguments.
  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,
      # Demandez au plus un seul appel à un outil par tour.
      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')"

  # Exécutez l'outil, puis renvoyez le résultat dans un bloc tool_result.
  # Claude utilise le résultat pour répondre à la question initiale.
  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 lit le corps de la requête au format YAML sur stdin ; jq transmet
  # l'état de la conversation dans la seconde requête.
  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
  # Demander au plus un appel d'outil par tour.
  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 répond avec un bloc tool_use nommant l'outil et ses arguments.
  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")"

  # Exécutez l'outil, puis renvoyez le résultat dans un bloc 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 utilise le résultat pour répondre à la question initiale.
  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 répond avec un bloc tool_use nommant l'outil et ses arguments.
  response = client.messages.create(
      model="claude-opus-5-5",
      max_tokens=1024,
      tools=tools,
      # Demandez au plus un appel d'outil par tour.
      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)}")

  # Exécutez l'outil, puis renvoyez le résultat dans un bloc 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 utilise le résultat pour répondre à la question initiale.
  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 répond avec un bloc tool_use nommant l'outil et ses arguments.
  const response = await client.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 1024,
    tools,
    // Demandez au maximum un appel d'outil par tour.
    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)}`);

  // Exécutez l'outil, puis renvoyez le résultat dans un bloc 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 utilise le résultat pour répondre à la question initiale.
  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"],
          },
      }),
  ];

  // Demandez au maximum un appel d'outil par tour.
  var toolChoice = new ToolChoice(new ToolChoiceAuto { DisableParallelToolUse = true });

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

  // Claude répond avec un bloc tool_use nommant l'outil et ses arguments.
  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)}");

  // Exécutez l'outil, puis renvoyez le résultat dans un bloc 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 utilise le résultat pour répondre à la question initiale.
  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"},
  		},
  	}},
  }
  // Demandez au plus un appel d'outil par tour.
  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 répond avec un bloc tool_use nommant l'outil et ses arguments.
  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))

  // Exécutez l'outil, puis renvoyez le résultat dans un bloc 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 utilise le résultat pour répondre à la question initiale.
  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();

      // Demandez au plus un appel d'outil par tour.
      ToolChoiceAuto toolChoice = ToolChoiceAuto.builder()
          .disableParallelToolUse(true)
          .build();

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

      // Claude répond avec un bloc tool_use nommant l'outil et ses arguments.
      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());

      // Exécutez l'outil, puis renvoyez le résultat dans un bloc 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 utilise le résultat pour répondre à la question initiale.
      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?"];

  // Demandez au plus un appel d'outil par tour.
  $toolChoice = ToolChoiceAuto::with(disableParallelToolUse: true);

  // Claude répond avec un bloc tool_use nommant l'outil et ses arguments.
  $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));

  // Exécutez l'outil, puis renvoyez le résultat dans un bloc 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 utilise le résultat pour répondre à la question initiale.
  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 répond avec un bloc tool_use nommant l'outil et ses arguments.
  response = client.messages.create(
    model: "claude-opus-5-5",
    max_tokens: 1024,
    tools: tools,
    # Demandez au plus un appel d'outil par tour.
    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)}"

  # Exécutez l'outil, puis renvoyez le résultat dans un bloc 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 utilise le résultat pour répondre à la question initiale.
  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.
```

[Gérer les appels d'outils](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/handle-tool-calls) couvre chaque étape en détail, y compris le formatage des résultats et la signalisation des erreurs ; [Utilisation d'outils en parallèle](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/parallel-tool-use) couvre les réponses qui appellent plusieurs outils à la fois. Pour éviter d'écrire vous-même cet aller-retour, utilisez [Tool Runner](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/tool-runner) : le SDK exécute vos outils et renvoie automatiquement les résultats.

Pour le modèle conceptuel complet, y compris la boucle agentique et le moment où choisir chaque approche, consultez [Fonctionnement de l'utilisation d'outils](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/how-tool-use-works).

Pour vous connecter à des serveurs « Model Context Protocol », ou MCP, consultez le [connecteur MCP](https://platform.claude.com/docs/fr/agents-and-tools/mcp-connector). Pour créer votre propre client MCP, consultez le guide Model Context Protocol sur la [création d'un client MCP](https://modelcontextprotocol.io/docs/develop/build-client).

## Quand Claude utilise des outils

Avec la valeur par défaut de `tool_choice`, `{"type": "auto"}`, Claude détermine à chaque tour s'il doit appeler un outil ou répondre directement. Il appelle un outil lorsque la demande correspond à la capacité décrite de cet outil et que la réponse ne se trouve pas déjà dans le contexte. Il répond directement pour les connaissances stables, les tâches créatives et les tours conversationnels.

Cette frontière est ajustable via votre invite système. Si Claude n'appelle pas les outils lorsque vous vous y attendez, une instruction légère telle que `"Use the tools to investigate before responding."` augmente l'utilisation d'outils. Une forme plus forte telle que `"Always call a tool first before responding."` pousse plus loin. À l'inverse, `"Use your judgment about whether to call a tool or respond directly."` maintient un comportement de déclenchement prudent.

Pour exiger un appel d'outil plutôt que de vous fier au prompt, définissez [`tool_choice`](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/define-tools#forcing-tool-use).

<Tip>
  **Garantissez la conformité au schéma avec l'utilisation d'outils stricte**

  Ajoutez `strict: true` à vos définitions d'outils personnalisés pour garantir que les appels d'outils de Claude correspondent toujours exactement à votre schéma. Consultez [Utilisation d'outils stricte](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/strict-tool-use).
</Tip>

La page de chaque outil serveur décrit plus en détail sa propre frontière de déclenchement.

<Accordion title="Lorsque des paramètres requis sont manquants">
  Si le prompt de l'utilisateur ne contient pas suffisamment d'informations pour remplir tous les paramètres requis d'un outil, Claude Opus est beaucoup plus susceptible de reconnaître qu'un paramètre est manquant et de le demander. Claude Sonnet peut le demander, en particulier lorsqu'on l'invite à réfléchir avant de produire une requête d'outil. Mais il peut aussi déduire une valeur raisonnable.

  Par exemple, avec un outil `get_weather` qui requiert un paramètre `location`, si vous demandez à Claude « Quel temps fait-il ? » sans préciser de lieu, Claude (en particulier Claude Sonnet) peut deviner des valeurs que vous n'avez pas fournies :

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

  Ce comportement n'est pas garanti, en particulier pour les prompts plus ambigus et pour les modèles moins performants.
</Accordion>

## Choisir un outil

Pour les chaînes `type`, les versions et les en-têtes bêta, consultez la [Référence des outils](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/tool-reference).

### Vos propres outils

Pour les outils que vous définissez, vous écrivez le schéma et votre application exécute chaque appel.

<CardGroup cols={2}>
  <Card title="Définir des outils" icon="hammer" href="https://platform.claude.com/docs/fr/agents-and-tools/tool-use/define-tools">
    Spécifiez les schémas d'outils, rédigez les descriptions et contrôlez quand Claude appelle vos outils.
  </Card>

  <Card title="Gérer les appels d'outils" icon="arrows-left-right" href="https://platform.claude.com/docs/fr/agents-and-tools/tool-use/handle-tool-calls">
    Analysez les blocs `tool_use`, formatez les réponses `tool_result` et gérez les erreurs.
  </Card>
</CardGroup>

### Outils client à schéma Anthropic

Anthropic publie le schéma et entraîne Claude dessus. Votre application exécute toujours chaque appel et renvoie le `tool_result`.

<CardGroup cols={2}>
  <Card title="Outil de mémoire" icon="brain" href="https://platform.claude.com/docs/fr/agents-and-tools/tool-use/memory-tool">
    Stockez et récupérez des informations d'une conversation à l'autre dans des fichiers que vous contrôlez.
  </Card>

  <Card title="Outil Bash" icon="terminal" href="https://platform.claude.com/docs/fr/agents-and-tools/tool-use/bash-tool">
    Exécutez des commandes shell dans une session persistante qui conserve l'état.
  </Card>

  <Card title="Outil d'édition de texte" icon="edit" href="https://platform.claude.com/docs/fr/agents-and-tools/tool-use/text-editor-tool">
    Affichez et modifiez des fichiers texte pour déboguer, corriger et améliorer du code.
  </Card>

  <Card title="Outil d'utilisation de l'ordinateur" icon="computer" href="https://platform.claude.com/docs/fr/agents-and-tools/tool-use/computer-use-tool">
    Prenez des captures d'écran et contrôlez la souris et le clavier dans un environnement de bureau.
  </Card>

  <Card title="Outil d'utilisation du navigateur" icon="browser" href="https://platform.claude.com/docs/fr/agents-and-tools/tool-use/browser-use-tool">
    Naviguez, lisez et interagissez avec des pages web dans votre propre environnement de navigateur.
  </Card>
</CardGroup>

### Outils serveur

Les outils serveur s'exécutent sur l'infrastructure d'Anthropic, sans code de gestion dans votre application. Consultez [Outils serveur](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/server-tools) pour les mécanismes qu'ils partagent.

<CardGroup cols={2}>
  <Card title="Outil de recherche web" icon="magnifying-glass" href="https://platform.claude.com/docs/fr/agents-and-tools/tool-use/web-search-tool">
    Recherchez sur le web des informations au-delà de la date limite des connaissances, avec des sources citées.
  </Card>

  <Card title="Outil de récupération web" icon="download" href="https://platform.claude.com/docs/fr/agents-and-tools/tool-use/web-fetch-tool">
    Récupérez le contenu complet de pages web et de documents PDF spécifiés.
  </Card>

  <Card title="Outil d'exécution de code" icon="code" href="https://platform.claude.com/docs/fr/agents-and-tools/tool-use/code-execution-tool">
    Exécutez du code Python et bash dans un conteneur isolé pour analyser des données et générer des fichiers.
  </Card>

  <Card title="Outil conseiller" icon="lightbulb" href="https://platform.claude.com/docs/fr/agents-and-tools/tool-use/advisor-tool">
    Permettez à un modèle exécuteur plus rapide de consulter un modèle conseiller plus intelligent en cours de génération.
  </Card>

  <Card title="Outil de recherche d'outils" icon="library" href="https://platform.claude.com/docs/fr/agents-and-tools/tool-use/tool-search-tool">
    Travaillez avec des milliers d'outils en les découvrant et en les chargeant à la demande.
  </Card>

  <Card title="Connecteur MCP" icon="link" href="https://platform.claude.com/docs/fr/agents-and-tools/mcp-connector">
    Connectez-vous à des serveurs MCP distants depuis l'API Messages sans client MCP séparé.
  </Card>
</CardGroup>

<Note>
  [Claude Managed Agents](https://platform.claude.com/docs/fr/managed-agents/overview) fournit un ensemble d'outils intégré que Claude utilise de manière autonome au sein d'une session. Pour cet ensemble d'outils et la manière propre à Managed Agents d'ajouter des outils personnalisés, consultez sa page [Outils](https://platform.claude.com/docs/fr/managed-agents/tools).
</Note>

## Tarification

Les requêtes de « tool use » (utilisation d'outils) sont facturées en fonction de :

1. Le nombre total de tokens d'entrée envoyés au modèle (y compris dans le paramètre `tools`)
2. Le nombre de tokens de sortie générés
3. Pour les outils côté serveur, une tarification supplémentaire basée sur l'usage (par exemple, la recherche web est facturée par recherche effectuée)

Les outils côté client sont facturés de la même manière que toute autre requête à l'API Claude, tandis que les outils côté serveur peuvent entraîner des frais supplémentaires en fonction de leur usage spécifique.

Les tokens supplémentaires liés à l'utilisation d'outils proviennent de :

* Le paramètre `tools` dans les requêtes API (noms, descriptions et schémas des outils)
* Les blocs de contenu `tool_use` dans les requêtes et réponses API
* Les blocs de contenu `tool_result` dans les requêtes API

Lorsque vous utilisez `tools`, l'API inclut également automatiquement une « system prompt » (invite système) spéciale pour le modèle, qui active l'utilisation d'outils. Le nombre de tokens d'utilisation d'outils requis pour chaque modèle est indiqué dans le tableau suivant (hors tokens supplémentaires mentionnés précédemment). Notez que le tableau suppose qu'au moins 1 outil est fourni. Si aucun `tools` n'est fourni, alors un choix d'outil de `none` utilise 0 token d'invite système supplémentaire.

| 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/fr/about-claude/model-deprecations)) | 313 tokens                                | 315 tokens                               |
| Claude Opus 4 ([retired, except on Google Cloud](https://platform.claude.com/docs/fr/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/fr/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/fr/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/fr/about-claude/model-deprecations) for more.

Ces nombres de tokens sont ajoutés à vos tokens d'entrée et de sortie habituels pour calculer le coût total d'une requête.

Consultez le tableau de la [Vue d'ensemble des modèles](https://platform.claude.com/docs/fr/models/overview#latest-models-comparison) pour les prix actuels par modèle.

Lorsque vous envoyez un prompt d'utilisation d'outils, comme pour toute autre requête API, la réponse inclut le nombre de tokens d'entrée et de sortie dans les métriques `usage` rapportées.

Certains outils serveur ajoutent des frais basés sur l'utilisation en plus des tokens : consultez l'[outil de recherche web](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/web-search-tool#usage-and-pricing) et l'[outil d'exécution de code](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/code-execution-tool#usage-and-pricing) pour leurs tarifs.

## Étapes suivantes

<CardGroup cols={3}>
  <Card href="https://platform.claude.com/docs/fr/agents-and-tools/tool-use/how-tool-use-works" title="Fonctionnement de l'utilisation d'outils" icon="compass">
    Comprenez la boucle d'utilisation d'outils, où les outils s'exécutent et quand utiliser des outils plutôt que de la prose.
  </Card>

  <Card href="https://platform.claude.com/docs/fr/agents-and-tools/tool-use/build-a-tool-using-agent" title="Tutoriel : créer un agent utilisant des outils" icon="graduation-cap">
    Un parcours guidé, d'un simple appel d'outil à une boucle agentique prête pour la production.
  </Card>

  <Card href="https://platform.claude.com/docs/fr/agents-and-tools/tool-use/tool-reference" title="Référence des outils" icon="book">
    Répertoire des outils fournis par Anthropic et référence des propriétés facultatives de définition d'outils.
  </Card>
</CardGroup>