
How to use Reasoning with Claude 3.7 Sonnet on Amazon Bedrock - JavaScript Edition
Learn how to use Claude 3.7 Sonnet's step-by-step thinking process with the AWS SDK for JavaScript v3. This tutorial walks you through a practical example showing how to receive and process Claude's internal thought process in your own applications.
- Break down complex questions into manageable components
- Explore multiple approaches to solving a problem
- Analyze information systematically and draw logical conclusions
- Show its work, particularly valuable for mathematical or logical problems
- Identify potential flaws in its own thinking
- An AWS account with access to Amazon Bedrock
- Node.js installed
- The AWS CLI installed and configured
- Access to Claude 3.7 Sonnet enabledin the region you want to use¹
1
npm install @aws-sdk/client-bedrock-runtime
1
2
3
4
5
{
"dependencies": {
"@aws-sdk/client-bedrock-runtime": "^3.755.0"
}
}
claude_reasoning.js
) where we'll implement our code to interact with Claude's reasoning capability:1
2
3
import { BedrockRuntimeClient, ConverseCommand } from "@aws-sdk/client-bedrock-runtime";
// We'll implement our code here
1
2
3
4
5
// Create the Amazon Bedrock runtime client
const client = new BedrockRuntimeClient({ region: "us-east-1" });
// Specify the model ID for Claude 3.7 Sonnet
const modelId = "us.anthropic.claude-3-7-sonnet-20250219-v1:0";
1
2
3
4
5
6
7
8
// Create the message with the user's prompt
const userMessage = "Describe the purpose of a 'hello world' program in one line.";
const conversation = [
{
role: "user",
content: [{ text: userMessage }],
},
];
1
2
3
4
5
6
7
// Configure reasoning parameters with a 2000 token budget
const reasoningConfig = {
thinking: {
type: "enabled",
budget_tokens: 2000
}
};
budget_tokens
parameter defines the maximum number of tokens Claude can use for its reasoning process. Adjust this value based on the complexity of your prompt.1
2
3
4
5
6
// Send message and reasoning configuration to the model
const response = await client.send(new ConverseCommand({
additionalModelRequestFields: reasoningConfig,
messages: conversation,
modelId
}));
additionalModelRequestFields
parameter is what allows us to pass the reasoning configuration. Notice that we're using the ConverseCommand
class from the AWS SDK for JavaScript v3.1
2
3
4
5
6
7
8
9
10
11
12
13
14
// Extract the list of content blocks from the model's response
const contentBlocks = response.output.message.content;
let reasoning = null;
let text = null;
// Process each content block to find reasoning and response text
for (const block of contentBlocks) {
if ("reasoningContent" in block) {
reasoning = block.reasoningContent.reasoningText.text;
}
if ("text" in block) {
text = block.text;
}
}
1
2
3
4
5
6
7
8
if (reasoning) {
console.log("<thinking>");
console.log(reasoning);
console.log("</thinking>\n");
}
if (text) {
console.log(text);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
import { BedrockRuntimeClient, ConverseCommand, } from "@aws-sdk/client-bedrock-runtime";
/**
* This example demonstrates how to use Anthropic Claude 3.7 Sonnet's reasoning capability
* with Amazon Bedrock. It shows how to:
* - Set up the Amazon Bedrock runtime client
* - Create a message
* - Configure reasoning parameters
* - Send a request with reasoning enabled
* - Process both the reasoning output and final response
*/
// Create the Amazon Bedrock runtime client
const client = new BedrockRuntimeClient({ region: "us-east-1" });
// Specify the model ID. For the latest available models, see:
// https://docs.aws.amazon.com/bedrock/latest/userguide/models-supported.html
const modelId = "us.anthropic.claude-3-7-sonnet-20250219-v1:0";
// Create the message with the user's prompt
const userMessage = "Describe the purpose of a 'hello world' program in one line.";
const conversation = [
{
role: "user",
content: [{ text: userMessage }],
},
];
// Configure reasoning parameters with a 2000 token budget
const reasoningConfig = {
thinking: {
type: "enabled",
budget_tokens: 2000
}
};
try {
// Send message and reasoning configuration to the model
const response = await client.send(new ConverseCommand({
additionalModelRequestFields: reasoningConfig,
messages: conversation,
modelId
}));
// Extract both reasoning and final response
const contentBlocks = response.output.message.content;
let reasoning = null;
let text = null;
// Process each content block to find reasoning and response text
for (const block of contentBlocks) {
if ("reasoningContent" in block) {
console.log("<thinking>");
console.log(block.reasoningContent.reasoningText.text);
console.log("</thinking>\n");
}
if ("text" in block) {
console.log(block.text);
}
}
} catch (err) {
console.log(`ERROR: Can't invoke '${modelId}'. Reason: ${err}`);
process.exit(1);
}
"type": "module"
to your package.json file or use the .mjs
extension for your JavaScript file.1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<thinking>
I need to explain the purpose of a "Hello World" program in a single line.
A "Hello World" program is typically the simplest program that can be written in
a programming language. Its purpose is to:
1. Verify that the programming environment is set up correctly
2. Demonstrate the minimal syntax needed to create a functioning program
3. Provide a simple introduction to the language
4. Output the text "Hello, World!" or a similar message
I need to condense this information into a concise, one-line description that
captures the essence of what a "Hello World" program is for.
</thinking>
A "Hello World" program serves as the simplest introduction to a programming
language by demonstrating basic syntax while verifying the environment works correctly.
- Adjusting the token budget based on your problem complexity – more complex problems may benefit from larger reasoning budgets
- Using the reasoning output to validate multi-step calculations or complex analytical processes
- Comparing different reasoning approaches by adjusting your prompts
- Integrating reasoning with other Claude capabilities like function calling for powerful, transparent AI solutions
- Using reasoning as an educational tool to understand expert-level problem-solving approaches
Any opinions in this post are those of the individual author and may not reflect the opinions of AWS.