Claude에서의 도구 사용

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?"}'

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)

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);

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);

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)

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());
}

$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;

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

Run the tool, then send the result back in a tool_result block.

Claude uses the result to answer the original question.

WEATHER="15 degrees Celsius, partly cloudy" curl -s https://api.anthropic.com/v1/messages
-H "x-api-key: $ANTHR...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 reads the request body as YAML on stdin; jq carries the conversation
# state into the second request.
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
# Ask for at most one tool call per turn.
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 replies with a tool_use block naming the tool and its 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")"

# Run the tool, then send the result back in a tool_result block.
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 uses the result to answer the original question.
call_api

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 replies with a tool_use block naming the tool and its arguments.
response = client.messages.create(
    model="claude-opus-5-5",
    max_tokens=1024,
    tools=tools,
    # Ask for at most one tool call per turn.
    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)}")

# Run the tool, then send the result back in a tool_result block.
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 uses the result to answer the original question.
final_text = next(block for block in followup.content if block.type == "text")
print(final_text.text)

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 replies with a tool_use block naming the tool and its arguments.
const response = await client.messages.create({
  model: "claude-opus-5-5",
  max_tokens: 1024,
  tools,
  // Ask for at most one tool call per turn.
  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)}`);

// Run the tool, then send the result back in a tool_result block.
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 uses the result to answer the original question.
const finalText = followup.content.find(
  (block): block is Anthropic.TextBlock => block.type === "text"
)!;
console.log(finalText.text);

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"],
        },
    }),
];

// Ask for at most one tool call per turn.
var toolChoice = new ToolChoice(new ToolChoiceAuto { DisableParallelToolUse = true });

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

// Claude replies with a tool_use block naming the tool and its 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)}");

// Run the tool, then send the result back in a tool_result block.
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 uses the result to answer the original question.
foreach (var block in followup.Content)
{
    if (block.TryPickText(out var text))
    {
        Console.WriteLine(text.Text);
    }
}

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"},
		},
	}},
}
// Ask for at most one tool call per turn.
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 replies with a tool_use block naming the tool and its 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))

// Run the tool, then send the result back in a tool_result block.
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 uses the result to answer the original question.
for _, block := range followup.Content {
	if block.Type == "text" {
		fmt.Println(block.Text)
	}
}

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();

    // Ask for at most one tool call per turn.
    ToolChoiceAuto toolChoice = ToolChoiceAuto.builder()
        .disableParallelToolUse(true)
        .build();

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

    // Claude replies with a tool_use block naming the tool and its 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());

    // Run the tool, then send the result back in a tool_result block.
    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 uses the result to answer the original question.
    followup.content().stream()
        .flatMap(block -> block.text().stream())
        .forEach(textBlock -> IO.println(textBlock.text()));
}

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?"];

// Ask for at most one tool call per turn.
$toolChoice = ToolChoiceAuto::with(disableParallelToolUse: true);

// Claude replies with a tool_use block naming the tool and its 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));

// Run the tool, then send the result back in a tool_result block.
$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 uses the result to answer the original question.
foreach ($followup->content as $block) {
    if ($block->type === 'text') {
        echo $block->text, "\n";
    }
}

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 replies with a tool_use block naming the tool and its arguments.
response = client.messages.create(
  model: "claude-opus-5-5",
  max_tokens: 1024,
  tools: tools,
  # Ask for at most one tool call per turn.
  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)}"

# Run the tool, then send the result back in a tool_result block.
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 uses the result to answer the original question.
final_text = followup.content.find { |block| block.type == :text }
puts final_text.text