# Code examples for Amazon Bedrock Runtime using AWS SDKs
The following code examples show how to use Amazon Bedrock Runtime with an AWS software development kit (SDK).
*Scenarios* are code examples that show you how to accomplish specific tasks by calling multiple functions within a service or combined with other AWS services.
For a complete list of AWS SDK developer guides and code examples, see [Using Amazon Bedrock with an AWS SDK](sdk-general-information-section.md). This topic also includes information about getting started and details about previous SDK versions.
**Contents**
+ [Basics](service_code_examples_bedrock-runtime_basics.md)
+ [Hello Amazon Bedrock](bedrock-runtime_example_bedrock-runtime_Hello_section.md)
+ [Scenarios](service_code_examples_bedrock-runtime_scenarios.md)
+ [Create a playground application to interact with Amazon Bedrock foundation models](bedrock-runtime_example_cross_FMPlayground_section.md)
+ [Create and invoke a managed prompt](bedrock-runtime_example_bedrock-agent_GettingStartedWithBedrockPrompts_section.md)
+ [Generate videos from text prompts using Amazon Bedrock](bedrock-runtime_example_bedrock-runtime_Scenario_GenerateVideos_NovaReel_section.md)
+ [Invoke multiple foundation models on Amazon Bedrock](bedrock-runtime_example_bedrock-runtime_Scenario_InvokeModels_section.md)
+ [Orchestrate generative AI applications with Step Functions](bedrock-runtime_example_cross_ServerlessPromptChaining_section.md)
+ [Tool use with the Converse API](bedrock-runtime_example_bedrock-runtime_Scenario_ToolUse_section.md)
+ [Amazon Nova](service_code_examples_bedrock-runtime_amazon_nova.md)
+ [Converse](bedrock-runtime_example_bedrock-runtime_Converse_AmazonNovaText_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_AmazonNovaText_section.md)
+ [Document understanding](bedrock-runtime_example_bedrock-runtime_DocumentUnderstanding_AmazonNova_section.md)
+ [Scenario: Tool use with the Converse API](bedrock-runtime_example_bedrock-runtime_Scenario_ToolUseDemo_AmazonNova_section.md)
+ [Amazon Nova Canvas](service_code_examples_bedrock-runtime_amazon_nova_canvas.md)
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_AmazonNovaImageGeneration_section.md)
+ [Amazon Nova Reel](service_code_examples_bedrock-runtime_amazon_nova_reel.md)
+ [Text-to-video](bedrock-runtime_example_bedrock-runtime_Scenario_AmazonNova_TextToVideo_section.md)
+ [Amazon Titan Image Generator](service_code_examples_bedrock-runtime_amazon_titan_image_generator.md)
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_TitanImageGenerator_section.md)
+ [Amazon Titan Text](service_code_examples_bedrock-runtime_amazon_titan_text.md)
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_TitanText_section.md)
+ [Amazon Titan Text Embeddings](service_code_examples_bedrock-runtime_amazon_titan_text_embeddings.md)
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModelWithResponseStream_TitanTextEmbeddings_section.md)
+ [Anthropic Claude](service_code_examples_bedrock-runtime_anthropic_claude.md)
+ [Converse](bedrock-runtime_example_bedrock-runtime_Converse_AnthropicClaude_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_AnthropicClaude_section.md)
+ [Document understanding](bedrock-runtime_example_bedrock-runtime_DocumentUnderstanding_AnthropicClaude_section.md)
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_AnthropicClaude_section.md)
+ [InvokeModelWithResponseStream](bedrock-runtime_example_bedrock-runtime_InvokeModelWithResponseStream_AnthropicClaude_section.md)
+ [Reasoning](bedrock-runtime_example_bedrock-runtime_Converse_AnthropicClaudeReasoning_section.md)
+ [Reasoning with a streaming response](bedrock-runtime_example_bedrock-runtime_ConverseStream_AnthropicClaudeReasoning_section.md)
+ [Scenario: Tool use with the Converse API](bedrock-runtime_example_bedrock-runtime_Scenario_ToolUseDemo_AnthropicClaude_section.md)
+ [Cohere Command](service_code_examples_bedrock-runtime_cohere_command.md)
+ [Converse](bedrock-runtime_example_bedrock-runtime_Converse_CohereCommand_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_CohereCommand_section.md)
+ [Document understanding](bedrock-runtime_example_bedrock-runtime_DocumentUnderstanding_CohereCommand_section.md)
+ [InvokeModel: Command R and R\$1](bedrock-runtime_example_bedrock-runtime_InvokeModel_CohereCommandR_section.md)
+ [InvokeModelWithResponseStream: Command R and R\$1](bedrock-runtime_example_bedrock-runtime_InvokeModelWithResponseStream_CohereCommandR_section.md)
+ [Scenario: Tool use with the Converse API](bedrock-runtime_example_bedrock-runtime_Scenario_ToolUseDemo_CohereCommand_section.md)
+ [DeepSeek](service_code_examples_bedrock-runtime_deepseek.md)
+ [Document understanding](bedrock-runtime_example_bedrock-runtime_DocumentUnderstanding_DeepSeek_section.md)
+ [Meta Llama](service_code_examples_bedrock-runtime_meta_llama.md)
+ [Converse](bedrock-runtime_example_bedrock-runtime_Converse_MetaLlama_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_MetaLlama_section.md)
+ [Document understanding](bedrock-runtime_example_bedrock-runtime_DocumentUnderstanding_MetaLlama_section.md)
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_MetaLlama3_section.md)
+ [InvokeModelWithResponseStream](bedrock-runtime_example_bedrock-runtime_InvokeModelWithResponseStream_MetaLlama3_section.md)
+ [Mistral AI](service_code_examples_bedrock-runtime_mistral_ai.md)
+ [Converse](bedrock-runtime_example_bedrock-runtime_Converse_Mistral_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_Mistral_section.md)
+ [Document understanding](bedrock-runtime_example_bedrock-runtime_DocumentUnderstanding_Mistral_section.md)
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_MistralAi_section.md)
+ [InvokeModelWithResponseStream](bedrock-runtime_example_bedrock-runtime_InvokeModelWithResponseStream_MistralAi_section.md)
+ [Stable Diffusion](service_code_examples_bedrock-runtime_stable_diffusion.md)
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_StableDiffusion_section.md)
# Basic examples for Amazon Bedrock Runtime using AWS SDKs
The following code examples show how to use the basics of Amazon Bedrock Runtime with AWS SDKs.
**Contents**
+ [Hello Amazon Bedrock](bedrock-runtime_example_bedrock-runtime_Hello_section.md)
# Hello Amazon Bedrock
The following code examples show how to get started using Amazon Bedrock.
------
#### [ Go ]
**SDK for Go V2**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/bedrock-runtime#code-examples).
```
package main
import (
"context"
"encoding/json"
"flag"
"fmt"
"log"
"os"
"strings"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/service/bedrockruntime"
)
// Each model provider defines their own individual request and response formats.
// For the format, ranges, and default values for the different models, refer to:
// https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters.html
type ClaudeRequest struct {
Prompt string `json:"prompt"`
MaxTokensToSample int `json:"max_tokens_to_sample"`
// Omitting optional request parameters
}
type ClaudeResponse struct {
Completion string `json:"completion"`
}
// main uses the AWS SDK for Go (v2) to create an Amazon Bedrock Runtime client
// and invokes Anthropic Claude 2 inside your account and the chosen region.
// This example uses the default settings specified in your shared credentials
// and config files.
func main() {
region := flag.String("region", "us-east-1", "The AWS region")
flag.Parse()
fmt.Printf("Using AWS region: %s\n", *region)
ctx := context.Background()
sdkConfig, err := config.LoadDefaultConfig(ctx, config.WithRegion(*region))
if err != nil {
fmt.Println("Couldn't load default configuration. Have you set up your AWS account?")
fmt.Println(err)
return
}
client := bedrockruntime.NewFromConfig(sdkConfig)
modelId := "anthropic.claude-v2"
prompt := "Hello, how are you today?"
// Anthropic Claude requires you to enclose the prompt as follows:
prefix := "Human: "
postfix := "\n\nAssistant:"
wrappedPrompt := prefix + prompt + postfix
request := ClaudeRequest{
Prompt: wrappedPrompt,
MaxTokensToSample: 200,
}
body, err := json.Marshal(request)
if err != nil {
log.Panicln("Couldn't marshal the request: ", err)
}
result, err := client.InvokeModel(ctx, &bedrockruntime.InvokeModelInput{
ModelId: aws.String(modelId),
ContentType: aws.String("application/json"),
Body: body,
})
if err != nil {
errMsg := err.Error()
if strings.Contains(errMsg, "no such host") {
fmt.Printf("Error: The Bedrock service is not available in the selected region. Please double-check the service availability for your region at https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/.\n")
} else if strings.Contains(errMsg, "Could not resolve the foundation model") {
fmt.Printf("Error: Could not resolve the foundation model from model identifier: \"%v\". Please verify that the requested model exists and is accessible within the specified region.\n", modelId)
} else {
fmt.Printf("Error: Couldn't invoke Anthropic Claude. Here's why: %v\n", err)
}
os.Exit(1)
}
var response ClaudeResponse
err = json.Unmarshal(result.Body, &response)
if err != nil {
log.Fatal("failed to unmarshal", err)
}
fmt.Println("Prompt:\n", prompt)
fmt.Println("Response from Anthropic Claude:\n", response.Completion)
}
```
+ For API details, see [InvokeModel](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/bedrockruntime#Client.InvokeModel) in *AWS SDK for Go API Reference*.
------
#### [ JavaScript ]
**SDK for JavaScript (v3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
```
/**
* @typedef {Object} Content
* @property {string} text
*
* @typedef {Object} Usage
* @property {number} input_tokens
* @property {number} output_tokens
*
* @typedef {Object} ResponseBody
* @property {Content[]} content
* @property {Usage} usage
*/
import { fileURLToPath } from "node:url";
import {
BedrockRuntimeClient,
InvokeModelCommand,
} from "@aws-sdk/client-bedrock-runtime";
const AWS_REGION = "us-east-1";
const MODEL_ID = "anthropic.claude-3-haiku-20240307-v1:0";
const PROMPT = "Hi. In a short paragraph, explain what you can do.";
const hello = async () => {
console.log("=".repeat(35));
console.log("Welcome to the Amazon Bedrock demo!");
console.log("=".repeat(35));
console.log("Model: Anthropic Claude 3 Haiku");
console.log(`Prompt: ${PROMPT}\n`);
console.log("Invoking model...\n");
// Create a new Bedrock Runtime client instance.
const client = new BedrockRuntimeClient({ region: AWS_REGION });
// Prepare the payload for the model.
const payload = {
anthropic_version: "bedrock-2023-05-31",
max_tokens: 1000,
messages: [{ role: "user", content: [{ type: "text", text: PROMPT }] }],
};
// Invoke Claude with the payload and wait for the response.
const apiResponse = await client.send(
new InvokeModelCommand({
contentType: "application/json",
body: JSON.stringify(payload),
modelId: MODEL_ID,
}),
);
// Decode and return the response(s)
const decodedResponseBody = new TextDecoder().decode(apiResponse.body);
/** @type {ResponseBody} */
const responseBody = JSON.parse(decodedResponseBody);
const responses = responseBody.content;
if (responses.length === 1) {
console.log(`Response: ${responses[0].text}`);
} else {
console.log("Haiku returned multiple responses:");
console.log(responses);
}
console.log(`\nNumber of input tokens: ${responseBody.usage.input_tokens}`);
console.log(`Number of output tokens: ${responseBody.usage.output_tokens}`);
};
if (process.argv[1] === fileURLToPath(import.meta.url)) {
await hello();
}
```
+ For API details, see [InvokeModel](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/InvokeModelCommand) in *AWS SDK for JavaScript API Reference*.
------
For a complete list of AWS SDK developer guides and code examples, see [Using Amazon Bedrock with an AWS SDK](sdk-general-information-section.md). This topic also includes information about getting started and details about previous SDK versions.
# Scenarios for Amazon Bedrock Runtime using AWS SDKs
The following code examples show you how to implement common scenarios in Amazon Bedrock Runtime with AWS SDKs. These scenarios show you how to accomplish specific tasks by calling multiple functions within Amazon Bedrock Runtime or combined with other AWS services. Each scenario includes a link to the complete source code, where you can find instructions on how to set up and run the code.
Scenarios target an intermediate level of experience to help you understand service actions in context.
**Topics**
+ [Create a playground application to interact with Amazon Bedrock foundation models](bedrock-runtime_example_cross_FMPlayground_section.md)
+ [Create and invoke a managed prompt](bedrock-runtime_example_bedrock-agent_GettingStartedWithBedrockPrompts_section.md)
+ [Generate videos from text prompts using Amazon Bedrock](bedrock-runtime_example_bedrock-runtime_Scenario_GenerateVideos_NovaReel_section.md)
+ [Invoke multiple foundation models on Amazon Bedrock](bedrock-runtime_example_bedrock-runtime_Scenario_InvokeModels_section.md)
+ [Orchestrate generative AI applications with Step Functions](bedrock-runtime_example_cross_ServerlessPromptChaining_section.md)
+ [Tool use with the Converse API](bedrock-runtime_example_bedrock-runtime_Scenario_ToolUse_section.md)
# Create a sample application that offers playgrounds to interact with Amazon Bedrock foundation models using an AWS SDK
The following code examples show how to create playgrounds to interact with Amazon Bedrock foundation models through different modalities.
------
#### [ .NET ]
**SDK for .NET**
.NET Foundation Model (FM) Playground is a .NET MAUI Blazor sample application that showcases how to use Amazon Bedrock from C\$1 code. This example shows how .NET and C\$1 developers can use Amazon Bedrock to build generative AI-enabled applications. You can test and interact with Amazon Bedrock foundation models by using the following four playgrounds:
+ A text playground.
+ A chat playground.
+ A voice chat playground.
+ An image playground.
The example also lists and displays the foundation models you have access to and their characteristics. For source code and deployment instructions, see the project in [GitHub](https://github.com/build-on-aws/dotnet-fm-playground).
**Services used in this example**
+ Amazon Bedrock Runtime
------
#### [ Java ]
**SDK for Java 2.x**
The Java Foundation Model (FM) Playground is a Spring Boot sample application that showcases how to use Amazon Bedrock with Java. This example shows how Java developers can use Amazon Bedrock to build generative AI-enabled applications. You can test and interact with Amazon Bedrock foundation models by using the following three playgrounds:
+ A text playground.
+ A chat playground.
+ An image playground.
The example also lists and displays the foundation models you have access to, along with their characteristics. For source code and deployment instructions, see the project in [GitHub](https://github.com/build-on-aws/java-fm-playground).
**Services used in this example**
+ Amazon Bedrock Runtime
------
#### [ Python ]
**SDK for Python (Boto3)**
The Python Foundation Model (FM) Playground is a Python/FastAPI sample application that showcases how to use Amazon Bedrock with Python. This example shows how Python developers can use Amazon Bedrock to build generative AI-enabled applications. You can test and interact with Amazon Bedrock foundation models by using the following three playgrounds:
+ A text playground.
+ A chat playground.
+ An image playground.
The example also lists and displays the foundation models you have access to, along with their characteristics. For source code and deployment instructions, see the project in [GitHub](https://github.com/build-on-aws/python-fm-playground).
**Services used in this example**
+ Amazon Bedrock Runtime
------
For a complete list of AWS SDK developer guides and code examples, see [Using Amazon Bedrock with an AWS SDK](sdk-general-information-section.md). This topic also includes information about getting started and details about previous SDK versions.
# An end-to-end example showing how to create and invoke Amazon Bedrock managed prompts using an AWS SDK
The following code example shows how to:
+ Create a managed prompt.
+ Create a version of the prompt.
+ Invoke the prompt using the version.
+ Clean up resources (optional).
------
#### [ Python ]
**SDK for Python (Boto3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples).
Create and invoke a managed prompt.
```
import argparse
import boto3
import logging
import time
# Now import the modules
from prompt import create_prompt, create_prompt_version, delete_prompt
from run_prompt import invoke_prompt
logging.basicConfig(
level=logging.INFO,
format='%(levelname)s: %(message)s'
)
logger = logging.getLogger(__name__)
def run_scenario(bedrock_client, bedrock_runtime_client, model_id, cleanup=True):
"""
Runs the Amazon Bedrock managed prompt scenario.
Args:
bedrock_client: The Amazon Bedrock Agent client.
bedrock_runtime_client: The Amazon Bedrock Runtime client.
model_id (str): The model ID to use for the prompt.
cleanup (bool): Whether to clean up resources at the end of the scenario.
Returns:
dict: A dictionary containing the created resources.
"""
prompt_id = None
try:
# Step 1: Create a prompt
print("\n=== Step 1: Creating a prompt ===")
prompt_name = f"PlaylistGenerator-{int(time.time())}"
prompt_description = "Playlist generator"
prompt_template = """
Make me a {{genre}} playlist consisting of the following number of songs: {{number}}."""
create_response = create_prompt(
bedrock_client,
prompt_name,
prompt_description,
prompt_template,
model_id
)
prompt_id = create_response['id']
print(f"Created prompt: {prompt_name} with ID: {prompt_id}")
# Create a version of the prompt
print("\n=== Creating a version of the prompt ===")
version_response = create_prompt_version(
bedrock_client,
prompt_id,
description="Initial version of the product description generator"
)
prompt_version_arn = version_response['arn']
prompt_version = version_response['version']
print(f"Created prompt version: {prompt_version}")
print(f"Prompt version ARN: {prompt_version_arn}")
# Step 2: Invoke the prompt directly
print("\n=== Step 2: Invoking the prompt ===")
input_variables = {
"genre": "pop",
"number": "2",
}
# Use the ARN from the create_prompt_version response
result = invoke_prompt(
bedrock_runtime_client,
prompt_version_arn,
input_variables
)
# Display the playlist
print(f"\n{result}")
# Step 3: Clean up resources (optional)
if cleanup:
print("\n=== Step 3: Cleaning up resources ===")
# Delete the prompt
print(f"Deleting prompt {prompt_id}...")
delete_prompt(bedrock_client, prompt_id)
print("Cleanup complete")
else:
print("\n=== Resources were not cleaned up ===")
print(f"Prompt ID: {prompt_id}")
except Exception as e:
logger.exception("Error in scenario: %s", str(e))
# Attempt to clean up if an error occurred and cleanup was requested
if cleanup and prompt_id:
try:
print("\nCleaning up resources after error...")
# Delete the prompt
try:
delete_prompt(bedrock_client, prompt_id)
print("Cleanup after error complete")
except Exception as cleanup_error:
logger.error("Error during cleanup: %s", str(cleanup_error))
except Exception as final_error:
logger.error("Final error during cleanup: %s", str(final_error))
# Re-raise the original exception
raise
def main():
"""
Entry point for the Amazon Bedrock managed prompt scenario.
"""
parser = argparse.ArgumentParser(
description="Run the Amazon Bedrock managed prompt scenario."
)
parser.add_argument(
'--region',
default='us-east-1',
help="The AWS Region to use."
)
parser.add_argument(
'--model-id',
default='anthropic.claude-v2',
help="The model ID to use for the prompt."
)
parser.add_argument(
'--cleanup',
action='store_true',
default=True,
help="Clean up resources at the end of the scenario."
)
parser.add_argument(
'--no-cleanup',
action='store_false',
dest='cleanup',
help="Don't clean up resources at the end of the scenario."
)
args = parser.parse_args()
bedrock_client = boto3.client('bedrock-agent', region_name=args.region)
bedrock_runtime_client = boto3.client('bedrock-runtime', region_name=args.region)
print("=== Amazon Bedrock Managed Prompt Scenario ===")
print(f"Region: {args.region}")
print(f"Model ID: {args.model_id}")
print(f"Cleanup resources: {args.cleanup}")
try:
run_scenario(
bedrock_client,
bedrock_runtime_client,
args.model_id,
args.cleanup
)
except Exception as e:
logger.exception("Error running scenario: %s", str(e))
if __name__ == "__main__":
main()
```
+ For API details, see the following topics in *AWS SDK for Python (Boto3) API Reference*.
+ [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse)
+ [CreatePrompt](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/CreatePrompt)
+ [CreatePromptVersion](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/CreatePromptVersion)
+ [DeletePrompt](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/DeletePrompt)
------
For a complete list of AWS SDK developer guides and code examples, see [Using Amazon Bedrock with an AWS SDK](sdk-general-information-section.md). This topic also includes information about getting started and details about previous SDK versions.
# Generate videos from text prompts using Amazon Bedrock and Nova-Reel
The following code example shows how to a Spring Boot app that generates videos from text prompts using Amazon Bedrock and the Nova-Reel model.
------
#### [ Java ]
**SDK for Java 2.x**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Generate videos from text prompts using Amazon Bedrock and Nova-Reel.
```
import org.springframework.stereotype.Service;
import software.amazon.awssdk.auth.credentials.ProfileCredentialsProvider;
import software.amazon.awssdk.core.document.Document;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.bedrockruntime.BedrockRuntimeAsyncClient;
import software.amazon.awssdk.services.bedrockruntime.model.*;
import java.util.concurrent.CompletableFuture;
@Service
public class VideoGenerationService {
public GenerateVideoResponse generateVideo(String prompt) {
// add S3 bucket you want to store your generated videos
String s3Bucket = "s3://mygeneratedvidoenovatest";
//Create json request as an instance of Document class
Document novaRequest = prepareDocument(prompt);
// Create request
StartAsyncInvokeRequest request = StartAsyncInvokeRequest.builder()
.modelId("amazon.nova-reel-v1:0")
.modelInput(novaRequest)
.outputDataConfig(AsyncInvokeOutputDataConfig.builder()
.s3OutputDataConfig(AsyncInvokeS3OutputDataConfig.builder().s3Uri(s3Bucket).build())
.build())
.build();
try (BedrockRuntimeAsyncClient bedrockClient = getBedrockRuntimeAsyncClient()) {
CompletableFuture startAsyncInvokeResponseCompletableFuture = bedrockClient.startAsyncInvoke(request);
//blocking operation to wait for the AWS API response
StartAsyncInvokeResponse startAsyncInvokeResponse = startAsyncInvokeResponseCompletableFuture.get();
System.out.println("invocation ARN: " + startAsyncInvokeResponse.invocationArn());
GenerateVideoResponse response = new GenerateVideoResponse();
response.setStatus("inProgress");
response.setExecutionArn(startAsyncInvokeResponse.invocationArn());
return response;
} catch (Exception e) {
System.out.println(e);
throw new RuntimeException(e);
}
}
public GenerateVideoResponse checkGenerationStatus(String invocationArn) {
GenerateVideoResponse response = new GenerateVideoResponse();
try (BedrockRuntimeAsyncClient bedrockClient = getBedrockRuntimeAsyncClient()) {
//creating async request to fetch status by invocation Arn
GetAsyncInvokeRequest asyncRequest = GetAsyncInvokeRequest.builder().invocationArn(invocationArn).build();
CompletableFuture asyncInvoke = bedrockClient.getAsyncInvoke(asyncRequest);
//blocking operation to wait for the AWS API response
GetAsyncInvokeResponse asyncInvokeResponse = asyncInvoke.get();
System.out.println("Invocation status =" + asyncInvokeResponse.statusAsString());
response.setExecutionArn(invocationArn);
response.setStatus(asyncInvokeResponse.statusAsString());
return response;
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException(e);
}
}
private static BedrockRuntimeAsyncClient getBedrockRuntimeAsyncClient() {
BedrockRuntimeAsyncClient bedrockClient = BedrockRuntimeAsyncClient.builder()
.region(Region.US_EAST_1)
.credentialsProvider(ProfileCredentialsProvider.create())
.build();
return bedrockClient;
}
private static Document prepareDocument(String prompt) {
Document textToVideoParams = Document.mapBuilder()
.putString("text", prompt)
.build();
Document videoGenerationConfig = Document.mapBuilder()
.putNumber("durationSeconds", 6)
.putNumber("fps", 24)
.putString("dimension", "1280x720")
.build();
Document novaRequest = Document.mapBuilder()
.putString("taskType", "TEXT_VIDEO")
.putDocument("textToVideoParams", textToVideoParams)
.putDocument("videoGenerationConfig", videoGenerationConfig)
.build();
return novaRequest;
}
}
```
+ For API details, see the following topics in *AWS SDK for Java 2.x API Reference*.
+ [GetAsyncInvoke](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/GetAsyncInvoke)
+ [StartAsyncInvoke](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/StartAsyncInvoke)
------
For a complete list of AWS SDK developer guides and code examples, see [Using Amazon Bedrock with an AWS SDK](sdk-general-information-section.md). This topic also includes information about getting started and details about previous SDK versions.
# Invoke multiple foundation models on Amazon Bedrock
The following code examples show how to prepare and send a prompt to a variety of large-language models (LLMs) on Amazon Bedrock
------
#### [ Go ]
**SDK for Go V2**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/bedrock-runtime#code-examples).
Invoke multiple foundation models on Amazon Bedrock.
```
import (
"context"
"encoding/base64"
"fmt"
"log"
"math/rand"
"os"
"path/filepath"
"strings"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/bedrockruntime"
"github.com/awsdocs/aws-doc-sdk-examples/gov2/bedrock-runtime/actions"
"github.com/awsdocs/aws-doc-sdk-examples/gov2/demotools"
)
// InvokeModelsScenario demonstrates how to use the Amazon Bedrock Runtime client
// to invoke various foundation models for text and image generation
//
// 1. Generate text with Anthropic Claude 2
// 2. Generate text with Meta Llama 2 Chat
// 3. Generate text and asynchronously process the response stream with Anthropic Claude 2
// 4. Generate an image with the Amazon Titan image generation model
type InvokeModelsScenario struct {
sdkConfig aws.Config
invokeModelWrapper actions.InvokeModelWrapper
responseStreamWrapper actions.InvokeModelWithResponseStreamWrapper
questioner demotools.IQuestioner
}
// NewInvokeModelsScenario constructs an InvokeModelsScenario instance from a configuration.
// It uses the specified config to get a Bedrock Runtime client and create wrappers for the
// actions used in the scenario.
func NewInvokeModelsScenario(sdkConfig aws.Config, questioner demotools.IQuestioner) InvokeModelsScenario {
client := bedrockruntime.NewFromConfig(sdkConfig)
return InvokeModelsScenario{
sdkConfig: sdkConfig,
invokeModelWrapper: actions.InvokeModelWrapper{BedrockRuntimeClient: client},
responseStreamWrapper: actions.InvokeModelWithResponseStreamWrapper{BedrockRuntimeClient: client},
questioner: questioner,
}
}
// Runs the interactive scenario.
func (scenario InvokeModelsScenario) Run(ctx context.Context) {
defer func() {
if r := recover(); r != nil {
log.Printf("Something went wrong with the demo: %v\n", r)
}
}()
log.Println(strings.Repeat("=", 77))
log.Println("Welcome to the Amazon Bedrock Runtime model invocation demo.")
log.Println(strings.Repeat("=", 77))
log.Printf("First, let's invoke a few large-language models using the synchronous client:\n\n")
text2textPrompt := "In one paragraph, who are you?"
log.Println(strings.Repeat("-", 77))
log.Printf("Invoking Claude with prompt: %v\n", text2textPrompt)
scenario.InvokeClaude(ctx, text2textPrompt)
log.Println(strings.Repeat("=", 77))
log.Printf("Now, let's invoke Claude with the asynchronous client and process the response stream:\n\n")
log.Println(strings.Repeat("-", 77))
log.Printf("Invoking Claude with prompt: %v\n", text2textPrompt)
scenario.InvokeWithResponseStream(ctx, text2textPrompt)
log.Println(strings.Repeat("=", 77))
log.Printf("Now, let's create an image with the Amazon Titan image generation model:\n\n")
text2ImagePrompt := "stylized picture of a cute old steampunk robot"
seed := rand.Int63n(2147483648)
log.Println(strings.Repeat("-", 77))
log.Printf("Invoking Amazon Titan with prompt: %v\n", text2ImagePrompt)
scenario.InvokeTitanImage(ctx, text2ImagePrompt, seed)
log.Println(strings.Repeat("=", 77))
log.Println("Thanks for watching!")
log.Println(strings.Repeat("=", 77))
}
func (scenario InvokeModelsScenario) InvokeClaude(ctx context.Context, prompt string) {
completion, err := scenario.invokeModelWrapper.InvokeClaude(ctx, prompt)
if err != nil {
panic(err)
}
log.Printf("\nClaude : %v\n", strings.TrimSpace(completion))
}
func (scenario InvokeModelsScenario) InvokeWithResponseStream(ctx context.Context, prompt string) {
log.Println("\nClaude with response stream:")
_, err := scenario.responseStreamWrapper.InvokeModelWithResponseStream(ctx, prompt)
if err != nil {
panic(err)
}
log.Println()
}
func (scenario InvokeModelsScenario) InvokeTitanImage(ctx context.Context, prompt string, seed int64) {
base64ImageData, err := scenario.invokeModelWrapper.InvokeTitanImage(ctx, prompt, seed)
if err != nil {
panic(err)
}
imagePath := saveImage(base64ImageData, "amazon.titan-image-generator-v2")
fmt.Printf("The generated image has been saved to %s\n", imagePath)
}
```
+ For API details, see the following topics in *AWS SDK for Go API Reference*.
+ [InvokeModel](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/bedrockruntime#Client.InvokeModel)
+ [InvokeModelWithResponseStream](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/bedrockruntime#Client.InvokeModelWithResponseStream)
------
#### [ JavaScript ]
**SDK for JavaScript (v3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
```
import { fileURLToPath } from "node:url";
import {
Scenario,
ScenarioAction,
ScenarioInput,
ScenarioOutput,
} from "@aws-doc-sdk-examples/lib/scenario/index.js";
import { FoundationModels } from "../config/foundation_models.js";
/**
* @typedef {Object} ModelConfig
* @property {Function} module
* @property {Function} invoker
* @property {string} modelId
* @property {string} modelName
*/
const greeting = new ScenarioOutput(
"greeting",
"Welcome to the Amazon Bedrock Runtime client demo!",
{ header: true },
);
const selectModel = new ScenarioInput("model", "First, select a model:", {
type: "select",
choices: Object.values(FoundationModels).map((model) => ({
name: model.modelName,
value: model,
})),
});
const enterPrompt = new ScenarioInput("prompt", "Now, enter your prompt:", {
type: "input",
});
const printDetails = new ScenarioOutput(
"print details",
/**
* @param {{ model: ModelConfig, prompt: string }} c
*/
(c) => console.log(`Invoking ${c.model.modelName} with '${c.prompt}'...`),
);
const invokeModel = new ScenarioAction(
"invoke model",
/**
* @param {{ model: ModelConfig, prompt: string, response: string }} c
*/
async (c) => {
const modelModule = await c.model.module();
const invoker = c.model.invoker(modelModule);
c.response = await invoker(c.prompt, c.model.modelId);
},
);
const printResponse = new ScenarioOutput(
"print response",
/**
* @param {{ response: string }} c
*/
(c) => c.response,
);
const scenario = new Scenario("Amazon Bedrock Runtime Demo", [
greeting,
selectModel,
enterPrompt,
printDetails,
invokeModel,
printResponse,
]);
if (process.argv[1] === fileURLToPath(import.meta.url)) {
scenario.run();
}
```
+ For API details, see the following topics in *AWS SDK for JavaScript API Reference*.
+ [InvokeModel](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/InvokeModelCommand)
+ [InvokeModelWithResponseStream](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/InvokeModelWithResponseStreamCommand)
------
#### [ PHP ]
**SDK for PHP**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/bedrock-runtime/#code-examples).
Invoke multiple LLMs on Amazon Bedrock.
```
namespace BedrockRuntime;
class GettingStartedWithBedrockRuntime
{
protected BedrockRuntimeService $bedrockRuntimeService;
public function runExample()
{
echo "\n";
echo "---------------------------------------------------------------------\n";
echo "Welcome to the Amazon Bedrock Runtime getting started demo using PHP!\n";
echo "---------------------------------------------------------------------\n";
$bedrockRuntimeService = new BedrockRuntimeService();
$prompt = 'In one paragraph, who are you?';
echo "\nPrompt: " . $prompt;
echo "\n\nAnthropic Claude:\n";
echo $bedrockRuntimeService->invokeClaude($prompt);
echo "\n---------------------------------------------------------------------\n";
$image_prompt = 'stylized picture of a cute old steampunk robot';
echo "\nImage prompt: " . $image_prompt;
echo "\n\nStability.ai Stable Diffusion XL:\n";
$diffusionSeed = rand(0, 4294967295);
$style_preset = 'photographic';
$base64 = $bedrockRuntimeService->invokeStableDiffusion($image_prompt, $diffusionSeed, $style_preset);
$image_path = $this->saveImage($base64, 'stability.stable-diffusion-xl');
echo "The generated image has been saved to $image_path";
echo "\n\nAmazon Titan Image Generation:\n";
$titanSeed = rand(0, 2147483647);
$base64 = $bedrockRuntimeService->invokeTitanImage($image_prompt, $titanSeed);
$image_path = $this->saveImage($base64, 'amazon.titan-image-generator-v2');
echo "The generated image has been saved to $image_path";
}
private function saveImage($base64_image_data, $model_id): string
{
$output_dir = "output";
if (!file_exists($output_dir)) {
mkdir($output_dir);
}
$i = 1;
while (file_exists("$output_dir/$model_id" . '_' . "$i.png")) {
$i++;
}
$image_data = base64_decode($base64_image_data);
$file_path = "$output_dir/$model_id" . '_' . "$i.png";
$file = fopen($file_path, 'wb');
fwrite($file, $image_data);
fclose($file);
return $file_path;
}
}
```
+ For API details, see the following topics in *AWS SDK for PHP API Reference*.
+ [InvokeModel](https://docs.aws.amazon.com/goto/SdkForPHPV3/bedrock-runtime-2023-09-30/InvokeModel)
+ [InvokeModelWithResponseStream](https://docs.aws.amazon.com/goto/SdkForPHPV3/bedrock-runtime-2023-09-30/InvokeModelWithResponseStream)
------
For a complete list of AWS SDK developer guides and code examples, see [Using Amazon Bedrock with an AWS SDK](sdk-general-information-section.md). This topic also includes information about getting started and details about previous SDK versions.
# Build and orchestrate generative AI applications with Amazon Bedrock and Step Functions
The following code example shows how to build and orchestrate generative AI applications with Amazon Bedrock and Step Functions.
------
#### [ Python ]
**SDK for Python (Boto3)**
The Amazon Bedrock Serverless Prompt Chaining scenario demonstrates how [AWS Step Functions](https://docs.aws.amazon.com/step-functions/latest/dg/welcome.html), [Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html), and [https://docs.aws.amazon.com/bedrock/latest/userguide/agents.html](https://docs.aws.amazon.com/bedrock/latest/userguide/agents.html) can be used to build and orchestrate complex, serverless, and highly scalable generative AI applications. It contains the following working examples:
+ Write an analysis of a given novel for a literature blog. This example illustrates a simple, sequential chain of prompts.
+ Generate a short story about a given topic. This example illustrates how the AI can iteratively process a list of items that it previously generated.
+ Create an itinerary for a weekend vacation to a given destination. This example illustrates how to parallelize multiple distinct prompts.
+ Pitch movie ideas to a human user acting as a movie producer. This example illustrates how to parallelize the same prompt with different inference parameters, how to backtrack to a previous step in the chain, and how to include human input as part of the workflow.
+ Plan a meal based on ingredients the user has at hand. This example illustrates how prompt chains can incorporate two distinct AI conversations, with two AI personas engaging in a debate with each other to improve the final outcome.
+ Find and summarize today's highest trending GitHub repository. This example illustrates chaining multiple AI agents that interact with external APIs.
For complete source code and instructions to set up and run, see the full project on [GitHub](https://github.com/aws-samples/amazon-bedrock-serverless-prompt-chaining).
**Services used in this example**
+ Amazon Bedrock
+ Amazon Bedrock Runtime
+ Amazon Bedrock Agents
+ Amazon Bedrock Agents Runtime
+ Step Functions
------
For a complete list of AWS SDK developer guides and code examples, see [Using Amazon Bedrock with an AWS SDK](sdk-general-information-section.md). This topic also includes information about getting started and details about previous SDK versions.
# A tool use example illustrating how to connect AI models on Amazon Bedrock with a custom tool or API
The following code examples show how to build a typical interaction between an application, a generative AI model, and connected tools or APIs to mediate interactions between the AI and the outside world. It uses the example of connecting an external weather API to the AI model so it can provide real-time weather information based on user input.
------
#### [ .NET ]
**SDK for .NET**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime/Scenarios/ConverseToolScenario#code-examples).
The primary execution of the scenario flow. This scenario orchestrates the conversation between the user, the Amazon Bedrock Converse API, and a weather tool.
```
using Amazon;
using Amazon.BedrockRuntime;
using Amazon.BedrockRuntime.Model;
using Amazon.Runtime.Documents;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.DependencyInjection.Extensions;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Http;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Logging.Console;
namespace ConverseToolScenario;
public static class ConverseToolScenario
{
/*
Before running this .NET code example, set up your development environment, including your credentials.
This demo illustrates a tool use scenario using Amazon Bedrock's Converse API and a weather tool.
The script interacts with a foundation model on Amazon Bedrock to provide weather information based on user
input. It uses the Open-Meteo API (https://open-meteo.com) to retrieve current weather data for a given location.
*/
public static BedrockActionsWrapper _bedrockActionsWrapper = null!;
public static WeatherTool _weatherTool = null!;
public static bool _interactive = true;
// Change this string to use a different model with Converse API.
private static string model_id = "amazon.nova-lite-v1:0";
private static string system_prompt = @"
You are a weather assistant that provides current weather data for user-specified locations using only
the Weather_Tool, which expects latitude and longitude. Infer the coordinates from the location yourself.
If the user specifies a state, country, or region, infer the locations of cities within that state.
If the user provides coordinates, infer the approximate location and refer to it in your response.
To use the tool, you strictly apply the provided tool specification.
- Explain your step-by-step process, and give brief updates before each step.
- Only use the Weather_Tool for data. Never guess or make up information.
- Repeat the tool use for subsequent requests if necessary.
- If the tool errors, apologize, explain weather is unavailable, and suggest other options.
- Report temperatures in °C (°F) and wind in km/h (mph). Keep weather reports concise. Sparingly use
emojis where appropriate.
- Only respond to weather queries. Remind off-topic users of your purpose.
- Never claim to search online, access external data, or use tools besides Weather_Tool.
- Complete the entire process until you have all required data before sending the complete response.
"
;
private static string default_prompt = "What is the weather like in Seattle?";
// The maximum number of recursive calls allowed in the tool use function.
// This helps prevent infinite loops and potential performance issues.
private static int max_recursions = 5;
public static async Task Main(string[] args)
{
// Set up dependency injection for the Amazon service.
using var host = Host.CreateDefaultBuilder(args)
.ConfigureLogging(logging =>
logging.AddFilter("System", LogLevel.Error)
.AddFilter("Microsoft", LogLevel.Trace))
.ConfigureServices((_, services) =>
services.AddHttpClient()
.AddSingleton(_ => new AmazonBedrockRuntimeClient(RegionEndpoint.USEast1)) // Specify a region that has access to the chosen model.
.AddTransient()
.AddTransient()
.RemoveAll()
)
.Build();
ServicesSetup(host);
try
{
await RunConversationAsync();
}
catch (Exception ex)
{
Console.WriteLine(new string('-', 80));
Console.WriteLine($"There was a problem running the scenario: {ex.Message}");
Console.WriteLine(new string('-', 80));
}
finally
{
Console.WriteLine(
"Amazon Bedrock Converse API with Tool Use Feature Scenario is complete.");
Console.WriteLine(new string('-', 80));
}
}
///
/// Populate the services for use within the console application.
///
/// The services host.
private static void ServicesSetup(IHost host)
{
_bedrockActionsWrapper = host.Services.GetRequiredService();
_weatherTool = host.Services.GetRequiredService();
}
///
/// Starts the conversation with the user and handles the interaction with Bedrock.
///
/// The conversation array.
public static async Task> RunConversationAsync()
{
// Print the greeting and a short user guide
PrintHeader();
// Start with an empty conversation
var conversation = new List();
// Get the first user input
var userInput = await GetUserInputAsync();
while (userInput != null)
{
// Create a new message with the user input and append it to the conversation
var message = new Message { Role = ConversationRole.User, Content = new List { new ContentBlock { Text = userInput } } };
conversation.Add(message);
// Send the conversation to Amazon Bedrock
var bedrockResponse = await SendConversationToBedrock(conversation);
// Recursively handle the model's response until the model has returned its final response or the recursion counter has reached 0
await ProcessModelResponseAsync(bedrockResponse, conversation, max_recursions);
// Repeat the loop until the user decides to exit the application
userInput = await GetUserInputAsync();
}
PrintFooter();
return conversation;
}
///
/// Sends the conversation, the system prompt, and the tool spec to Amazon Bedrock, and returns the response.
///
/// The conversation history including the next message to send.
/// The response from Amazon Bedrock.
private static async Task SendConversationToBedrock(List conversation)
{
Console.WriteLine("\tCalling Bedrock...");
// Send the conversation, system prompt, and tool configuration, and return the response
return await _bedrockActionsWrapper.SendConverseRequestAsync(model_id, system_prompt, conversation, _weatherTool.GetToolSpec());
}
///
/// Processes the response received via Amazon Bedrock and performs the necessary actions based on the stop reason.
///
/// The model's response returned via Amazon Bedrock.
/// The conversation history.
/// The maximum number of recursive calls allowed.
private static async Task ProcessModelResponseAsync(ConverseResponse modelResponse, List conversation, int maxRecursion)
{
if (maxRecursion <= 0)
{
// Stop the process, the number of recursive calls could indicate an infinite loop
Console.WriteLine("\tWarning: Maximum number of recursions reached. Please try again.");
}
// Append the model's response to the ongoing conversation
conversation.Add(modelResponse.Output.Message);
if (modelResponse.StopReason == "tool_use")
{
// If the stop reason is "tool_use", forward everything to the tool use handler
await HandleToolUseAsync(modelResponse.Output, conversation, maxRecursion - 1);
}
if (modelResponse.StopReason == "end_turn")
{
// If the stop reason is "end_turn", print the model's response text, and finish the process
PrintModelResponse(modelResponse.Output.Message.Content[0].Text);
if (!_interactive)
{
default_prompt = "x";
}
}
}
///
/// Handles the tool use case by invoking the specified tool and sending the tool's response back to Bedrock.
/// The tool response is appended to the conversation, and the conversation is sent back to Amazon Bedrock for further processing.
///
/// The model's response containing the tool use request.
/// The conversation history.
/// The maximum number of recursive calls allowed.
public static async Task HandleToolUseAsync(ConverseOutput modelResponse, List conversation, int maxRecursion)
{
// Initialize an empty list of tool results
var toolResults = new List();
// The model's response can consist of multiple content blocks
foreach (var contentBlock in modelResponse.Message.Content)
{
if (!String.IsNullOrEmpty(contentBlock.Text))
{
// If the content block contains text, print it to the console
PrintModelResponse(contentBlock.Text);
}
if (contentBlock.ToolUse != null)
{
// If the content block is a tool use request, forward it to the tool
var toolResponse = await InvokeTool(contentBlock.ToolUse);
// Add the tool use ID and the tool's response to the list of results
toolResults.Add(new ContentBlock
{
ToolResult = new ToolResultBlock()
{
ToolUseId = toolResponse.ToolUseId,
Content = new List()
{ new ToolResultContentBlock { Json = toolResponse.Content } }
}
});
}
}
// Embed the tool results in a new user message
var message = new Message() { Role = ConversationRole.User, Content = toolResults };
// Append the new message to the ongoing conversation
conversation.Add(message);
// Send the conversation to Amazon Bedrock
var response = await SendConversationToBedrock(conversation);
// Recursively handle the model's response until the model has returned its final response or the recursion counter has reached 0
await ProcessModelResponseAsync(response, conversation, maxRecursion);
}
///
/// Invokes the specified tool with the given payload and returns the tool's response.
/// If the requested tool does not exist, an error message is returned.
///
/// The payload containing the tool name and input data.
/// The tool's response or an error message.
public static async Task InvokeTool(ToolUseBlock payload)
{
var toolName = payload.Name;
if (toolName == "Weather_Tool")
{
var inputData = payload.Input.AsDictionary();
PrintToolUse(toolName, inputData);
// Invoke the weather tool with the input data provided
var weatherResponse = await _weatherTool.FetchWeatherDataAsync(inputData["latitude"].ToString(), inputData["longitude"].ToString());
return new ToolResponse { ToolUseId = payload.ToolUseId, Content = weatherResponse };
}
else
{
var errorMessage = $"\tThe requested tool with name '{toolName}' does not exist.";
return new ToolResponse { ToolUseId = payload.ToolUseId, Content = new { error = true, message = errorMessage } };
}
}
///
/// Prompts the user for input and returns the user's response.
/// Returns null if the user enters 'x' to exit.
///
/// The prompt to display to the user.
/// The user's input or null if the user chooses to exit.
private static async Task GetUserInputAsync(string prompt = "\tYour weather info request:")
{
var userInput = default_prompt;
if (_interactive)
{
Console.WriteLine(new string('*', 80));
Console.WriteLine($"{prompt} (x to exit): \n\t");
userInput = Console.ReadLine();
}
if (string.IsNullOrWhiteSpace(userInput))
{
prompt = "\tPlease enter your weather info request, e.g. the name of a city";
return await GetUserInputAsync(prompt);
}
if (userInput.ToLowerInvariant() == "x")
{
return null;
}
return userInput;
}
///
/// Logs the welcome message and usage guide for the tool use demo.
///
public static void PrintHeader()
{
Console.WriteLine(@"
=================================================
Welcome to the Amazon Bedrock Tool Use demo!
=================================================
This assistant provides current weather information for user-specified locations.
You can ask for weather details by providing the location name or coordinates. Weather information
will be provided using a custom Tool and open-meteo API.
Example queries:
- What's the weather like in New York?
- Current weather for latitude 40.70, longitude -74.01
- Is it warmer in Rome or Barcelona today?
To exit the program, simply type 'x' and press Enter.
P.S.: You're not limited to single locations, or even to using English!
Have fun and experiment with the app!
");
}
///
/// Logs the footer information for the tool use demo.
///
public static void PrintFooter()
{
Console.WriteLine(@"
=================================================
Thank you for checking out the Amazon Bedrock Tool Use demo. We hope you
learned something new, or got some inspiration for your own apps today!
For more Bedrock examples in different programming languages, have a look at:
https://docs.aws.amazon.com/bedrock/latest/userguide/service_code_examples.html
=================================================
");
}
///
/// Logs information about the tool use.
///
/// The name of the tool being used.
/// The input data for the tool.
public static void PrintToolUse(string toolName, Dictionary inputData)
{
Console.WriteLine($"\n\tInvoking tool: {toolName} with input: {inputData["latitude"].ToString()}, {inputData["longitude"].ToString()}...\n");
}
///
/// Logs the model's response.
///
/// The model's response message.
public static void PrintModelResponse(string message)
{
Console.WriteLine("\tThe model's response:\n");
Console.WriteLine(message);
Console.WriteLine();
}
}
```
The weather tool used by the demo. This file defines the tool specification and implements the logic to retrieve weather data using from the Open-Meteo API.
```
using Amazon.BedrockRuntime.Model;
using Amazon.Runtime.Documents;
using Microsoft.Extensions.Logging;
namespace ConverseToolScenario;
///
/// Weather tool that will be invoked when requested by the Bedrock response.
///
public class WeatherTool
{
private readonly ILogger _logger;
private readonly IHttpClientFactory _httpClientFactory;
public WeatherTool(ILogger logger, IHttpClientFactory httpClientFactory)
{
_logger = logger;
_httpClientFactory = httpClientFactory;
}
///
/// Returns the JSON Schema specification for the Weather tool. The tool specification
/// defines the input schema and describes the tool's functionality.
/// For more information, see https://json-schema.org/understanding-json-schema/reference.
///
/// The tool specification for the Weather tool.
public ToolSpecification GetToolSpec()
{
ToolSpecification toolSpecification = new ToolSpecification();
toolSpecification.Name = "Weather_Tool";
toolSpecification.Description = "Get the current weather for a given location, based on its WGS84 coordinates.";
Document toolSpecDocument = Document.FromObject(
new
{
type = "object",
properties = new
{
latitude = new
{
type = "string",
description = "Geographical WGS84 latitude of the location."
},
longitude = new
{
type = "string",
description = "Geographical WGS84 longitude of the location."
}
},
required = new[] { "latitude", "longitude" }
});
toolSpecification.InputSchema = new ToolInputSchema() { Json = toolSpecDocument };
return toolSpecification;
}
///
/// Fetches weather data for the given latitude and longitude using the Open-Meteo API.
/// Returns the weather data or an error message if the request fails.
///
/// The latitude of the location.
/// The longitude of the location.
/// The weather data or an error message.
public async Task FetchWeatherDataAsync(string latitude, string longitude)
{
string endpoint = "https://api.open-meteo.com/v1/forecast";
try
{
var httpClient = _httpClientFactory.CreateClient();
var response = await httpClient.GetAsync($"{endpoint}?latitude={latitude}&longitude={longitude}¤t_weather=True");
response.EnsureSuccessStatusCode();
var weatherData = await response.Content.ReadAsStringAsync();
Document weatherDocument = Document.FromObject(
new { weather_data = weatherData });
return weatherDocument;
}
catch (HttpRequestException e)
{
_logger.LogError(e, "Error fetching weather data: {Message}", e.Message);
throw;
}
catch (Exception e)
{
_logger.LogError(e, "Unexpected error fetching weather data: {Message}", e.Message);
throw;
}
}
}
```
The Converse API action with a tool configuration.
```
///
/// Wrapper class for interacting with the Amazon Bedrock Converse API.
///
public class BedrockActionsWrapper
{
private readonly IAmazonBedrockRuntime _bedrockClient;
private readonly ILogger _logger;
///
/// Initializes a new instance of the class.
///
/// The Bedrock Converse API client.
/// The logger instance.
public BedrockActionsWrapper(IAmazonBedrockRuntime bedrockClient, ILogger logger)
{
_bedrockClient = bedrockClient;
_logger = logger;
}
///
/// Sends a Converse request to the Amazon Bedrock Converse API.
///
/// The Bedrock Model Id.
/// A system prompt instruction.
/// The array of messages in the conversation.
/// The specification for a tool.
/// The response of the model.
public async Task SendConverseRequestAsync(string modelId, string systemPrompt, List conversation, ToolSpecification toolSpec)
{
try
{
var request = new ConverseRequest()
{
ModelId = modelId,
System = new List()
{
new SystemContentBlock()
{
Text = systemPrompt
}
},
Messages = conversation,
ToolConfig = new ToolConfiguration()
{
Tools = new List()
{
new Tool()
{
ToolSpec = toolSpec
}
}
}
};
var response = await _bedrockClient.ConverseAsync(request);
return response;
}
catch (ModelNotReadyException ex)
{
_logger.LogError(ex, "Model not ready, please wait and try again.");
throw;
}
catch (AmazonBedrockRuntimeException ex)
{
_logger.LogError(ex, "Error occurred while sending Converse request.");
throw;
}
}
}
```
+ For API details, see [Converse](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/Converse) in *AWS SDK for .NET API Reference*.
------
#### [ Java ]
**SDK for Java 2.x**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
The primary execution of the scenario flow. This scenario orchestrates the conversation between the user, the Amazon Bedrock Converse API, and a weather tool.
```
/*
This demo illustrates a tool use scenario using Amazon Bedrock's Converse API and a weather tool.
The program interacts with a foundation model on Amazon Bedrock to provide weather information based on user
input. It uses the Open-Meteo API (https://open-meteo.com) to retrieve current weather data for a given location.
*/
public class BedrockScenario {
public static final String DASHES = new String(new char[80]).replace("\0", "-");
private static String modelId = "amazon.nova-lite-v1:0";
private static String defaultPrompt = "What is the weather like in Seattle?";
private static WeatherTool weatherTool = new WeatherTool();
// The maximum number of recursive calls allowed in the tool use function.
// This helps prevent infinite loops and potential performance issues.
private static int maxRecursions = 5;
static BedrockActions bedrockActions = new BedrockActions();
public static boolean interactive = true;
private static final String systemPrompt = """
You are a weather assistant that provides current weather data for user-specified locations using only
the Weather_Tool, which expects latitude and longitude. Infer the coordinates from the location yourself.
If the user provides coordinates, infer the approximate location and refer to it in your response.
To use the tool, you strictly apply the provided tool specification.
- Explain your step-by-step process, and give brief updates before each step.
- Only use the Weather_Tool for data. Never guess or make up information.
- Repeat the tool use for subsequent requests if necessary.
- If the tool errors, apologize, explain weather is unavailable, and suggest other options.
- Report temperatures in °C (°F) and wind in km/h (mph). Keep weather reports concise. Sparingly use
emojis where appropriate.
- Only respond to weather queries. Remind off-topic users of your purpose.
- Never claim to search online, access external data, or use tools besides Weather_Tool.
- Complete the entire process until you have all required data before sending the complete response.
""";
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("""
=================================================
Welcome to the Amazon Bedrock Tool Use demo!
=================================================
This assistant provides current weather information for user-specified locations.
You can ask for weather details by providing the location name or coordinates.
Example queries:
- What's the weather like in New York?
- Current weather for latitude 40.70, longitude -74.01
- Is it warmer in Rome or Barcelona today?
To exit the program, simply type 'x' and press Enter.
P.S.: You're not limited to single locations, or even to using English!
Have fun and experiment with the app!
""");
System.out.println(DASHES);
try {
runConversation(scanner);
} catch (Exception ex) {
System.out.println("There was a problem running the scenario: " + ex.getMessage());
}
waitForInputToContinue(scanner);
System.out.println(DASHES);
System.out.println("Amazon Bedrock Converse API with Tool Use Feature Scenario is complete.");
System.out.println(DASHES);
}
/**
* Starts the conversation with the user and handles the interaction with Bedrock.
*/
private static List runConversation(Scanner scanner) {
List conversation = new ArrayList<>();
// Get the first user input
String userInput = getUserInput("Your weather info request:", scanner);
System.out.println(userInput);
while (userInput != null) {
ContentBlock block = ContentBlock.builder()
.text(userInput)
.build();
List blockList = new ArrayList<>();
blockList.add(block);
Message message = Message.builder()
.role(ConversationRole.USER)
.content(blockList)
.build();
conversation.add(message);
// Send the conversation to Amazon Bedrock.
ConverseResponse bedrockResponse = sendConversationToBedrock(conversation);
// Recursively handle the model's response until the model has returned its final response or the recursion counter has reached 0.
processModelResponse(bedrockResponse, conversation, maxRecursions);
// Repeat the loop until the user decides to exit the application.
userInput = getUserInput("Your weather info request:", scanner);
}
printFooter();
return conversation;
}
/**
* Processes the response from the model and updates the conversation accordingly.
*
* @param modelResponse the response from the model
* @param conversation the ongoing conversation
* @param maxRecursion the maximum number of recursions allowed
*/
private static void processModelResponse(ConverseResponse modelResponse, List conversation, int maxRecursion) {
if (maxRecursion <= 0) {
// Stop the process, the number of recursive calls could indicate an infinite loop
System.out.println("\tWarning: Maximum number of recursions reached. Please try again.");
}
// Append the model's response to the ongoing conversation
conversation.add(modelResponse.output().message());
String modelResponseVal = modelResponse.stopReasonAsString();
if (modelResponseVal.compareTo("tool_use") == 0) {
// If the stop reason is "tool_use", forward everything to the tool use handler
handleToolUse(modelResponse.output(), conversation, maxRecursion - 1);
}
if (modelResponseVal.compareTo("end_turn") == 0) {
// If the stop reason is "end_turn", print the model's response text, and finish the process
PrintModelResponse(modelResponse.output().message().content().get(0).text());
if (!interactive) {
defaultPrompt = "x";
}
}
}
/**
* Handles the use of a tool by the model in a conversation.
*
* @param modelResponse the response from the model, which may include a tool use request
* @param conversation the current conversation, which will be updated with the tool use results
* @param maxRecursion the maximum number of recursive calls allowed to handle the model's response
*/
private static void handleToolUse(ConverseOutput modelResponse, List conversation, int maxRecursion) {
List toolResults = new ArrayList<>();
// The model's response can consist of multiple content blocks
for (ContentBlock contentBlock : modelResponse.message().content()) {
if (contentBlock.text() != null && !contentBlock.text().isEmpty()) {
// If the content block contains text, print it to the console
PrintModelResponse(contentBlock.text());
}
if (contentBlock.toolUse() != null) {
ToolResponse toolResponse = invokeTool(contentBlock.toolUse());
// Add the tool use ID and the tool's response to the list of results
List contentBlockList = new ArrayList<>();
ToolResultContentBlock block = ToolResultContentBlock.builder()
.json(toolResponse.getContent())
.build();
contentBlockList.add(block);
ToolResultBlock toolResultBlock = ToolResultBlock.builder()
.toolUseId(toolResponse.getToolUseId())
.content(contentBlockList)
.build();
ContentBlock contentBlock1 = ContentBlock.builder()
.toolResult(toolResultBlock)
.build();
toolResults.add(contentBlock1);
}
}
// Embed the tool results in a new user message
Message message = Message.builder()
.role(ConversationRole.USER)
.content(toolResults)
.build();
// Append the new message to the ongoing conversation
//conversation.add(message);
conversation.add(message);
// Send the conversation to Amazon Bedrock
var response = sendConversationToBedrock(conversation);
// Recursively handle the model's response until the model has returned its final response or the recursion counter has reached 0
processModelResponse(response, conversation, maxRecursion);
}
// Invokes the specified tool with the given payload and returns the tool's response.
// If the requested tool does not exist, an error message is returned.
private static ToolResponse invokeTool(ToolUseBlock payload) {
String toolName = payload.name();
if (Objects.equals(toolName, "Weather_Tool")) {
Map inputData = payload.input().asMap();
printToolUse(toolName, inputData);
// Invoke the weather tool with the input data provided
Document weatherResponse = weatherTool.fetchWeatherData(inputData.get("latitude").toString(), inputData.get("longitude").toString());
ToolResponse toolResponse = new ToolResponse();
toolResponse.setContent(weatherResponse);
toolResponse.setToolUseId(payload.toolUseId());
return toolResponse;
} else {
String errorMessage = "The requested tool with name " + toolName + " does not exist.";
System.out.println(errorMessage);
return null;
}
}
public static void printToolUse(String toolName, Map inputData) {
System.out.println("Invoking tool: " + toolName + " with input: " + inputData.get("latitude").toString() + ", " + inputData.get("longitude").toString() + "...");
}
private static void PrintModelResponse(String message) {
System.out.println("\tThe model's response:\n");
System.out.println(message);
System.out.println("");
}
private static ConverseResponse sendConversationToBedrock(List conversation) {
System.out.println("Calling Bedrock...");
try {
return bedrockActions.sendConverseRequestAsync(modelId, systemPrompt, conversation, weatherTool.getToolSpec());
} catch (ModelNotReadyException ex) {
System.err.println("Model is not ready. Please try again later: " + ex.getMessage());
throw ex;
} catch (BedrockRuntimeException ex) {
System.err.println("Bedrock service error: " + ex.getMessage());
throw ex;
} catch (RuntimeException ex) {
System.err.println("Unexpected error occurred: " + ex.getMessage());
throw ex;
}
}
private static ConverseResponse sendConversationToBedrockwithSpec(List conversation, ToolSpecification toolSpec) {
System.out.println("Calling Bedrock...");
// Send the conversation, system prompt, and tool configuration, and return the response
return bedrockActions.sendConverseRequestAsync(modelId, systemPrompt, conversation, toolSpec);
}
public static String getUserInput(String prompt, Scanner scanner) {
String userInput = defaultPrompt;
if (interactive) {
System.out.println("*".repeat(80));
System.out.println(prompt + " (x to exit): \n\t");
userInput = scanner.nextLine();
}
if (userInput == null || userInput.trim().isEmpty()) {
return getUserInput("\tPlease enter your weather info request, e.g., the name of a city", scanner);
}
if (userInput.equalsIgnoreCase("x")) {
return null;
}
return userInput;
}
private static void waitForInputToContinue(Scanner scanner) {
while (true) {
System.out.println("");
System.out.println("Enter 'c' followed by to continue:");
String input = scanner.nextLine();
if (input.trim().equalsIgnoreCase("c")) {
System.out.println("Continuing with the program...");
System.out.println("");
break;
} else {
// Handle invalid input.
System.out.println("Invalid input. Please try again.");
}
}
}
public static void printFooter() {
System.out.println("""
=================================================
Thank you for checking out the Amazon Bedrock Tool Use demo. We hope you
learned something new, or got some inspiration for your own apps today!
For more Bedrock examples in different programming languages, have a look at:
https://docs.aws.amazon.com/bedrock/latest/userguide/service_code_examples.html
=================================================
""");
}
}
```
The weather tool used by the demo. This file defines the tool specification and implements the logic to retrieve weather data using from the Open-Meteo API.
```
public class WeatherTool {
private static final Logger logger = LoggerFactory.getLogger(WeatherTool.class);
private static java.net.http.HttpClient httpClient = null;
/**
* Returns the JSON Schema specification for the Weather tool. The tool specification
* defines the input schema and describes the tool's functionality.
* For more information, see https://json-schema.org/understanding-json-schema/reference.
*
* @return The tool specification for the Weather tool.
*/
public ToolSpecification getToolSpec() {
Map latitudeMap = new HashMap<>();
latitudeMap.put("type", Document.fromString("string"));
latitudeMap.put("description", Document.fromString("Geographical WGS84 latitude of the location."));
// Create the nested "longitude" object
Map longitudeMap = new HashMap<>();
longitudeMap.put("type", Document.fromString("string"));
longitudeMap.put("description", Document.fromString("Geographical WGS84 longitude of the location."));
// Create the "properties" object
Map propertiesMap = new HashMap<>();
propertiesMap.put("latitude", Document.fromMap(latitudeMap));
propertiesMap.put("longitude", Document.fromMap(longitudeMap));
// Create the "required" array
List requiredList = new ArrayList<>();
requiredList.add(Document.fromString("latitude"));
requiredList.add(Document.fromString("longitude"));
// Create the root object
Map rootMap = new HashMap<>();
rootMap.put("type", Document.fromString("object"));
rootMap.put("properties", Document.fromMap(propertiesMap));
rootMap.put("required", Document.fromList(requiredList));
// Now create the Document representing the JSON schema
Document document = Document.fromMap(rootMap);
ToolSpecification specification = ToolSpecification.builder()
.name("Weather_Tool")
.description("Get the current weather for a given location, based on its WGS84 coordinates.")
.inputSchema(ToolInputSchema.builder()
.json(document)
.build())
.build();
return specification;
}
/**
* Fetches weather data for the given latitude and longitude.
*
* @param latitude the latitude coordinate
* @param longitude the longitude coordinate
* @return a {@link CompletableFuture} containing the weather data as a JSON string
*/
public Document fetchWeatherData(String latitude, String longitude) {
HttpClient httpClient = HttpClient.newHttpClient();
// Ensure no extra double quotes
latitude = latitude.replace("\"", "");
longitude = longitude.replace("\"", "");
String endpoint = "https://api.open-meteo.com/v1/forecast";
String url = String.format("%s?latitude=%s&longitude=%s¤t_weather=True", endpoint, latitude, longitude);
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(url))
.build();
try {
HttpResponse response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());
if (response.statusCode() == 200) {
String weatherJson = response.body();
System.out.println(weatherJson);
ObjectMapper objectMapper = new ObjectMapper();
Map rawMap = objectMapper.readValue(weatherJson, new TypeReference>() {});
Map documentMap = convertToDocumentMap(rawMap);
Document weatherDocument = Document.fromMap(documentMap);
System.out.println(weatherDocument);
return weatherDocument;
} else {
throw new RuntimeException("Error fetching weather data: " + response.statusCode());
}
} catch (Exception e) {
System.out.println("Error fetching weather data: " + e.getMessage());
throw new RuntimeException("Error fetching weather data", e);
}
}
private static Map convertToDocumentMap(Map inputMap) {
Map result = new HashMap<>();
for (Map.Entry entry : inputMap.entrySet()) {
result.put(entry.getKey(), convertToDocument(entry.getValue()));
}
return result;
}
// Convert different types of Objects to Document
private static Document convertToDocument(Object value) {
if (value instanceof Map) {
return Document.fromMap(convertToDocumentMap((Map) value));
} else if (value instanceof Integer) {
return Document.fromNumber(SdkNumber.fromInteger((Integer) value));
} else if (value instanceof Double) { //
return Document.fromNumber(SdkNumber.fromDouble((Double) value));
} else if (value instanceof Boolean) {
return Document.fromBoolean((Boolean) value);
} else if (value instanceof String) {
return Document.fromString((String) value);
}
return Document.fromNull(); // Handle null values safely
}
}
```
The Converse API action with a tool configuration.
```
/**
* Sends an asynchronous converse request to the AI model.
*
* @param modelId the unique identifier of the AI model to be used for the converse request
* @param systemPrompt the system prompt to be included in the converse request
* @param conversation a list of messages representing the conversation history
* @param toolSpec the specification of the tool to be used in the converse request
* @return the converse response received from the AI model
*/
public ConverseResponse sendConverseRequestAsync(String modelId, String systemPrompt, List conversation, ToolSpecification toolSpec) {
List toolList = new ArrayList<>();
Tool tool = Tool.builder()
.toolSpec(toolSpec)
.build();
toolList.add(tool);
ToolConfiguration configuration = ToolConfiguration.builder()
.tools(toolList)
.build();
SystemContentBlock block = SystemContentBlock.builder()
.text(systemPrompt)
.build();
ConverseRequest request = ConverseRequest.builder()
.modelId(modelId)
.system(block)
.messages(conversation)
.toolConfig(configuration)
.build();
try {
ConverseResponse response = getClient().converse(request).join();
return response;
} catch (ModelNotReadyException ex) {
throw new RuntimeException("Model is not ready: " + ex.getMessage(), ex);
} catch (BedrockRuntimeException ex) {
throw new RuntimeException("Failed to converse with Bedrock model: " + ex.getMessage(), ex);
}
}
```
+ For API details, see [Converse](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/Converse) in *AWS SDK for Java 2.x API Reference*.
------
#### [ JavaScript ]
**SDK for JavaScript (v3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime/scenarios/converse_tool_scenario#code-examples).
The primary execution of the scenario flow. This scenario orchestrates the conversation between the user, the Amazon Bedrock Converse API, and a weather tool.
```
/* Before running this JavaScript code example, set up your development environment, including your credentials.
This demo illustrates a tool use scenario using Amazon Bedrock's Converse API and a weather tool.
The script interacts with a foundation model on Amazon Bedrock to provide weather information based on user
input. It uses the Open-Meteo API (https://open-meteo.com) to retrieve current weather data for a given location.*/
import {
Scenario,
ScenarioAction,
ScenarioInput,
ScenarioOutput,
} from "@aws-doc-sdk-examples/lib/scenario/index.js";
import {
BedrockRuntimeClient,
ConverseCommand,
} from "@aws-sdk/client-bedrock-runtime";
import { parseArgs } from "node:util";
import { fileURLToPath } from "node:url";
import data from "./questions.json" with { type: "json" };
import toolConfig from "./tool_config.json" with { type: "json" };
const __filename = fileURLToPath(import.meta.url);
const systemPrompt = [
{
text:
"You are a weather assistant that provides current weather data for user-specified locations using only\n" +
"the Weather_Tool, which expects latitude and longitude. Infer the coordinates from the location yourself.\n" +
"If the user provides coordinates, infer the approximate location and refer to it in your response.\n" +
"To use the tool, you strictly apply the provided tool specification.\n" +
"If the user specifies a state, country, or region, infer the locations of cities within that state.\n" +
"\n" +
"- Explain your step-by-step process, and give brief updates before each step.\n" +
"- Only use the Weather_Tool for data. Never guess or make up information. \n" +
"- Repeat the tool use for subsequent requests if necessary.\n" +
"- If the tool errors, apologize, explain weather is unavailable, and suggest other options.\n" +
"- Report temperatures in °C (°F) and wind in km/h (mph). Keep weather reports concise. Sparingly use\n" +
" emojis where appropriate.\n" +
"- Only respond to weather queries. Remind off-topic users of your purpose. \n" +
"- Never claim to search online, access external data, or use tools besides Weather_Tool.\n" +
"- Complete the entire process until you have all required data before sending the complete response.",
},
];
const tools_config = toolConfig;
/// Starts the conversation with the user and handles the interaction with Bedrock.
async function askQuestion(userMessage) {
// The maximum number of recursive calls allowed in the tool use function.
// This helps prevent infinite loops and potential performance issues.
const max_recursions = 5;
const messages = [
{
role: "user",
content: [{ text: userMessage }],
},
];
try {
const response = await SendConversationtoBedrock(messages);
await ProcessModelResponseAsync(response, messages, max_recursions);
} catch (error) {
console.log("error ", error);
}
}
// Sends the conversation, the system prompt, and the tool spec to Amazon Bedrock, and returns the response.
// param "messages" - The conversation history including the next message to send.
// return - The response from Amazon Bedrock.
async function SendConversationtoBedrock(messages) {
const bedRockRuntimeClient = new BedrockRuntimeClient({
region: "us-east-1",
});
try {
const modelId = "amazon.nova-lite-v1:0";
const response = await bedRockRuntimeClient.send(
new ConverseCommand({
modelId: modelId,
messages: messages,
system: systemPrompt,
toolConfig: tools_config,
}),
);
return response;
} catch (caught) {
if (caught.name === "ModelNotReady") {
console.log(
"`${caught.name}` - Model not ready, please wait and try again.",
);
throw caught;
}
if (caught.name === "BedrockRuntimeException") {
console.log(
'`${caught.name}` - "Error occurred while sending Converse request.',
);
throw caught;
}
}
}
// Processes the response received via Amazon Bedrock and performs the necessary actions based on the stop reason.
// param "response" - The model's response returned via Amazon Bedrock.
// param "messages" - The conversation history.
// param "max_recursions" - The maximum number of recursive calls allowed.
async function ProcessModelResponseAsync(response, messages, max_recursions) {
if (max_recursions <= 0) {
await HandleToolUseAsync(response, messages);
}
if (response.stopReason === "tool_use") {
await HandleToolUseAsync(response, messages, max_recursions - 1);
}
if (response.stopReason === "end_turn") {
const messageToPrint = response.output.message.content[0].text;
console.log(messageToPrint.replace(/<[^>]+>/g, ""));
}
}
// Handles the tool use case by invoking the specified tool and sending the tool's response back to Bedrock.
// The tool response is appended to the conversation, and the conversation is sent back to Amazon Bedrock for further processing.
// param "response" - the model's response containing the tool use request.
// param "messages" - the conversation history.
// param "max_recursions" - The maximum number of recursive calls allowed.
async function HandleToolUseAsync(response, messages, max_recursions) {
const toolResultFinal = [];
try {
const output_message = response.output.message;
messages.push(output_message);
const toolRequests = output_message.content;
const toolMessage = toolRequests[0].text;
console.log(toolMessage.replace(/<[^>]+>/g, ""));
for (const toolRequest of toolRequests) {
if (Object.hasOwn(toolRequest, "toolUse")) {
const toolUse = toolRequest.toolUse;
const latitude = toolUse.input.latitude;
const longitude = toolUse.input.longitude;
const toolUseID = toolUse.toolUseId;
console.log(
`Requesting tool ${toolUse.name}, Tool use id ${toolUseID}`,
);
if (toolUse.name === "Weather_Tool") {
try {
const current_weather = await callWeatherTool(
longitude,
latitude,
).then((current_weather) => current_weather);
const currentWeather = current_weather;
const toolResult = {
toolResult: {
toolUseId: toolUseID,
content: [{ json: currentWeather }],
},
};
toolResultFinal.push(toolResult);
} catch (err) {
console.log("An error occurred. ", err);
}
}
}
}
const toolResultMessage = {
role: "user",
content: toolResultFinal,
};
messages.push(toolResultMessage);
// Send the conversation to Amazon Bedrock
await ProcessModelResponseAsync(
await SendConversationtoBedrock(messages),
messages,
);
} catch (error) {
console.log("An error occurred. ", error);
}
}
// Call the Weathertool.
// param = longitude of location
// param = latitude of location
async function callWeatherTool(longitude, latitude) {
// Open-Meteo API endpoint
const apiUrl = `https://api.open-meteo.com/v1/forecast?latitude=${latitude}&longitude=${longitude}¤t_weather=true`;
// Fetch the weather data.
return fetch(apiUrl)
.then((response) => {
return response.json().then((current_weather) => {
return current_weather;
});
})
.catch((error) => {
console.error("Error fetching weather data:", error);
});
}
/**
* Used repeatedly to have the user press enter.
* @type {ScenarioInput}
*/
const pressEnter = new ScenarioInput("continue", "Press Enter to continue", {
type: "input",
default: "",
});
const greet = new ScenarioOutput(
"greet",
"Welcome to the Amazon Bedrock Tool Use demo! \n" +
"This assistant provides current weather information for user-specified locations. " +
"You can ask for weather details by providing the location name or coordinates." +
"Weather information will be provided using a custom Tool and open-meteo API." +
"For the purposes of this example, we'll use in order the questions in ./questions.json :\n" +
"What's the weather like in Seattle? " +
"What's the best kind of cat? " +
"Where is the warmest city in Washington State right now? " +
"What's the warmest city in California right now?\n" +
"To exit the program, simply type 'x' and press Enter.\n" +
"Have fun and experiment with the app by editing the questions in ./questions.json! " +
"P.S.: You're not limited to single locations, or even to using English! ",
{ header: true },
);
const displayAskQuestion1 = new ScenarioOutput(
"displayAskQuestion1",
"Press enter to ask question number 1 (default is 'What's the weather like in Seattle?')",
);
const askQuestion1 = new ScenarioAction(
"askQuestion1",
async (/** @type {State} */ state) => {
const userMessage1 = data.questions["question-1"];
await askQuestion(userMessage1);
},
);
const displayAskQuestion2 = new ScenarioOutput(
"displayAskQuestion2",
"Press enter to ask question number 2 (default is 'What's the best kind of cat?')",
);
const askQuestion2 = new ScenarioAction(
"askQuestion2",
async (/** @type {State} */ state) => {
const userMessage2 = data.questions["question-2"];
await askQuestion(userMessage2);
},
);
const displayAskQuestion3 = new ScenarioOutput(
"displayAskQuestion3",
"Press enter to ask question number 3 (default is 'Where is the warmest city in Washington State right now?')",
);
const askQuestion3 = new ScenarioAction(
"askQuestion3",
async (/** @type {State} */ state) => {
const userMessage3 = data.questions["question-3"];
await askQuestion(userMessage3);
},
);
const displayAskQuestion4 = new ScenarioOutput(
"displayAskQuestion4",
"Press enter to ask question number 4 (default is 'What's the warmest city in California right now?')",
);
const askQuestion4 = new ScenarioAction(
"askQuestion4",
async (/** @type {State} */ state) => {
const userMessage4 = data.questions["question-4"];
await askQuestion(userMessage4);
},
);
const goodbye = new ScenarioOutput(
"goodbye",
"Thank you for checking out the Amazon Bedrock Tool Use demo. We hope you\n" +
"learned something new, or got some inspiration for your own apps today!\n" +
"For more Bedrock examples in different programming languages, have a look at:\n" +
"https://docs.aws.amazon.com/bedrock/latest/userguide/service_code_examples.html",
);
const myScenario = new Scenario("Converse Tool Scenario", [
greet,
pressEnter,
displayAskQuestion1,
askQuestion1,
pressEnter,
displayAskQuestion2,
askQuestion2,
pressEnter,
displayAskQuestion3,
askQuestion3,
pressEnter,
displayAskQuestion4,
askQuestion4,
pressEnter,
goodbye,
]);
/** @type {{ stepHandlerOptions: StepHandlerOptions }} */
export const main = async (stepHandlerOptions) => {
await myScenario.run(stepHandlerOptions);
};
// Invoke main function if this file was run directly.
if (process.argv[1] === fileURLToPath(import.meta.url)) {
const { values } = parseArgs({
options: {
yes: {
type: "boolean",
short: "y",
},
},
});
main({ confirmAll: values.yes });
}
```
+ For API details, see [Converse](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseCommand) in *AWS SDK for JavaScript API Reference*.
------
#### [ Python ]
**SDK for Python (Boto3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
The primary execution script of the demo. This script orchestrates the conversation between the user, the Amazon Bedrock Converse API, and a weather tool.
```
"""
This demo illustrates a tool use scenario using Amazon Bedrock's Converse API and a weather tool.
The script interacts with a foundation model on Amazon Bedrock to provide weather information based on user
input. It uses the Open-Meteo API (https://open-meteo.com) to retrieve current weather data for a given location.
"""
import boto3
import logging
from enum import Enum
import utils.tool_use_print_utils as output
import weather_tool
logging.basicConfig(level=logging.INFO, format="%(message)s")
AWS_REGION = "us-east-1"
# For the most recent list of models supported by the Converse API's tool use functionality, visit:
# https://docs.aws.amazon.com/bedrock/latest/userguide/conversation-inference.html
class SupportedModels(Enum):
CLAUDE_OPUS = "anthropic.claude-3-opus-20240229-v1:0"
CLAUDE_SONNET = "anthropic.claude-3-sonnet-20240229-v1:0"
CLAUDE_HAIKU = "anthropic.claude-3-haiku-20240307-v1:0"
COHERE_COMMAND_R = "cohere.command-r-v1:0"
COHERE_COMMAND_R_PLUS = "cohere.command-r-plus-v1:0"
# Set the model ID, e.g., Claude 3 Haiku.
MODEL_ID = SupportedModels.CLAUDE_HAIKU.value
SYSTEM_PROMPT = """
You are a weather assistant that provides current weather data for user-specified locations using only
the Weather_Tool, which expects latitude and longitude. Infer the coordinates from the location yourself.
If the user provides coordinates, infer the approximate location and refer to it in your response.
To use the tool, you strictly apply the provided tool specification.
- Explain your step-by-step process, and give brief updates before each step.
- Only use the Weather_Tool for data. Never guess or make up information.
- Repeat the tool use for subsequent requests if necessary.
- If the tool errors, apologize, explain weather is unavailable, and suggest other options.
- Report temperatures in °C (°F) and wind in km/h (mph). Keep weather reports concise. Sparingly use
emojis where appropriate.
- Only respond to weather queries. Remind off-topic users of your purpose.
- Never claim to search online, access external data, or use tools besides Weather_Tool.
- Complete the entire process until you have all required data before sending the complete response.
"""
# The maximum number of recursive calls allowed in the tool_use_demo function.
# This helps prevent infinite loops and potential performance issues.
MAX_RECURSIONS = 5
class ToolUseDemo:
"""
Demonstrates the tool use feature with the Amazon Bedrock Converse API.
"""
def __init__(self):
# Prepare the system prompt
self.system_prompt = [{"text": SYSTEM_PROMPT}]
# Prepare the tool configuration with the weather tool's specification
self.tool_config = {"tools": [weather_tool.get_tool_spec()]}
# Create a Bedrock Runtime client in the specified AWS Region.
self.bedrockRuntimeClient = boto3.client(
"bedrock-runtime", region_name=AWS_REGION
)
def run(self):
"""
Starts the conversation with the user and handles the interaction with Bedrock.
"""
# Print the greeting and a short user guide
output.header()
# Start with an emtpy conversation
conversation = []
# Get the first user input
user_input = self._get_user_input()
while user_input is not None:
# Create a new message with the user input and append it to the conversation
message = {"role": "user", "content": [{"text": user_input}]}
conversation.append(message)
# Send the conversation to Amazon Bedrock
bedrock_response = self._send_conversation_to_bedrock(conversation)
# Recursively handle the model's response until the model has returned
# its final response or the recursion counter has reached 0
self._process_model_response(
bedrock_response, conversation, max_recursion=MAX_RECURSIONS
)
# Repeat the loop until the user decides to exit the application
user_input = self._get_user_input()
output.footer()
def _send_conversation_to_bedrock(self, conversation):
"""
Sends the conversation, the system prompt, and the tool spec to Amazon Bedrock, and returns the response.
:param conversation: The conversation history including the next message to send.
:return: The response from Amazon Bedrock.
"""
output.call_to_bedrock(conversation)
# Send the conversation, system prompt, and tool configuration, and return the response
return self.bedrockRuntimeClient.converse(
modelId=MODEL_ID,
messages=conversation,
system=self.system_prompt,
toolConfig=self.tool_config,
)
def _process_model_response(
self, model_response, conversation, max_recursion=MAX_RECURSIONS
):
"""
Processes the response received via Amazon Bedrock and performs the necessary actions
based on the stop reason.
:param model_response: The model's response returned via Amazon Bedrock.
:param conversation: The conversation history.
:param max_recursion: The maximum number of recursive calls allowed.
"""
if max_recursion <= 0:
# Stop the process, the number of recursive calls could indicate an infinite loop
logging.warning(
"Warning: Maximum number of recursions reached. Please try again."
)
exit(1)
# Append the model's response to the ongoing conversation
message = model_response["output"]["message"]
conversation.append(message)
if model_response["stopReason"] == "tool_use":
# If the stop reason is "tool_use", forward everything to the tool use handler
self._handle_tool_use(message, conversation, max_recursion)
if model_response["stopReason"] == "end_turn":
# If the stop reason is "end_turn", print the model's response text, and finish the process
output.model_response(message["content"][0]["text"])
return
def _handle_tool_use(
self, model_response, conversation, max_recursion=MAX_RECURSIONS
):
"""
Handles the tool use case by invoking the specified tool and sending the tool's response back to Bedrock.
The tool response is appended to the conversation, and the conversation is sent back to Amazon Bedrock for further processing.
:param model_response: The model's response containing the tool use request.
:param conversation: The conversation history.
:param max_recursion: The maximum number of recursive calls allowed.
"""
# Initialize an empty list of tool results
tool_results = []
# The model's response can consist of multiple content blocks
for content_block in model_response["content"]:
if "text" in content_block:
# If the content block contains text, print it to the console
output.model_response(content_block["text"])
if "toolUse" in content_block:
# If the content block is a tool use request, forward it to the tool
tool_response = self._invoke_tool(content_block["toolUse"])
# Add the tool use ID and the tool's response to the list of results
tool_results.append(
{
"toolResult": {
"toolUseId": (tool_response["toolUseId"]),
"content": [{"json": tool_response["content"]}],
}
}
)
# Embed the tool results in a new user message
message = {"role": "user", "content": tool_results}
# Append the new message to the ongoing conversation
conversation.append(message)
# Send the conversation to Amazon Bedrock
response = self._send_conversation_to_bedrock(conversation)
# Recursively handle the model's response until the model has returned
# its final response or the recursion counter has reached 0
self._process_model_response(response, conversation, max_recursion - 1)
def _invoke_tool(self, payload):
"""
Invokes the specified tool with the given payload and returns the tool's response.
If the requested tool does not exist, an error message is returned.
:param payload: The payload containing the tool name and input data.
:return: The tool's response or an error message.
"""
tool_name = payload["name"]
if tool_name == "Weather_Tool":
input_data = payload["input"]
output.tool_use(tool_name, input_data)
# Invoke the weather tool with the input data provided by
response = weather_tool.fetch_weather_data(input_data)
else:
error_message = (
f"The requested tool with name '{tool_name}' does not exist."
)
response = {"error": "true", "message": error_message}
return {"toolUseId": payload["toolUseId"], "content": response}
@staticmethod
def _get_user_input(prompt="Your weather info request"):
"""
Prompts the user for input and returns the user's response.
Returns None if the user enters 'x' to exit.
:param prompt: The prompt to display to the user.
:return: The user's input or None if the user chooses to exit.
"""
output.separator()
user_input = input(f"{prompt} (x to exit): ")
if user_input == "":
prompt = "Please enter your weather info request, e.g. the name of a city"
return ToolUseDemo._get_user_input(prompt)
elif user_input.lower() == "x":
return None
else:
return user_input
if __name__ == "__main__":
tool_use_demo = ToolUseDemo()
tool_use_demo.run()
```
The weather tool used by the demo. This script defines the tool specification and implements the logic to retrieve weather data using from the Open-Meteo API.
```
import requests
from requests.exceptions import RequestException
def get_tool_spec():
"""
Returns the JSON Schema specification for the Weather tool. The tool specification
defines the input schema and describes the tool's functionality.
For more information, see https://json-schema.org/understanding-json-schema/reference.
:return: The tool specification for the Weather tool.
"""
return {
"toolSpec": {
"name": "Weather_Tool",
"description": "Get the current weather for a given location, based on its WGS84 coordinates.",
"inputSchema": {
"json": {
"type": "object",
"properties": {
"latitude": {
"type": "string",
"description": "Geographical WGS84 latitude of the location.",
},
"longitude": {
"type": "string",
"description": "Geographical WGS84 longitude of the location.",
},
},
"required": ["latitude", "longitude"],
}
},
}
}
def fetch_weather_data(input_data):
"""
Fetches weather data for the given latitude and longitude using the Open-Meteo API.
Returns the weather data or an error message if the request fails.
:param input_data: The input data containing the latitude and longitude.
:return: The weather data or an error message.
"""
endpoint = "https://api.open-meteo.com/v1/forecast"
latitude = input_data.get("latitude")
longitude = input_data.get("longitude", "")
params = {"latitude": latitude, "longitude": longitude, "current_weather": True}
try:
response = requests.get(endpoint, params=params)
weather_data = {"weather_data": response.json()}
response.raise_for_status()
return weather_data
except RequestException as e:
return e.response.json()
except Exception as e:
return {"error": type(e), "message": str(e)}
```
+ For API details, see [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) in *AWS SDK for Python (Boto3) API Reference*.
------
#### [ Rust ]
**SDK for Rust**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/bedrock-runtime#code-examples).
The primary scenario and logic for the demo. This orchestrates the conversation between the user, the Amazon Bedrock Converse API, and a weather tool.
```
#[derive(Debug)]
#[allow(dead_code)]
struct InvokeToolResult(String, ToolResultBlock);
struct ToolUseScenario {
client: Client,
conversation: Vec,
system_prompt: SystemContentBlock,
tool_config: ToolConfiguration,
}
impl ToolUseScenario {
fn new(client: Client) -> Self {
let system_prompt = SystemContentBlock::Text(SYSTEM_PROMPT.into());
let tool_config = ToolConfiguration::builder()
.tools(Tool::ToolSpec(
ToolSpecification::builder()
.name(TOOL_NAME)
.description(TOOL_DESCRIPTION)
.input_schema(ToolInputSchema::Json(make_tool_schema()))
.build()
.unwrap(),
))
.build()
.unwrap();
ToolUseScenario {
client,
conversation: vec![],
system_prompt,
tool_config,
}
}
async fn run(&mut self) -> Result<(), ToolUseScenarioError> {
loop {
let input = get_input().await?;
if input.is_none() {
break;
}
let message = Message::builder()
.role(User)
.content(ContentBlock::Text(input.unwrap()))
.build()
.map_err(ToolUseScenarioError::from)?;
self.conversation.push(message);
let response = self.send_to_bedrock().await?;
self.process_model_response(response).await?;
}
Ok(())
}
async fn send_to_bedrock(&mut self) -> Result {
debug!("Sending conversation to bedrock");
self.client
.converse()
.model_id(MODEL_ID)
.set_messages(Some(self.conversation.clone()))
.system(self.system_prompt.clone())
.tool_config(self.tool_config.clone())
.send()
.await
.map_err(ToolUseScenarioError::from)
}
async fn process_model_response(
&mut self,
mut response: ConverseOutput,
) -> Result<(), ToolUseScenarioError> {
let mut iteration = 0;
while iteration < MAX_RECURSIONS {
iteration += 1;
let message = if let Some(ref output) = response.output {
if output.is_message() {
Ok(output.as_message().unwrap().clone())
} else {
Err(ToolUseScenarioError(
"Converse Output is not a message".into(),
))
}
} else {
Err(ToolUseScenarioError("Missing Converse Output".into()))
}?;
self.conversation.push(message.clone());
match response.stop_reason {
StopReason::ToolUse => {
response = self.handle_tool_use(&message).await?;
}
StopReason::EndTurn => {
print_model_response(&message.content[0])?;
return Ok(());
}
_ => (),
}
}
Err(ToolUseScenarioError(
"Exceeded MAX_ITERATIONS when calling tools".into(),
))
}
async fn handle_tool_use(
&mut self,
message: &Message,
) -> Result {
let mut tool_results: Vec = vec![];
for block in &message.content {
match block {
ContentBlock::Text(_) => print_model_response(block)?,
ContentBlock::ToolUse(tool) => {
let tool_response = self.invoke_tool(tool).await?;
tool_results.push(ContentBlock::ToolResult(tool_response.1));
}
_ => (),
};
}
let message = Message::builder()
.role(User)
.set_content(Some(tool_results))
.build()?;
self.conversation.push(message);
self.send_to_bedrock().await
}
async fn invoke_tool(
&mut self,
tool: &ToolUseBlock,
) -> Result {
match tool.name() {
TOOL_NAME => {
println!(
"\x1b[0;90mExecuting tool: {TOOL_NAME} with input: {:?}...\x1b[0m",
tool.input()
);
let content = fetch_weather_data(tool).await?;
println!(
"\x1b[0;90mTool responded with {:?}\x1b[0m",
content.content()
);
Ok(InvokeToolResult(tool.tool_use_id.clone(), content))
}
_ => Err(ToolUseScenarioError(format!(
"The requested tool with name {} does not exist",
tool.name()
))),
}
}
}
#[tokio::main]
async fn main() {
tracing_subscriber::fmt::init();
let sdk_config = aws_config::defaults(BehaviorVersion::latest())
.region(CLAUDE_REGION)
.load()
.await;
let client = Client::new(&sdk_config);
let mut scenario = ToolUseScenario::new(client);
header();
if let Err(err) = scenario.run().await {
println!("There was an error running the scenario! {}", err.0)
}
footer();
}
```
The weather tool used by the demo. This script defines the tool specification and implements the logic to retrieve weather data using from the Open-Meteo API.
```
const ENDPOINT: &str = "https://api.open-meteo.com/v1/forecast";
async fn fetch_weather_data(
tool_use: &ToolUseBlock,
) -> Result {
let input = tool_use.input();
let latitude = input
.as_object()
.unwrap()
.get("latitude")
.unwrap()
.as_string()
.unwrap();
let longitude = input
.as_object()
.unwrap()
.get("longitude")
.unwrap()
.as_string()
.unwrap();
let params = [
("latitude", latitude),
("longitude", longitude),
("current_weather", "true"),
];
debug!("Calling {ENDPOINT} with {params:?}");
let response = reqwest::Client::new()
.get(ENDPOINT)
.query(¶ms)
.send()
.await
.map_err(|e| ToolUseScenarioError(format!("Error requesting weather: {e:?}")))?
.error_for_status()
.map_err(|e| ToolUseScenarioError(format!("Failed to request weather: {e:?}")))?;
debug!("Response: {response:?}");
let bytes = response
.bytes()
.await
.map_err(|e| ToolUseScenarioError(format!("Error reading response: {e:?}")))?;
let result = String::from_utf8(bytes.to_vec())
.map_err(|_| ToolUseScenarioError("Response was not utf8".into()))?;
Ok(ToolResultBlock::builder()
.tool_use_id(tool_use.tool_use_id())
.content(ToolResultContentBlock::Text(result))
.build()?)
}
```
Utilities to print the Message Content Blocks.
```
fn print_model_response(block: &ContentBlock) -> Result<(), ToolUseScenarioError> {
if block.is_text() {
let text = block.as_text().unwrap();
println!("\x1b[0;90mThe model's response:\x1b[0m\n{text}");
Ok(())
} else {
Err(ToolUseScenarioError(format!(
"Content block is not text ({block:?})"
)))
}
}
```
Use statements, Error utility, and constants.
```
use std::{collections::HashMap, io::stdin};
use aws_config::BehaviorVersion;
use aws_sdk_bedrockruntime::{
error::{BuildError, SdkError},
operation::converse::{ConverseError, ConverseOutput},
types::{
ContentBlock, ConversationRole::User, Message, StopReason, SystemContentBlock, Tool,
ToolConfiguration, ToolInputSchema, ToolResultBlock, ToolResultContentBlock,
ToolSpecification, ToolUseBlock,
},
Client,
};
use aws_smithy_runtime_api::http::Response;
use aws_smithy_types::Document;
use tracing::debug;
// Set the model ID, e.g., Claude 3 Haiku.
const MODEL_ID: &str = "anthropic.claude-3-haiku-20240307-v1:0";
const CLAUDE_REGION: &str = "us-east-1";
const SYSTEM_PROMPT: &str = "You are a weather assistant that provides current weather data for user-specified locations using only
the Weather_Tool, which expects latitude and longitude. Infer the coordinates from the location yourself.
If the user provides coordinates, infer the approximate location and refer to it in your response.
To use the tool, you strictly apply the provided tool specification.
- Explain your step-by-step process, and give brief updates before each step.
- Only use the Weather_Tool for data. Never guess or make up information.
- Repeat the tool use for subsequent requests if necessary.
- If the tool errors, apologize, explain weather is unavailable, and suggest other options.
- Report temperatures in °C (°F) and wind in km/h (mph). Keep weather reports concise. Sparingly use
emojis where appropriate.
- Only respond to weather queries. Remind off-topic users of your purpose.
- Never claim to search online, access external data, or use tools besides Weather_Tool.
- Complete the entire process until you have all required data before sending the complete response.
";
// The maximum number of recursive calls allowed in the tool_use_demo function.
// This helps prevent infinite loops and potential performance issues.
const MAX_RECURSIONS: i8 = 5;
const TOOL_NAME: &str = "Weather_Tool";
const TOOL_DESCRIPTION: &str =
"Get the current weather for a given location, based on its WGS84 coordinates.";
fn make_tool_schema() -> Document {
Document::Object(HashMap::::from([
("type".into(), Document::String("object".into())),
(
"properties".into(),
Document::Object(HashMap::from([
(
"latitude".into(),
Document::Object(HashMap::from([
("type".into(), Document::String("string".into())),
(
"description".into(),
Document::String("Geographical WGS84 latitude of the location.".into()),
),
])),
),
(
"longitude".into(),
Document::Object(HashMap::from([
("type".into(), Document::String("string".into())),
(
"description".into(),
Document::String(
"Geographical WGS84 longitude of the location.".into(),
),
),
])),
),
])),
),
(
"required".into(),
Document::Array(vec![
Document::String("latitude".into()),
Document::String("longitude".into()),
]),
),
]))
}
#[derive(Debug)]
struct ToolUseScenarioError(String);
impl std::fmt::Display for ToolUseScenarioError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "Tool use error with '{}'. Reason: {}", MODEL_ID, self.0)
}
}
impl From<&str> for ToolUseScenarioError {
fn from(value: &str) -> Self {
ToolUseScenarioError(value.into())
}
}
impl From for ToolUseScenarioError {
fn from(value: BuildError) -> Self {
ToolUseScenarioError(value.to_string().clone())
}
}
impl From> for ToolUseScenarioError {
fn from(value: SdkError) -> Self {
ToolUseScenarioError(match value.as_service_error() {
Some(value) => value.meta().message().unwrap_or("Unknown").into(),
None => "Unknown".into(),
})
}
}
```
+ For API details, see [Converse](https://docs.rs/aws-sdk-bedrockruntime/latest/aws_sdk_bedrockruntime/client/struct.Client.html#method.converse) in *AWS SDK for Rust API reference*.
------
For a complete list of AWS SDK developer guides and code examples, see [Using Amazon Bedrock with an AWS SDK](sdk-general-information-section.md). This topic also includes information about getting started and details about previous SDK versions.
# Amazon Nova for Amazon Bedrock Runtime
The following code examples show how to use Amazon Bedrock Runtime with AWS SDKs.
**Topics**
+ [Converse](bedrock-runtime_example_bedrock-runtime_Converse_AmazonNovaText_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_AmazonNovaText_section.md)
+ [Document understanding](bedrock-runtime_example_bedrock-runtime_DocumentUnderstanding_AmazonNova_section.md)
+ [Scenario: Tool use with the Converse API](bedrock-runtime_example_bedrock-runtime_Scenario_ToolUseDemo_AmazonNova_section.md)
# Invoke Amazon Nova on Amazon Bedrock using Bedrock's Converse API
The following code examples show how to send a text message to Amazon Nova, using Bedrock's Converse API.
------
#### [ .NET ]
**SDK for .NET**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime#code-examples).
Send a text message to Amazon Nova, using Bedrock's Converse API.
```
// Use the Converse API to send a text message to Amazon Nova.
using System;
using System.Collections.Generic;
using Amazon;
using Amazon.BedrockRuntime;
using Amazon.BedrockRuntime.Model;
// Create a Bedrock Runtime client in the AWS Region you want to use.
var client = new AmazonBedrockRuntimeClient(RegionEndpoint.USEast1);
// Set the model ID, e.g., Amazon Nova Lite.
var modelId = "amazon.nova-lite-v1:0";
// Define the user message.
var userMessage = "Describe the purpose of a 'hello world' program in one line.";
// Create a request with the model ID, the user message, and an inference configuration.
var request = new ConverseRequest
{
ModelId = modelId,
Messages = new List
{
new Message
{
Role = ConversationRole.User,
Content = new List { new ContentBlock { Text = userMessage } }
}
},
InferenceConfig = new InferenceConfiguration()
{
MaxTokens = 512,
Temperature = 0.5F,
TopP = 0.9F
}
};
try
{
// Send the request to the Bedrock Runtime and wait for the result.
var response = await client.ConverseAsync(request);
// Extract and print the response text.
string responseText = response?.Output?.Message?.Content?[0]?.Text ?? "";
Console.WriteLine(responseText);
}
catch (AmazonBedrockRuntimeException e)
{
Console.WriteLine($"ERROR: Can't invoke '{modelId}'. Reason: {e.Message}");
throw;
}
```
Send a conversation of messages to Amazon Nova using Bedrock's Converse API with a tool configuration.
```
///
/// Wrapper class for interacting with the Amazon Bedrock Converse API.
///
public class BedrockActionsWrapper
{
private readonly IAmazonBedrockRuntime _bedrockClient;
private readonly ILogger _logger;
///
/// Initializes a new instance of the class.
///
/// The Bedrock Converse API client.
/// The logger instance.
public BedrockActionsWrapper(IAmazonBedrockRuntime bedrockClient, ILogger logger)
{
_bedrockClient = bedrockClient;
_logger = logger;
}
///
/// Sends a Converse request to the Amazon Bedrock Converse API.
///
/// The Bedrock Model Id.
/// A system prompt instruction.
/// The array of messages in the conversation.
/// The specification for a tool.
/// The response of the model.
public async Task SendConverseRequestAsync(string modelId, string systemPrompt, List conversation, ToolSpecification toolSpec)
{
try
{
var request = new ConverseRequest()
{
ModelId = modelId,
System = new List()
{
new SystemContentBlock()
{
Text = systemPrompt
}
},
Messages = conversation,
ToolConfig = new ToolConfiguration()
{
Tools = new List()
{
new Tool()
{
ToolSpec = toolSpec
}
}
}
};
var response = await _bedrockClient.ConverseAsync(request);
return response;
}
catch (ModelNotReadyException ex)
{
_logger.LogError(ex, "Model not ready, please wait and try again.");
throw;
}
catch (AmazonBedrockRuntimeException ex)
{
_logger.LogError(ex, "Error occurred while sending Converse request.");
throw;
}
}
}
```
+ For API details, see [Converse](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/Converse) in *AWS SDK for .NET API Reference*.
------
#### [ Java ]
**SDK for Java 2.x**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Send a text message to Amazon Nova using Bedrock's Converse API with the async Java client.
```
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.bedrockruntime.BedrockRuntimeAsyncClient;
import software.amazon.awssdk.services.bedrockruntime.model.*;
import java.util.concurrent.CompletableFuture;
/**
* This example demonstrates how to use the Amazon Nova foundation models
* with an asynchronous Amazon Bedrock runtime client to generate text.
* It shows how to:
* - Set up the Amazon Bedrock runtime client
* - Create a message
* - Configure and send a request
* - Process the response
*/
public class ConverseAsync {
public static String converseAsync() {
// Step 1: Create the Amazon Bedrock runtime client
// The runtime client handles the communication with AI models on Amazon Bedrock
BedrockRuntimeAsyncClient client = BedrockRuntimeAsyncClient.builder()
.credentialsProvider(DefaultCredentialsProvider.create())
.region(Region.US_EAST_1)
.build();
// Step 2: Specify which model to use
// Available Amazon Nova models and their characteristics:
// - Amazon Nova Micro: Text-only model optimized for lowest latency and cost
// - Amazon Nova Lite: Fast, low-cost multimodal model for image, video, and text
// - Amazon Nova Pro: Advanced multimodal model balancing accuracy, speed, and cost
//
// For the latest available models, see:
// https://docs.aws.amazon.com/bedrock/latest/userguide/models-supported.html
String modelId = "amazon.nova-lite-v1:0";
// Step 3: Create the message
// The message includes the text prompt and specifies that it comes from the user
var inputText = "Describe the purpose of a 'hello world' program in one line.";
var message = Message.builder()
.content(ContentBlock.fromText(inputText))
.role(ConversationRole.USER)
.build();
// Step 4: Configure the request
// Optional parameters to control the model's response:
// - maxTokens: maximum number of tokens to generate
// - temperature: randomness (max: 1.0, default: 0.7)
// OR
// - topP: diversity of word choice (max: 1.0, default: 0.9)
// Note: Use either temperature OR topP, but not both
ConverseRequest request = ConverseRequest.builder()
.modelId(modelId)
.messages(message)
.inferenceConfig(config -> config
.maxTokens(500) // The maximum response length
.temperature(0.5F) // Using temperature for randomness control
//.topP(0.9F) // Alternative: use topP instead of temperature
).build();
// Step 5: Send and process the request asynchronously
// - Send the request to the model
// - Extract and return the generated text from the response
try {
CompletableFuture asyncResponse = client.converse(request);
return asyncResponse.thenApply(
response -> response.output().message().content().get(0).text()
).get();
} catch (Exception e) {
System.err.printf("Can't invoke '%s': %s", modelId, e.getMessage());
throw new RuntimeException(e);
}
}
public static void main(String[] args) {
String response = converseAsync();
System.out.println(response);
}
}
```
Send a text message to Amazon Nova, using Bedrock's Converse API.
```
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.core.exception.SdkClientException;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.bedrockruntime.BedrockRuntimeClient;
import software.amazon.awssdk.services.bedrockruntime.model.*;
/**
* This example demonstrates how to use the Amazon Nova foundation models
* with a synchronous Amazon Bedrock runtime client to generate text.
* It shows how to:
* - Set up the Amazon Bedrock runtime client
* - Create a message
* - Configure and send a request
* - Process the response
*/
public class Converse {
public static String converse() {
// Step 1: Create the Amazon Bedrock runtime client
// The runtime client handles the communication with AI models on Amazon Bedrock
BedrockRuntimeClient client = BedrockRuntimeClient.builder()
.credentialsProvider(DefaultCredentialsProvider.create())
.region(Region.US_EAST_1)
.build();
// Step 2: Specify which model to use
// Available Amazon Nova models and their characteristics:
// - Amazon Nova Micro: Text-only model optimized for lowest latency and cost
// - Amazon Nova Lite: Fast, low-cost multimodal model for image, video, and text
// - Amazon Nova Pro: Advanced multimodal model balancing accuracy, speed, and cost
//
// For the latest available models, see:
// https://docs.aws.amazon.com/bedrock/latest/userguide/models-supported.html
String modelId = "amazon.nova-lite-v1:0";
// Step 3: Create the message
// The message includes the text prompt and specifies that it comes from the user
var inputText = "Describe the purpose of a 'hello world' program in one line.";
var message = Message.builder()
.content(ContentBlock.fromText(inputText))
.role(ConversationRole.USER)
.build();
// Step 4: Configure the request
// Optional parameters to control the model's response:
// - maxTokens: maximum number of tokens to generate
// - temperature: randomness (max: 1.0, default: 0.7)
// OR
// - topP: diversity of word choice (max: 1.0, default: 0.9)
// Note: Use either temperature OR topP, but not both
ConverseRequest request = ConverseRequest.builder()
.modelId(modelId)
.messages(message)
.inferenceConfig(config -> config
.maxTokens(500) // The maximum response length
.temperature(0.5F) // Using temperature for randomness control
//.topP(0.9F) // Alternative: use topP instead of temperature
).build();
// Step 5: Send and process the request
// - Send the request to the model
// - Extract and return the generated text from the response
try {
ConverseResponse response = client.converse(request);
return response.output().message().content().get(0).text();
} catch (SdkClientException e) {
System.err.printf("ERROR: Can't invoke '%s'. Reason: %s", modelId, e.getMessage());
throw new RuntimeException(e);
}
}
public static void main(String[] args) {
String response = converse();
System.out.println(response);
}
}
```
+ For API details, see [Converse](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/Converse) in *AWS SDK for Java 2.x API Reference*.
------
#### [ JavaScript ]
**SDK for JavaScript (v3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Send a text message to Amazon Nova, using Bedrock's Converse API.
```
// This example demonstrates how to use the Amazon Nova foundation models to generate text.
// It shows how to:
// - Set up the Amazon Bedrock runtime client
// - Create a message
// - Configure and send a request
// - Process the response
import {
BedrockRuntimeClient,
ConversationRole,
ConverseCommand,
} from "@aws-sdk/client-bedrock-runtime";
// Step 1: Create the Amazon Bedrock runtime client
// Credentials will be automatically loaded from the environment.
const client = new BedrockRuntimeClient({ region: "us-east-1" });
// Step 2: Specify which model to use:
// Available Amazon Nova models and their characteristics:
// - Amazon Nova Micro: Text-only model optimized for lowest latency and cost
// - Amazon Nova Lite: Fast, low-cost multimodal model for image, video, and text
// - Amazon Nova Pro: Advanced multimodal model balancing accuracy, speed, and cost
//
// For the most current model IDs, see:
// https://docs.aws.amazon.com/bedrock/latest/userguide/models-supported.html
const modelId = "amazon.nova-lite-v1:0";
// Step 3: Create the message
// The message includes the text prompt and specifies that it comes from the user
const inputText =
"Describe the purpose of a 'hello world' program in one line.";
const message = {
content: [{ text: inputText }],
role: ConversationRole.USER,
};
// Step 4: Configure the request
// Optional parameters to control the model's response:
// - maxTokens: maximum number of tokens to generate
// - temperature: randomness (max: 1.0, default: 0.7)
// OR
// - topP: diversity of word choice (max: 1.0, default: 0.9)
// Note: Use either temperature OR topP, but not both
const request = {
modelId,
messages: [message],
inferenceConfig: {
maxTokens: 500, // The maximum response length
temperature: 0.5, // Using temperature for randomness control
//topP: 0.9, // Alternative: use topP instead of temperature
},
};
// Step 5: Send and process the request
// - Send the request to the model
// - Extract and return the generated text from the response
try {
const response = await client.send(new ConverseCommand(request));
console.log(response.output.message.content[0].text);
} catch (error) {
console.error(`ERROR: Can't invoke '${modelId}'. Reason: ${error.message}`);
throw error;
}
```
Send a conversation of messages to Amazon Nova using Bedrock's Converse API with a tool configuration.
```
// This example demonstrates how to send a conversation of messages to Amazon Nova using Bedrock's Converse API with a tool configuration.
// It shows how to:
// - 1. Set up the Amazon Bedrock runtime client
// - 2. Define the parameters required enable Amazon Bedrock to use a tool when formulating its response (model ID, user input, system prompt, and the tool spec)
// - 3. Send the request to Amazon Bedrock, and returns the response.
// - 4. Add the tool response to the conversation, and send it back to Amazon Bedrock.
// - 5. Publish the response.
import {
BedrockRuntimeClient,
ConverseCommand,
} from "@aws-sdk/client-bedrock-runtime";
// Step 1: Create the Amazon Bedrock runtime client
// Credentials will be automatically loaded from the environment
const bedRockRuntimeClient = new BedrockRuntimeClient({
region: "us-east-1",
});
// Step 2. Define the parameters required enable Amazon Bedrock to use a tool when formulating its response.
// The Bedrock Model ID.
const modelId = "amazon.nova-lite-v1:0";
// The system prompt to help Amazon Bedrock craft it's response.
const system_prompt = [
{
text:
"You are a music expert that provides the most popular song played on a radio station, using only the\n" +
"the top_song tool, which he call sign for the radio station for which you want the most popular song. " +
"Example calls signs are WZPZ and WKRP. \n" +
"- Only use the top_song tool. Never guess or make up information. \n" +
"- If the tool errors, apologize, explain weather is unavailable, and suggest other options.\n" +
"- Only respond to queries about the most popular song played on a radio station\n" +
"Remind off-topic users of your purpose. \n" +
"- Never claim to search online, access external data, or use tools besides the top_song tool.\n",
},
];
// The user's question.
const message = [
{
role: "user",
content: [{ text: "What is the most popular song on WZPZ?" }],
},
];
// The tool specification. In this case, it uses an example schema for
// a tool that gets the most popular song played on a radio station.
const tool_config = {
tools: [
{
toolSpec: {
name: "top_song",
description: "Get the most popular song played on a radio station.",
inputSchema: {
json: {
type: "object",
properties: {
sign: {
type: "string",
description:
"The call sign for the radio station for which you want the most popular song. Example calls signs are WZPZ and WKRP.",
},
},
required: ["sign"],
},
},
},
},
],
};
// Helper function to return the song and artist from top_song tool.
async function get_top_song(call_sign) {
try {
if (call_sign === "WZPZ") {
const song = "Elemental Hotel";
const artist = "8 Storey Hike";
return { song, artist };
}
} catch (error) {
console.log(`${error.message}`);
}
}
// 3. Send the request to Amazon Bedrock, and returns the response.
export async function SendConversationtoBedrock(
modelId,
message,
system_prompt,
tool_config,
) {
try {
const response = await bedRockRuntimeClient.send(
new ConverseCommand({
modelId: modelId,
messages: message,
system: system_prompt,
toolConfig: tool_config,
}),
);
if (response.stopReason === "tool_use") {
const toolResultFinal = [];
try {
const output_message = response.output.message;
message.push(output_message);
const toolRequests = output_message.content;
const toolMessage = toolRequests[0].text;
console.log(toolMessage.replace(/<[^>]+>/g, ""));
for (const toolRequest of toolRequests) {
if (Object.hasOwn(toolRequest, "toolUse")) {
const toolUse = toolRequest.toolUse;
const sign = toolUse.input.sign;
const toolUseID = toolUse.toolUseId;
console.log(
`Requesting tool ${toolUse.name}, Tool use id ${toolUseID}`,
);
if (toolUse.name === "top_song") {
const toolResult = [];
try {
const top_song = await get_top_song(toolUse.input.sign).then(
(top_song) => top_song,
);
const toolResult = {
toolResult: {
toolUseId: toolUseID,
content: [
{
json: { song: top_song.song, artist: top_song.artist },
},
],
},
};
toolResultFinal.push(toolResult);
} catch (err) {
const toolResult = {
toolUseId: toolUseID,
content: [{ json: { text: err.message } }],
status: "error",
};
}
}
}
}
const toolResultMessage = {
role: "user",
content: toolResultFinal,
};
// Step 4. Add the tool response to the conversation, and send it back to Amazon Bedrock.
message.push(toolResultMessage);
await SendConversationtoBedrock(
modelId,
message,
system_prompt,
tool_config,
);
} catch (caught) {
console.error(`${caught.message}`);
throw caught;
}
}
// 4. Publish the response.
if (response.stopReason === "end_turn") {
const finalMessage = response.output.message.content[0].text;
const messageToPrint = finalMessage.replace(/<[^>]+>/g);
console.log(messageToPrint.replace(/<[^>]+>/g));
return messageToPrint;
}
} catch (caught) {
if (caught.name === "ModelNotReady") {
console.log(
`${caught.name} - Model not ready, please wait and try again.`,
);
throw caught;
}
if (caught.name === "BedrockRuntimeException") {
console.log(
`${caught.name} - Error occurred while sending Converse request`,
);
throw caught;
}
}
}
await SendConversationtoBedrock(modelId, message, system_prompt, tool_config);
```
+ For API details, see [Converse](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseCommand) in *AWS SDK for JavaScript API Reference*.
------
#### [ Kotlin ]
**SDK for Kotlin**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/bedrock-runtime#code-examples).
Send a text message to Amazon Nova, using Bedrock's Converse API.
```
import aws.sdk.kotlin.services.bedrockruntime.BedrockRuntimeClient
import aws.sdk.kotlin.services.bedrockruntime.model.ContentBlock
import aws.sdk.kotlin.services.bedrockruntime.model.ConversationRole
import aws.sdk.kotlin.services.bedrockruntime.model.ConverseRequest
import aws.sdk.kotlin.services.bedrockruntime.model.Message
/**
* This example demonstrates how to use the Amazon Nova foundation models to generate text.
* It shows how to:
* - Set up the Amazon Bedrock runtime client
* - Create a message
* - Configure and send a request
* - Process the response
*/
suspend fun main() {
converse().also { println(it) }
}
suspend fun converse(): String {
// Create and configure the Bedrock runtime client
BedrockRuntimeClient { region = "us-east-1" }.use { client ->
// Specify the model ID. For the latest available models, see:
// https://docs.aws.amazon.com/bedrock/latest/userguide/models-supported.html
val modelId = "amazon.nova-lite-v1:0"
// Create the message with the user's prompt
val prompt = "Describe the purpose of a 'hello world' program in one line."
val message = Message {
role = ConversationRole.User
content = listOf(ContentBlock.Text(prompt))
}
// Configure the request with optional model parameters
val request = ConverseRequest {
this.modelId = modelId
messages = listOf(message)
inferenceConfig {
maxTokens = 500 // Maximum response length
temperature = 0.5F // Lower values: more focused output
// topP = 0.8F // Alternative to temperature
}
}
// Send the request and process the model's response
runCatching {
val response = client.converse(request)
return response.output!!.asMessage().content.first().asText()
}.getOrElse { error ->
error.message?.let { e -> System.err.println("ERROR: Can't invoke '$modelId'. Reason: $e") }
throw RuntimeException("Failed to generate text with model $modelId", error)
}
}
}
```
+ For API details, see [Converse](https://sdk.amazonaws.com/kotlin/api/latest/index.html) in *AWS SDK for Kotlin API reference*.
------
#### [ PHP ]
**SDK for PHP**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/bedrock-runtime#code-examples).
Send a text message to Amazon Nova, using Bedrock's Converse API.
```
// Use the Conversation API to send a text message to Amazon Nova.
use Aws\BedrockRuntime\BedrockRuntimeClient;
use Aws\Exception\AwsException;
use RuntimeException;
class Converse
{
public function converse(): string
{
// Create a Bedrock Runtime client in the AWS Region you want to use.
$client = new BedrockRuntimeClient([
'region' => 'us-east-1',
'profile' => 'default'
]);
// Set the model ID, e.g., Amazon Nova Lite.
$modelId = 'amazon.nova-lite-v1:0';
// Start a conversation with the user message.
$userMessage = "Describe the purpose of a 'hello world' program in one line.";
$conversation = [
[
"role" => "user",
"content" => [["text" => $userMessage]]
]
];
try {
// Send the message to the model, using a basic inference configuration.
$response = $client->converse([
'modelId' => $modelId,
'messages' => $conversation,
'inferenceConfig' => [
'maxTokens' => 512,
'temperature' => 0.5
]
]);
// Extract and return the response text.
$responseText = $response['output']['message']['content'][0]['text'];
return $responseText;
} catch (AwsException $e) {
echo "ERROR: Can't invoke {$modelId}. Reason: {$e->getAwsErrorMessage()}";
throw new RuntimeException("Failed to invoke model: " . $e->getAwsErrorMessage(), 0, $e);
}
}
}
$demo = new Converse();
echo $demo->converse();
```
+ For API details, see [Converse](https://docs.aws.amazon.com/goto/SdkForPHPV3/bedrock-runtime-2023-09-30/Converse) in *AWS SDK for PHP API Reference*.
------
#### [ Python ]
**SDK for Python (Boto3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Send a text message to Amazon Nova, using Bedrock's Converse API.
```
# Use the Conversation API to send a text message to Amazon Nova.
import boto3
from botocore.exceptions import ClientError
# Create a Bedrock Runtime client in the AWS Region you want to use.
client = boto3.client("bedrock-runtime", region_name="us-east-1")
# Set the model ID, e.g., Amazon Nova Lite.
model_id = "amazon.nova-lite-v1:0"
# Start a conversation with the user message.
user_message = "Describe the purpose of a 'hello world' program in one line."
conversation = [
{
"role": "user",
"content": [{"text": user_message}],
}
]
try:
# Send the message to the model, using a basic inference configuration.
response = client.converse(
modelId=model_id,
messages=conversation,
inferenceConfig={"maxTokens": 512, "temperature": 0.5, "topP": 0.9},
)
# Extract and print the response text.
response_text = response["output"]["message"]["content"][0]["text"]
print(response_text)
except (ClientError, Exception) as e:
print(f"ERROR: Can't invoke '{model_id}'. Reason: {e}")
exit(1)
```
+ For API details, see [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) in *AWS SDK for Python (Boto3) API Reference*.
------
#### [ Swift ]
**SDK for Swift**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/bedrock-runtime#code-examples).
Send a text message to Amazon Nova, using Bedrock's Converse API.
```
// An example demonstrating how to use the Conversation API to send
// a text message to Amazon Nova.
import AWSBedrockRuntime
func converse(_ textPrompt: String) async throws -> String {
// Create a Bedrock Runtime client in the AWS Region you want to use.
let config =
try await BedrockRuntimeClient.BedrockRuntimeClientConfiguration(
region: "us-east-1"
)
let client = BedrockRuntimeClient(config: config)
// Set the model ID.
let modelId = "amazon.nova-micro-v1:0"
// Start a conversation with the user message.
let message = BedrockRuntimeClientTypes.Message(
content: [.text(textPrompt)],
role: .user
)
// Optionally use inference parameters
let inferenceConfig =
BedrockRuntimeClientTypes.InferenceConfiguration(
maxTokens: 512,
stopSequences: ["END"],
temperature: 0.5,
topp: 0.9
)
// Create the ConverseInput to send to the model
let input = ConverseInput(
inferenceConfig: inferenceConfig, messages: [message], modelId: modelId)
// Send the ConverseInput to the model
let response = try await client.converse(input: input)
// Extract and return the response text.
if case let .message(msg) = response.output {
if case let .text(textResponse) = msg.content![0] {
return textResponse
} else {
return "No text response found in message content"
}
} else {
return "No message found in converse output"
}
}
```
+ For API details, see [Converse](https://sdk.amazonaws.com/swift/api/awsbedrockruntime/latest/documentation/awsbedrockruntime/bedrockruntimeclient/converse(input:)) in *AWS SDK for Swift API reference*.
------
For a complete list of AWS SDK developer guides and code examples, see [Using Amazon Bedrock with an AWS SDK](sdk-general-information-section.md). This topic also includes information about getting started and details about previous SDK versions.
# Invoke Amazon Nova on Amazon Bedrock using Bedrock's Converse API with a response stream
The following code examples show how to send a text message to Amazon Nova, using Bedrock's Converse API and process the response stream in real-time.
------
#### [ .NET ]
**SDK for .NET**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime#code-examples).
Send a text message to Amazon Nova, using Bedrock's Converse API and process the response stream in real-time.
```
// Use the Converse API to send a text message to Amazon Nova
// and print the response stream.
using System;
using System.Collections.Generic;
using System.Linq;
using Amazon;
using Amazon.BedrockRuntime;
using Amazon.BedrockRuntime.Model;
// Create a Bedrock Runtime client in the AWS Region you want to use.
var client = new AmazonBedrockRuntimeClient(RegionEndpoint.USEast1);
// Set the model ID, e.g., Amazon Nova Lite.
var modelId = "amazon.nova-lite-v1:0";
// Define the user message.
var userMessage = "Describe the purpose of a 'hello world' program in one line.";
// Create a request with the model ID, the user message, and an inference configuration.
var request = new ConverseStreamRequest
{
ModelId = modelId,
Messages = new List
{
new Message
{
Role = ConversationRole.User,
Content = new List { new ContentBlock { Text = userMessage } }
}
},
InferenceConfig = new InferenceConfiguration()
{
MaxTokens = 512,
Temperature = 0.5F,
TopP = 0.9F
}
};
try
{
// Send the request to the Bedrock Runtime and wait for the result.
var response = await client.ConverseStreamAsync(request);
// Extract and print the streamed response text in real-time.
foreach (var chunk in response.Stream.AsEnumerable())
{
if (chunk is ContentBlockDeltaEvent)
{
Console.Write((chunk as ContentBlockDeltaEvent).Delta.Text);
}
}
}
catch (AmazonBedrockRuntimeException e)
{
Console.WriteLine($"ERROR: Can't invoke '{modelId}'. Reason: {e.Message}");
throw;
}
```
+ For API details, see [ConverseStream](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/ConverseStream) in *AWS SDK for .NET API Reference*.
------
#### [ Java ]
**SDK for Java 2.x**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Send a text message to Amazon Nova using Bedrock's Converse API and process the response stream in real-time.
```
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.bedrockruntime.BedrockRuntimeAsyncClient;
import software.amazon.awssdk.services.bedrockruntime.model.*;
import java.util.concurrent.ExecutionException;
/**
* This example demonstrates how to use the Amazon Nova foundation models with an
* asynchronous Amazon Bedrock runtime client to generate streaming text responses.
* It shows how to:
* - Set up the Amazon Bedrock runtime client
* - Create a message
* - Configure a streaming request
* - Set up a stream handler to process the response chunks
* - Process the streaming response
*/
public class ConverseStream {
public static void converseStream() {
// Step 1: Create the Amazon Bedrock runtime client
// The runtime client handles the communication with AI models on Amazon Bedrock
BedrockRuntimeAsyncClient client = BedrockRuntimeAsyncClient.builder()
.credentialsProvider(DefaultCredentialsProvider.create())
.region(Region.US_EAST_1)
.build();
// Step 2: Specify which model to use
// Available Amazon Nova models and their characteristics:
// - Amazon Nova Micro: Text-only model optimized for lowest latency and cost
// - Amazon Nova Lite: Fast, low-cost multimodal model for image, video, and text
// - Amazon Nova Pro: Advanced multimodal model balancing accuracy, speed, and cost
//
// For the latest available models, see:
// https://docs.aws.amazon.com/bedrock/latest/userguide/models-supported.html
String modelId = "amazon.nova-lite-v1:0";
// Step 3: Create the message
// The message includes the text prompt and specifies that it comes from the user
var inputText = "Describe the purpose of a 'hello world' program in one paragraph";
var message = Message.builder()
.content(ContentBlock.fromText(inputText))
.role(ConversationRole.USER)
.build();
// Step 4: Configure the request
// Optional parameters to control the model's response:
// - maxTokens: maximum number of tokens to generate
// - temperature: randomness (max: 1.0, default: 0.7)
// OR
// - topP: diversity of word choice (max: 1.0, default: 0.9)
// Note: Use either temperature OR topP, but not both
ConverseStreamRequest request = ConverseStreamRequest.builder()
.modelId(modelId)
.messages(message)
.inferenceConfig(config -> config
.maxTokens(500) // The maximum response length
.temperature(0.5F) // Using temperature for randomness control
//.topP(0.9F) // Alternative: use topP instead of temperature
).build();
// Step 5: Set up the stream handler
// The stream handler processes chunks of the response as they arrive
// - onContentBlockDelta: Processes each text chunk
// - onError: Handles any errors during streaming
var streamHandler = ConverseStreamResponseHandler.builder()
.subscriber(ConverseStreamResponseHandler.Visitor.builder()
.onContentBlockDelta(chunk -> {
System.out.print(chunk.delta().text());
System.out.flush(); // Ensure immediate output of each chunk
}).build())
.onError(err -> System.err.printf("Can't invoke '%s': %s", modelId, err.getMessage()))
.build();
// Step 6: Send the streaming request and process the response
// - Send the request to the model
// - Attach the handler to process response chunks as they arrive
// - Handle any errors during streaming
try {
client.converseStream(request, streamHandler).get();
} catch (ExecutionException | InterruptedException e) {
System.err.printf("Can't invoke '%s': %s", modelId, e.getCause().getMessage());
}
}
public static void main(String[] args) {
converseStream();
}
}
```
+ For API details, see [ConverseStream](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/ConverseStream) in *AWS SDK for Java 2.x API Reference*.
------
#### [ JavaScript ]
**SDK for JavaScript (v3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Send a text message to Amazon Nova using Bedrock's Converse API and process the response stream in real-time.
```
// This example demonstrates how to use the Amazon Nova foundation models
// to generate streaming text responses.
// It shows how to:
// - Set up the Amazon Bedrock runtime client
// - Create a message
// - Configure a streaming request
// - Process the streaming response
import {
BedrockRuntimeClient,
ConversationRole,
ConverseStreamCommand,
} from "@aws-sdk/client-bedrock-runtime";
// Step 1: Create the Amazon Bedrock runtime client
// Credentials will be automatically loaded from the environment
const client = new BedrockRuntimeClient({ region: "us-east-1" });
// Step 2: Specify which model to use
// Available Amazon Nova models and their characteristics:
// - Amazon Nova Micro: Text-only model optimized for lowest latency and cost
// - Amazon Nova Lite: Fast, low-cost multimodal model for image, video, and text
// - Amazon Nova Pro: Advanced multimodal model balancing accuracy, speed, and cost
//
// For the most current model IDs, see:
// https://docs.aws.amazon.com/bedrock/latest/userguide/models-supported.html
const modelId = "amazon.nova-lite-v1:0";
// Step 3: Create the message
// The message includes the text prompt and specifies that it comes from the user
const inputText =
"Describe the purpose of a 'hello world' program in one paragraph";
const message = {
content: [{ text: inputText }],
role: ConversationRole.USER,
};
// Step 4: Configure the streaming request
// Optional parameters to control the model's response:
// - maxTokens: maximum number of tokens to generate
// - temperature: randomness (max: 1.0, default: 0.7)
// OR
// - topP: diversity of word choice (max: 1.0, default: 0.9)
// Note: Use either temperature OR topP, but not both
const request = {
modelId,
messages: [message],
inferenceConfig: {
maxTokens: 500, // The maximum response length
temperature: 0.5, // Using temperature for randomness control
//topP: 0.9, // Alternative: use topP instead of temperature
},
};
// Step 5: Send and process the streaming request
// - Send the request to the model
// - Process each chunk of the streaming response
try {
const response = await client.send(new ConverseStreamCommand(request));
for await (const chunk of response.stream) {
if (chunk.contentBlockDelta) {
// Print each text chunk as it arrives
process.stdout.write(chunk.contentBlockDelta.delta?.text || "");
}
}
} catch (error) {
console.error(`ERROR: Can't invoke '${modelId}'. Reason: ${error.message}`);
process.exitCode = 1;
}
```
+ For API details, see [ConverseStream](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseStreamCommand) in *AWS SDK for JavaScript API Reference*.
------
#### [ Kotlin ]
**SDK for Kotlin**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/bedrock-runtime#code-examples).
Send a text message to Amazon Nova using Bedrock's Converse API and process the response stream in real-time.
```
import aws.sdk.kotlin.services.bedrockruntime.BedrockRuntimeClient
import aws.sdk.kotlin.services.bedrockruntime.model.ContentBlock
import aws.sdk.kotlin.services.bedrockruntime.model.ConversationRole
import aws.sdk.kotlin.services.bedrockruntime.model.ConverseStreamOutput
import aws.sdk.kotlin.services.bedrockruntime.model.ConverseStreamRequest
import aws.sdk.kotlin.services.bedrockruntime.model.Message
/**
* This example demonstrates how to use the Amazon Nova foundation models
* to generate streaming text responses.
* It shows how to:
* - Set up the Amazon Bedrock runtime client
* - Create a message with a prompt
* - Configure a streaming request with parameters
* - Process the response stream in real time
*/
suspend fun main() {
converseStream()
}
suspend fun converseStream(): String {
// A buffer to collect the complete response
val completeResponseBuffer = StringBuilder()
// Create and configure the Bedrock runtime client
BedrockRuntimeClient { region = "us-east-1" }.use { client ->
// Specify the model ID. For the latest available models, see:
// https://docs.aws.amazon.com/bedrock/latest/userguide/models-supported.html
val modelId = "amazon.nova-lite-v1:0"
// Create the message with the user's prompt
val prompt = "Describe the purpose of a 'hello world' program in a paragraph."
val message = Message {
role = ConversationRole.User
content = listOf(ContentBlock.Text(prompt))
}
// Configure the request with optional model parameters
val request = ConverseStreamRequest {
this.modelId = modelId
messages = listOf(message)
inferenceConfig {
maxTokens = 500 // Maximum response length
temperature = 0.5F // Lower values: more focused output
// topP = 0.8F // Alternative to temperature
}
}
// Process the streaming response
runCatching {
client.converseStream(request) { response ->
response.stream?.collect { chunk ->
when (chunk) {
is ConverseStreamOutput.ContentBlockDelta -> {
// Process each text chunk as it arrives
chunk.value.delta?.asText()?.let { text ->
print(text)
System.out.flush() // Ensure immediate output
completeResponseBuffer.append(text)
}
}
else -> {} // Other output block types can be handled as needed
}
}
}
}.onFailure { error ->
error.message?.let { e -> System.err.println("ERROR: Can't invoke '$modelId'. Reason: $e") }
throw RuntimeException("Failed to generate text with model $modelId: $error", error)
}
}
return completeResponseBuffer.toString()
}
```
+ For API details, see [ConverseStream](https://sdk.amazonaws.com/kotlin/api/latest/index.html) in *AWS SDK for Kotlin API reference*.
------
#### [ Python ]
**SDK for Python (Boto3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Send a text message to Amazon Nova, using Bedrock's Converse API and process the response stream in real-time.
```
# Use the Conversation API to send a text message to Amazon Nova Text
# and print the response stream.
import boto3
from botocore.exceptions import ClientError
# Create a Bedrock Runtime client in the AWS Region you want to use.
client = boto3.client("bedrock-runtime", region_name="us-east-1")
# Set the model ID, e.g., Amazon Nova Lite.
model_id = "amazon.nova-lite-v1:0"
# Start a conversation with the user message.
user_message = "Describe the purpose of a 'hello world' program in one line."
conversation = [
{
"role": "user",
"content": [{"text": user_message}],
}
]
try:
# Send the message to the model, using a basic inference configuration.
streaming_response = client.converse_stream(
modelId=model_id,
messages=conversation,
inferenceConfig={"maxTokens": 512, "temperature": 0.5, "topP": 0.9},
)
# Extract and print the streamed response text in real-time.
for chunk in streaming_response["stream"]:
if "contentBlockDelta" in chunk:
text = chunk["contentBlockDelta"]["delta"]["text"]
print(text, end="")
except (ClientError, Exception) as e:
print(f"ERROR: Can't invoke '{model_id}'. Reason: {e}")
exit(1)
```
+ For API details, see [ConverseStream](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/ConverseStream) in *AWS SDK for Python (Boto3) API Reference*.
------
#### [ Swift ]
**SDK for Swift**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/bedrock-runtime#code-examples).
Send a text message to Amazon Nova, using Bedrock's Converse API and process the response stream in real-time.
```
// An example demonstrating how to use the Conversation API to send a text message
// to Amazon Nova and print the response stream
import AWSBedrockRuntime
func printConverseStream(_ textPrompt: String) async throws {
// Create a Bedrock Runtime client in the AWS Region you want to use.
let config =
try await BedrockRuntimeClient.BedrockRuntimeClientConfiguration(
region: "us-east-1"
)
let client = BedrockRuntimeClient(config: config)
// Set the model ID.
let modelId = "amazon.nova-lite-v1:0"
// Start a conversation with the user message.
let message = BedrockRuntimeClientTypes.Message(
content: [.text(textPrompt)],
role: .user
)
// Optionally use inference parameters.
let inferenceConfig =
BedrockRuntimeClientTypes.InferenceConfiguration(
maxTokens: 512,
stopSequences: ["END"],
temperature: 0.5,
topp: 0.9
)
// Create the ConverseStreamInput to send to the model.
let input = ConverseStreamInput(
inferenceConfig: inferenceConfig, messages: [message], modelId: modelId)
// Send the ConverseStreamInput to the model.
let response = try await client.converseStream(input: input)
// Extract the streaming response.
guard let stream = response.stream else {
print("No stream available")
return
}
// Extract and print the streamed response text in real-time.
for try await event in stream {
switch event {
case .messagestart(_):
print("\nNova Lite:")
case .contentblockdelta(let deltaEvent):
if case .text(let text) = deltaEvent.delta {
print(text, terminator: "")
}
default:
break
}
}
}
```
+ For API details, see [ConverseStream](https://sdk.amazonaws.com/swift/api/awsbedrockruntime/latest/documentation/awsbedrockruntime/bedrockruntimeclient/conversestream(input:)) in *AWS SDK for Swift API reference*.
------
For a complete list of AWS SDK developer guides and code examples, see [Using Amazon Bedrock with an AWS SDK](sdk-general-information-section.md). This topic also includes information about getting started and details about previous SDK versions.
# Send and process a document with Amazon Nova on Amazon Bedrock
The following code example shows how to send and process a document with Amazon Nova on Amazon Bedrock.
------
#### [ Python ]
**SDK for Python (Boto3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Send and process a document with Amazon Nova on Amazon Bedrock.
```
# Send and process a document with Amazon Nova on Amazon Bedrock.
import boto3
from botocore.exceptions import ClientError
# Create a Bedrock Runtime client in the AWS Region you want to use.
client = boto3.client("bedrock-runtime", region_name="us-east-1")
# Set the model ID, e.g. Amazon Nova Lite.
model_id = "amazon.nova-lite-v1:0"
# Load the document
with open("example-data/amazon-nova-service-cards.pdf", "rb") as file:
document_bytes = file.read()
# Start a conversation with a user message and the document
conversation = [
{
"role": "user",
"content": [
{"text": "Briefly compare the models described in this document"},
{
"document": {
# Available formats: html, md, pdf, doc/docx, xls/xlsx, csv, and txt
"format": "pdf",
"name": "Amazon Nova Service Cards",
"source": {"bytes": document_bytes},
}
},
],
}
]
try:
# Send the message to the model, using a basic inference configuration.
response = client.converse(
modelId=model_id,
messages=conversation,
inferenceConfig={"maxTokens": 500, "temperature": 0.3},
)
# Extract and print the response text.
response_text = response["output"]["message"]["content"][0]["text"]
print(response_text)
except (ClientError, Exception) as e:
print(f"ERROR: Can't invoke '{model_id}'. Reason: {e}")
exit(1)
```
+ For API details, see [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) in *AWS SDK for Python (Boto3) API Reference*.
------
For a complete list of AWS SDK developer guides and code examples, see [Using Amazon Bedrock with an AWS SDK](sdk-general-information-section.md). This topic also includes information about getting started and details about previous SDK versions.
# A tool use demo illustrating how to connect AI models on Amazon Bedrock with a custom tool or API
The following code examples show how to build a typical interaction between an application, a generative AI model, and connected tools or APIs to mediate interactions between the AI and the outside world. It uses the example of connecting an external weather API to the AI model so it can provide real-time weather information based on user input.
------
#### [ .NET ]
**SDK for .NET**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime/Scenarios/ConverseToolScenario#code-examples).
The primary execution of the scenario flow. This scenario orchestrates the conversation between the user, the Amazon Bedrock Converse API, and a weather tool.
```
using Amazon;
using Amazon.BedrockRuntime;
using Amazon.BedrockRuntime.Model;
using Amazon.Runtime.Documents;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.DependencyInjection.Extensions;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Http;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Logging.Console;
namespace ConverseToolScenario;
public static class ConverseToolScenario
{
/*
Before running this .NET code example, set up your development environment, including your credentials.
This demo illustrates a tool use scenario using Amazon Bedrock's Converse API and a weather tool.
The script interacts with a foundation model on Amazon Bedrock to provide weather information based on user
input. It uses the Open-Meteo API (https://open-meteo.com) to retrieve current weather data for a given location.
*/
public static BedrockActionsWrapper _bedrockActionsWrapper = null!;
public static WeatherTool _weatherTool = null!;
public static bool _interactive = true;
// Change this string to use a different model with Converse API.
private static string model_id = "amazon.nova-lite-v1:0";
private static string system_prompt = @"
You are a weather assistant that provides current weather data for user-specified locations using only
the Weather_Tool, which expects latitude and longitude. Infer the coordinates from the location yourself.
If the user specifies a state, country, or region, infer the locations of cities within that state.
If the user provides coordinates, infer the approximate location and refer to it in your response.
To use the tool, you strictly apply the provided tool specification.
- Explain your step-by-step process, and give brief updates before each step.
- Only use the Weather_Tool for data. Never guess or make up information.
- Repeat the tool use for subsequent requests if necessary.
- If the tool errors, apologize, explain weather is unavailable, and suggest other options.
- Report temperatures in °C (°F) and wind in km/h (mph). Keep weather reports concise. Sparingly use
emojis where appropriate.
- Only respond to weather queries. Remind off-topic users of your purpose.
- Never claim to search online, access external data, or use tools besides Weather_Tool.
- Complete the entire process until you have all required data before sending the complete response.
"
;
private static string default_prompt = "What is the weather like in Seattle?";
// The maximum number of recursive calls allowed in the tool use function.
// This helps prevent infinite loops and potential performance issues.
private static int max_recursions = 5;
public static async Task Main(string[] args)
{
// Set up dependency injection for the Amazon service.
using var host = Host.CreateDefaultBuilder(args)
.ConfigureLogging(logging =>
logging.AddFilter("System", LogLevel.Error)
.AddFilter("Microsoft", LogLevel.Trace))
.ConfigureServices((_, services) =>
services.AddHttpClient()
.AddSingleton(_ => new AmazonBedrockRuntimeClient(RegionEndpoint.USEast1)) // Specify a region that has access to the chosen model.
.AddTransient()
.AddTransient()
.RemoveAll()
)
.Build();
ServicesSetup(host);
try
{
await RunConversationAsync();
}
catch (Exception ex)
{
Console.WriteLine(new string('-', 80));
Console.WriteLine($"There was a problem running the scenario: {ex.Message}");
Console.WriteLine(new string('-', 80));
}
finally
{
Console.WriteLine(
"Amazon Bedrock Converse API with Tool Use Feature Scenario is complete.");
Console.WriteLine(new string('-', 80));
}
}
///
/// Populate the services for use within the console application.
///
/// The services host.
private static void ServicesSetup(IHost host)
{
_bedrockActionsWrapper = host.Services.GetRequiredService();
_weatherTool = host.Services.GetRequiredService();
}
///
/// Starts the conversation with the user and handles the interaction with Bedrock.
///
/// The conversation array.
public static async Task> RunConversationAsync()
{
// Print the greeting and a short user guide
PrintHeader();
// Start with an empty conversation
var conversation = new List();
// Get the first user input
var userInput = await GetUserInputAsync();
while (userInput != null)
{
// Create a new message with the user input and append it to the conversation
var message = new Message { Role = ConversationRole.User, Content = new List { new ContentBlock { Text = userInput } } };
conversation.Add(message);
// Send the conversation to Amazon Bedrock
var bedrockResponse = await SendConversationToBedrock(conversation);
// Recursively handle the model's response until the model has returned its final response or the recursion counter has reached 0
await ProcessModelResponseAsync(bedrockResponse, conversation, max_recursions);
// Repeat the loop until the user decides to exit the application
userInput = await GetUserInputAsync();
}
PrintFooter();
return conversation;
}
///
/// Sends the conversation, the system prompt, and the tool spec to Amazon Bedrock, and returns the response.
///
/// The conversation history including the next message to send.
/// The response from Amazon Bedrock.
private static async Task SendConversationToBedrock(List conversation)
{
Console.WriteLine("\tCalling Bedrock...");
// Send the conversation, system prompt, and tool configuration, and return the response
return await _bedrockActionsWrapper.SendConverseRequestAsync(model_id, system_prompt, conversation, _weatherTool.GetToolSpec());
}
///
/// Processes the response received via Amazon Bedrock and performs the necessary actions based on the stop reason.
///
/// The model's response returned via Amazon Bedrock.
/// The conversation history.
/// The maximum number of recursive calls allowed.
private static async Task ProcessModelResponseAsync(ConverseResponse modelResponse, List conversation, int maxRecursion)
{
if (maxRecursion <= 0)
{
// Stop the process, the number of recursive calls could indicate an infinite loop
Console.WriteLine("\tWarning: Maximum number of recursions reached. Please try again.");
}
// Append the model's response to the ongoing conversation
conversation.Add(modelResponse.Output.Message);
if (modelResponse.StopReason == "tool_use")
{
// If the stop reason is "tool_use", forward everything to the tool use handler
await HandleToolUseAsync(modelResponse.Output, conversation, maxRecursion - 1);
}
if (modelResponse.StopReason == "end_turn")
{
// If the stop reason is "end_turn", print the model's response text, and finish the process
PrintModelResponse(modelResponse.Output.Message.Content[0].Text);
if (!_interactive)
{
default_prompt = "x";
}
}
}
///
/// Handles the tool use case by invoking the specified tool and sending the tool's response back to Bedrock.
/// The tool response is appended to the conversation, and the conversation is sent back to Amazon Bedrock for further processing.
///
/// The model's response containing the tool use request.
/// The conversation history.
/// The maximum number of recursive calls allowed.
public static async Task HandleToolUseAsync(ConverseOutput modelResponse, List conversation, int maxRecursion)
{
// Initialize an empty list of tool results
var toolResults = new List();
// The model's response can consist of multiple content blocks
foreach (var contentBlock in modelResponse.Message.Content)
{
if (!String.IsNullOrEmpty(contentBlock.Text))
{
// If the content block contains text, print it to the console
PrintModelResponse(contentBlock.Text);
}
if (contentBlock.ToolUse != null)
{
// If the content block is a tool use request, forward it to the tool
var toolResponse = await InvokeTool(contentBlock.ToolUse);
// Add the tool use ID and the tool's response to the list of results
toolResults.Add(new ContentBlock
{
ToolResult = new ToolResultBlock()
{
ToolUseId = toolResponse.ToolUseId,
Content = new List()
{ new ToolResultContentBlock { Json = toolResponse.Content } }
}
});
}
}
// Embed the tool results in a new user message
var message = new Message() { Role = ConversationRole.User, Content = toolResults };
// Append the new message to the ongoing conversation
conversation.Add(message);
// Send the conversation to Amazon Bedrock
var response = await SendConversationToBedrock(conversation);
// Recursively handle the model's response until the model has returned its final response or the recursion counter has reached 0
await ProcessModelResponseAsync(response, conversation, maxRecursion);
}
///
/// Invokes the specified tool with the given payload and returns the tool's response.
/// If the requested tool does not exist, an error message is returned.
///
/// The payload containing the tool name and input data.
/// The tool's response or an error message.
public static async Task InvokeTool(ToolUseBlock payload)
{
var toolName = payload.Name;
if (toolName == "Weather_Tool")
{
var inputData = payload.Input.AsDictionary();
PrintToolUse(toolName, inputData);
// Invoke the weather tool with the input data provided
var weatherResponse = await _weatherTool.FetchWeatherDataAsync(inputData["latitude"].ToString(), inputData["longitude"].ToString());
return new ToolResponse { ToolUseId = payload.ToolUseId, Content = weatherResponse };
}
else
{
var errorMessage = $"\tThe requested tool with name '{toolName}' does not exist.";
return new ToolResponse { ToolUseId = payload.ToolUseId, Content = new { error = true, message = errorMessage } };
}
}
///
/// Prompts the user for input and returns the user's response.
/// Returns null if the user enters 'x' to exit.
///
/// The prompt to display to the user.
/// The user's input or null if the user chooses to exit.
private static async Task GetUserInputAsync(string prompt = "\tYour weather info request:")
{
var userInput = default_prompt;
if (_interactive)
{
Console.WriteLine(new string('*', 80));
Console.WriteLine($"{prompt} (x to exit): \n\t");
userInput = Console.ReadLine();
}
if (string.IsNullOrWhiteSpace(userInput))
{
prompt = "\tPlease enter your weather info request, e.g. the name of a city";
return await GetUserInputAsync(prompt);
}
if (userInput.ToLowerInvariant() == "x")
{
return null;
}
return userInput;
}
///
/// Logs the welcome message and usage guide for the tool use demo.
///
public static void PrintHeader()
{
Console.WriteLine(@"
=================================================
Welcome to the Amazon Bedrock Tool Use demo!
=================================================
This assistant provides current weather information for user-specified locations.
You can ask for weather details by providing the location name or coordinates. Weather information
will be provided using a custom Tool and open-meteo API.
Example queries:
- What's the weather like in New York?
- Current weather for latitude 40.70, longitude -74.01
- Is it warmer in Rome or Barcelona today?
To exit the program, simply type 'x' and press Enter.
P.S.: You're not limited to single locations, or even to using English!
Have fun and experiment with the app!
");
}
///
/// Logs the footer information for the tool use demo.
///
public static void PrintFooter()
{
Console.WriteLine(@"
=================================================
Thank you for checking out the Amazon Bedrock Tool Use demo. We hope you
learned something new, or got some inspiration for your own apps today!
For more Bedrock examples in different programming languages, have a look at:
https://docs.aws.amazon.com/bedrock/latest/userguide/service_code_examples.html
=================================================
");
}
///
/// Logs information about the tool use.
///
/// The name of the tool being used.
/// The input data for the tool.
public static void PrintToolUse(string toolName, Dictionary inputData)
{
Console.WriteLine($"\n\tInvoking tool: {toolName} with input: {inputData["latitude"].ToString()}, {inputData["longitude"].ToString()}...\n");
}
///
/// Logs the model's response.
///
/// The model's response message.
public static void PrintModelResponse(string message)
{
Console.WriteLine("\tThe model's response:\n");
Console.WriteLine(message);
Console.WriteLine();
}
}
```
The weather tool used by the demo. This file defines the tool specification and implements the logic to retrieve weather data using from the Open-Meteo API.
```
using Amazon.BedrockRuntime.Model;
using Amazon.Runtime.Documents;
using Microsoft.Extensions.Logging;
namespace ConverseToolScenario;
///
/// Weather tool that will be invoked when requested by the Bedrock response.
///
public class WeatherTool
{
private readonly ILogger _logger;
private readonly IHttpClientFactory _httpClientFactory;
public WeatherTool(ILogger logger, IHttpClientFactory httpClientFactory)
{
_logger = logger;
_httpClientFactory = httpClientFactory;
}
///
/// Returns the JSON Schema specification for the Weather tool. The tool specification
/// defines the input schema and describes the tool's functionality.
/// For more information, see https://json-schema.org/understanding-json-schema/reference.
///
/// The tool specification for the Weather tool.
public ToolSpecification GetToolSpec()
{
ToolSpecification toolSpecification = new ToolSpecification();
toolSpecification.Name = "Weather_Tool";
toolSpecification.Description = "Get the current weather for a given location, based on its WGS84 coordinates.";
Document toolSpecDocument = Document.FromObject(
new
{
type = "object",
properties = new
{
latitude = new
{
type = "string",
description = "Geographical WGS84 latitude of the location."
},
longitude = new
{
type = "string",
description = "Geographical WGS84 longitude of the location."
}
},
required = new[] { "latitude", "longitude" }
});
toolSpecification.InputSchema = new ToolInputSchema() { Json = toolSpecDocument };
return toolSpecification;
}
///
/// Fetches weather data for the given latitude and longitude using the Open-Meteo API.
/// Returns the weather data or an error message if the request fails.
///
/// The latitude of the location.
/// The longitude of the location.
/// The weather data or an error message.
public async Task FetchWeatherDataAsync(string latitude, string longitude)
{
string endpoint = "https://api.open-meteo.com/v1/forecast";
try
{
var httpClient = _httpClientFactory.CreateClient();
var response = await httpClient.GetAsync($"{endpoint}?latitude={latitude}&longitude={longitude}¤t_weather=True");
response.EnsureSuccessStatusCode();
var weatherData = await response.Content.ReadAsStringAsync();
Document weatherDocument = Document.FromObject(
new { weather_data = weatherData });
return weatherDocument;
}
catch (HttpRequestException e)
{
_logger.LogError(e, "Error fetching weather data: {Message}", e.Message);
throw;
}
catch (Exception e)
{
_logger.LogError(e, "Unexpected error fetching weather data: {Message}", e.Message);
throw;
}
}
}
```
The Converse API action with a tool configuration.
```
///
/// Wrapper class for interacting with the Amazon Bedrock Converse API.
///
public class BedrockActionsWrapper
{
private readonly IAmazonBedrockRuntime _bedrockClient;
private readonly ILogger _logger;
///
/// Initializes a new instance of the class.
///
/// The Bedrock Converse API client.
/// The logger instance.
public BedrockActionsWrapper(IAmazonBedrockRuntime bedrockClient, ILogger logger)
{
_bedrockClient = bedrockClient;
_logger = logger;
}
///
/// Sends a Converse request to the Amazon Bedrock Converse API.
///
/// The Bedrock Model Id.
/// A system prompt instruction.
/// The array of messages in the conversation.
/// The specification for a tool.
/// The response of the model.
public async Task SendConverseRequestAsync(string modelId, string systemPrompt, List conversation, ToolSpecification toolSpec)
{
try
{
var request = new ConverseRequest()
{
ModelId = modelId,
System = new List()
{
new SystemContentBlock()
{
Text = systemPrompt
}
},
Messages = conversation,
ToolConfig = new ToolConfiguration()
{
Tools = new List()
{
new Tool()
{
ToolSpec = toolSpec
}
}
}
};
var response = await _bedrockClient.ConverseAsync(request);
return response;
}
catch (ModelNotReadyException ex)
{
_logger.LogError(ex, "Model not ready, please wait and try again.");
throw;
}
catch (AmazonBedrockRuntimeException ex)
{
_logger.LogError(ex, "Error occurred while sending Converse request.");
throw;
}
}
}
```
+ For API details, see [Converse](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/Converse) in *AWS SDK for .NET API Reference*.
------
#### [ Java ]
**SDK for Java 2.x**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
The primary execution of the scenario flow. This scenario orchestrates the conversation between the user, the Amazon Bedrock Converse API, and a weather tool.
```
/*
This demo illustrates a tool use scenario using Amazon Bedrock's Converse API and a weather tool.
The program interacts with a foundation model on Amazon Bedrock to provide weather information based on user
input. It uses the Open-Meteo API (https://open-meteo.com) to retrieve current weather data for a given location.
*/
public class BedrockScenario {
public static final String DASHES = new String(new char[80]).replace("\0", "-");
private static String modelId = "amazon.nova-lite-v1:0";
private static String defaultPrompt = "What is the weather like in Seattle?";
private static WeatherTool weatherTool = new WeatherTool();
// The maximum number of recursive calls allowed in the tool use function.
// This helps prevent infinite loops and potential performance issues.
private static int maxRecursions = 5;
static BedrockActions bedrockActions = new BedrockActions();
public static boolean interactive = true;
private static final String systemPrompt = """
You are a weather assistant that provides current weather data for user-specified locations using only
the Weather_Tool, which expects latitude and longitude. Infer the coordinates from the location yourself.
If the user provides coordinates, infer the approximate location and refer to it in your response.
To use the tool, you strictly apply the provided tool specification.
- Explain your step-by-step process, and give brief updates before each step.
- Only use the Weather_Tool for data. Never guess or make up information.
- Repeat the tool use for subsequent requests if necessary.
- If the tool errors, apologize, explain weather is unavailable, and suggest other options.
- Report temperatures in °C (°F) and wind in km/h (mph). Keep weather reports concise. Sparingly use
emojis where appropriate.
- Only respond to weather queries. Remind off-topic users of your purpose.
- Never claim to search online, access external data, or use tools besides Weather_Tool.
- Complete the entire process until you have all required data before sending the complete response.
""";
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("""
=================================================
Welcome to the Amazon Bedrock Tool Use demo!
=================================================
This assistant provides current weather information for user-specified locations.
You can ask for weather details by providing the location name or coordinates.
Example queries:
- What's the weather like in New York?
- Current weather for latitude 40.70, longitude -74.01
- Is it warmer in Rome or Barcelona today?
To exit the program, simply type 'x' and press Enter.
P.S.: You're not limited to single locations, or even to using English!
Have fun and experiment with the app!
""");
System.out.println(DASHES);
try {
runConversation(scanner);
} catch (Exception ex) {
System.out.println("There was a problem running the scenario: " + ex.getMessage());
}
waitForInputToContinue(scanner);
System.out.println(DASHES);
System.out.println("Amazon Bedrock Converse API with Tool Use Feature Scenario is complete.");
System.out.println(DASHES);
}
/**
* Starts the conversation with the user and handles the interaction with Bedrock.
*/
private static List runConversation(Scanner scanner) {
List conversation = new ArrayList<>();
// Get the first user input
String userInput = getUserInput("Your weather info request:", scanner);
System.out.println(userInput);
while (userInput != null) {
ContentBlock block = ContentBlock.builder()
.text(userInput)
.build();
List blockList = new ArrayList<>();
blockList.add(block);
Message message = Message.builder()
.role(ConversationRole.USER)
.content(blockList)
.build();
conversation.add(message);
// Send the conversation to Amazon Bedrock.
ConverseResponse bedrockResponse = sendConversationToBedrock(conversation);
// Recursively handle the model's response until the model has returned its final response or the recursion counter has reached 0.
processModelResponse(bedrockResponse, conversation, maxRecursions);
// Repeat the loop until the user decides to exit the application.
userInput = getUserInput("Your weather info request:", scanner);
}
printFooter();
return conversation;
}
/**
* Processes the response from the model and updates the conversation accordingly.
*
* @param modelResponse the response from the model
* @param conversation the ongoing conversation
* @param maxRecursion the maximum number of recursions allowed
*/
private static void processModelResponse(ConverseResponse modelResponse, List conversation, int maxRecursion) {
if (maxRecursion <= 0) {
// Stop the process, the number of recursive calls could indicate an infinite loop
System.out.println("\tWarning: Maximum number of recursions reached. Please try again.");
}
// Append the model's response to the ongoing conversation
conversation.add(modelResponse.output().message());
String modelResponseVal = modelResponse.stopReasonAsString();
if (modelResponseVal.compareTo("tool_use") == 0) {
// If the stop reason is "tool_use", forward everything to the tool use handler
handleToolUse(modelResponse.output(), conversation, maxRecursion - 1);
}
if (modelResponseVal.compareTo("end_turn") == 0) {
// If the stop reason is "end_turn", print the model's response text, and finish the process
PrintModelResponse(modelResponse.output().message().content().get(0).text());
if (!interactive) {
defaultPrompt = "x";
}
}
}
/**
* Handles the use of a tool by the model in a conversation.
*
* @param modelResponse the response from the model, which may include a tool use request
* @param conversation the current conversation, which will be updated with the tool use results
* @param maxRecursion the maximum number of recursive calls allowed to handle the model's response
*/
private static void handleToolUse(ConverseOutput modelResponse, List conversation, int maxRecursion) {
List toolResults = new ArrayList<>();
// The model's response can consist of multiple content blocks
for (ContentBlock contentBlock : modelResponse.message().content()) {
if (contentBlock.text() != null && !contentBlock.text().isEmpty()) {
// If the content block contains text, print it to the console
PrintModelResponse(contentBlock.text());
}
if (contentBlock.toolUse() != null) {
ToolResponse toolResponse = invokeTool(contentBlock.toolUse());
// Add the tool use ID and the tool's response to the list of results
List contentBlockList = new ArrayList<>();
ToolResultContentBlock block = ToolResultContentBlock.builder()
.json(toolResponse.getContent())
.build();
contentBlockList.add(block);
ToolResultBlock toolResultBlock = ToolResultBlock.builder()
.toolUseId(toolResponse.getToolUseId())
.content(contentBlockList)
.build();
ContentBlock contentBlock1 = ContentBlock.builder()
.toolResult(toolResultBlock)
.build();
toolResults.add(contentBlock1);
}
}
// Embed the tool results in a new user message
Message message = Message.builder()
.role(ConversationRole.USER)
.content(toolResults)
.build();
// Append the new message to the ongoing conversation
//conversation.add(message);
conversation.add(message);
// Send the conversation to Amazon Bedrock
var response = sendConversationToBedrock(conversation);
// Recursively handle the model's response until the model has returned its final response or the recursion counter has reached 0
processModelResponse(response, conversation, maxRecursion);
}
// Invokes the specified tool with the given payload and returns the tool's response.
// If the requested tool does not exist, an error message is returned.
private static ToolResponse invokeTool(ToolUseBlock payload) {
String toolName = payload.name();
if (Objects.equals(toolName, "Weather_Tool")) {
Map inputData = payload.input().asMap();
printToolUse(toolName, inputData);
// Invoke the weather tool with the input data provided
Document weatherResponse = weatherTool.fetchWeatherData(inputData.get("latitude").toString(), inputData.get("longitude").toString());
ToolResponse toolResponse = new ToolResponse();
toolResponse.setContent(weatherResponse);
toolResponse.setToolUseId(payload.toolUseId());
return toolResponse;
} else {
String errorMessage = "The requested tool with name " + toolName + " does not exist.";
System.out.println(errorMessage);
return null;
}
}
public static void printToolUse(String toolName, Map inputData) {
System.out.println("Invoking tool: " + toolName + " with input: " + inputData.get("latitude").toString() + ", " + inputData.get("longitude").toString() + "...");
}
private static void PrintModelResponse(String message) {
System.out.println("\tThe model's response:\n");
System.out.println(message);
System.out.println("");
}
private static ConverseResponse sendConversationToBedrock(List conversation) {
System.out.println("Calling Bedrock...");
try {
return bedrockActions.sendConverseRequestAsync(modelId, systemPrompt, conversation, weatherTool.getToolSpec());
} catch (ModelNotReadyException ex) {
System.err.println("Model is not ready. Please try again later: " + ex.getMessage());
throw ex;
} catch (BedrockRuntimeException ex) {
System.err.println("Bedrock service error: " + ex.getMessage());
throw ex;
} catch (RuntimeException ex) {
System.err.println("Unexpected error occurred: " + ex.getMessage());
throw ex;
}
}
private static ConverseResponse sendConversationToBedrockwithSpec(List conversation, ToolSpecification toolSpec) {
System.out.println("Calling Bedrock...");
// Send the conversation, system prompt, and tool configuration, and return the response
return bedrockActions.sendConverseRequestAsync(modelId, systemPrompt, conversation, toolSpec);
}
public static String getUserInput(String prompt, Scanner scanner) {
String userInput = defaultPrompt;
if (interactive) {
System.out.println("*".repeat(80));
System.out.println(prompt + " (x to exit): \n\t");
userInput = scanner.nextLine();
}
if (userInput == null || userInput.trim().isEmpty()) {
return getUserInput("\tPlease enter your weather info request, e.g., the name of a city", scanner);
}
if (userInput.equalsIgnoreCase("x")) {
return null;
}
return userInput;
}
private static void waitForInputToContinue(Scanner scanner) {
while (true) {
System.out.println("");
System.out.println("Enter 'c' followed by to continue:");
String input = scanner.nextLine();
if (input.trim().equalsIgnoreCase("c")) {
System.out.println("Continuing with the program...");
System.out.println("");
break;
} else {
// Handle invalid input.
System.out.println("Invalid input. Please try again.");
}
}
}
public static void printFooter() {
System.out.println("""
=================================================
Thank you for checking out the Amazon Bedrock Tool Use demo. We hope you
learned something new, or got some inspiration for your own apps today!
For more Bedrock examples in different programming languages, have a look at:
https://docs.aws.amazon.com/bedrock/latest/userguide/service_code_examples.html
=================================================
""");
}
}
```
The weather tool used by the demo. This file defines the tool specification and implements the logic to retrieve weather data using from the Open-Meteo API.
```
public class WeatherTool {
private static final Logger logger = LoggerFactory.getLogger(WeatherTool.class);
private static java.net.http.HttpClient httpClient = null;
/**
* Returns the JSON Schema specification for the Weather tool. The tool specification
* defines the input schema and describes the tool's functionality.
* For more information, see https://json-schema.org/understanding-json-schema/reference.
*
* @return The tool specification for the Weather tool.
*/
public ToolSpecification getToolSpec() {
Map latitudeMap = new HashMap<>();
latitudeMap.put("type", Document.fromString("string"));
latitudeMap.put("description", Document.fromString("Geographical WGS84 latitude of the location."));
// Create the nested "longitude" object
Map longitudeMap = new HashMap<>();
longitudeMap.put("type", Document.fromString("string"));
longitudeMap.put("description", Document.fromString("Geographical WGS84 longitude of the location."));
// Create the "properties" object
Map propertiesMap = new HashMap<>();
propertiesMap.put("latitude", Document.fromMap(latitudeMap));
propertiesMap.put("longitude", Document.fromMap(longitudeMap));
// Create the "required" array
List requiredList = new ArrayList<>();
requiredList.add(Document.fromString("latitude"));
requiredList.add(Document.fromString("longitude"));
// Create the root object
Map rootMap = new HashMap<>();
rootMap.put("type", Document.fromString("object"));
rootMap.put("properties", Document.fromMap(propertiesMap));
rootMap.put("required", Document.fromList(requiredList));
// Now create the Document representing the JSON schema
Document document = Document.fromMap(rootMap);
ToolSpecification specification = ToolSpecification.builder()
.name("Weather_Tool")
.description("Get the current weather for a given location, based on its WGS84 coordinates.")
.inputSchema(ToolInputSchema.builder()
.json(document)
.build())
.build();
return specification;
}
/**
* Fetches weather data for the given latitude and longitude.
*
* @param latitude the latitude coordinate
* @param longitude the longitude coordinate
* @return a {@link CompletableFuture} containing the weather data as a JSON string
*/
public Document fetchWeatherData(String latitude, String longitude) {
HttpClient httpClient = HttpClient.newHttpClient();
// Ensure no extra double quotes
latitude = latitude.replace("\"", "");
longitude = longitude.replace("\"", "");
String endpoint = "https://api.open-meteo.com/v1/forecast";
String url = String.format("%s?latitude=%s&longitude=%s¤t_weather=True", endpoint, latitude, longitude);
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(url))
.build();
try {
HttpResponse response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());
if (response.statusCode() == 200) {
String weatherJson = response.body();
System.out.println(weatherJson);
ObjectMapper objectMapper = new ObjectMapper();
Map rawMap = objectMapper.readValue(weatherJson, new TypeReference>() {});
Map documentMap = convertToDocumentMap(rawMap);
Document weatherDocument = Document.fromMap(documentMap);
System.out.println(weatherDocument);
return weatherDocument;
} else {
throw new RuntimeException("Error fetching weather data: " + response.statusCode());
}
} catch (Exception e) {
System.out.println("Error fetching weather data: " + e.getMessage());
throw new RuntimeException("Error fetching weather data", e);
}
}
private static Map convertToDocumentMap(Map inputMap) {
Map result = new HashMap<>();
for (Map.Entry entry : inputMap.entrySet()) {
result.put(entry.getKey(), convertToDocument(entry.getValue()));
}
return result;
}
// Convert different types of Objects to Document
private static Document convertToDocument(Object value) {
if (value instanceof Map) {
return Document.fromMap(convertToDocumentMap((Map) value));
} else if (value instanceof Integer) {
return Document.fromNumber(SdkNumber.fromInteger((Integer) value));
} else if (value instanceof Double) { //
return Document.fromNumber(SdkNumber.fromDouble((Double) value));
} else if (value instanceof Boolean) {
return Document.fromBoolean((Boolean) value);
} else if (value instanceof String) {
return Document.fromString((String) value);
}
return Document.fromNull(); // Handle null values safely
}
}
```
The Converse API action with a tool configuration.
```
/**
* Sends an asynchronous converse request to the AI model.
*
* @param modelId the unique identifier of the AI model to be used for the converse request
* @param systemPrompt the system prompt to be included in the converse request
* @param conversation a list of messages representing the conversation history
* @param toolSpec the specification of the tool to be used in the converse request
* @return the converse response received from the AI model
*/
public ConverseResponse sendConverseRequestAsync(String modelId, String systemPrompt, List conversation, ToolSpecification toolSpec) {
List toolList = new ArrayList<>();
Tool tool = Tool.builder()
.toolSpec(toolSpec)
.build();
toolList.add(tool);
ToolConfiguration configuration = ToolConfiguration.builder()
.tools(toolList)
.build();
SystemContentBlock block = SystemContentBlock.builder()
.text(systemPrompt)
.build();
ConverseRequest request = ConverseRequest.builder()
.modelId(modelId)
.system(block)
.messages(conversation)
.toolConfig(configuration)
.build();
try {
ConverseResponse response = getClient().converse(request).join();
return response;
} catch (ModelNotReadyException ex) {
throw new RuntimeException("Model is not ready: " + ex.getMessage(), ex);
} catch (BedrockRuntimeException ex) {
throw new RuntimeException("Failed to converse with Bedrock model: " + ex.getMessage(), ex);
}
}
```
+ For API details, see [Converse](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/Converse) in *AWS SDK for Java 2.x API Reference*.
------
#### [ JavaScript ]
**SDK for JavaScript (v3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime/scenarios/converse_tool_scenario#code-examples).
The primary execution of the scenario flow. This scenario orchestrates the conversation between the user, the Amazon Bedrock Converse API, and a weather tool.
```
/* Before running this JavaScript code example, set up your development environment, including your credentials.
This demo illustrates a tool use scenario using Amazon Bedrock's Converse API and a weather tool.
The script interacts with a foundation model on Amazon Bedrock to provide weather information based on user
input. It uses the Open-Meteo API (https://open-meteo.com) to retrieve current weather data for a given location.*/
import {
Scenario,
ScenarioAction,
ScenarioInput,
ScenarioOutput,
} from "@aws-doc-sdk-examples/lib/scenario/index.js";
import {
BedrockRuntimeClient,
ConverseCommand,
} from "@aws-sdk/client-bedrock-runtime";
import { parseArgs } from "node:util";
import { fileURLToPath } from "node:url";
import data from "./questions.json" with { type: "json" };
import toolConfig from "./tool_config.json" with { type: "json" };
const __filename = fileURLToPath(import.meta.url);
const systemPrompt = [
{
text:
"You are a weather assistant that provides current weather data for user-specified locations using only\n" +
"the Weather_Tool, which expects latitude and longitude. Infer the coordinates from the location yourself.\n" +
"If the user provides coordinates, infer the approximate location and refer to it in your response.\n" +
"To use the tool, you strictly apply the provided tool specification.\n" +
"If the user specifies a state, country, or region, infer the locations of cities within that state.\n" +
"\n" +
"- Explain your step-by-step process, and give brief updates before each step.\n" +
"- Only use the Weather_Tool for data. Never guess or make up information. \n" +
"- Repeat the tool use for subsequent requests if necessary.\n" +
"- If the tool errors, apologize, explain weather is unavailable, and suggest other options.\n" +
"- Report temperatures in °C (°F) and wind in km/h (mph). Keep weather reports concise. Sparingly use\n" +
" emojis where appropriate.\n" +
"- Only respond to weather queries. Remind off-topic users of your purpose. \n" +
"- Never claim to search online, access external data, or use tools besides Weather_Tool.\n" +
"- Complete the entire process until you have all required data before sending the complete response.",
},
];
const tools_config = toolConfig;
/// Starts the conversation with the user and handles the interaction with Bedrock.
async function askQuestion(userMessage) {
// The maximum number of recursive calls allowed in the tool use function.
// This helps prevent infinite loops and potential performance issues.
const max_recursions = 5;
const messages = [
{
role: "user",
content: [{ text: userMessage }],
},
];
try {
const response = await SendConversationtoBedrock(messages);
await ProcessModelResponseAsync(response, messages, max_recursions);
} catch (error) {
console.log("error ", error);
}
}
// Sends the conversation, the system prompt, and the tool spec to Amazon Bedrock, and returns the response.
// param "messages" - The conversation history including the next message to send.
// return - The response from Amazon Bedrock.
async function SendConversationtoBedrock(messages) {
const bedRockRuntimeClient = new BedrockRuntimeClient({
region: "us-east-1",
});
try {
const modelId = "amazon.nova-lite-v1:0";
const response = await bedRockRuntimeClient.send(
new ConverseCommand({
modelId: modelId,
messages: messages,
system: systemPrompt,
toolConfig: tools_config,
}),
);
return response;
} catch (caught) {
if (caught.name === "ModelNotReady") {
console.log(
"`${caught.name}` - Model not ready, please wait and try again.",
);
throw caught;
}
if (caught.name === "BedrockRuntimeException") {
console.log(
'`${caught.name}` - "Error occurred while sending Converse request.',
);
throw caught;
}
}
}
// Processes the response received via Amazon Bedrock and performs the necessary actions based on the stop reason.
// param "response" - The model's response returned via Amazon Bedrock.
// param "messages" - The conversation history.
// param "max_recursions" - The maximum number of recursive calls allowed.
async function ProcessModelResponseAsync(response, messages, max_recursions) {
if (max_recursions <= 0) {
await HandleToolUseAsync(response, messages);
}
if (response.stopReason === "tool_use") {
await HandleToolUseAsync(response, messages, max_recursions - 1);
}
if (response.stopReason === "end_turn") {
const messageToPrint = response.output.message.content[0].text;
console.log(messageToPrint.replace(/<[^>]+>/g, ""));
}
}
// Handles the tool use case by invoking the specified tool and sending the tool's response back to Bedrock.
// The tool response is appended to the conversation, and the conversation is sent back to Amazon Bedrock for further processing.
// param "response" - the model's response containing the tool use request.
// param "messages" - the conversation history.
// param "max_recursions" - The maximum number of recursive calls allowed.
async function HandleToolUseAsync(response, messages, max_recursions) {
const toolResultFinal = [];
try {
const output_message = response.output.message;
messages.push(output_message);
const toolRequests = output_message.content;
const toolMessage = toolRequests[0].text;
console.log(toolMessage.replace(/<[^>]+>/g, ""));
for (const toolRequest of toolRequests) {
if (Object.hasOwn(toolRequest, "toolUse")) {
const toolUse = toolRequest.toolUse;
const latitude = toolUse.input.latitude;
const longitude = toolUse.input.longitude;
const toolUseID = toolUse.toolUseId;
console.log(
`Requesting tool ${toolUse.name}, Tool use id ${toolUseID}`,
);
if (toolUse.name === "Weather_Tool") {
try {
const current_weather = await callWeatherTool(
longitude,
latitude,
).then((current_weather) => current_weather);
const currentWeather = current_weather;
const toolResult = {
toolResult: {
toolUseId: toolUseID,
content: [{ json: currentWeather }],
},
};
toolResultFinal.push(toolResult);
} catch (err) {
console.log("An error occurred. ", err);
}
}
}
}
const toolResultMessage = {
role: "user",
content: toolResultFinal,
};
messages.push(toolResultMessage);
// Send the conversation to Amazon Bedrock
await ProcessModelResponseAsync(
await SendConversationtoBedrock(messages),
messages,
);
} catch (error) {
console.log("An error occurred. ", error);
}
}
// Call the Weathertool.
// param = longitude of location
// param = latitude of location
async function callWeatherTool(longitude, latitude) {
// Open-Meteo API endpoint
const apiUrl = `https://api.open-meteo.com/v1/forecast?latitude=${latitude}&longitude=${longitude}¤t_weather=true`;
// Fetch the weather data.
return fetch(apiUrl)
.then((response) => {
return response.json().then((current_weather) => {
return current_weather;
});
})
.catch((error) => {
console.error("Error fetching weather data:", error);
});
}
/**
* Used repeatedly to have the user press enter.
* @type {ScenarioInput}
*/
const pressEnter = new ScenarioInput("continue", "Press Enter to continue", {
type: "input",
default: "",
});
const greet = new ScenarioOutput(
"greet",
"Welcome to the Amazon Bedrock Tool Use demo! \n" +
"This assistant provides current weather information for user-specified locations. " +
"You can ask for weather details by providing the location name or coordinates." +
"Weather information will be provided using a custom Tool and open-meteo API." +
"For the purposes of this example, we'll use in order the questions in ./questions.json :\n" +
"What's the weather like in Seattle? " +
"What's the best kind of cat? " +
"Where is the warmest city in Washington State right now? " +
"What's the warmest city in California right now?\n" +
"To exit the program, simply type 'x' and press Enter.\n" +
"Have fun and experiment with the app by editing the questions in ./questions.json! " +
"P.S.: You're not limited to single locations, or even to using English! ",
{ header: true },
);
const displayAskQuestion1 = new ScenarioOutput(
"displayAskQuestion1",
"Press enter to ask question number 1 (default is 'What's the weather like in Seattle?')",
);
const askQuestion1 = new ScenarioAction(
"askQuestion1",
async (/** @type {State} */ state) => {
const userMessage1 = data.questions["question-1"];
await askQuestion(userMessage1);
},
);
const displayAskQuestion2 = new ScenarioOutput(
"displayAskQuestion2",
"Press enter to ask question number 2 (default is 'What's the best kind of cat?')",
);
const askQuestion2 = new ScenarioAction(
"askQuestion2",
async (/** @type {State} */ state) => {
const userMessage2 = data.questions["question-2"];
await askQuestion(userMessage2);
},
);
const displayAskQuestion3 = new ScenarioOutput(
"displayAskQuestion3",
"Press enter to ask question number 3 (default is 'Where is the warmest city in Washington State right now?')",
);
const askQuestion3 = new ScenarioAction(
"askQuestion3",
async (/** @type {State} */ state) => {
const userMessage3 = data.questions["question-3"];
await askQuestion(userMessage3);
},
);
const displayAskQuestion4 = new ScenarioOutput(
"displayAskQuestion4",
"Press enter to ask question number 4 (default is 'What's the warmest city in California right now?')",
);
const askQuestion4 = new ScenarioAction(
"askQuestion4",
async (/** @type {State} */ state) => {
const userMessage4 = data.questions["question-4"];
await askQuestion(userMessage4);
},
);
const goodbye = new ScenarioOutput(
"goodbye",
"Thank you for checking out the Amazon Bedrock Tool Use demo. We hope you\n" +
"learned something new, or got some inspiration for your own apps today!\n" +
"For more Bedrock examples in different programming languages, have a look at:\n" +
"https://docs.aws.amazon.com/bedrock/latest/userguide/service_code_examples.html",
);
const myScenario = new Scenario("Converse Tool Scenario", [
greet,
pressEnter,
displayAskQuestion1,
askQuestion1,
pressEnter,
displayAskQuestion2,
askQuestion2,
pressEnter,
displayAskQuestion3,
askQuestion3,
pressEnter,
displayAskQuestion4,
askQuestion4,
pressEnter,
goodbye,
]);
/** @type {{ stepHandlerOptions: StepHandlerOptions }} */
export const main = async (stepHandlerOptions) => {
await myScenario.run(stepHandlerOptions);
};
// Invoke main function if this file was run directly.
if (process.argv[1] === fileURLToPath(import.meta.url)) {
const { values } = parseArgs({
options: {
yes: {
type: "boolean",
short: "y",
},
},
});
main({ confirmAll: values.yes });
}
```
+ For API details, see [Converse](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseCommand) in *AWS SDK for JavaScript API Reference*.
------
For a complete list of AWS SDK developer guides and code examples, see [Using Amazon Bedrock with an AWS SDK](sdk-general-information-section.md). This topic also includes information about getting started and details about previous SDK versions.
# Amazon Nova Canvas for Amazon Bedrock Runtime
The following code examples show how to use Amazon Bedrock Runtime with AWS SDKs.
**Topics**
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_AmazonNovaImageGeneration_section.md)
# Invoke Amazon Nova Canvas on Amazon Bedrock to generate an image
The following code examples show how to invoke Amazon Nova Canvas on Amazon Bedrock to generate an image.
------
#### [ .NET ]
**SDK for .NET**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime#code-examples).
Create an image with Amazon Nova Canvas.
```
// Use the native inference API to create an image with Amazon Nova Canvas.
using System;
using System.IO;
using System.Text.Json;
using System.Text.Json.Nodes;
using Amazon;
using Amazon.BedrockRuntime;
using Amazon.BedrockRuntime.Model;
// Create a Bedrock Runtime client in the AWS Region you want to use.
var client = new AmazonBedrockRuntimeClient(RegionEndpoint.USEast1);
// Set the model ID.
var modelId = "amazon.nova-canvas-v1:0";
// Define the image generation prompt for the model.
var prompt = "A stylized picture of a cute old steampunk robot.";
// Create a random seed between 0 and 858,993,459
int seed = new Random().Next(0, 858993460);
//Format the request payload using the model's native structure.
var nativeRequest = JsonSerializer.Serialize(new
{
taskType = "TEXT_IMAGE",
textToImageParams = new
{
text = prompt
},
imageGenerationConfig = new
{
seed,
quality = "standard",
width = 512,
height = 512,
numberOfImages = 1
}
});
// Create a request with the model ID and the model's native request payload.
var request = new InvokeModelRequest()
{
ModelId = modelId,
Body = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(nativeRequest)),
ContentType = "application/json"
};
try
{
// Send the request to the Bedrock Runtime and wait for the response.
var response = await client.InvokeModelAsync(request);
// Decode the response body.
var modelResponse = await JsonNode.ParseAsync(response.Body);
// Extract the image data.
var base64Image = modelResponse["images"]?[0].ToString() ?? "";
// Save the image in a local folder
string savedPath = AmazonNovaCanvas.InvokeModel.SaveBase64Image(base64Image);
Console.WriteLine($"Image saved to: {savedPath}");
}
catch (AmazonBedrockRuntimeException e)
{
Console.WriteLine($"ERROR: Can't invoke '{modelId}'. Reason: {e.Message}");
throw;
}
```
+ For API details, see [InvokeModel](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/InvokeModel) in *AWS SDK for .NET API Reference*.
------
#### [ Java ]
**SDK for Java 2.x**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Create an image with Amazon Nova Canvas.
```
import org.json.JSONObject;
import org.json.JSONPointer;
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.core.SdkBytes;
import software.amazon.awssdk.core.exception.SdkClientException;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.bedrockruntime.BedrockRuntimeClient;
import software.amazon.awssdk.services.bedrockruntime.model.InvokeModelResponse;
import java.security.SecureRandom;
import java.util.Base64;
import static com.example.bedrockruntime.libs.ImageTools.displayImage;
/**
* This example demonstrates how to use Amazon Nova Canvas to generate images.
* It shows how to:
* - Set up the Amazon Bedrock runtime client
* - Configure the image generation parameters
* - Send a request to generate an image
* - Process the response and handle the generated image
*/
public class InvokeModel {
public static byte[] invokeModel() {
// Step 1: Create the Amazon Bedrock runtime client
// The runtime client handles the communication with AI models on Amazon Bedrock
BedrockRuntimeClient client = BedrockRuntimeClient.builder()
.credentialsProvider(DefaultCredentialsProvider.create())
.region(Region.US_EAST_1)
.build();
// Step 2: Specify which model to use
// For the latest available models, see:
// https://docs.aws.amazon.com/bedrock/latest/userguide/models-supported.html
String modelId = "amazon.nova-canvas-v1:0";
// Step 3: Configure the generation parameters and create the request
// First, set the main parameters:
// - prompt: Text description of the image to generate
// - seed: Random number for reproducible generation (0 to 858,993,459)
String prompt = "A stylized picture of a cute old steampunk robot";
int seed = new SecureRandom().nextInt(858_993_460);
// Then, create the request using a template with the following structure:
// - taskType: TEXT_IMAGE (specifies text-to-image generation)
// - textToImageParams: Contains the text prompt
// - imageGenerationConfig: Contains optional generation settings (seed, quality, etc.)
// For a list of available request parameters, see:
// https://docs.aws.amazon.com/nova/latest/userguide/image-gen-req-resp-structure.html
String request = """
{
"taskType": "TEXT_IMAGE",
"textToImageParams": {
"text": "{{prompt}}"
},
"imageGenerationConfig": {
"seed": {{seed}},
"quality": "standard"
}
}"""
.replace("{{prompt}}", prompt)
.replace("{{seed}}", String.valueOf(seed));
// Step 4: Send and process the request
// - Send the request to the model using InvokeModelResponse
// - Extract the Base64-encoded image from the JSON response
// - Convert the encoded image to a byte array and return it
try {
InvokeModelResponse response = client.invokeModel(builder -> builder
.modelId(modelId)
.body(SdkBytes.fromUtf8String(request))
);
JSONObject responseBody = new JSONObject(response.body().asUtf8String());
// Convert the Base64 string to byte array for better handling
return Base64.getDecoder().decode(
new JSONPointer("/images/0").queryFrom(responseBody).toString()
);
} catch (SdkClientException e) {
System.err.printf("ERROR: Can't invoke '%s'. Reason: %s%n", modelId, e.getMessage());
throw new RuntimeException(e);
}
}
public static void main(String[] args) {
System.out.println("Generating image. This may take a few seconds...");
byte[] imageData = invokeModel();
displayImage(imageData);
}
}
```
+ For API details, see [InvokeModel](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModel) in *AWS SDK for Java 2.x API Reference*.
------
#### [ JavaScript ]
**SDK for JavaScript (v3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Create an image with Amazon Nova Canvas.
```
import {
BedrockRuntimeClient,
InvokeModelCommand,
} from "@aws-sdk/client-bedrock-runtime";
import { saveImage } from "../../utils/image-creation.js";
import { fileURLToPath } from "node:url";
/**
* This example demonstrates how to use Amazon Nova Canvas to generate images.
* It shows how to:
* - Set up the Amazon Bedrock runtime client
* - Configure the image generation parameters
* - Send a request to generate an image
* - Process the response and handle the generated image
*
* @returns {Promise} Base64-encoded image data
*/
export const invokeModel = async () => {
// Step 1: Create the Amazon Bedrock runtime client
// Credentials will be automatically loaded from the environment
const client = new BedrockRuntimeClient({ region: "us-east-1" });
// Step 2: Specify which model to use
// For the latest available models, see:
// https://docs.aws.amazon.com/bedrock/latest/userguide/models-supported.html
const modelId = "amazon.nova-canvas-v1:0";
// Step 3: Configure the request payload
// First, set the main parameters:
// - prompt: Text description of the image to generate
// - seed: Random number for reproducible generation (0 to 858,993,459)
const prompt = "A stylized picture of a cute old steampunk robot";
const seed = Math.floor(Math.random() * 858993460);
// Then, create the payload using the following structure:
// - taskType: TEXT_IMAGE (specifies text-to-image generation)
// - textToImageParams: Contains the text prompt
// - imageGenerationConfig: Contains optional generation settings (seed, quality, etc.)
// For a list of available request parameters, see:
// https://docs.aws.amazon.com/nova/latest/userguide/image-gen-req-resp-structure.html
const payload = {
taskType: "TEXT_IMAGE",
textToImageParams: {
text: prompt,
},
imageGenerationConfig: {
seed,
quality: "standard",
},
};
// Step 4: Send and process the request
// - Embed the payload in a request object
// - Send the request to the model
// - Extract and return the generated image data from the response
try {
const request = {
modelId,
body: JSON.stringify(payload),
};
const response = await client.send(new InvokeModelCommand(request));
const decodedResponseBody = new TextDecoder().decode(response.body);
// The response includes an array of base64-encoded PNG images
/** @type {{images: string[]}} */
const responseBody = JSON.parse(decodedResponseBody);
return responseBody.images[0]; // Base64-encoded image data
} catch (error) {
console.error(`ERROR: Can't invoke '${modelId}'. Reason: ${error.message}`);
throw error;
}
};
// If run directly, execute the example and save the generated image
if (process.argv[1] === fileURLToPath(import.meta.url)) {
console.log("Generating image. This may take a few seconds...");
invokeModel()
.then(async (imageData) => {
const imagePath = await saveImage(imageData, "nova-canvas");
// Example path: javascriptv3/example_code/bedrock-runtime/output/nova-canvas/image-01.png
console.log(`Image saved to: ${imagePath}`);
})
.catch((error) => {
console.error("Execution failed:", error);
process.exitCode = 1;
});
}
```
+ For API details, see [InvokeModel](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/InvokeModelCommand) in *AWS SDK for JavaScript API Reference*.
------
#### [ Python ]
**SDK for Python (Boto3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Create an image with the Amazon Nova Canvas.
```
# Use the native inference API to create an image with Amazon Nova Canvas
import base64
import json
import os
import random
import boto3
# Create a Bedrock Runtime client in the AWS Region of your choice.
client = boto3.client("bedrock-runtime", region_name="us-east-1")
# Set the model ID.
model_id = "amazon.nova-canvas-v1:0"
# Define the image generation prompt for the model.
prompt = "A stylized picture of a cute old steampunk robot."
# Generate a random seed between 0 and 858,993,459
seed = random.randint(0, 858993460)
# Format the request payload using the model's native structure.
native_request = {
"taskType": "TEXT_IMAGE",
"textToImageParams": {"text": prompt},
"imageGenerationConfig": {
"seed": seed,
"quality": "standard",
"height": 512,
"width": 512,
"numberOfImages": 1,
},
}
# Convert the native request to JSON.
request = json.dumps(native_request)
# Invoke the model with the request.
response = client.invoke_model(modelId=model_id, body=request)
# Decode the response body.
model_response = json.loads(response["body"].read())
# Extract the image data.
base64_image_data = model_response["images"][0]
# Save the generated image to a local folder.
i, output_dir = 1, "output"
if not os.path.exists(output_dir):
os.makedirs(output_dir)
while os.path.exists(os.path.join(output_dir, f"nova_canvas_{i}.png")):
i += 1
image_data = base64.b64decode(base64_image_data)
image_path = os.path.join(output_dir, f"nova_canvas_{i}.png")
with open(image_path, "wb") as file:
file.write(image_data)
print(f"The generated image has been saved to {image_path}")
```
+ For API details, see [InvokeModel](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModel) in *AWS SDK for Python (Boto3) API Reference*.
------
#### [ Swift ]
**SDK for Swift**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/bedrock-runtime#code-examples).
Create an image with Amazon Nova Canvas.
```
// Use the native inference API to create an image with Amazon Nova Canvas
import AWSBedrockRuntime
import AWSSDKIdentity
import Foundation
struct NovaImageOutput: Decodable {
let images: [Data]
}
func generateImage(_ textPrompt: String) async throws {
// Create a Bedrock Runtime client in the AWS Region you want to use.
let config =
try await BedrockRuntimeClient.BedrockRuntimeClientConfiguration(
region: "us-east-1"
)
config.awsCredentialIdentityResolver = try SSOAWSCredentialIdentityResolver()
let client = BedrockRuntimeClient(config: config)
// Set the model ID.
let modelId = "amazon.nova-canvas-v1:0"
// Format the request payload using the model's native structure.
let input = InvokeModelInput(
accept: "application/json",
body: """
{
"textToImageParams": {
"text": "\(textPrompt)"
},
"taskType": "TEXT_IMAGE",
"imageGenerationConfig": {
"seed": 42,
"quality": "standard",
"width": 512,
"height": 512,
"numberOfImages": 1
}
}
""".data(using: .utf8),
modelId: modelId
)
// Invoke the model with the request.
let response = try await client.invokeModel(input: input)
// Decode the response body.
let output = try JSONDecoder().decode(NovaImageOutput.self, from: response.body!)
// Extract the image data.
guard let data = output.images.first else {
print("No image data found")
return
}
// Save the generated image to a local folder.
let fileURL = URL.documentsDirectory.appending(path: "nova_canvas.png")
print(fileURL)
try data.write(to: fileURL)
print("Image is saved at \(fileURL)")
}
```
+ For API details, see [InvokeModel](https://sdk.amazonaws.com/swift/api/awsbedrockruntime/latest/documentation/awsbedrockruntime/bedrockruntimeclient/invokemodel(input:)) in *AWS SDK for Swift API reference*.
------
For a complete list of AWS SDK developer guides and code examples, see [Using Amazon Bedrock with an AWS SDK](sdk-general-information-section.md). This topic also includes information about getting started and details about previous SDK versions.
# Amazon Nova Reel for Amazon Bedrock Runtime
The following code examples show how to use Amazon Bedrock Runtime with AWS SDKs.
**Topics**
+ [Text-to-video](bedrock-runtime_example_bedrock-runtime_Scenario_AmazonNova_TextToVideo_section.md)
# Use Amazon Nova Reel to generate a video from a text prompt
The following code examples show how to use Amazon Nova Reel to generate a video from a text prompt.
------
#### [ Python ]
**SDK for Python (Boto3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Use Amazon Nova Reel to generate a video from a text prompt.
```
"""
This example demonstrates how to use Amazon Nova Reel to generate a video from a text prompt.
It shows how to:
- Set up the Amazon Bedrock runtime client
- Configure a text-to-video request
- Submit an asynchronous job for video generation
- Poll for job completion status
- Access the generated video from S3
"""
import random
import time
import boto3
# Replace with your own S3 bucket to store the generated video
# Format: s3://your-bucket-name
OUTPUT_S3_URI = "s3://REPLACE-WITH-YOUR-S3-BUCKET-NAME"
def start_text_to_video_generation_job(bedrock_runtime, prompt, output_s3_uri):
"""
Starts an asynchronous text-to-video generation job using Amazon Nova Reel.
:param bedrock_runtime: The Bedrock runtime client
:param prompt: The text description of the video to generate
:param output_s3_uri: S3 URI where the generated video will be stored
:return: The invocation ARN of the async job
"""
# Specify the model ID for text-to-video generation
model_id = "amazon.nova-reel-v1:0"
# Generate a random seed between 0 and 2,147,483,646
# This helps ensure unique video generation results
seed = random.randint(0, 2147483646)
# Configure the video generation request with additional parameters
model_input = {
"taskType": "TEXT_VIDEO",
"textToVideoParams": {"text": prompt},
"videoGenerationConfig": {
"fps": 24,
"durationSeconds": 6,
"dimension": "1280x720",
"seed": seed,
},
}
# Specify the S3 location for the output video
output_config = {"s3OutputDataConfig": {"s3Uri": output_s3_uri}}
# Invoke the model asynchronously
response = bedrock_runtime.start_async_invoke(
modelId=model_id, modelInput=model_input, outputDataConfig=output_config
)
invocation_arn = response["invocationArn"]
return invocation_arn
def query_job_status(bedrock_runtime, invocation_arn):
"""
Queries the status of an asynchronous video generation job.
:param bedrock_runtime: The Bedrock runtime client
:param invocation_arn: The ARN of the async invocation to check
:return: The runtime response containing the job status and details
"""
return bedrock_runtime.get_async_invoke(invocationArn=invocation_arn)
def main():
"""
Main function that demonstrates the complete workflow for generating
a video from a text prompt using Amazon Nova Reel.
"""
# Create a Bedrock Runtime client
# Note: Credentials will be loaded from the environment or AWS CLI config
bedrock_runtime = boto3.client("bedrock-runtime", region_name="us-east-1")
# Configure the text prompt and output location
prompt = "Closeup of a cute old steampunk robot. Camera zoom in."
# Verify the S3 URI has been set to a valid bucket
if "REPLACE-WITH-YOUR-S3-BUCKET-NAME" in OUTPUT_S3_URI:
print("ERROR: You must replace the OUTPUT_S3_URI with your own S3 bucket URI")
return
print("Submitting video generation job...")
invocation_arn = start_text_to_video_generation_job(
bedrock_runtime, prompt, OUTPUT_S3_URI
)
print(f"Job started with invocation ARN: {invocation_arn}")
# Poll for job completion
while True:
print("\nPolling job status...")
job = query_job_status(bedrock_runtime, invocation_arn)
status = job["status"]
if status == "Completed":
bucket_uri = job["outputDataConfig"]["s3OutputDataConfig"]["s3Uri"]
print(f"\nSuccess! The video is available at: {bucket_uri}/output.mp4")
break
elif status == "Failed":
print(
f"\nVideo generation failed: {job.get('failureMessage', 'Unknown error')}"
)
break
else:
print("In progress. Waiting 15 seconds...")
time.sleep(15)
if __name__ == "__main__":
main()
```
+ For API details, see the following topics in *AWS SDK for Python (Boto3) API Reference*.
+ [GetAsyncInvoke](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/GetAsyncInvoke)
+ [StartAsyncInvoke](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/StartAsyncInvoke)
------
#### [ Swift ]
**SDK for Swift**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/bedrock-runtime#code-examples).
Use Amazon Nova Reel to generate a video from a text prompt.
```
// This example demonstrates how to use Amazon Nova Reel to generate a video from a text prompt.
// It shows how to:
// - Set up the Amazon Bedrock runtime client
// - Configure a text-to-video request
// - Submit an asynchronous job for video generation
// - Poll for job completion status
// - Access the generated video from S3
import AWSBedrockRuntime
import Foundation
import Smithy
func startTextToVideoGenerationJob(
bedrockRuntimeClient: BedrockRuntimeClient, prompt: String, outputS3Uri: String
) async throws -> String? {
// Specify the model ID for text-to-video generation
let modelId = "amazon.nova-reel-v1:0"
// Configure the video generation request with additional parameters
let modelInputSource: [String: Any] = [
"taskType": "TEXT_VIDEO",
"textToVideoParams": [
"text": "\(prompt)"
],
"videoGenerationConfig": [
"durationSeconds": 6,
"fps": 24,
"dimension": "1280x720",
],
]
let modelInput = try Document.make(from: modelInputSource)
let input = StartAsyncInvokeInput(
modelId: modelId,
modelInput: modelInput,
outputDataConfig: .s3outputdataconfig(
BedrockRuntimeClientTypes.AsyncInvokeS3OutputDataConfig(
s3Uri: outputS3Uri
)
)
)
// Invoke the model asynchronously
let output = try await bedrockRuntimeClient.startAsyncInvoke(input: input)
return output.invocationArn
}
func queryJobStatus(
bedrockRuntimeClient: BedrockRuntimeClient,
invocationArn: String?
) async throws -> GetAsyncInvokeOutput {
try await bedrockRuntimeClient.getAsyncInvoke(
input: GetAsyncInvokeInput(invocationArn: invocationArn))
}
func main() async throws {
// Create a Bedrock Runtime client
let config =
try await BedrockRuntimeClient.BedrockRuntimeClientConfiguration(
region: "us-east-1"
)
let client = BedrockRuntimeClient(config: config)
// Specify the S3 location for the output video
let bucket = "s3://REPLACE-WITH-YOUR-S3-BUCKET-NAM"
print("Submitting video generation job...")
let invocationArn = try await startTextToVideoGenerationJob(
bedrockRuntimeClient: client,
prompt: "A pomegranate juice in a railway station",
outputS3Uri: bucket
)
print("Job started with invocation ARN: \(String(describing:invocationArn))")
// Poll for job completion
var status: BedrockRuntimeClientTypes.AsyncInvokeStatus?
var isReady = false
var hasFailed = false
while !isReady && !hasFailed {
print("\nPolling job status...")
status = try await queryJobStatus(
bedrockRuntimeClient: client, invocationArn: invocationArn
).status
switch status {
case .completed:
isReady = true
print("Video is ready\nCheck S3 bucket: \(bucket)")
case .failed:
hasFailed = true
print("Something went wrong")
case .inProgress:
print("Job is in progress...")
try await Task.sleep(nanoseconds: 15 * 1_000_000_000) // 15 seconds
default:
isReady = true
}
}
}
do {
try await main()
} catch {
print("An error occurred: \(error)")
}
```
+ For API details, see the following topics in *AWS SDK for Swift API reference*.
+ [GetAsyncInvoke](https://sdk.amazonaws.com/swift/api/awsbedrockruntime/latest/documentation/awsbedrockruntime/bedrockruntimeclient/getasyncinvoke(input:))
+ [StartAsyncInvoke](https://sdk.amazonaws.com/swift/api/awsbedrockruntime/latest/documentation/awsbedrockruntime/bedrockruntimeclient/startasyncinvoke(input:))
------
For a complete list of AWS SDK developer guides and code examples, see [Using Amazon Bedrock with an AWS SDK](sdk-general-information-section.md). This topic also includes information about getting started and details about previous SDK versions.
# Amazon Titan Image Generator for Amazon Bedrock Runtime
The following code examples show how to use Amazon Bedrock Runtime with AWS SDKs.
**Topics**
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_TitanImageGenerator_section.md)
# Invoke Amazon Titan Image on Amazon Bedrock to generate an image
The following code examples show how to invoke Amazon Titan Image on Amazon Bedrock to generate an image.
------
#### [ Go ]
**SDK for Go V2**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/bedrock-runtime#code-examples).
Create an image with the Amazon Titan Image Generator.
```
import (
"context"
"encoding/json"
"log"
"strings"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/bedrockruntime"
)
// InvokeModelWrapper encapsulates Amazon Bedrock actions used in the examples.
// It contains a Bedrock Runtime client that is used to invoke foundation models.
type InvokeModelWrapper struct {
BedrockRuntimeClient *bedrockruntime.Client
}
type TitanImageRequest struct {
TaskType string `json:"taskType"`
TextToImageParams TextToImageParams `json:"textToImageParams"`
ImageGenerationConfig ImageGenerationConfig `json:"imageGenerationConfig"`
}
type TextToImageParams struct {
Text string `json:"text"`
}
type ImageGenerationConfig struct {
NumberOfImages int `json:"numberOfImages"`
Quality string `json:"quality"`
CfgScale float64 `json:"cfgScale"`
Height int `json:"height"`
Width int `json:"width"`
Seed int64 `json:"seed"`
}
type TitanImageResponse struct {
Images []string `json:"images"`
}
// Invokes the Titan Image model to create an image using the input provided
// in the request body.
func (wrapper InvokeModelWrapper) InvokeTitanImage(ctx context.Context, prompt string, seed int64) (string, error) {
modelId := "amazon.titan-image-generator-v2:0"
body, err := json.Marshal(TitanImageRequest{
TaskType: "TEXT_IMAGE",
TextToImageParams: TextToImageParams{
Text: prompt,
},
ImageGenerationConfig: ImageGenerationConfig{
NumberOfImages: 1,
Quality: "standard",
CfgScale: 8.0,
Height: 512,
Width: 512,
Seed: seed,
},
})
if err != nil {
log.Fatal("failed to marshal", err)
}
output, err := wrapper.BedrockRuntimeClient.InvokeModel(ctx, &bedrockruntime.InvokeModelInput{
ModelId: aws.String(modelId),
ContentType: aws.String("application/json"),
Body: body,
})
if err != nil {
ProcessError(err, modelId)
}
var response TitanImageResponse
if err := json.Unmarshal(output.Body, &response); err != nil {
log.Fatal("failed to unmarshal", err)
}
base64ImageData := response.Images[0]
return base64ImageData, nil
}
```
+ For API details, see [InvokeModel](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/bedrockruntime#Client.InvokeModel) in *AWS SDK for Go API Reference*.
------
#### [ Java ]
**SDK for Java 2.x**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Create an image with the Amazon Titan Image Generator.
```
// Create an image with the Amazon Titan Image Generator.
import org.json.JSONObject;
import org.json.JSONPointer;
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.core.SdkBytes;
import software.amazon.awssdk.core.exception.SdkClientException;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.bedrockruntime.BedrockRuntimeClient;
import java.math.BigInteger;
import java.security.SecureRandom;
import static com.example.bedrockruntime.libs.ImageTools.displayImage;
public class InvokeModel {
public static String invokeModel() {
// Create a Bedrock Runtime client in the AWS Region you want to use.
// Replace the DefaultCredentialsProvider with your preferred credentials provider.
var client = BedrockRuntimeClient.builder()
.credentialsProvider(DefaultCredentialsProvider.create())
.region(Region.US_EAST_1)
.build();
// Set the model ID, e.g., Titan Image G2.
var modelId = "amazon.titan-image-generator-v2:0";
// The InvokeModel API uses the model's native payload.
// Learn more about the available inference parameters and response fields at:
// https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-titan-image.html
var nativeRequestTemplate = """
{
"taskType": "TEXT_IMAGE",
"textToImageParams": { "text": "{{prompt}}" },
"imageGenerationConfig": { "seed": {{seed}} }
}""";
// Define the prompt for the image generation.
var prompt = "A stylized picture of a cute old steampunk robot";
// Get a random 31-bit seed for the image generation (max. 2,147,483,647).
var seed = new BigInteger(31, new SecureRandom());
// Embed the prompt and seed in the model's native request payload.
var nativeRequest = nativeRequestTemplate
.replace("{{prompt}}", prompt)
.replace("{{seed}}", seed.toString());
try {
// Encode and send the request to the Bedrock Runtime.
var response = client.invokeModel(request -> request
.body(SdkBytes.fromUtf8String(nativeRequest))
.modelId(modelId)
);
// Decode the response body.
var responseBody = new JSONObject(response.body().asUtf8String());
// Retrieve the generated image data from the model's response.
var base64ImageData = new JSONPointer("/images/0").queryFrom(responseBody).toString();
return base64ImageData;
} catch (SdkClientException e) {
System.err.printf("ERROR: Can't invoke '%s'. Reason: %s", modelId, e.getMessage());
throw new RuntimeException(e);
}
}
public static void main(String[] args) {
System.out.println("Generating image. This may take a few seconds...");
String base64ImageData = invokeModel();
displayImage(base64ImageData);
}
}
```
+ For API details, see [InvokeModel](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModel) in *AWS SDK for Java 2.x API Reference*.
------
#### [ PHP ]
**SDK for PHP**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/bedrock-runtime#code-examples).
Create an image with the Amazon Titan Image Generator.
```
public function invokeTitanImage(string $prompt, int $seed)
{
// The different model providers have individual request and response formats.
// For the format, ranges, and default values for Titan Image models refer to:
// https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-titan-image.html
$base64_image_data = "";
try {
$modelId = 'amazon.titan-image-generator-v2:0';
$request = json_encode([
'taskType' => 'TEXT_IMAGE',
'textToImageParams' => [
'text' => $prompt
],
'imageGenerationConfig' => [
'numberOfImages' => 1,
'quality' => 'standard',
'cfgScale' => 8.0,
'height' => 512,
'width' => 512,
'seed' => $seed
]
]);
$result = $this->bedrockRuntimeClient->invokeModel([
'contentType' => 'application/json',
'body' => $request,
'modelId' => $modelId,
]);
$response_body = json_decode($result['body']);
$base64_image_data = $response_body->images[0];
} catch (Exception $e) {
echo "Error: ({$e->getCode()}) - {$e->getMessage()}\n";
}
return $base64_image_data;
}
```
+ For API details, see [InvokeModel](https://docs.aws.amazon.com/goto/SdkForPHPV3/bedrock-runtime-2023-09-30/InvokeModel) in *AWS SDK for PHP API Reference*.
------
#### [ Python ]
**SDK for Python (Boto3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Create an image with the Amazon Titan Image Generator.
```
# Use the native inference API to create an image with Amazon Titan Image Generator
import base64
import boto3
import json
import os
import random
# Create a Bedrock Runtime client in the AWS Region of your choice.
client = boto3.client("bedrock-runtime", region_name="us-east-1")
# Set the model ID, e.g., Titan Image Generator G1.
model_id = "amazon.titan-image-generator-v2:0"
# Define the image generation prompt for the model.
prompt = "A stylized picture of a cute old steampunk robot."
# Generate a random seed.
seed = random.randint(0, 2147483647)
# Format the request payload using the model's native structure.
native_request = {
"taskType": "TEXT_IMAGE",
"textToImageParams": {"text": prompt},
"imageGenerationConfig": {
"numberOfImages": 1,
"quality": "standard",
"cfgScale": 8.0,
"height": 512,
"width": 512,
"seed": seed,
},
}
# Convert the native request to JSON.
request = json.dumps(native_request)
# Invoke the model with the request.
response = client.invoke_model(modelId=model_id, body=request)
# Decode the response body.
model_response = json.loads(response["body"].read())
# Extract the image data.
base64_image_data = model_response["images"][0]
# Save the generated image to a local folder.
i, output_dir = 1, "output"
if not os.path.exists(output_dir):
os.makedirs(output_dir)
while os.path.exists(os.path.join(output_dir, f"titan_{i}.png")):
i += 1
image_data = base64.b64decode(base64_image_data)
image_path = os.path.join(output_dir, f"titan_{i}.png")
with open(image_path, "wb") as file:
file.write(image_data)
print(f"The generated image has been saved to {image_path}")
```
+ For API details, see [InvokeModel](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModel) in *AWS SDK for Python (Boto3) API Reference*.
------
For a complete list of AWS SDK developer guides and code examples, see [Using Amazon Bedrock with an AWS SDK](sdk-general-information-section.md). This topic also includes information about getting started and details about previous SDK versions.
# Amazon Titan Text for Amazon Bedrock Runtime
The following code examples show how to use Amazon Bedrock Runtime with AWS SDKs.
**Topics**
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_TitanText_section.md)
# Invoke Amazon Titan Text models on Amazon Bedrock using the Invoke Model API
The following code example shows how to send a text message to Amazon Titan Text, using the Invoke Model API.
------
#### [ Python ]
**SDK for Python (Boto3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Use the Invoke Model API to send a text message.
```
# Use the native inference API to send a text message to Amazon Titan Text.
import boto3
import json
from botocore.exceptions import ClientError
# Create a Bedrock Runtime client in the AWS Region of your choice.
client = boto3.client("bedrock-runtime", region_name="us-east-1")
# Set the model ID, e.g., Titan Text Premier.
model_id = "amazon.titan-text-premier-v1:0"
# Define the prompt for the model.
prompt = "Describe the purpose of a 'hello world' program in one line."
# Format the request payload using the model's native structure.
native_request = {
"inputText": prompt,
"textGenerationConfig": {
"maxTokenCount": 512,
"temperature": 0.5,
},
}
# Convert the native request to JSON.
request = json.dumps(native_request)
try:
# Invoke the model with the request.
response = client.invoke_model(modelId=model_id, body=request)
except (ClientError, Exception) as e:
print(f"ERROR: Can't invoke '{model_id}'. Reason: {e}")
exit(1)
# Decode the response body.
model_response = json.loads(response["body"].read())
# Extract and print the response text.
response_text = model_response["results"][0]["outputText"]
print(response_text)
```
+ For API details, see [InvokeModel](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModel) in *AWS SDK for Python (Boto3) API Reference*.
------
For a complete list of AWS SDK developer guides and code examples, see [Using Amazon Bedrock with an AWS SDK](sdk-general-information-section.md). This topic also includes information about getting started and details about previous SDK versions.
# Amazon Titan Text Embeddings for Amazon Bedrock Runtime
The following code examples show how to use Amazon Bedrock Runtime with AWS SDKs.
**Topics**
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModelWithResponseStream_TitanTextEmbeddings_section.md)
# Invoke Amazon Titan Text Embeddings on Amazon Bedrock
The following code examples show how to:
+ Get started creating your first embedding.
+ Create embeddings configuring the number of dimensions and normalization (V2 only).
------
#### [ Java ]
**SDK for Java 2.x**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Create your first embedding with Titan Text Embeddings V2.
```
// Generate and print an embedding with Amazon Titan Text Embeddings.
import org.json.JSONObject;
import org.json.JSONPointer;
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.core.SdkBytes;
import software.amazon.awssdk.core.exception.SdkClientException;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.bedrockruntime.BedrockRuntimeClient;
public class InvokeModel {
public static String invokeModel() {
// Create a Bedrock Runtime client in the AWS Region you want to use.
// Replace the DefaultCredentialsProvider with your preferred credentials provider.
var client = BedrockRuntimeClient.builder()
.credentialsProvider(DefaultCredentialsProvider.create())
.region(Region.US_EAST_1)
.build();
// Set the model ID, e.g., Titan Text Embeddings V2.
var modelId = "amazon.titan-embed-text-v2:0";
// The InvokeModel API uses the model's native payload.
// Learn more about the available inference parameters and response fields at:
// https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-titan-embed-text.html
var nativeRequestTemplate = "{ \"inputText\": \"{{inputText}}\" }";
// The text to convert into an embedding.
var inputText = "Please recommend books with a theme similar to the movie 'Inception'.";
// Embed the prompt in the model's native request payload.
String nativeRequest = nativeRequestTemplate.replace("{{inputText}}", inputText);
try {
// Encode and send the request to the Bedrock Runtime.
var response = client.invokeModel(request -> request
.body(SdkBytes.fromUtf8String(nativeRequest))
.modelId(modelId)
);
// Decode the response body.
var responseBody = new JSONObject(response.body().asUtf8String());
// Retrieve the generated text from the model's response.
var text = new JSONPointer("/embedding").queryFrom(responseBody).toString();
System.out.println(text);
return text;
} catch (SdkClientException e) {
System.err.printf("ERROR: Can't invoke '%s'. Reason: %s", modelId, e.getMessage());
throw new RuntimeException(e);
}
}
public static void main(String[] args) {
invokeModel();
}
}
```
Invoke Titan Text Embeddings V2 configuring the number of dimensions and normalization.
```
/**
* Invoke Amazon Titan Text Embeddings V2 with additional inference parameters.
*
* @param inputText - The text to convert to an embedding.
* @param dimensions - The number of dimensions the output embeddings should have.
* Values accepted by the model: 256, 512, 1024.
* @param normalize - A flag indicating whether or not to normalize the output embeddings.
* @return The {@link JSONObject} representing the model's response.
*/
public static JSONObject invokeModel(String inputText, int dimensions, boolean normalize) {
// Create a Bedrock Runtime client in the AWS Region of your choice.
var client = BedrockRuntimeClient.builder()
.region(Region.US_WEST_2)
.build();
// Set the model ID, e.g., Titan Embed Text v2.0.
var modelId = "amazon.titan-embed-text-v2:0";
// Create the request for the model.
var nativeRequest = """
{
"inputText": "%s",
"dimensions": %d,
"normalize": %b
}
""".formatted(inputText, dimensions, normalize);
// Encode and send the request.
var response = client.invokeModel(request -> {
request.body(SdkBytes.fromUtf8String(nativeRequest));
request.modelId(modelId);
});
// Decode the model's response.
var modelResponse = new JSONObject(response.body().asUtf8String());
// Extract and print the generated embedding and the input text token count.
var embedding = modelResponse.getJSONArray("embedding");
var inputTokenCount = modelResponse.getBigInteger("inputTextTokenCount");
System.out.println("Embedding: " + embedding);
System.out.println("\nInput token count: " + inputTokenCount);
// Return the model's native response.
return modelResponse;
}
```
+ For API details, see [InvokeModel](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModel) in *AWS SDK for Java 2.x API Reference*.
------
#### [ Python ]
**SDK for Python (Boto3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Create your first embedding with Amazon Titan Text Embeddings.
```
# Generate and print an embedding with Amazon Titan Text Embeddings V2.
import boto3
import json
# Create a Bedrock Runtime client in the AWS Region of your choice.
client = boto3.client("bedrock-runtime", region_name="us-east-1")
# Set the model ID, e.g., Titan Text Embeddings V2.
model_id = "amazon.titan-embed-text-v2:0"
# The text to convert to an embedding.
input_text = "Please recommend books with a theme similar to the movie 'Inception'."
# Create the request for the model.
native_request = {"inputText": input_text}
# Convert the native request to JSON.
request = json.dumps(native_request)
# Invoke the model with the request.
response = client.invoke_model(modelId=model_id, body=request)
# Decode the model's native response body.
model_response = json.loads(response["body"].read())
# Extract and print the generated embedding and the input text token count.
embedding = model_response["embedding"]
input_token_count = model_response["inputTextTokenCount"]
print("\nYour input:")
print(input_text)
print(f"Number of input tokens: {input_token_count}")
print(f"Size of the generated embedding: {len(embedding)}")
print("Embedding:")
print(embedding)
```
+ For API details, see [InvokeModel](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModel) in *AWS SDK for Python (Boto3) API Reference*.
------
For a complete list of AWS SDK developer guides and code examples, see [Using Amazon Bedrock with an AWS SDK](sdk-general-information-section.md). This topic also includes information about getting started and details about previous SDK versions.
# Anthropic Claude for Amazon Bedrock Runtime
The following code examples show how to use Amazon Bedrock Runtime with AWS SDKs.
**Topics**
+ [Converse](bedrock-runtime_example_bedrock-runtime_Converse_AnthropicClaude_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_AnthropicClaude_section.md)
+ [Document understanding](bedrock-runtime_example_bedrock-runtime_DocumentUnderstanding_AnthropicClaude_section.md)
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_AnthropicClaude_section.md)
+ [InvokeModelWithResponseStream](bedrock-runtime_example_bedrock-runtime_InvokeModelWithResponseStream_AnthropicClaude_section.md)
+ [Reasoning](bedrock-runtime_example_bedrock-runtime_Converse_AnthropicClaudeReasoning_section.md)
+ [Reasoning with a streaming response](bedrock-runtime_example_bedrock-runtime_ConverseStream_AnthropicClaudeReasoning_section.md)
+ [Scenario: Tool use with the Converse API](bedrock-runtime_example_bedrock-runtime_Scenario_ToolUseDemo_AnthropicClaude_section.md)
# Invoke Anthropic Claude on Amazon Bedrock using Bedrock's Converse API
The following code examples show how to send a text message to Anthropic Claude, using Bedrock's Converse API.
------
#### [ .NET ]
**SDK for .NET (v4)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Bedrock-runtime#code-examples).
Send a text message to Anthropic Claude, using Bedrock's Converse API.
```
// Use the Converse API to send a text message to Anthropic Claude.
using System;
using System.Collections.Generic;
using Amazon;
using Amazon.BedrockRuntime;
using Amazon.BedrockRuntime.Model;
// Create a Bedrock Runtime client in the AWS Region you want to use.
var client = new AmazonBedrockRuntimeClient(RegionEndpoint.USEast1);
// Set the model ID, e.g., Claude 3 Haiku.
var modelId = "anthropic.claude-3-haiku-20240307-v1:0";
// Define the user message.
var userMessage = "Describe the purpose of a 'hello world' program in one line.";
// Create a request with the model ID, the user message, and an inference configuration.
var request = new ConverseRequest
{
ModelId = modelId,
Messages = new List
{
new Message
{
Role = ConversationRole.User,
Content = new List { new ContentBlock { Text = userMessage } }
}
},
InferenceConfig = new InferenceConfiguration()
{
MaxTokens = 512,
Temperature = 0.5F,
TopP = 0.9F
}
};
try
{
// Send the request to the Bedrock Runtime and wait for the result.
var response = await client.ConverseAsync(request);
// Extract and print the response text.
string responseText = response?.Output?.Message?.Content?[0]?.Text ?? "";
Console.WriteLine(responseText);
}
catch (AmazonBedrockRuntimeException e)
{
Console.WriteLine($"ERROR: Can't invoke '{modelId}'. Reason: {e.Message}");
throw;
}
```
+ For API details, see [Converse](https://docs.aws.amazon.com/goto/DotNetSDKV4/bedrock-runtime-2023-09-30/Converse) in *AWS SDK for .NET API Reference*.
------
#### [ Go ]
**SDK for Go V2**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/bedrock-runtime#code-examples).
Send a text message to Anthropic Claude, using Bedrock's Converse API.
```
import (
"context"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/bedrockruntime"
"github.com/aws/aws-sdk-go-v2/service/bedrockruntime/types"
)
// ConverseWrapper encapsulates Amazon Bedrock actions used in the examples.
// It contains a Bedrock Runtime client that is used to invoke Bedrock.
type ConverseWrapper struct {
BedrockRuntimeClient *bedrockruntime.Client
}
func (wrapper ConverseWrapper) ConverseClaude(ctx context.Context, prompt string) (string, error) {
var content = types.ContentBlockMemberText{
Value: prompt,
}
var message = types.Message{
Content: []types.ContentBlock{&content},
Role: "user",
}
modelId := "anthropic.claude-3-haiku-20240307-v1:0"
var converseInput = bedrockruntime.ConverseInput{
ModelId: aws.String(modelId),
Messages: []types.Message{message},
}
response, err := wrapper.BedrockRuntimeClient.Converse(ctx, &converseInput)
if err != nil {
ProcessError(err, modelId)
}
responseText, _ := response.Output.(*types.ConverseOutputMemberMessage)
responseContentBlock := responseText.Value.Content[0]
text, _ := responseContentBlock.(*types.ContentBlockMemberText)
return text.Value, nil
}
```
+ For API details, see [Converse](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/bedrockruntime#Client.Converse) in *AWS SDK for Go API Reference*.
------
#### [ Java ]
**SDK for Java 2.x**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Send a text message to Anthropic Claude, using Bedrock's Converse API.
```
// Use the Converse API to send a text message to Anthropic Claude.
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.core.exception.SdkClientException;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.bedrockruntime.BedrockRuntimeClient;
import software.amazon.awssdk.services.bedrockruntime.model.ContentBlock;
import software.amazon.awssdk.services.bedrockruntime.model.ConversationRole;
import software.amazon.awssdk.services.bedrockruntime.model.ConverseResponse;
import software.amazon.awssdk.services.bedrockruntime.model.Message;
public class Converse {
public static String converse() {
// Create a Bedrock Runtime client in the AWS Region you want to use.
// Replace the DefaultCredentialsProvider with your preferred credentials provider.
var client = BedrockRuntimeClient.builder()
.credentialsProvider(DefaultCredentialsProvider.create())
.region(Region.US_EAST_1)
.build();
// Set the model ID, e.g., Claude 3 Haiku.
var modelId = "anthropic.claude-3-haiku-20240307-v1:0";
// Create the input text and embed it in a message object with the user role.
var inputText = "Describe the purpose of a 'hello world' program in one line.";
var message = Message.builder()
.content(ContentBlock.fromText(inputText))
.role(ConversationRole.USER)
.build();
try {
// Send the message with a basic inference configuration.
ConverseResponse response = client.converse(request -> request
.modelId(modelId)
.messages(message)
.inferenceConfig(config -> config
.maxTokens(512)
.temperature(0.5F)
.topP(0.9F)));
// Retrieve the generated text from Bedrock's response object.
var responseText = response.output().message().content().getFirst().text();
System.out.println(responseText);
return responseText;
} catch (SdkClientException e) {
System.err.printf("ERROR: Can't invoke '%s'. Reason: %s", modelId, e.getMessage());
throw new RuntimeException(e);
}
}
public static void main(String[] args) {
converse();
}
}
```
Send a text message to Anthropic Claude, using Bedrock's Converse API with the async Java client.
```
// Use the Converse API to send a text message to Anthropic Claude
// with the async Java client.
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.bedrockruntime.BedrockRuntimeAsyncClient;
import software.amazon.awssdk.services.bedrockruntime.model.ContentBlock;
import software.amazon.awssdk.services.bedrockruntime.model.ConversationRole;
import software.amazon.awssdk.services.bedrockruntime.model.Message;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
public class ConverseAsync {
public static String converseAsync() {
// Create a Bedrock Runtime client in the AWS Region you want to use.
// Replace the DefaultCredentialsProvider with your preferred credentials provider.
var client = BedrockRuntimeAsyncClient.builder()
.credentialsProvider(DefaultCredentialsProvider.create())
.region(Region.US_EAST_1)
.build();
// Set the model ID, e.g., Claude 3 Haiku.
var modelId = "anthropic.claude-3-haiku-20240307-v1:0";
// Create the input text and embed it in a message object with the user role.
var inputText = "Describe the purpose of a 'hello world' program in one line.";
var message = Message.builder()
.content(ContentBlock.fromText(inputText))
.role(ConversationRole.USER)
.build();
// Send the message with a basic inference configuration.
var request = client.converse(params -> params
.modelId(modelId)
.messages(message)
.inferenceConfig(config -> config
.maxTokens(512)
.temperature(0.5F)
.topP(0.9F))
);
// Prepare a future object to handle the asynchronous response.
CompletableFuture future = new CompletableFuture<>();
// Handle the response or error using the future object.
request.whenComplete((response, error) -> {
if (error == null) {
// Extract the generated text from Bedrock's response object.
String responseText = response.output().message().content().getFirst().text();
future.complete(responseText);
} else {
future.completeExceptionally(error);
}
});
try {
// Wait for the future object to complete and retrieve the generated text.
String responseText = future.get();
System.out.println(responseText);
return responseText;
} catch (ExecutionException | InterruptedException e) {
System.err.printf("Can't invoke '%s': %s", modelId, e.getMessage());
throw new RuntimeException(e);
}
}
public static void main(String[] args) {
converseAsync();
}
}
```
+ For API details, see [Converse](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/Converse) in *AWS SDK for Java 2.x API Reference*.
------
#### [ JavaScript ]
**SDK for JavaScript (v3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Send a text message to Anthropic Claude, using Bedrock's Converse API.
```
// Use the Conversation API to send a text message to Anthropic Claude.
import {
BedrockRuntimeClient,
ConverseCommand,
} from "@aws-sdk/client-bedrock-runtime";
// Create a Bedrock Runtime client in the AWS Region you want to use.
const client = new BedrockRuntimeClient({ region: "us-east-1" });
// Set the model ID, e.g., Claude 3 Haiku.
const modelId = "anthropic.claude-3-haiku-20240307-v1:0";
// Start a conversation with the user message.
const userMessage =
"Describe the purpose of a 'hello world' program in one line.";
const conversation = [
{
role: "user",
content: [{ text: userMessage }],
},
];
// Create a command with the model ID, the message, and a basic configuration.
const command = new ConverseCommand({
modelId,
messages: conversation,
inferenceConfig: { maxTokens: 512, temperature: 0.5, topP: 0.9 },
});
try {
// Send the command to the model and wait for the response
const response = await client.send(command);
// Extract and print the response text.
const responseText = response.output.message.content[0].text;
console.log(responseText);
} catch (err) {
console.log(`ERROR: Can't invoke '${modelId}'. Reason: ${err}`);
process.exit(1);
}
```
+ For API details, see [Converse](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseCommand) in *AWS SDK for JavaScript API Reference*.
------
#### [ Python ]
**SDK for Python (Boto3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Send a text message to Anthropic Claude, using Bedrock's Converse API.
```
# Use the Conversation API to send a text message to Anthropic Claude.
import boto3
from botocore.exceptions import ClientError
# Create a Bedrock Runtime client in the AWS Region you want to use.
client = boto3.client("bedrock-runtime", region_name="us-east-1")
# Set the model ID, e.g., Claude 3 Haiku.
model_id = "anthropic.claude-3-haiku-20240307-v1:0"
# Start a conversation with the user message.
user_message = "Describe the purpose of a 'hello world' program in one line."
conversation = [
{
"role": "user",
"content": [{"text": user_message}],
}
]
try:
# Send the message to the model, using a basic inference configuration.
response = client.converse(
modelId=model_id,
messages=conversation,
inferenceConfig={"maxTokens": 512, "temperature": 0.5, "topP": 0.9},
)
# Extract and print the response text.
response_text = response["output"]["message"]["content"][0]["text"]
print(response_text)
except (ClientError, Exception) as e:
print(f"ERROR: Can't invoke '{model_id}'. Reason: {e}")
exit(1)
```
+ For API details, see [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) in *AWS SDK for Python (Boto3) API Reference*.
------
#### [ Rust ]
**SDK for Rust**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/bedrock-runtime#code-examples).
Send a text message to Anthropic Claude, using Bedrock's Converse API.
```
#[tokio::main]
async fn main() -> Result<(), BedrockConverseError> {
tracing_subscriber::fmt::init();
let sdk_config = aws_config::defaults(BehaviorVersion::latest())
.region(CLAUDE_REGION)
.load()
.await;
let client = Client::new(&sdk_config);
let response = client
.converse()
.model_id(MODEL_ID)
.messages(
Message::builder()
.role(ConversationRole::User)
.content(ContentBlock::Text(USER_MESSAGE.to_string()))
.build()
.map_err(|_| "failed to build message")?,
)
.send()
.await;
match response {
Ok(output) => {
let text = get_converse_output_text(output)?;
println!("{}", text);
Ok(())
}
Err(e) => Err(e
.as_service_error()
.map(BedrockConverseError::from)
.unwrap_or_else(|| BedrockConverseError("Unknown service error".into()))),
}
}
fn get_converse_output_text(output: ConverseOutput) -> Result {
let text = output
.output()
.ok_or("no output")?
.as_message()
.map_err(|_| "output not a message")?
.content()
.first()
.ok_or("no content in message")?
.as_text()
.map_err(|_| "content is not text")?
.to_string();
Ok(text)
}
```
Use statements, Error utility, and constants.
```
use aws_config::BehaviorVersion;
use aws_sdk_bedrockruntime::{
operation::converse::{ConverseError, ConverseOutput},
types::{ContentBlock, ConversationRole, Message},
Client,
};
// Set the model ID, e.g., Claude 3 Haiku.
const MODEL_ID: &str = "anthropic.claude-3-haiku-20240307-v1:0";
const CLAUDE_REGION: &str = "us-east-1";
// Start a conversation with the user message.
const USER_MESSAGE: &str = "Describe the purpose of a 'hello world' program in one line.";
#[derive(Debug)]
struct BedrockConverseError(String);
impl std::fmt::Display for BedrockConverseError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "Can't invoke '{}'. Reason: {}", MODEL_ID, self.0)
}
}
impl std::error::Error for BedrockConverseError {}
impl From<&str> for BedrockConverseError {
fn from(value: &str) -> Self {
BedrockConverseError(value.to_string())
}
}
impl From<&ConverseError> for BedrockConverseError {
fn from(value: &ConverseError) -> Self {
BedrockConverseError::from(match value {
ConverseError::ModelTimeoutException(_) => "Model took too long",
ConverseError::ModelNotReadyException(_) => "Model is not ready",
_ => "Unknown",
})
}
}
```
+ For API details, see [Converse](https://docs.rs/aws-sdk-bedrockruntime/latest/aws_sdk_bedrockruntime/client/struct.Client.html#method.converse) in *AWS SDK for Rust API reference*.
------
#### [ Swift ]
**SDK for Swift**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/bedrock-runtime#code-examples).
Send a text message to Anthropic Claude, using Bedrock's Converse API.
```
// An example demonstrating how to use the Conversation API to send
// a text message to Anthropic Claude.
import AWSBedrockRuntime
func converse(_ textPrompt: String) async throws -> String {
// Create a Bedrock Runtime client in the AWS Region you want to use.
let config =
try await BedrockRuntimeClient.BedrockRuntimeClientConfiguration(
region: "us-east-1"
)
let client = BedrockRuntimeClient(config: config)
// Set the model ID.
let modelId = "anthropic.claude-3-haiku-20240307-v1:0"
// Start a conversation with the user message.
let message = BedrockRuntimeClientTypes.Message(
content: [.text(textPrompt)],
role: .user
)
// Optionally use inference parameters
let inferenceConfig =
BedrockRuntimeClientTypes.InferenceConfiguration(
maxTokens: 512,
stopSequences: ["END"],
temperature: 0.5,
topp: 0.9
)
// Create the ConverseInput to send to the model
let input = ConverseInput(
inferenceConfig: inferenceConfig, messages: [message], modelId: modelId)
// Send the ConverseInput to the model
let response = try await client.converse(input: input)
// Extract and return the response text.
if case let .message(msg) = response.output {
if case let .text(textResponse) = msg.content![0] {
return textResponse
} else {
return "No text response found in message content"
}
} else {
return "No message found in converse output"
}
}
```
+ For API details, see [Converse](https://sdk.amazonaws.com/swift/api/awsbedrockruntime/latest/documentation/awsbedrockruntime/bedrockruntimeclient/converse(input:)) in *AWS SDK for Swift API reference*.
------
For a complete list of AWS SDK developer guides and code examples, see [Using Amazon Bedrock with an AWS SDK](sdk-general-information-section.md). This topic also includes information about getting started and details about previous SDK versions.
# Invoke Anthropic Claude on Amazon Bedrock using Bedrock's Converse API with a response stream
The following code examples show how to send a text message to Anthropic Claude, using Bedrock's Converse API and process the response stream in real-time.
------
#### [ .NET ]
**SDK for .NET (v4)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Bedrock-runtime#code-examples).
Send a text message to Anthropic Claude, using Bedrock's Converse API and process the response stream in real-time.
```
// Use the Converse API to send a text message to Anthropic Claude
// and print the response stream.
using System;
using System.Collections.Generic;
using System.Linq;
using Amazon;
using Amazon.BedrockRuntime;
using Amazon.BedrockRuntime.Model;
// Create a Bedrock Runtime client in the AWS Region you want to use.
var client = new AmazonBedrockRuntimeClient(RegionEndpoint.USEast1);
// Set the model ID, e.g., Claude 3 Haiku.
var modelId = "anthropic.claude-3-haiku-20240307-v1:0";
// Define the user message.
var userMessage = "Describe the purpose of a 'hello world' program in one line.";
// Create a request with the model ID, the user message, and an inference configuration.
var request = new ConverseStreamRequest
{
ModelId = modelId,
Messages = new List
{
new Message
{
Role = ConversationRole.User,
Content = new List { new ContentBlock { Text = userMessage } }
}
},
InferenceConfig = new InferenceConfiguration()
{
MaxTokens = 512,
Temperature = 0.5F,
TopP = 0.9F
}
};
try
{
// Send the request to the Bedrock Runtime and wait for the result.
var response = await client.ConverseStreamAsync(request);
// Extract and print the streamed response text in real-time.
foreach (var chunk in response.Stream.AsEnumerable())
{
if (chunk is ContentBlockDeltaEvent)
{
Console.Write((chunk as ContentBlockDeltaEvent).Delta.Text);
}
}
}
catch (AmazonBedrockRuntimeException e)
{
Console.WriteLine($"ERROR: Can't invoke '{modelId}'. Reason: {e.Message}");
throw;
}
```
+ For API details, see [ConverseStream](https://docs.aws.amazon.com/goto/DotNetSDKV4/bedrock-runtime-2023-09-30/ConverseStream) in *AWS SDK for .NET API Reference*.
------
#### [ Java ]
**SDK for Java 2.x**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Send a text message to Anthropic Claude, using Bedrock's Converse API and process the response stream in real-time.
```
// Use the Converse API to send a text message to Anthropic Claude
// and print the response stream.
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.bedrockruntime.BedrockRuntimeAsyncClient;
import software.amazon.awssdk.services.bedrockruntime.model.ContentBlock;
import software.amazon.awssdk.services.bedrockruntime.model.ConversationRole;
import software.amazon.awssdk.services.bedrockruntime.model.ConverseStreamResponseHandler;
import software.amazon.awssdk.services.bedrockruntime.model.Message;
import java.util.concurrent.ExecutionException;
public class ConverseStream {
public static void main(String[] args) {
// Create a Bedrock Runtime client in the AWS Region you want to use.
// Replace the DefaultCredentialsProvider with your preferred credentials provider.
var client = BedrockRuntimeAsyncClient.builder()
.credentialsProvider(DefaultCredentialsProvider.create())
.region(Region.US_EAST_1)
.build();
// Set the model ID, e.g., Claude 3 Haiku.
var modelId = "anthropic.claude-3-haiku-20240307-v1:0";
// Create the input text and embed it in a message object with the user role.
var inputText = "Describe the purpose of a 'hello world' program in one line.";
var message = Message.builder()
.content(ContentBlock.fromText(inputText))
.role(ConversationRole.USER)
.build();
// Create a handler to extract and print the response text in real-time.
var responseStreamHandler = ConverseStreamResponseHandler.builder()
.subscriber(ConverseStreamResponseHandler.Visitor.builder()
.onContentBlockDelta(chunk -> {
String responseText = chunk.delta().text();
System.out.print(responseText);
}).build()
).onError(err ->
System.err.printf("Can't invoke '%s': %s", modelId, err.getMessage())
).build();
try {
// Send the message with a basic inference configuration and attach the handler.
client.converseStream(request -> request.modelId(modelId)
.messages(message)
.inferenceConfig(config -> config
.maxTokens(512)
.temperature(0.5F)
.topP(0.9F)
), responseStreamHandler).get();
} catch (ExecutionException | InterruptedException e) {
System.err.printf("Can't invoke '%s': %s", modelId, e.getCause().getMessage());
}
}
}
```
+ For API details, see [ConverseStream](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/ConverseStream) in *AWS SDK for Java 2.x API Reference*.
------
#### [ JavaScript ]
**SDK for JavaScript (v3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Send a text message to Anthropic Claude, using Bedrock's Converse API and process the response stream in real-time.
```
// Use the Conversation API to send a text message to Anthropic Claude.
import {
BedrockRuntimeClient,
ConverseStreamCommand,
} from "@aws-sdk/client-bedrock-runtime";
// Create a Bedrock Runtime client in the AWS Region you want to use.
const client = new BedrockRuntimeClient({ region: "us-east-1" });
// Set the model ID, e.g., Claude 3 Haiku.
const modelId = "anthropic.claude-3-haiku-20240307-v1:0";
// Start a conversation with the user message.
const userMessage =
"Describe the purpose of a 'hello world' program in one line.";
const conversation = [
{
role: "user",
content: [{ text: userMessage }],
},
];
// Create a command with the model ID, the message, and a basic configuration.
const command = new ConverseStreamCommand({
modelId,
messages: conversation,
inferenceConfig: { maxTokens: 512, temperature: 0.5, topP: 0.9 },
});
try {
// Send the command to the model and wait for the response
const response = await client.send(command);
// Extract and print the streamed response text in real-time.
for await (const item of response.stream) {
if (item.contentBlockDelta) {
process.stdout.write(item.contentBlockDelta.delta?.text);
}
}
} catch (err) {
console.log(`ERROR: Can't invoke '${modelId}'. Reason: ${err}`);
process.exit(1);
}
```
+ For API details, see [ConverseStream](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseStreamCommand) in *AWS SDK for JavaScript API Reference*.
------
#### [ Python ]
**SDK for Python (Boto3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Send a text message to Anthropic Claude, using Bedrock's Converse API and process the response stream in real-time.
```
# Use the Conversation API to send a text message to Anthropic Claude
# and print the response stream.
import boto3
from botocore.exceptions import ClientError
# Create a Bedrock Runtime client in the AWS Region you want to use.
client = boto3.client("bedrock-runtime", region_name="us-east-1")
# Set the model ID, e.g., Claude 3 Haiku.
model_id = "anthropic.claude-3-haiku-20240307-v1:0"
# Start a conversation with the user message.
user_message = "Describe the purpose of a 'hello world' program in one line."
conversation = [
{
"role": "user",
"content": [{"text": user_message}],
}
]
try:
# Send the message to the model, using a basic inference configuration.
streaming_response = client.converse_stream(
modelId=model_id,
messages=conversation,
inferenceConfig={"maxTokens": 512, "temperature": 0.5, "topP": 0.9},
)
# Extract and print the streamed response text in real-time.
for chunk in streaming_response["stream"]:
if "contentBlockDelta" in chunk:
text = chunk["contentBlockDelta"]["delta"]["text"]
print(text, end="")
except (ClientError, Exception) as e:
print(f"ERROR: Can't invoke '{model_id}'. Reason: {e}")
exit(1)
```
+ For API details, see [ConverseStream](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/ConverseStream) in *AWS SDK for Python (Boto3) API Reference*.
------
#### [ Rust ]
**SDK for Rust**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/bedrock-runtime#code-examples).
Send a text message to Anthropic Claude and stream reply tokens, using Bedrock's ConverseStream API.
```
#[tokio::main]
async fn main() -> Result<(), BedrockConverseStreamError> {
tracing_subscriber::fmt::init();
let sdk_config = aws_config::defaults(BehaviorVersion::latest())
.region(CLAUDE_REGION)
.load()
.await;
let client = Client::new(&sdk_config);
let response = client
.converse_stream()
.model_id(MODEL_ID)
.messages(
Message::builder()
.role(ConversationRole::User)
.content(ContentBlock::Text(USER_MESSAGE.to_string()))
.build()
.map_err(|_| "failed to build message")?,
)
.send()
.await;
let mut stream = match response {
Ok(output) => Ok(output.stream),
Err(e) => Err(BedrockConverseStreamError::from(
e.as_service_error().unwrap(),
)),
}?;
loop {
let token = stream.recv().await;
match token {
Ok(Some(text)) => {
let next = get_converse_output_text(text)?;
print!("{}", next);
Ok(())
}
Ok(None) => break,
Err(e) => Err(e
.as_service_error()
.map(BedrockConverseStreamError::from)
.unwrap_or(BedrockConverseStreamError(
"Unknown error receiving stream".into(),
))),
}?
}
println!();
Ok(())
}
fn get_converse_output_text(
output: ConverseStreamOutputType,
) -> Result {
Ok(match output {
ConverseStreamOutputType::ContentBlockDelta(event) => match event.delta() {
Some(delta) => delta.as_text().cloned().unwrap_or_else(|_| "".into()),
None => "".into(),
},
_ => "".into(),
})
}
```
Use statements, Error utility, and constants.
```
use aws_config::BehaviorVersion;
use aws_sdk_bedrockruntime::{
error::ProvideErrorMetadata,
operation::converse_stream::ConverseStreamError,
types::{
error::ConverseStreamOutputError, ContentBlock, ConversationRole,
ConverseStreamOutput as ConverseStreamOutputType, Message,
},
Client,
};
// Set the model ID, e.g., Claude 3 Haiku.
const MODEL_ID: &str = "anthropic.claude-3-haiku-20240307-v1:0";
const CLAUDE_REGION: &str = "us-east-1";
// Start a conversation with the user message.
const USER_MESSAGE: &str = "Describe the purpose of a 'hello world' program in one line.";
#[derive(Debug)]
struct BedrockConverseStreamError(String);
impl std::fmt::Display for BedrockConverseStreamError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "Can't invoke '{}'. Reason: {}", MODEL_ID, self.0)
}
}
impl std::error::Error for BedrockConverseStreamError {}
impl From<&str> for BedrockConverseStreamError {
fn from(value: &str) -> Self {
BedrockConverseStreamError(value.into())
}
}
impl From<&ConverseStreamError> for BedrockConverseStreamError {
fn from(value: &ConverseStreamError) -> Self {
BedrockConverseStreamError(
match value {
ConverseStreamError::ModelTimeoutException(_) => "Model took too long",
ConverseStreamError::ModelNotReadyException(_) => "Model is not ready",
_ => "Unknown",
}
.into(),
)
}
}
impl From<&ConverseStreamOutputError> for BedrockConverseStreamError {
fn from(value: &ConverseStreamOutputError) -> Self {
match value {
ConverseStreamOutputError::ValidationException(ve) => BedrockConverseStreamError(
ve.message().unwrap_or("Unknown ValidationException").into(),
),
ConverseStreamOutputError::ThrottlingException(te) => BedrockConverseStreamError(
te.message().unwrap_or("Unknown ThrottlingException").into(),
),
value => BedrockConverseStreamError(
value
.message()
.unwrap_or("Unknown StreamOutput exception")
.into(),
),
}
}
}
```
+ For API details, see [ConverseStream](https://docs.rs/aws-sdk-bedrockruntime/latest/aws_sdk_bedrockruntime/client/struct.Client.html#method.converse_stream) in *AWS SDK for Rust API reference*.
------
#### [ Swift ]
**SDK for Swift**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/bedrock-runtime#code-examples).
Send a text message to Anthropic Claude, using Bedrock's Converse API and process the response stream in real-time.
```
// An example demonstrating how to use the Conversation API to send a text message
// to Anthropic Claude and print the response stream
import AWSBedrockRuntime
func printConverseStream(_ textPrompt: String) async throws {
// Create a Bedrock Runtime client in the AWS Region you want to use.
let config =
try await BedrockRuntimeClient.BedrockRuntimeClientConfiguration(
region: "us-east-1"
)
let client = BedrockRuntimeClient(config: config)
// Set the model ID.
let modelId = "anthropic.claude-3-haiku-20240307-v1:0"
// Start a conversation with the user message.
let message = BedrockRuntimeClientTypes.Message(
content: [.text(textPrompt)],
role: .user
)
// Optionally use inference parameters.
let inferenceConfig =
BedrockRuntimeClientTypes.InferenceConfiguration(
maxTokens: 512,
stopSequences: ["END"],
temperature: 0.5,
topp: 0.9
)
// Create the ConverseStreamInput to send to the model.
let input = ConverseStreamInput(
inferenceConfig: inferenceConfig, messages: [message], modelId: modelId)
// Send the ConverseStreamInput to the model.
let response = try await client.converseStream(input: input)
// Extract the streaming response.
guard let stream = response.stream else {
print("No stream available")
return
}
// Extract and print the streamed response text in real-time.
for try await event in stream {
switch event {
case .messagestart(_):
print("\nAnthropic Claude:")
case .contentblockdelta(let deltaEvent):
if case .text(let text) = deltaEvent.delta {
print(text, terminator: "")
}
default:
break
}
}
}
```
+ For API details, see [ConverseStream](https://sdk.amazonaws.com/swift/api/awsbedrockruntime/latest/documentation/awsbedrockruntime/bedrockruntimeclient/conversestream(input:)) in *AWS SDK for Swift API reference*.
------
For a complete list of AWS SDK developer guides and code examples, see [Using Amazon Bedrock with an AWS SDK](sdk-general-information-section.md). This topic also includes information about getting started and details about previous SDK versions.
# Send and process a document with Anthropic Claude on Amazon Bedrock
The following code example shows how to send and process a document with Anthropic Claude on Amazon Bedrock.
------
#### [ Python ]
**SDK for Python (Boto3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Send and process a document with Anthropic Claude on Amazon Bedrock.
```
# Send and process a document with Anthropic Claude on Amazon Bedrock.
import boto3
from botocore.exceptions import ClientError
# Create a Bedrock Runtime client in the AWS Region you want to use.
client = boto3.client("bedrock-runtime", region_name="us-east-1")
# Set the model ID, e.g. Claude 3 Haiku.
model_id = "anthropic.claude-3-haiku-20240307-v1:0"
# Load the document
with open("example-data/amazon-nova-service-cards.pdf", "rb") as file:
document_bytes = file.read()
# Start a conversation with a user message and the document
conversation = [
{
"role": "user",
"content": [
{"text": "Briefly compare the models described in this document"},
{
"document": {
# Available formats: html, md, pdf, doc/docx, xls/xlsx, csv, and txt
"format": "pdf",
"name": "Amazon Nova Service Cards",
"source": {"bytes": document_bytes},
}
},
],
}
]
try:
# Send the message to the model, using a basic inference configuration.
response = client.converse(
modelId=model_id,
messages=conversation,
inferenceConfig={"maxTokens": 500, "temperature": 0.3},
)
# Extract and print the response text.
response_text = response["output"]["message"]["content"][0]["text"]
print(response_text)
except (ClientError, Exception) as e:
print(f"ERROR: Can't invoke '{model_id}'. Reason: {e}")
exit(1)
```
+ For API details, see [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) in *AWS SDK for Python (Boto3) API Reference*.
------
For a complete list of AWS SDK developer guides and code examples, see [Using Amazon Bedrock with an AWS SDK](sdk-general-information-section.md). This topic also includes information about getting started and details about previous SDK versions.
# Invoke Anthropic Claude on Amazon Bedrock using the Invoke Model API
The following code examples show how to send a text message to Anthropic Claude, using the Invoke Model API.
------
#### [ .NET ]
**SDK for .NET (v4)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Bedrock-runtime#code-examples).
Use the Invoke Model API to send a text message.
```
// Use the native inference API to send a text message to Anthropic Claude.
using System;
using System.IO;
using System.Text.Json;
using System.Text.Json.Nodes;
using Amazon;
using Amazon.BedrockRuntime;
using Amazon.BedrockRuntime.Model;
// Create a Bedrock Runtime client in the AWS Region you want to use.
var client = new AmazonBedrockRuntimeClient(RegionEndpoint.USEast1);
// Set the model ID, e.g., Claude 3 Haiku.
var modelId = "anthropic.claude-3-haiku-20240307-v1:0";
// Define the user message.
var userMessage = "Describe the purpose of a 'hello world' program in one line.";
//Format the request payload using the model's native structure.
var nativeRequest = JsonSerializer.Serialize(new
{
anthropic_version = "bedrock-2023-05-31",
max_tokens = 512,
temperature = 0.5,
messages = new[]
{
new { role = "user", content = userMessage }
}
});
// Create a request with the model ID and the model's native request payload.
var request = new InvokeModelRequest()
{
ModelId = modelId,
Body = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(nativeRequest)),
ContentType = "application/json"
};
try
{
// Send the request to the Bedrock Runtime and wait for the response.
var response = await client.InvokeModelAsync(request);
// Decode the response body.
var modelResponse = await JsonNode.ParseAsync(response.Body);
// Extract and print the response text.
var responseText = modelResponse["content"]?[0]?["text"] ?? "";
Console.WriteLine(responseText);
}
catch (AmazonBedrockRuntimeException e)
{
Console.WriteLine($"ERROR: Can't invoke '{modelId}'. Reason: {e.Message}");
throw;
}
```
+ For API details, see [InvokeModel](https://docs.aws.amazon.com/goto/DotNetSDKV4/bedrock-runtime-2023-09-30/InvokeModel) in *AWS SDK for .NET API Reference*.
------
#### [ Go ]
**SDK for Go V2**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/bedrock-runtime#code-examples).
Invoke the Anthropic Claude 2 foundation model to generate text.
```
import (
"context"
"encoding/json"
"log"
"strings"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/bedrockruntime"
)
// InvokeModelWrapper encapsulates Amazon Bedrock actions used in the examples.
// It contains a Bedrock Runtime client that is used to invoke foundation models.
type InvokeModelWrapper struct {
BedrockRuntimeClient *bedrockruntime.Client
}
// Each model provider has their own individual request and response formats.
// For the format, ranges, and default values for Anthropic Claude, refer to:
// https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-claude.html
type ClaudeRequest struct {
Prompt string `json:"prompt"`
MaxTokensToSample int `json:"max_tokens_to_sample"`
Temperature float64 `json:"temperature,omitempty"`
StopSequences []string `json:"stop_sequences,omitempty"`
}
type ClaudeResponse struct {
Completion string `json:"completion"`
}
// Invokes Anthropic Claude on Amazon Bedrock to run an inference using the input
// provided in the request body.
func (wrapper InvokeModelWrapper) InvokeClaude(ctx context.Context, prompt string) (string, error) {
modelId := "anthropic.claude-v2"
// Anthropic Claude requires enclosing the prompt as follows:
enclosedPrompt := "Human: " + prompt + "\n\nAssistant:"
body, err := json.Marshal(ClaudeRequest{
Prompt: enclosedPrompt,
MaxTokensToSample: 200,
Temperature: 0.5,
StopSequences: []string{"\n\nHuman:"},
})
if err != nil {
log.Fatal("failed to marshal", err)
}
output, err := wrapper.BedrockRuntimeClient.InvokeModel(ctx, &bedrockruntime.InvokeModelInput{
ModelId: aws.String(modelId),
ContentType: aws.String("application/json"),
Body: body,
})
if err != nil {
ProcessError(err, modelId)
}
var response ClaudeResponse
if err := json.Unmarshal(output.Body, &response); err != nil {
log.Fatal("failed to unmarshal", err)
}
return response.Completion, nil
}
```
+ For API details, see [InvokeModel](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/bedrockruntime#Client.InvokeModel) in *AWS SDK for Go API Reference*.
------
#### [ Java ]
**SDK for Java 2.x**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Use the Invoke Model API to send a text message.
```
// Use the native inference API to send a text message to Anthropic Claude.
import org.json.JSONObject;
import org.json.JSONPointer;
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.core.SdkBytes;
import software.amazon.awssdk.core.exception.SdkClientException;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.bedrockruntime.BedrockRuntimeClient;
public class InvokeModel {
public static String invokeModel() {
// Create a Bedrock Runtime client in the AWS Region you want to use.
// Replace the DefaultCredentialsProvider with your preferred credentials provider.
var client = BedrockRuntimeClient.builder()
.credentialsProvider(DefaultCredentialsProvider.create())
.region(Region.US_EAST_1)
.build();
// Set the model ID, e.g., Claude 3 Haiku.
var modelId = "anthropic.claude-3-haiku-20240307-v1:0";
// The InvokeModel API uses the model's native payload.
// Learn more about the available inference parameters and response fields at:
// https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-anthropic-claude-messages.html
var nativeRequestTemplate = """
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 512,
"temperature": 0.5,
"messages": [{
"role": "user",
"content": "{{prompt}}"
}]
}""";
// Define the prompt for the model.
var prompt = "Describe the purpose of a 'hello world' program in one line.";
// Embed the prompt in the model's native request payload.
String nativeRequest = nativeRequestTemplate.replace("{{prompt}}", prompt);
try {
// Encode and send the request to the Bedrock Runtime.
var response = client.invokeModel(request -> request
.body(SdkBytes.fromUtf8String(nativeRequest))
.modelId(modelId)
);
// Decode the response body.
var responseBody = new JSONObject(response.body().asUtf8String());
// Retrieve the generated text from the model's response.
var text = new JSONPointer("/content/0/text").queryFrom(responseBody).toString();
System.out.println(text);
return text;
} catch (SdkClientException e) {
System.err.printf("ERROR: Can't invoke '%s'. Reason: %s", modelId, e.getMessage());
throw new RuntimeException(e);
}
}
public static void main(String[] args) {
invokeModel();
}
}
```
+ For API details, see [InvokeModel](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModel) in *AWS SDK for Java 2.x API Reference*.
------
#### [ JavaScript ]
**SDK for JavaScript (v3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Use the Invoke Model API to send a text message.
```
import { fileURLToPath } from "node:url";
import { FoundationModels } from "../../config/foundation_models.js";
import {
BedrockRuntimeClient,
InvokeModelCommand,
InvokeModelWithResponseStreamCommand,
} from "@aws-sdk/client-bedrock-runtime";
/**
* @typedef {Object} ResponseContent
* @property {string} text
*
* @typedef {Object} MessagesResponseBody
* @property {ResponseContent[]} content
*
* @typedef {Object} Delta
* @property {string} text
*
* @typedef {Object} Message
* @property {string} role
*
* @typedef {Object} Chunk
* @property {string} type
* @property {Delta} delta
* @property {Message} message
*/
/**
* Invokes Anthropic Claude 3 using the Messages API.
*
* To learn more about the Anthropic Messages API, go to:
* https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-anthropic-claude-messages.html
*
* @param {string} prompt - The input text prompt for the model to complete.
* @param {string} [modelId] - The ID of the model to use. Defaults to "anthropic.claude-3-haiku-20240307-v1:0".
*/
export const invokeModel = async (
prompt,
modelId = "anthropic.claude-3-haiku-20240307-v1:0",
) => {
// Create a new Bedrock Runtime client instance.
const client = new BedrockRuntimeClient({ region: "us-east-1" });
// Prepare the payload for the model.
const payload = {
anthropic_version: "bedrock-2023-05-31",
max_tokens: 1000,
messages: [
{
role: "user",
content: [{ type: "text", text: prompt }],
},
],
};
// Invoke Claude with the payload and wait for the response.
const command = new InvokeModelCommand({
contentType: "application/json",
body: JSON.stringify(payload),
modelId,
});
const apiResponse = await client.send(command);
// Decode and return the response(s)
const decodedResponseBody = new TextDecoder().decode(apiResponse.body);
/** @type {MessagesResponseBody} */
const responseBody = JSON.parse(decodedResponseBody);
return responseBody.content[0].text;
};
/**
* Invokes Anthropic Claude 3 and processes the response stream.
*
* To learn more about the Anthropic Messages API, go to:
* https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-anthropic-claude-messages.html
*
* @param {string} prompt - The input text prompt for the model to complete.
* @param {string} [modelId] - The ID of the model to use. Defaults to "anthropic.claude-3-haiku-20240307-v1:0".
*/
export const invokeModelWithResponseStream = async (
prompt,
modelId = "anthropic.claude-3-haiku-20240307-v1:0",
) => {
// Create a new Bedrock Runtime client instance.
const client = new BedrockRuntimeClient({ region: "us-east-1" });
// Prepare the payload for the model.
const payload = {
anthropic_version: "bedrock-2023-05-31",
max_tokens: 1000,
messages: [
{
role: "user",
content: [{ type: "text", text: prompt }],
},
],
};
// Invoke Claude with the payload and wait for the API to respond.
const command = new InvokeModelWithResponseStreamCommand({
contentType: "application/json",
body: JSON.stringify(payload),
modelId,
});
const apiResponse = await client.send(command);
let completeMessage = "";
// Decode and process the response stream
for await (const item of apiResponse.body) {
/** @type Chunk */
const chunk = JSON.parse(new TextDecoder().decode(item.chunk.bytes));
const chunk_type = chunk.type;
if (chunk_type === "content_block_delta") {
const text = chunk.delta.text;
completeMessage = completeMessage + text;
process.stdout.write(text);
}
}
// Return the final response
return completeMessage;
};
// Invoke the function if this file was run directly.
if (process.argv[1] === fileURLToPath(import.meta.url)) {
const prompt = 'Write a paragraph starting with: "Once upon a time..."';
const modelId = FoundationModels.CLAUDE_3_HAIKU.modelId;
console.log(`Prompt: ${prompt}`);
console.log(`Model ID: ${modelId}`);
try {
console.log("-".repeat(53));
const response = await invokeModel(prompt, modelId);
console.log(`\n${"-".repeat(53)}`);
console.log("Final structured response:");
console.log(response);
} catch (err) {
console.log(`\n${err}`);
}
}
```
+ For API details, see [InvokeModel](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/InvokeModelCommand) in *AWS SDK for JavaScript API Reference*.
------
#### [ PHP ]
**SDK for PHP**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/bedrock-runtime#code-examples).
Invoke the Anthropic Claude 2 foundation model to generate text.
```
public function invokeClaude($prompt)
{
// The different model providers have individual request and response formats.
// For the format, ranges, and default values for Anthropic Claude, refer to:
// https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-claude.html
$completion = "";
try {
$modelId = 'anthropic.claude-3-haiku-20240307-v1:0';
// Claude requires you to enclose the prompt as follows:
$body = [
'anthropic_version' => 'bedrock-2023-05-31',
'max_tokens' => 512,
'temperature' => 0.5,
'messages' => [[
'role' => 'user',
'content' => $prompt
]]
];
$result = $this->bedrockRuntimeClient->invokeModel([
'contentType' => 'application/json',
'body' => json_encode($body),
'modelId' => $modelId,
]);
$response_body = json_decode($result['body']);
$completion = $response_body->content[0]->text;
} catch (Exception $e) {
echo "Error: ({$e->getCode()}) - {$e->getMessage()}\n";
}
return $completion;
}
```
+ For API details, see [InvokeModel](https://docs.aws.amazon.com/goto/SdkForPHPV3/bedrock-runtime-2023-09-30/InvokeModel) in *AWS SDK for PHP API Reference*.
------
#### [ Python ]
**SDK for Python (Boto3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Use the Invoke Model API to send a text message.
```
# Use the native inference API to send a text message to Anthropic Claude.
import boto3
import json
from botocore.exceptions import ClientError
# Create a Bedrock Runtime client in the AWS Region of your choice.
client = boto3.client("bedrock-runtime", region_name="us-east-1")
# Set the model ID, e.g., Claude 3 Haiku.
model_id = "anthropic.claude-3-haiku-20240307-v1:0"
# Define the prompt for the model.
prompt = "Describe the purpose of a 'hello world' program in one line."
# Format the request payload using the model's native structure.
native_request = {
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 512,
"temperature": 0.5,
"messages": [
{
"role": "user",
"content": [{"type": "text", "text": prompt}],
}
],
}
# Convert the native request to JSON.
request = json.dumps(native_request)
try:
# Invoke the model with the request.
response = client.invoke_model(modelId=model_id, body=request)
except (ClientError, Exception) as e:
print(f"ERROR: Can't invoke '{model_id}'. Reason: {e}")
exit(1)
# Decode the response body.
model_response = json.loads(response["body"].read())
# Extract and print the response text.
response_text = model_response["content"][0]["text"]
print(response_text)
```
+ For API details, see [InvokeModel](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModel) in *AWS SDK for Python (Boto3) API Reference*.
------
#### [ SAP ABAP ]
**SDK for SAP ABAP**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/bdr#code-examples).
Invoke the Anthropic Claude 2 foundation model to generate text. This example uses features of /US2/CL\$1JSON which might not be available on some NetWeaver versions.
```
"Claude V2 Input Parameters should be in a format like this:
* {
* "prompt":"\n\nHuman:\\nTell me a joke\n\nAssistant:\n",
* "max_tokens_to_sample":2048,
* "temperature":0.5,
* "top_k":250,
* "top_p":1.0,
* "stop_sequences":[]
* }
DATA: BEGIN OF ls_input,
prompt TYPE string,
max_tokens_to_sample TYPE /aws1/rt_shape_integer,
temperature TYPE /aws1/rt_shape_float,
top_k TYPE /aws1/rt_shape_integer,
top_p TYPE /aws1/rt_shape_float,
stop_sequences TYPE /aws1/rt_stringtab,
END OF ls_input.
"Leave ls_input-stop_sequences empty.
ls_input-prompt = |\n\nHuman:\\n{ iv_prompt }\n\nAssistant:\n|.
ls_input-max_tokens_to_sample = 2048.
ls_input-temperature = '0.5'.
ls_input-top_k = 250.
ls_input-top_p = 1.
"Serialize into JSON with /ui2/cl_json -- this assumes SAP_UI is installed.
DATA(lv_json) = /ui2/cl_json=>serialize(
data = ls_input
pretty_name = /ui2/cl_json=>pretty_mode-low_case ).
TRY.
DATA(lo_response) = lo_bdr->invokemodel(
iv_body = /aws1/cl_rt_util=>string_to_xstring( lv_json )
iv_modelid = 'anthropic.claude-v2'
iv_accept = 'application/json'
iv_contenttype = 'application/json' ).
"Claude V2 Response format will be:
* {
* "completion": "Knock Knock...",
* "stop_reason": "stop_sequence"
* }
DATA: BEGIN OF ls_response,
completion TYPE string,
stop_reason TYPE string,
END OF ls_response.
/ui2/cl_json=>deserialize(
EXPORTING jsonx = lo_response->get_body( )
pretty_name = /ui2/cl_json=>pretty_mode-camel_case
CHANGING data = ls_response ).
DATA(lv_answer) = ls_response-completion.
CATCH /aws1/cx_bdraccessdeniedex INTO DATA(lo_ex).
WRITE / lo_ex->get_text( ).
WRITE / |Don't forget to enable model access at https://console.aws.amazon.com/bedrock/home?#/modelaccess|.
ENDTRY.
```
Invoke the Anthropic Claude 2 foundation model to generate text using L2 high level client.
```
TRY.
DATA(lo_bdr_l2_claude) = /aws1/cl_bdr_l2_factory=>create_claude_2( lo_bdr ).
" iv_prompt can contain a prompt like 'tell me a joke about Java programmers'.
DATA(lv_answer) = lo_bdr_l2_claude->prompt_for_text( iv_prompt ).
CATCH /aws1/cx_bdraccessdeniedex INTO DATA(lo_ex).
WRITE / lo_ex->get_text( ).
WRITE / |Don't forget to enable model access at https://console.aws.amazon.com/bedrock/home?#/modelaccess|.
ENDTRY.
```
Invoke the Anthropic Claude 3 foundation model to generate text using L2 high level client.
```
TRY.
" Choose a model ID from Anthropic that supports the Messages API - currently this is
" Claude v2, Claude v3 and v3.5. For the list of model ID, see:
" https://docs.aws.amazon.com/bedrock/latest/userguide/model-ids.html
" for the list of models that support the Messages API see:
" https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-anthropic-claude-messages.html
DATA(lo_bdr_l2_claude) = /aws1/cl_bdr_l2_factory=>create_anthropic_msg_api(
io_bdr = lo_bdr
iv_model_id = 'anthropic.claude-3-sonnet-20240229-v1:0' ). " choosing Claude v3 Sonnet
" iv_prompt can contain a prompt like 'tell me a joke about Java programmers'.
DATA(lv_answer) = lo_bdr_l2_claude->prompt_for_text( iv_prompt = iv_prompt
iv_max_tokens = 100 ).
CATCH /aws1/cx_bdraccessdeniedex INTO DATA(lo_ex).
WRITE / lo_ex->get_text( ).
WRITE / |Don't forget to enable model access at https://console.aws.amazon.com/bedrock/home?#/modelaccess|.
ENDTRY.
```
+ For API details, see [InvokeModel](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html) in *AWS SDK for SAP ABAP API reference*.
------
For a complete list of AWS SDK developer guides and code examples, see [Using Amazon Bedrock with an AWS SDK](sdk-general-information-section.md). This topic also includes information about getting started and details about previous SDK versions.
# Invoke Anthropic Claude models on Amazon Bedrock using the Invoke Model API with a response stream
The following code examples show how to send a text message to Anthropic Claude models, using the Invoke Model API, and print the response stream.
------
#### [ .NET ]
**SDK for .NET**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime#code-examples).
Use the Invoke Model API to send a text message and process the response stream in real-time.
```
// Use the native inference API to send a text message to Anthropic Claude
// and print the response stream.
using System;
using System.IO;
using System.Text.Json;
using System.Text.Json.Nodes;
using Amazon;
using Amazon.BedrockRuntime;
using Amazon.BedrockRuntime.Model;
// Create a Bedrock Runtime client in the AWS Region you want to use.
var client = new AmazonBedrockRuntimeClient(RegionEndpoint.USEast1);
// Set the model ID, e.g., Claude 3 Haiku.
var modelId = "anthropic.claude-3-haiku-20240307-v1:0";
// Define the user message.
var userMessage = "Describe the purpose of a 'hello world' program in one line.";
//Format the request payload using the model's native structure.
var nativeRequest = JsonSerializer.Serialize(new
{
anthropic_version = "bedrock-2023-05-31",
max_tokens = 512,
temperature = 0.5,
messages = new[]
{
new { role = "user", content = userMessage }
}
});
// Create a request with the model ID, the user message, and an inference configuration.
var request = new InvokeModelWithResponseStreamRequest()
{
ModelId = modelId,
Body = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(nativeRequest)),
ContentType = "application/json"
};
try
{
// Send the request to the Bedrock Runtime and wait for the response.
var streamingResponse = await client.InvokeModelWithResponseStreamAsync(request);
// Extract and print the streamed response text in real-time.
foreach (var item in streamingResponse.Body)
{
var chunk = JsonSerializer.Deserialize((item as PayloadPart).Bytes);
var text = chunk["delta"]?["text"] ?? "";
Console.Write(text);
}
}
catch (AmazonBedrockRuntimeException e)
{
Console.WriteLine($"ERROR: Can't invoke '{modelId}'. Reason: {e.Message}");
throw;
}
```
+ For API details, see [InvokeModelWithResponseStream](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/InvokeModelWithResponseStream) in *AWS SDK for .NET API Reference*.
------
#### [ Go ]
**SDK for Go V2**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/bedrock-runtime#code-examples).
Use the Invoke Model API to send a text message and process the response stream in real-time.
```
import (
"bytes"
"context"
"encoding/json"
"fmt"
"log"
"strings"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/bedrockruntime"
"github.com/aws/aws-sdk-go-v2/service/bedrockruntime/types"
)
// InvokeModelWithResponseStreamWrapper encapsulates Amazon Bedrock actions used in the examples.
// It contains a Bedrock Runtime client that is used to invoke foundation models.
type InvokeModelWithResponseStreamWrapper struct {
BedrockRuntimeClient *bedrockruntime.Client
}
// Each model provider defines their own individual request and response formats.
// For the format, ranges, and default values for the different models, refer to:
// https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters.html
type Request struct {
Prompt string `json:"prompt"`
MaxTokensToSample int `json:"max_tokens_to_sample"`
Temperature float64 `json:"temperature,omitempty"`
}
type Response struct {
Completion string `json:"completion"`
}
// Invokes Anthropic Claude on Amazon Bedrock to run an inference and asynchronously
// process the response stream.
func (wrapper InvokeModelWithResponseStreamWrapper) InvokeModelWithResponseStream(ctx context.Context, prompt string) (string, error) {
modelId := "anthropic.claude-v2"
// Anthropic Claude requires you to enclose the prompt as follows:
prefix := "Human: "
postfix := "\n\nAssistant:"
prompt = prefix + prompt + postfix
request := ClaudeRequest{
Prompt: prompt,
MaxTokensToSample: 200,
Temperature: 0.5,
StopSequences: []string{"\n\nHuman:"},
}
body, err := json.Marshal(request)
if err != nil {
log.Panicln("Couldn't marshal the request: ", err)
}
output, err := wrapper.BedrockRuntimeClient.InvokeModelWithResponseStream(ctx, &bedrockruntime.InvokeModelWithResponseStreamInput{
Body: body,
ModelId: aws.String(modelId),
ContentType: aws.String("application/json"),
})
if err != nil {
errMsg := err.Error()
if strings.Contains(errMsg, "no such host") {
log.Printf("The Bedrock service is not available in the selected region. Please double-check the service availability for your region at https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/.\n")
} else if strings.Contains(errMsg, "Could not resolve the foundation model") {
log.Printf("Could not resolve the foundation model from model identifier: \"%v\". Please verify that the requested model exists and is accessible within the specified region.\n", modelId)
} else {
log.Printf("Couldn't invoke Anthropic Claude. Here's why: %v\n", err)
}
}
resp, err := processStreamingOutput(ctx, output, func(ctx context.Context, part []byte) error {
fmt.Print(string(part))
return nil
})
if err != nil {
log.Fatal("streaming output processing error: ", err)
}
return resp.Completion, nil
}
type StreamingOutputHandler func(ctx context.Context, part []byte) error
func processStreamingOutput(ctx context.Context, output *bedrockruntime.InvokeModelWithResponseStreamOutput, handler StreamingOutputHandler) (Response, error) {
var combinedResult string
resp := Response{}
for event := range output.GetStream().Events() {
switch v := event.(type) {
case *types.ResponseStreamMemberChunk:
//fmt.Println("payload", string(v.Value.Bytes))
var resp Response
err := json.NewDecoder(bytes.NewReader(v.Value.Bytes)).Decode(&resp)
if err != nil {
return resp, err
}
err = handler(ctx, []byte(resp.Completion))
if err != nil {
return resp, err
}
combinedResult += resp.Completion
case *types.UnknownUnionMember:
fmt.Println("unknown tag:", v.Tag)
default:
fmt.Println("union is nil or unknown type")
}
}
resp.Completion = combinedResult
return resp, nil
}
```
+ For API details, see [InvokeModelWithResponseStream](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/bedrockruntime#Client.InvokeModelWithResponseStream) in *AWS SDK for Go API Reference*.
------
#### [ Java ]
**SDK for Java 2.x**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Use the Invoke Model API to send a text message and process the response stream in real-time.
```
// Use the native inference API to send a text message to Anthropic Claude
// and print the response stream.
import org.json.JSONObject;
import org.json.JSONPointer;
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.core.SdkBytes;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.bedrockruntime.BedrockRuntimeAsyncClient;
import software.amazon.awssdk.services.bedrockruntime.model.InvokeModelWithResponseStreamRequest;
import software.amazon.awssdk.services.bedrockruntime.model.InvokeModelWithResponseStreamResponseHandler;
import java.util.Objects;
import java.util.concurrent.ExecutionException;
import static software.amazon.awssdk.services.bedrockruntime.model.InvokeModelWithResponseStreamResponseHandler.Visitor;
public class InvokeModelWithResponseStream {
public static String invokeModelWithResponseStream() {
// Create a Bedrock Runtime client in the AWS Region you want to use.
// Replace the DefaultCredentialsProvider with your preferred credentials provider.
var client = BedrockRuntimeAsyncClient.builder()
.credentialsProvider(DefaultCredentialsProvider.create())
.region(Region.US_EAST_1)
.build();
// Set the model ID, e.g., Claude 3 Haiku.
var modelId = "anthropic.claude-3-haiku-20240307-v1:0";
// The InvokeModelWithResponseStream API uses the model's native payload.
// Learn more about the available inference parameters and response fields at:
// https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-anthropic-claude-messages.html
var nativeRequestTemplate = """
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 512,
"temperature": 0.5,
"messages": [{
"role": "user",
"content": "{{prompt}}"
}]
}""";
// Define the prompt for the model.
var prompt = "Describe the purpose of a 'hello world' program in one line.";
// Embed the prompt in the model's native request payload.
String nativeRequest = nativeRequestTemplate.replace("{{prompt}}", prompt);
// Create a request with the model ID and the model's native request payload.
var request = InvokeModelWithResponseStreamRequest.builder()
.body(SdkBytes.fromUtf8String(nativeRequest))
.modelId(modelId)
.build();
// Prepare a buffer to accumulate the generated response text.
var completeResponseTextBuffer = new StringBuilder();
// Prepare a handler to extract, accumulate, and print the response text in real-time.
var responseStreamHandler = InvokeModelWithResponseStreamResponseHandler.builder()
.subscriber(Visitor.builder().onChunk(chunk -> {
var response = new JSONObject(chunk.bytes().asUtf8String());
// Extract and print the text from the content blocks.
if (Objects.equals(response.getString("type"), "content_block_delta")) {
var text = new JSONPointer("/delta/text").queryFrom(response);
System.out.print(text);
// Append the text to the response text buffer.
completeResponseTextBuffer.append(text);
}
}).build()).build();
try {
// Send the request and wait for the handler to process the response.
client.invokeModelWithResponseStream(request, responseStreamHandler).get();
// Return the complete response text.
return completeResponseTextBuffer.toString();
} catch (ExecutionException | InterruptedException e) {
System.err.printf("Can't invoke '%s': %s", modelId, e.getCause().getMessage());
throw new RuntimeException(e);
}
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
invokeModelWithResponseStream();
}
}
```
+ For API details, see [InvokeModelWithResponseStream](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModelWithResponseStream) in *AWS SDK for Java 2.x API Reference*.
------
#### [ JavaScript ]
**SDK for JavaScript (v3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Use the Invoke Model API to send a text message and process the response stream in real-time.
```
import { fileURLToPath } from "node:url";
import { FoundationModels } from "../../config/foundation_models.js";
import {
BedrockRuntimeClient,
InvokeModelCommand,
InvokeModelWithResponseStreamCommand,
} from "@aws-sdk/client-bedrock-runtime";
/**
* @typedef {Object} ResponseContent
* @property {string} text
*
* @typedef {Object} MessagesResponseBody
* @property {ResponseContent[]} content
*
* @typedef {Object} Delta
* @property {string} text
*
* @typedef {Object} Message
* @property {string} role
*
* @typedef {Object} Chunk
* @property {string} type
* @property {Delta} delta
* @property {Message} message
*/
/**
* Invokes Anthropic Claude 3 using the Messages API.
*
* To learn more about the Anthropic Messages API, go to:
* https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-anthropic-claude-messages.html
*
* @param {string} prompt - The input text prompt for the model to complete.
* @param {string} [modelId] - The ID of the model to use. Defaults to "anthropic.claude-3-haiku-20240307-v1:0".
*/
export const invokeModel = async (
prompt,
modelId = "anthropic.claude-3-haiku-20240307-v1:0",
) => {
// Create a new Bedrock Runtime client instance.
const client = new BedrockRuntimeClient({ region: "us-east-1" });
// Prepare the payload for the model.
const payload = {
anthropic_version: "bedrock-2023-05-31",
max_tokens: 1000,
messages: [
{
role: "user",
content: [{ type: "text", text: prompt }],
},
],
};
// Invoke Claude with the payload and wait for the response.
const command = new InvokeModelCommand({
contentType: "application/json",
body: JSON.stringify(payload),
modelId,
});
const apiResponse = await client.send(command);
// Decode and return the response(s)
const decodedResponseBody = new TextDecoder().decode(apiResponse.body);
/** @type {MessagesResponseBody} */
const responseBody = JSON.parse(decodedResponseBody);
return responseBody.content[0].text;
};
/**
* Invokes Anthropic Claude 3 and processes the response stream.
*
* To learn more about the Anthropic Messages API, go to:
* https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-anthropic-claude-messages.html
*
* @param {string} prompt - The input text prompt for the model to complete.
* @param {string} [modelId] - The ID of the model to use. Defaults to "anthropic.claude-3-haiku-20240307-v1:0".
*/
export const invokeModelWithResponseStream = async (
prompt,
modelId = "anthropic.claude-3-haiku-20240307-v1:0",
) => {
// Create a new Bedrock Runtime client instance.
const client = new BedrockRuntimeClient({ region: "us-east-1" });
// Prepare the payload for the model.
const payload = {
anthropic_version: "bedrock-2023-05-31",
max_tokens: 1000,
messages: [
{
role: "user",
content: [{ type: "text", text: prompt }],
},
],
};
// Invoke Claude with the payload and wait for the API to respond.
const command = new InvokeModelWithResponseStreamCommand({
contentType: "application/json",
body: JSON.stringify(payload),
modelId,
});
const apiResponse = await client.send(command);
let completeMessage = "";
// Decode and process the response stream
for await (const item of apiResponse.body) {
/** @type Chunk */
const chunk = JSON.parse(new TextDecoder().decode(item.chunk.bytes));
const chunk_type = chunk.type;
if (chunk_type === "content_block_delta") {
const text = chunk.delta.text;
completeMessage = completeMessage + text;
process.stdout.write(text);
}
}
// Return the final response
return completeMessage;
};
// Invoke the function if this file was run directly.
if (process.argv[1] === fileURLToPath(import.meta.url)) {
const prompt = 'Write a paragraph starting with: "Once upon a time..."';
const modelId = FoundationModels.CLAUDE_3_HAIKU.modelId;
console.log(`Prompt: ${prompt}`);
console.log(`Model ID: ${modelId}`);
try {
console.log("-".repeat(53));
const response = await invokeModel(prompt, modelId);
console.log(`\n${"-".repeat(53)}`);
console.log("Final structured response:");
console.log(response);
} catch (err) {
console.log(`\n${err}`);
}
}
```
+ For API details, see [InvokeModelWithResponseStream](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/InvokeModelWithResponseStreamCommand) in *AWS SDK for JavaScript API Reference*.
------
#### [ Python ]
**SDK for Python (Boto3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Use the Invoke Model API to send a text message and process the response stream in real-time.
```
# Use the native inference API to send a text message to Anthropic Claude
# and print the response stream.
import boto3
import json
# Create a Bedrock Runtime client in the AWS Region of your choice.
client = boto3.client("bedrock-runtime", region_name="us-east-1")
# Set the model ID, e.g., Claude 3 Haiku.
model_id = "anthropic.claude-3-haiku-20240307-v1:0"
# Define the prompt for the model.
prompt = "Describe the purpose of a 'hello world' program in one line."
# Format the request payload using the model's native structure.
native_request = {
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 512,
"temperature": 0.5,
"messages": [
{
"role": "user",
"content": [{"type": "text", "text": prompt}],
}
],
}
# Convert the native request to JSON.
request = json.dumps(native_request)
# Invoke the model with the request.
streaming_response = client.invoke_model_with_response_stream(
modelId=model_id, body=request
)
# Extract and print the response text in real-time.
for event in streaming_response["body"]:
chunk = json.loads(event["chunk"]["bytes"])
if chunk["type"] == "content_block_delta":
print(chunk["delta"].get("text", ""), end="")
```
+ For API details, see [InvokeModelWithResponseStream](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModelWithResponseStream) in *AWS SDK for Python (Boto3) API Reference*.
------
For a complete list of AWS SDK developer guides and code examples, see [Using Amazon Bedrock with an AWS SDK](sdk-general-information-section.md). This topic also includes information about getting started and details about previous SDK versions.
# Use Anthropic Claude 3.7 Sonnet's reasoning capability on Amazon Bedrock
The following code example shows how to use Anthropic Claude 3.7 Sonnet's reasoning capability on Amazon Bedrock
------
#### [ Java ]
**SDK for Java 2.x**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Use Anthropic Claude 3.7 Sonnet's reasoning capability with the asynchronous Bedrock runtime client.
```
import com.example.bedrockruntime.models.anthropicClaude.lib.ReasoningResponse;
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.core.document.Document;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.bedrockruntime.BedrockRuntimeAsyncClient;
import software.amazon.awssdk.services.bedrockruntime.model.*;
import java.util.concurrent.CompletableFuture;
/**
* This example demonstrates how to use Anthropic Claude 3.7 Sonnet's reasoning capability
* with an asynchronous Amazon Bedrock runtime client.
* It shows how to:
* - Set up the Amazon Bedrock async runtime client
* - Create a message
* - Configure reasoning parameters
* - Send an asynchronous request with reasoning enabled
* - Process both the reasoning output and final response
*/
public class ReasoningAsync {
public static ReasoningResponse reasoningAsync() {
// Create the Amazon Bedrock runtime client
var client = BedrockRuntimeAsyncClient.builder()
.credentialsProvider(DefaultCredentialsProvider.create())
.region(Region.US_EAST_1)
.build();
// Specify the model ID. For the latest available models, see:
// https://docs.aws.amazon.com/bedrock/latest/userguide/models-supported.html
var modelId = "us.anthropic.claude-3-7-sonnet-20250219-v1:0";
// Create the message with the user's prompt
var prompt = "Describe the purpose of a 'hello world' program in one line.";
var message = Message.builder()
.content(ContentBlock.fromText(prompt))
.role(ConversationRole.USER)
.build();
// Configure reasoning parameters with a 2000 token budget
Document reasoningConfig = Document.mapBuilder()
.putDocument("thinking", Document.mapBuilder()
.putString("type", "enabled")
.putNumber("budget_tokens", 2000)
.build())
.build();
try {
// Send message and reasoning configuration to the model
CompletableFuture asyncResponse = client.converse(request -> request
.additionalModelRequestFields(reasoningConfig)
.messages(message)
.modelId(modelId)
);
// Process the response asynchronously
return asyncResponse.thenApply(response -> {
var content = response.output().message().content();
ReasoningContentBlock reasoning = null;
String text = null;
// Process each content block to find reasoning and response text
for (ContentBlock block : content) {
if (block.reasoningContent() != null) {
reasoning = block.reasoningContent();
} else if (block.text() != null) {
text = block.text();
}
}
return new ReasoningResponse(reasoning, text);
}
).get();
} catch (Exception e) {
System.err.printf("Can't invoke '%s': %s", modelId, e.getMessage());
throw new RuntimeException(e);
}
}
public static void main(String[] args) {
// Execute the example and display reasoning and final response
ReasoningResponse response = reasoningAsync();
System.out.println("\n");
System.out.println(response.reasoning().reasoningText());
System.out.println("\n");
System.out.println(response.text());
}
}
```
Use Anthropic Claude 3.7 Sonnet's reasoning capability with the synchronous Bedrock runtime client.
```
import com.example.bedrockruntime.models.anthropicClaude.lib.ReasoningResponse;
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.core.document.Document;
import software.amazon.awssdk.core.exception.SdkClientException;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.bedrockruntime.BedrockRuntimeClient;
import software.amazon.awssdk.services.bedrockruntime.model.*;
/**
* This example demonstrates how to use Anthropic Claude 3.7 Sonnet's reasoning capability
* with the synchronous Amazon Bedrock runtime client.
* 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
*/
public class Reasoning {
public static ReasoningResponse reasoning() {
// Create the Amazon Bedrock runtime client
var client = BedrockRuntimeClient.builder()
.credentialsProvider(DefaultCredentialsProvider.create())
.region(Region.US_EAST_1)
.build();
// Specify the model ID. For the latest available models, see:
// https://docs.aws.amazon.com/bedrock/latest/userguide/models-supported.html
var modelId = "us.anthropic.claude-3-7-sonnet-20250219-v1:0";
// Create the message with the user's prompt
var prompt = "Describe the purpose of a 'hello world' program in one line.";
var message = Message.builder()
.content(ContentBlock.fromText(prompt))
.role(ConversationRole.USER)
.build();
// Configure reasoning parameters with a 2000 token budget
Document reasoningConfig = Document.mapBuilder()
.putDocument("thinking", Document.mapBuilder()
.putString("type", "enabled")
.putNumber("budget_tokens", 2000)
.build())
.build();
try {
// Send message and reasoning configuration to the model
ConverseResponse bedrockResponse = client.converse(request -> request
.additionalModelRequestFields(reasoningConfig)
.messages(message)
.modelId(modelId)
);
// Extract both reasoning and final response
var content = bedrockResponse.output().message().content();
ReasoningContentBlock reasoning = null;
String text = null;
// Process each content block to find reasoning and response text
for (ContentBlock block : content) {
if (block.reasoningContent() != null) {
reasoning = block.reasoningContent();
} else if (block.text() != null) {
text = block.text();
}
}
return new ReasoningResponse(reasoning, text);
} catch (SdkClientException e) {
System.err.printf("ERROR: Can't invoke '%s'. Reason: %s", modelId, e.getMessage());
throw new RuntimeException(e);
}
}
public static void main(String[] args) {
// Execute the example and display reasoning and final response
ReasoningResponse response = reasoning();
System.out.println("\n");
System.out.println(response.reasoning().reasoningText());
System.out.println("\n");
System.out.println(response.text());
}
}
```
+ For API details, see [Converse](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/Converse) in *AWS SDK for Java 2.x API Reference*.
------
For a complete list of AWS SDK developer guides and code examples, see [Using Amazon Bedrock with an AWS SDK](sdk-general-information-section.md). This topic also includes information about getting started and details about previous SDK versions.
# Use Anthropic Claude 3.7 Sonnet's reasoning capability on Amazon Bedrock
The following code example shows how to use Anthropic Claude 3.7 Sonnet's reasoning capability on Amazon Bedrock
------
#### [ Java ]
**SDK for Java 2.x**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Use Anthropic Claude 3.7 Sonnet's reasoning capability to generate streaming text responses.
```
import com.example.bedrockruntime.models.anthropicClaude.lib.ReasoningResponse;
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.core.document.Document;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.bedrockruntime.BedrockRuntimeAsyncClient;
import software.amazon.awssdk.services.bedrockruntime.model.*;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.atomic.AtomicReference;
/**
* This example demonstrates how to use Anthropic Claude 3.7 Sonnet's reasoning
* capability to generate streaming text responses.
* It shows how to:
* - Set up the Amazon Bedrock runtime client
* - Create a message
* - Configure a streaming request
* - Set up a stream handler to process the response chunks
* - Process the streaming response
*/
public class ReasoningStream {
public static ReasoningResponse reasoningStream() {
// Create the Amazon Bedrock runtime client
var client = BedrockRuntimeAsyncClient.builder()
.credentialsProvider(DefaultCredentialsProvider.create())
.region(Region.US_EAST_1)
.build();
// Specify the model ID. For the latest available models, see:
// https://docs.aws.amazon.com/bedrock/latest/userguide/models-supported.html
var modelId = "us.anthropic.claude-3-7-sonnet-20250219-v1:0";
// Create the message with the user's prompt
var prompt = "Describe the purpose of a 'hello world' program in one line.";
var message = Message.builder()
.content(ContentBlock.fromText(prompt))
.role(ConversationRole.USER)
.build();
// Configure reasoning parameters with a 2000 token budget
Document reasoningConfig = Document.mapBuilder()
.putDocument("thinking", Document.mapBuilder()
.putString("type", "enabled")
.putNumber("budget_tokens", 2000)
.build())
.build();
// Configure the request with the message, model ID, and reasoning config
ConverseStreamRequest request = ConverseStreamRequest.builder()
.additionalModelRequestFields(reasoningConfig)
.messages(message)
.modelId(modelId)
.build();
StringBuilder reasoning = new StringBuilder();
StringBuilder text = new StringBuilder();
AtomicReference finalresponse = new AtomicReference<>();
// Set up the stream handler to processes chunks of the response as they arrive
var streamHandler = ConverseStreamResponseHandler.builder()
.subscriber(ConverseStreamResponseHandler.Visitor.builder()
.onContentBlockDelta(chunk -> {
ContentBlockDelta delta = chunk.delta();
if (delta.reasoningContent() != null) {
if (reasoning.isEmpty()) {
System.out.println("\n");
}
if (delta.reasoningContent().text() != null) {
System.out.print(delta.reasoningContent().text());
reasoning.append(delta.reasoningContent().text());
}
} else if (delta.text() != null) {
if (text.isEmpty()) {
System.out.println("\n\n");
}
System.out.print(delta.text());
text.append(delta.text());
}
System.out.flush(); // Ensure immediate output of each chunk
}).build())
.onComplete(() -> finalresponse.set(new ReasoningResponse(
ReasoningContentBlock.fromReasoningText(t -> t.text(reasoning.toString())),
text.toString()
)))
.onError(err -> System.err.printf("Can't invoke '%s': %s", modelId, err.getMessage()))
.build();
// Step 6: Send the streaming request and process the response
// - Send the request to the model
// - Attach the handler to process response chunks as they arrive
// - Handle any errors during streaming
try {
client.converseStream(request, streamHandler).get();
return finalresponse.get();
} catch (ExecutionException | InterruptedException e) {
System.err.printf("Can't invoke '%s': %s", modelId, e.getCause().getMessage());
throw new RuntimeException(e);
} catch (Exception e) {
System.err.printf("Can't invoke '%s': %s", modelId, e.getMessage());
throw new RuntimeException(e);
}
}
public static void main(String[] args) {
reasoningStream();
}
}
```
+ For API details, see [Converse](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/Converse) in *AWS SDK for Java 2.x API Reference*.
------
For a complete list of AWS SDK developer guides and code examples, see [Using Amazon Bedrock with an AWS SDK](sdk-general-information-section.md). This topic also includes information about getting started and details about previous SDK versions.
# A tool use demo illustrating how to connect AI models on Amazon Bedrock with a custom tool or API
The following code examples show how to build a typical interaction between an application, a generative AI model, and connected tools or APIs to mediate interactions between the AI and the outside world. It uses the example of connecting an external weather API to the AI model so it can provide real-time weather information based on user input.
------
#### [ Python ]
**SDK for Python (Boto3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
The primary execution script of the demo. This script orchestrates the conversation between the user, the Amazon Bedrock Converse API, and a weather tool.
```
"""
This demo illustrates a tool use scenario using Amazon Bedrock's Converse API and a weather tool.
The script interacts with a foundation model on Amazon Bedrock to provide weather information based on user
input. It uses the Open-Meteo API (https://open-meteo.com) to retrieve current weather data for a given location.
"""
import boto3
import logging
from enum import Enum
import utils.tool_use_print_utils as output
import weather_tool
logging.basicConfig(level=logging.INFO, format="%(message)s")
AWS_REGION = "us-east-1"
# For the most recent list of models supported by the Converse API's tool use functionality, visit:
# https://docs.aws.amazon.com/bedrock/latest/userguide/conversation-inference.html
class SupportedModels(Enum):
CLAUDE_OPUS = "anthropic.claude-3-opus-20240229-v1:0"
CLAUDE_SONNET = "anthropic.claude-3-sonnet-20240229-v1:0"
CLAUDE_HAIKU = "anthropic.claude-3-haiku-20240307-v1:0"
COHERE_COMMAND_R = "cohere.command-r-v1:0"
COHERE_COMMAND_R_PLUS = "cohere.command-r-plus-v1:0"
# Set the model ID, e.g., Claude 3 Haiku.
MODEL_ID = SupportedModels.CLAUDE_HAIKU.value
SYSTEM_PROMPT = """
You are a weather assistant that provides current weather data for user-specified locations using only
the Weather_Tool, which expects latitude and longitude. Infer the coordinates from the location yourself.
If the user provides coordinates, infer the approximate location and refer to it in your response.
To use the tool, you strictly apply the provided tool specification.
- Explain your step-by-step process, and give brief updates before each step.
- Only use the Weather_Tool for data. Never guess or make up information.
- Repeat the tool use for subsequent requests if necessary.
- If the tool errors, apologize, explain weather is unavailable, and suggest other options.
- Report temperatures in °C (°F) and wind in km/h (mph). Keep weather reports concise. Sparingly use
emojis where appropriate.
- Only respond to weather queries. Remind off-topic users of your purpose.
- Never claim to search online, access external data, or use tools besides Weather_Tool.
- Complete the entire process until you have all required data before sending the complete response.
"""
# The maximum number of recursive calls allowed in the tool_use_demo function.
# This helps prevent infinite loops and potential performance issues.
MAX_RECURSIONS = 5
class ToolUseDemo:
"""
Demonstrates the tool use feature with the Amazon Bedrock Converse API.
"""
def __init__(self):
# Prepare the system prompt
self.system_prompt = [{"text": SYSTEM_PROMPT}]
# Prepare the tool configuration with the weather tool's specification
self.tool_config = {"tools": [weather_tool.get_tool_spec()]}
# Create a Bedrock Runtime client in the specified AWS Region.
self.bedrockRuntimeClient = boto3.client(
"bedrock-runtime", region_name=AWS_REGION
)
def run(self):
"""
Starts the conversation with the user and handles the interaction with Bedrock.
"""
# Print the greeting and a short user guide
output.header()
# Start with an emtpy conversation
conversation = []
# Get the first user input
user_input = self._get_user_input()
while user_input is not None:
# Create a new message with the user input and append it to the conversation
message = {"role": "user", "content": [{"text": user_input}]}
conversation.append(message)
# Send the conversation to Amazon Bedrock
bedrock_response = self._send_conversation_to_bedrock(conversation)
# Recursively handle the model's response until the model has returned
# its final response or the recursion counter has reached 0
self._process_model_response(
bedrock_response, conversation, max_recursion=MAX_RECURSIONS
)
# Repeat the loop until the user decides to exit the application
user_input = self._get_user_input()
output.footer()
def _send_conversation_to_bedrock(self, conversation):
"""
Sends the conversation, the system prompt, and the tool spec to Amazon Bedrock, and returns the response.
:param conversation: The conversation history including the next message to send.
:return: The response from Amazon Bedrock.
"""
output.call_to_bedrock(conversation)
# Send the conversation, system prompt, and tool configuration, and return the response
return self.bedrockRuntimeClient.converse(
modelId=MODEL_ID,
messages=conversation,
system=self.system_prompt,
toolConfig=self.tool_config,
)
def _process_model_response(
self, model_response, conversation, max_recursion=MAX_RECURSIONS
):
"""
Processes the response received via Amazon Bedrock and performs the necessary actions
based on the stop reason.
:param model_response: The model's response returned via Amazon Bedrock.
:param conversation: The conversation history.
:param max_recursion: The maximum number of recursive calls allowed.
"""
if max_recursion <= 0:
# Stop the process, the number of recursive calls could indicate an infinite loop
logging.warning(
"Warning: Maximum number of recursions reached. Please try again."
)
exit(1)
# Append the model's response to the ongoing conversation
message = model_response["output"]["message"]
conversation.append(message)
if model_response["stopReason"] == "tool_use":
# If the stop reason is "tool_use", forward everything to the tool use handler
self._handle_tool_use(message, conversation, max_recursion)
if model_response["stopReason"] == "end_turn":
# If the stop reason is "end_turn", print the model's response text, and finish the process
output.model_response(message["content"][0]["text"])
return
def _handle_tool_use(
self, model_response, conversation, max_recursion=MAX_RECURSIONS
):
"""
Handles the tool use case by invoking the specified tool and sending the tool's response back to Bedrock.
The tool response is appended to the conversation, and the conversation is sent back to Amazon Bedrock for further processing.
:param model_response: The model's response containing the tool use request.
:param conversation: The conversation history.
:param max_recursion: The maximum number of recursive calls allowed.
"""
# Initialize an empty list of tool results
tool_results = []
# The model's response can consist of multiple content blocks
for content_block in model_response["content"]:
if "text" in content_block:
# If the content block contains text, print it to the console
output.model_response(content_block["text"])
if "toolUse" in content_block:
# If the content block is a tool use request, forward it to the tool
tool_response = self._invoke_tool(content_block["toolUse"])
# Add the tool use ID and the tool's response to the list of results
tool_results.append(
{
"toolResult": {
"toolUseId": (tool_response["toolUseId"]),
"content": [{"json": tool_response["content"]}],
}
}
)
# Embed the tool results in a new user message
message = {"role": "user", "content": tool_results}
# Append the new message to the ongoing conversation
conversation.append(message)
# Send the conversation to Amazon Bedrock
response = self._send_conversation_to_bedrock(conversation)
# Recursively handle the model's response until the model has returned
# its final response or the recursion counter has reached 0
self._process_model_response(response, conversation, max_recursion - 1)
def _invoke_tool(self, payload):
"""
Invokes the specified tool with the given payload and returns the tool's response.
If the requested tool does not exist, an error message is returned.
:param payload: The payload containing the tool name and input data.
:return: The tool's response or an error message.
"""
tool_name = payload["name"]
if tool_name == "Weather_Tool":
input_data = payload["input"]
output.tool_use(tool_name, input_data)
# Invoke the weather tool with the input data provided by
response = weather_tool.fetch_weather_data(input_data)
else:
error_message = (
f"The requested tool with name '{tool_name}' does not exist."
)
response = {"error": "true", "message": error_message}
return {"toolUseId": payload["toolUseId"], "content": response}
@staticmethod
def _get_user_input(prompt="Your weather info request"):
"""
Prompts the user for input and returns the user's response.
Returns None if the user enters 'x' to exit.
:param prompt: The prompt to display to the user.
:return: The user's input or None if the user chooses to exit.
"""
output.separator()
user_input = input(f"{prompt} (x to exit): ")
if user_input == "":
prompt = "Please enter your weather info request, e.g. the name of a city"
return ToolUseDemo._get_user_input(prompt)
elif user_input.lower() == "x":
return None
else:
return user_input
if __name__ == "__main__":
tool_use_demo = ToolUseDemo()
tool_use_demo.run()
```
The weather tool used by the demo. This script defines the tool specification and implements the logic to retrieve weather data using from the Open-Meteo API.
```
import requests
from requests.exceptions import RequestException
def get_tool_spec():
"""
Returns the JSON Schema specification for the Weather tool. The tool specification
defines the input schema and describes the tool's functionality.
For more information, see https://json-schema.org/understanding-json-schema/reference.
:return: The tool specification for the Weather tool.
"""
return {
"toolSpec": {
"name": "Weather_Tool",
"description": "Get the current weather for a given location, based on its WGS84 coordinates.",
"inputSchema": {
"json": {
"type": "object",
"properties": {
"latitude": {
"type": "string",
"description": "Geographical WGS84 latitude of the location.",
},
"longitude": {
"type": "string",
"description": "Geographical WGS84 longitude of the location.",
},
},
"required": ["latitude", "longitude"],
}
},
}
}
def fetch_weather_data(input_data):
"""
Fetches weather data for the given latitude and longitude using the Open-Meteo API.
Returns the weather data or an error message if the request fails.
:param input_data: The input data containing the latitude and longitude.
:return: The weather data or an error message.
"""
endpoint = "https://api.open-meteo.com/v1/forecast"
latitude = input_data.get("latitude")
longitude = input_data.get("longitude", "")
params = {"latitude": latitude, "longitude": longitude, "current_weather": True}
try:
response = requests.get(endpoint, params=params)
weather_data = {"weather_data": response.json()}
response.raise_for_status()
return weather_data
except RequestException as e:
return e.response.json()
except Exception as e:
return {"error": type(e), "message": str(e)}
```
+ For API details, see [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) in *AWS SDK for Python (Boto3) API Reference*.
------
#### [ Rust ]
**SDK for Rust**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/bedrock-runtime#code-examples).
The primary scenario and logic for the demo. This orchestrates the conversation between the user, the Amazon Bedrock Converse API, and a weather tool.
```
#[derive(Debug)]
#[allow(dead_code)]
struct InvokeToolResult(String, ToolResultBlock);
struct ToolUseScenario {
client: Client,
conversation: Vec,
system_prompt: SystemContentBlock,
tool_config: ToolConfiguration,
}
impl ToolUseScenario {
fn new(client: Client) -> Self {
let system_prompt = SystemContentBlock::Text(SYSTEM_PROMPT.into());
let tool_config = ToolConfiguration::builder()
.tools(Tool::ToolSpec(
ToolSpecification::builder()
.name(TOOL_NAME)
.description(TOOL_DESCRIPTION)
.input_schema(ToolInputSchema::Json(make_tool_schema()))
.build()
.unwrap(),
))
.build()
.unwrap();
ToolUseScenario {
client,
conversation: vec![],
system_prompt,
tool_config,
}
}
async fn run(&mut self) -> Result<(), ToolUseScenarioError> {
loop {
let input = get_input().await?;
if input.is_none() {
break;
}
let message = Message::builder()
.role(User)
.content(ContentBlock::Text(input.unwrap()))
.build()
.map_err(ToolUseScenarioError::from)?;
self.conversation.push(message);
let response = self.send_to_bedrock().await?;
self.process_model_response(response).await?;
}
Ok(())
}
async fn send_to_bedrock(&mut self) -> Result {
debug!("Sending conversation to bedrock");
self.client
.converse()
.model_id(MODEL_ID)
.set_messages(Some(self.conversation.clone()))
.system(self.system_prompt.clone())
.tool_config(self.tool_config.clone())
.send()
.await
.map_err(ToolUseScenarioError::from)
}
async fn process_model_response(
&mut self,
mut response: ConverseOutput,
) -> Result<(), ToolUseScenarioError> {
let mut iteration = 0;
while iteration < MAX_RECURSIONS {
iteration += 1;
let message = if let Some(ref output) = response.output {
if output.is_message() {
Ok(output.as_message().unwrap().clone())
} else {
Err(ToolUseScenarioError(
"Converse Output is not a message".into(),
))
}
} else {
Err(ToolUseScenarioError("Missing Converse Output".into()))
}?;
self.conversation.push(message.clone());
match response.stop_reason {
StopReason::ToolUse => {
response = self.handle_tool_use(&message).await?;
}
StopReason::EndTurn => {
print_model_response(&message.content[0])?;
return Ok(());
}
_ => (),
}
}
Err(ToolUseScenarioError(
"Exceeded MAX_ITERATIONS when calling tools".into(),
))
}
async fn handle_tool_use(
&mut self,
message: &Message,
) -> Result {
let mut tool_results: Vec = vec![];
for block in &message.content {
match block {
ContentBlock::Text(_) => print_model_response(block)?,
ContentBlock::ToolUse(tool) => {
let tool_response = self.invoke_tool(tool).await?;
tool_results.push(ContentBlock::ToolResult(tool_response.1));
}
_ => (),
};
}
let message = Message::builder()
.role(User)
.set_content(Some(tool_results))
.build()?;
self.conversation.push(message);
self.send_to_bedrock().await
}
async fn invoke_tool(
&mut self,
tool: &ToolUseBlock,
) -> Result {
match tool.name() {
TOOL_NAME => {
println!(
"\x1b[0;90mExecuting tool: {TOOL_NAME} with input: {:?}...\x1b[0m",
tool.input()
);
let content = fetch_weather_data(tool).await?;
println!(
"\x1b[0;90mTool responded with {:?}\x1b[0m",
content.content()
);
Ok(InvokeToolResult(tool.tool_use_id.clone(), content))
}
_ => Err(ToolUseScenarioError(format!(
"The requested tool with name {} does not exist",
tool.name()
))),
}
}
}
#[tokio::main]
async fn main() {
tracing_subscriber::fmt::init();
let sdk_config = aws_config::defaults(BehaviorVersion::latest())
.region(CLAUDE_REGION)
.load()
.await;
let client = Client::new(&sdk_config);
let mut scenario = ToolUseScenario::new(client);
header();
if let Err(err) = scenario.run().await {
println!("There was an error running the scenario! {}", err.0)
}
footer();
}
```
The weather tool used by the demo. This script defines the tool specification and implements the logic to retrieve weather data using from the Open-Meteo API.
```
const ENDPOINT: &str = "https://api.open-meteo.com/v1/forecast";
async fn fetch_weather_data(
tool_use: &ToolUseBlock,
) -> Result {
let input = tool_use.input();
let latitude = input
.as_object()
.unwrap()
.get("latitude")
.unwrap()
.as_string()
.unwrap();
let longitude = input
.as_object()
.unwrap()
.get("longitude")
.unwrap()
.as_string()
.unwrap();
let params = [
("latitude", latitude),
("longitude", longitude),
("current_weather", "true"),
];
debug!("Calling {ENDPOINT} with {params:?}");
let response = reqwest::Client::new()
.get(ENDPOINT)
.query(¶ms)
.send()
.await
.map_err(|e| ToolUseScenarioError(format!("Error requesting weather: {e:?}")))?
.error_for_status()
.map_err(|e| ToolUseScenarioError(format!("Failed to request weather: {e:?}")))?;
debug!("Response: {response:?}");
let bytes = response
.bytes()
.await
.map_err(|e| ToolUseScenarioError(format!("Error reading response: {e:?}")))?;
let result = String::from_utf8(bytes.to_vec())
.map_err(|_| ToolUseScenarioError("Response was not utf8".into()))?;
Ok(ToolResultBlock::builder()
.tool_use_id(tool_use.tool_use_id())
.content(ToolResultContentBlock::Text(result))
.build()?)
}
```
Utilities to print the Message Content Blocks.
```
fn print_model_response(block: &ContentBlock) -> Result<(), ToolUseScenarioError> {
if block.is_text() {
let text = block.as_text().unwrap();
println!("\x1b[0;90mThe model's response:\x1b[0m\n{text}");
Ok(())
} else {
Err(ToolUseScenarioError(format!(
"Content block is not text ({block:?})"
)))
}
}
```
Use statements, Error utility, and constants.
```
use std::{collections::HashMap, io::stdin};
use aws_config::BehaviorVersion;
use aws_sdk_bedrockruntime::{
error::{BuildError, SdkError},
operation::converse::{ConverseError, ConverseOutput},
types::{
ContentBlock, ConversationRole::User, Message, StopReason, SystemContentBlock, Tool,
ToolConfiguration, ToolInputSchema, ToolResultBlock, ToolResultContentBlock,
ToolSpecification, ToolUseBlock,
},
Client,
};
use aws_smithy_runtime_api::http::Response;
use aws_smithy_types::Document;
use tracing::debug;
// Set the model ID, e.g., Claude 3 Haiku.
const MODEL_ID: &str = "anthropic.claude-3-haiku-20240307-v1:0";
const CLAUDE_REGION: &str = "us-east-1";
const SYSTEM_PROMPT: &str = "You are a weather assistant that provides current weather data for user-specified locations using only
the Weather_Tool, which expects latitude and longitude. Infer the coordinates from the location yourself.
If the user provides coordinates, infer the approximate location and refer to it in your response.
To use the tool, you strictly apply the provided tool specification.
- Explain your step-by-step process, and give brief updates before each step.
- Only use the Weather_Tool for data. Never guess or make up information.
- Repeat the tool use for subsequent requests if necessary.
- If the tool errors, apologize, explain weather is unavailable, and suggest other options.
- Report temperatures in °C (°F) and wind in km/h (mph). Keep weather reports concise. Sparingly use
emojis where appropriate.
- Only respond to weather queries. Remind off-topic users of your purpose.
- Never claim to search online, access external data, or use tools besides Weather_Tool.
- Complete the entire process until you have all required data before sending the complete response.
";
// The maximum number of recursive calls allowed in the tool_use_demo function.
// This helps prevent infinite loops and potential performance issues.
const MAX_RECURSIONS: i8 = 5;
const TOOL_NAME: &str = "Weather_Tool";
const TOOL_DESCRIPTION: &str =
"Get the current weather for a given location, based on its WGS84 coordinates.";
fn make_tool_schema() -> Document {
Document::Object(HashMap::::from([
("type".into(), Document::String("object".into())),
(
"properties".into(),
Document::Object(HashMap::from([
(
"latitude".into(),
Document::Object(HashMap::from([
("type".into(), Document::String("string".into())),
(
"description".into(),
Document::String("Geographical WGS84 latitude of the location.".into()),
),
])),
),
(
"longitude".into(),
Document::Object(HashMap::from([
("type".into(), Document::String("string".into())),
(
"description".into(),
Document::String(
"Geographical WGS84 longitude of the location.".into(),
),
),
])),
),
])),
),
(
"required".into(),
Document::Array(vec![
Document::String("latitude".into()),
Document::String("longitude".into()),
]),
),
]))
}
#[derive(Debug)]
struct ToolUseScenarioError(String);
impl std::fmt::Display for ToolUseScenarioError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "Tool use error with '{}'. Reason: {}", MODEL_ID, self.0)
}
}
impl From<&str> for ToolUseScenarioError {
fn from(value: &str) -> Self {
ToolUseScenarioError(value.into())
}
}
impl From for ToolUseScenarioError {
fn from(value: BuildError) -> Self {
ToolUseScenarioError(value.to_string().clone())
}
}
impl From> for ToolUseScenarioError {
fn from(value: SdkError) -> Self {
ToolUseScenarioError(match value.as_service_error() {
Some(value) => value.meta().message().unwrap_or("Unknown").into(),
None => "Unknown".into(),
})
}
}
```
+ For API details, see [Converse](https://docs.rs/aws-sdk-bedrockruntime/latest/aws_sdk_bedrockruntime/client/struct.Client.html#method.converse) in *AWS SDK for Rust API reference*.
------
For a complete list of AWS SDK developer guides and code examples, see [Using Amazon Bedrock with an AWS SDK](sdk-general-information-section.md). This topic also includes information about getting started and details about previous SDK versions.
# Cohere Command for Amazon Bedrock Runtime
The following code examples show how to use Amazon Bedrock Runtime with AWS SDKs.
**Topics**
+ [Converse](bedrock-runtime_example_bedrock-runtime_Converse_CohereCommand_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_CohereCommand_section.md)
+ [Document understanding](bedrock-runtime_example_bedrock-runtime_DocumentUnderstanding_CohereCommand_section.md)
+ [InvokeModel: Command R and R\$1](bedrock-runtime_example_bedrock-runtime_InvokeModel_CohereCommandR_section.md)
+ [InvokeModelWithResponseStream: Command R and R\$1](bedrock-runtime_example_bedrock-runtime_InvokeModelWithResponseStream_CohereCommandR_section.md)
+ [Scenario: Tool use with the Converse API](bedrock-runtime_example_bedrock-runtime_Scenario_ToolUseDemo_CohereCommand_section.md)
# Invoke Cohere Command on Amazon Bedrock using Bedrock's Converse API
The following code examples show how to send a text message to Cohere Command, using Bedrock's Converse API.
------
#### [ .NET ]
**SDK for .NET (v4)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Bedrock-runtime#code-examples).
Send a text message to Cohere Command, using Bedrock's Converse API.
```
// Use the Converse API to send a text message to Cohere Command.
using System;
using System.Collections.Generic;
using Amazon;
using Amazon.BedrockRuntime;
using Amazon.BedrockRuntime.Model;
// Create a Bedrock Runtime client in the AWS Region you want to use.
var client = new AmazonBedrockRuntimeClient(RegionEndpoint.USEast1);
// Set the model ID, e.g., Command R.
var modelId = "cohere.command-r-v1:0";
// Define the user message.
var userMessage = "Describe the purpose of a 'hello world' program in one line.";
// Create a request with the model ID, the user message, and an inference configuration.
var request = new ConverseRequest
{
ModelId = modelId,
Messages = new List
{
new Message
{
Role = ConversationRole.User,
Content = new List { new ContentBlock { Text = userMessage } }
}
},
InferenceConfig = new InferenceConfiguration()
{
MaxTokens = 512,
Temperature = 0.5F,
TopP = 0.9F
}
};
try
{
// Send the request to the Bedrock Runtime and wait for the result.
var response = await client.ConverseAsync(request);
// Extract and print the response text.
string responseText = response?.Output?.Message?.Content?[0]?.Text ?? "";
Console.WriteLine(responseText);
}
catch (AmazonBedrockRuntimeException e)
{
Console.WriteLine($"ERROR: Can't invoke '{modelId}'. Reason: {e.Message}");
throw;
}
```
+ For API details, see [Converse](https://docs.aws.amazon.com/goto/DotNetSDKV4/bedrock-runtime-2023-09-30/Converse) in *AWS SDK for .NET API Reference*.
------
#### [ Java ]
**SDK for Java 2.x**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Send a text message to Cohere Command, using Bedrock's Converse API.
```
// Use the Converse API to send a text message to Cohere Command.
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.core.exception.SdkClientException;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.bedrockruntime.BedrockRuntimeClient;
import software.amazon.awssdk.services.bedrockruntime.model.ContentBlock;
import software.amazon.awssdk.services.bedrockruntime.model.ConversationRole;
import software.amazon.awssdk.services.bedrockruntime.model.ConverseResponse;
import software.amazon.awssdk.services.bedrockruntime.model.Message;
public class Converse {
public static String converse() {
// Create a Bedrock Runtime client in the AWS Region you want to use.
// Replace the DefaultCredentialsProvider with your preferred credentials provider.
var client = BedrockRuntimeClient.builder()
.credentialsProvider(DefaultCredentialsProvider.create())
.region(Region.US_EAST_1)
.build();
// Set the model ID, e.g., Command R.
var modelId = "cohere.command-r-v1:0";
// Create the input text and embed it in a message object with the user role.
var inputText = "Describe the purpose of a 'hello world' program in one line.";
var message = Message.builder()
.content(ContentBlock.fromText(inputText))
.role(ConversationRole.USER)
.build();
try {
// Send the message with a basic inference configuration.
ConverseResponse response = client.converse(request -> request
.modelId(modelId)
.messages(message)
.inferenceConfig(config -> config
.maxTokens(512)
.temperature(0.5F)
.topP(0.9F)));
// Retrieve the generated text from Bedrock's response object.
var responseText = response.output().message().content().get(0).text();
System.out.println(responseText);
return responseText;
} catch (SdkClientException e) {
System.err.printf("ERROR: Can't invoke '%s'. Reason: %s", modelId, e.getMessage());
throw new RuntimeException(e);
}
}
public static void main(String[] args) {
converse();
}
}
```
Send a text message to Cohere Command, using Bedrock's Converse API with the async Java client.
```
// Use the Converse API to send a text message to Cohere Command
// with the async Java client.
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.bedrockruntime.BedrockRuntimeAsyncClient;
import software.amazon.awssdk.services.bedrockruntime.model.ContentBlock;
import software.amazon.awssdk.services.bedrockruntime.model.ConversationRole;
import software.amazon.awssdk.services.bedrockruntime.model.Message;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
public class ConverseAsync {
public static String converseAsync() {
// Create a Bedrock Runtime client in the AWS Region you want to use.
// Replace the DefaultCredentialsProvider with your preferred credentials provider.
var client = BedrockRuntimeAsyncClient.builder()
.credentialsProvider(DefaultCredentialsProvider.create())
.region(Region.US_EAST_1)
.build();
// Set the model ID, e.g., Command R.
var modelId = "cohere.command-r-v1:0";
// Create the input text and embed it in a message object with the user role.
var inputText = "Describe the purpose of a 'hello world' program in one line.";
var message = Message.builder()
.content(ContentBlock.fromText(inputText))
.role(ConversationRole.USER)
.build();
// Send the message with a basic inference configuration.
var request = client.converse(params -> params
.modelId(modelId)
.messages(message)
.inferenceConfig(config -> config
.maxTokens(512)
.temperature(0.5F)
.topP(0.9F))
);
// Prepare a future object to handle the asynchronous response.
CompletableFuture future = new CompletableFuture<>();
// Handle the response or error using the future object.
request.whenComplete((response, error) -> {
if (error == null) {
// Extract the generated text from Bedrock's response object.
String responseText = response.output().message().content().get(0).text();
future.complete(responseText);
} else {
future.completeExceptionally(error);
}
});
try {
// Wait for the future object to complete and retrieve the generated text.
String responseText = future.get();
System.out.println(responseText);
return responseText;
} catch (ExecutionException | InterruptedException e) {
System.err.printf("Can't invoke '%s': %s", modelId, e.getMessage());
throw new RuntimeException(e);
}
}
public static void main(String[] args) {
converseAsync();
}
}
```
+ For API details, see [Converse](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/Converse) in *AWS SDK for Java 2.x API Reference*.
------
#### [ JavaScript ]
**SDK for JavaScript (v3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Send a text message to Cohere Command, using Bedrock's Converse API.
```
// Use the Conversation API to send a text message to Cohere Command.
import {
BedrockRuntimeClient,
ConverseCommand,
} from "@aws-sdk/client-bedrock-runtime";
// Create a Bedrock Runtime client in the AWS Region you want to use.
const client = new BedrockRuntimeClient({ region: "us-east-1" });
// Set the model ID, e.g., Command R.
const modelId = "cohere.command-r-v1:0";
// Start a conversation with the user message.
const userMessage =
"Describe the purpose of a 'hello world' program in one line.";
const conversation = [
{
role: "user",
content: [{ text: userMessage }],
},
];
// Create a command with the model ID, the message, and a basic configuration.
const command = new ConverseCommand({
modelId,
messages: conversation,
inferenceConfig: { maxTokens: 512, temperature: 0.5, topP: 0.9 },
});
try {
// Send the command to the model and wait for the response
const response = await client.send(command);
// Extract and print the response text.
const responseText = response.output.message.content[0].text;
console.log(responseText);
} catch (err) {
console.log(`ERROR: Can't invoke '${modelId}'. Reason: ${err}`);
process.exit(1);
}
```
+ For API details, see [Converse](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseCommand) in *AWS SDK for JavaScript API Reference*.
------
#### [ Python ]
**SDK for Python (Boto3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Send a text message to Cohere Command, using Bedrock's Converse API.
```
# Use the Conversation API to send a text message to Cohere Command.
import boto3
from botocore.exceptions import ClientError
# Create a Bedrock Runtime client in the AWS Region you want to use.
client = boto3.client("bedrock-runtime", region_name="us-east-1")
# Set the model ID, e.g., Command R.
model_id = "cohere.command-r-v1:0"
# Start a conversation with the user message.
user_message = "Describe the purpose of a 'hello world' program in one line."
conversation = [
{
"role": "user",
"content": [{"text": user_message}],
}
]
try:
# Send the message to the model, using a basic inference configuration.
response = client.converse(
modelId=model_id,
messages=conversation,
inferenceConfig={"maxTokens": 512, "temperature": 0.5, "topP": 0.9},
)
# Extract and print the response text.
response_text = response["output"]["message"]["content"][0]["text"]
print(response_text)
except (ClientError, Exception) as e:
print(f"ERROR: Can't invoke '{model_id}'. Reason: {e}")
exit(1)
```
+ For API details, see [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) in *AWS SDK for Python (Boto3) API Reference*.
------
For a complete list of AWS SDK developer guides and code examples, see [Using Amazon Bedrock with an AWS SDK](sdk-general-information-section.md). This topic also includes information about getting started and details about previous SDK versions.
# Invoke Cohere Command on Amazon Bedrock using Bedrock's Converse API with a response stream
The following code examples show how to send a text message to Cohere Command, using Bedrock's Converse API and process the response stream in real-time.
------
#### [ .NET ]
**SDK for .NET (v4)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Bedrock-runtime#code-examples).
Send a text message to Cohere Command, using Bedrock's Converse API and process the response stream in real-time.
```
// Use the Converse API to send a text message to Cohere Command
// and print the response stream.
using System;
using System.Collections.Generic;
using System.Linq;
using Amazon;
using Amazon.BedrockRuntime;
using Amazon.BedrockRuntime.Model;
// Create a Bedrock Runtime client in the AWS Region you want to use.
var client = new AmazonBedrockRuntimeClient(RegionEndpoint.USEast1);
// Set the model ID, e.g., Command R.
var modelId = "cohere.command-r-v1:0";
// Define the user message.
var userMessage = "Describe the purpose of a 'hello world' program in one line.";
// Create a request with the model ID, the user message, and an inference configuration.
var request = new ConverseStreamRequest
{
ModelId = modelId,
Messages = new List
{
new Message
{
Role = ConversationRole.User,
Content = new List { new ContentBlock { Text = userMessage } }
}
},
InferenceConfig = new InferenceConfiguration()
{
MaxTokens = 512,
Temperature = 0.5F,
TopP = 0.9F
}
};
try
{
// Send the request to the Bedrock Runtime and wait for the result.
var response = await client.ConverseStreamAsync(request);
// Extract and print the streamed response text in real-time.
foreach (var chunk in response.Stream.AsEnumerable())
{
if (chunk is ContentBlockDeltaEvent)
{
Console.Write((chunk as ContentBlockDeltaEvent).Delta.Text);
}
}
}
catch (AmazonBedrockRuntimeException e)
{
Console.WriteLine($"ERROR: Can't invoke '{modelId}'. Reason: {e.Message}");
throw;
}
```
+ For API details, see [ConverseStream](https://docs.aws.amazon.com/goto/DotNetSDKV4/bedrock-runtime-2023-09-30/ConverseStream) in *AWS SDK for .NET API Reference*.
------
#### [ Java ]
**SDK for Java 2.x**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Send a text message to Cohere Command, using Bedrock's Converse API and process the response stream in real-time.
```
// Use the Converse API to send a text message to Cohere Command
// and print the response stream.
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.bedrockruntime.BedrockRuntimeAsyncClient;
import software.amazon.awssdk.services.bedrockruntime.model.ContentBlock;
import software.amazon.awssdk.services.bedrockruntime.model.ConversationRole;
import software.amazon.awssdk.services.bedrockruntime.model.ConverseStreamResponseHandler;
import software.amazon.awssdk.services.bedrockruntime.model.Message;
import java.util.concurrent.ExecutionException;
public class ConverseStream {
public static void main(String[] args) {
// Create a Bedrock Runtime client in the AWS Region you want to use.
// Replace the DefaultCredentialsProvider with your preferred credentials provider.
var client = BedrockRuntimeAsyncClient.builder()
.credentialsProvider(DefaultCredentialsProvider.create())
.region(Region.US_EAST_1)
.build();
// Set the model ID, e.g., Command R.
var modelId = "cohere.command-r-v1:0";
// Create the input text and embed it in a message object with the user role.
var inputText = "Describe the purpose of a 'hello world' program in one line.";
var message = Message.builder()
.content(ContentBlock.fromText(inputText))
.role(ConversationRole.USER)
.build();
// Create a handler to extract and print the response text in real-time.
var responseStreamHandler = ConverseStreamResponseHandler.builder()
.subscriber(ConverseStreamResponseHandler.Visitor.builder()
.onContentBlockDelta(chunk -> {
String responseText = chunk.delta().text();
System.out.print(responseText);
}).build()
).onError(err ->
System.err.printf("Can't invoke '%s': %s", modelId, err.getMessage())
).build();
try {
// Send the message with a basic inference configuration and attach the handler.
client.converseStream(request -> request.modelId(modelId)
.messages(message)
.inferenceConfig(config -> config
.maxTokens(512)
.temperature(0.5F)
.topP(0.9F)
), responseStreamHandler).get();
} catch (ExecutionException | InterruptedException e) {
System.err.printf("Can't invoke '%s': %s", modelId, e.getCause().getMessage());
}
}
}
```
+ For API details, see [ConverseStream](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/ConverseStream) in *AWS SDK for Java 2.x API Reference*.
------
#### [ JavaScript ]
**SDK for JavaScript (v3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Send a text message to Cohere Command, using Bedrock's Converse API and process the response stream in real-time.
```
// Use the Conversation API to send a text message to Cohere Command.
import {
BedrockRuntimeClient,
ConverseStreamCommand,
} from "@aws-sdk/client-bedrock-runtime";
// Create a Bedrock Runtime client in the AWS Region you want to use.
const client = new BedrockRuntimeClient({ region: "us-east-1" });
// Set the model ID, e.g., Command R.
const modelId = "cohere.command-r-v1:0";
// Start a conversation with the user message.
const userMessage =
"Describe the purpose of a 'hello world' program in one line.";
const conversation = [
{
role: "user",
content: [{ text: userMessage }],
},
];
// Create a command with the model ID, the message, and a basic configuration.
const command = new ConverseStreamCommand({
modelId,
messages: conversation,
inferenceConfig: { maxTokens: 512, temperature: 0.5, topP: 0.9 },
});
try {
// Send the command to the model and wait for the response
const response = await client.send(command);
// Extract and print the streamed response text in real-time.
for await (const item of response.stream) {
if (item.contentBlockDelta) {
process.stdout.write(item.contentBlockDelta.delta?.text);
}
}
} catch (err) {
console.log(`ERROR: Can't invoke '${modelId}'. Reason: ${err}`);
process.exit(1);
}
```
+ For API details, see [ConverseStream](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseStreamCommand) in *AWS SDK for JavaScript API Reference*.
------
#### [ Python ]
**SDK for Python (Boto3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Send a text message to Cohere Command, using Bedrock's Converse API and process the response stream in real-time.
```
# Use the Conversation API to send a text message to Cohere Command
# and print the response stream.
import boto3
from botocore.exceptions import ClientError
# Create a Bedrock Runtime client in the AWS Region you want to use.
client = boto3.client("bedrock-runtime", region_name="us-east-1")
# Set the model ID, e.g., Command R.
model_id = "cohere.command-r-v1:0"
# Start a conversation with the user message.
user_message = "Describe the purpose of a 'hello world' program in one line."
conversation = [
{
"role": "user",
"content": [{"text": user_message}],
}
]
try:
# Send the message to the model, using a basic inference configuration.
streaming_response = client.converse_stream(
modelId=model_id,
messages=conversation,
inferenceConfig={"maxTokens": 512, "temperature": 0.5, "topP": 0.9},
)
# Extract and print the streamed response text in real-time.
for chunk in streaming_response["stream"]:
if "contentBlockDelta" in chunk:
text = chunk["contentBlockDelta"]["delta"]["text"]
print(text, end="")
except (ClientError, Exception) as e:
print(f"ERROR: Can't invoke '{model_id}'. Reason: {e}")
exit(1)
```
+ For API details, see [ConverseStream](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/ConverseStream) in *AWS SDK for Python (Boto3) API Reference*.
------
For a complete list of AWS SDK developer guides and code examples, see [Using Amazon Bedrock with an AWS SDK](sdk-general-information-section.md). This topic also includes information about getting started and details about previous SDK versions.
# Send and process a document with Cohere Command models on Amazon Bedrock
The following code example shows how to send and process a document with Cohere Command models on Amazon Bedrock.
------
#### [ Python ]
**SDK for Python (Boto3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Send and process a document with Cohere Command models on Amazon Bedrock.
```
# Send and process a document with Cohere Command models on Amazon Bedrock.
import boto3
from botocore.exceptions import ClientError
# Create a Bedrock Runtime client in the AWS Region you want to use.
client = boto3.client("bedrock-runtime", region_name="us-east-1")
# Set the model ID, e.g. Command R+.
model_id = "cohere.command-r-plus-v1:0"
# Load the document
with open("example-data/amazon-nova-service-cards.pdf", "rb") as file:
document_bytes = file.read()
# Start a conversation with a user message and the document
conversation = [
{
"role": "user",
"content": [
{"text": "Briefly compare the models described in this document"},
{
"document": {
# Available formats: html, md, pdf, doc/docx, xls/xlsx, csv, and txt
"format": "pdf",
"name": "Amazon Nova Service Cards",
"source": {"bytes": document_bytes},
}
},
],
}
]
try:
# Send the message to the model, using a basic inference configuration.
response = client.converse(
modelId=model_id,
messages=conversation,
inferenceConfig={"maxTokens": 500, "temperature": 0.3},
)
# Extract and print the response text.
response_text = response["output"]["message"]["content"][0]["text"]
print(response_text)
except (ClientError, Exception) as e:
print(f"ERROR: Can't invoke '{model_id}'. Reason: {e}")
exit(1)
```
+ For API details, see [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) in *AWS SDK for Python (Boto3) API Reference*.
------
For a complete list of AWS SDK developer guides and code examples, see [Using Amazon Bedrock with an AWS SDK](sdk-general-information-section.md). This topic also includes information about getting started and details about previous SDK versions.
# Invoke Cohere Command R and R\$1 on Amazon Bedrock using the Invoke Model API
The following code examples show how to send a text message to Cohere Command R and R\$1, using the Invoke Model API.
------
#### [ .NET ]
**SDK for .NET**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime#code-examples).
Use the Invoke Model API to send a text message.
```
// Use the native inference API to send a text message to Cohere Command R.
using System;
using System.IO;
using System.Text.Json;
using System.Text.Json.Nodes;
using Amazon;
using Amazon.BedrockRuntime;
using Amazon.BedrockRuntime.Model;
// Create a Bedrock Runtime client in the AWS Region you want to use.
var client = new AmazonBedrockRuntimeClient(RegionEndpoint.USEast1);
// Set the model ID, e.g., Command R.
var modelId = "cohere.command-r-v1:0";
// Define the user message.
var userMessage = "Describe the purpose of a 'hello world' program in one line.";
//Format the request payload using the model's native structure.
var nativeRequest = JsonSerializer.Serialize(new
{
message = userMessage,
max_tokens = 512,
temperature = 0.5
});
// Create a request with the model ID and the model's native request payload.
var request = new InvokeModelRequest()
{
ModelId = modelId,
Body = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(nativeRequest)),
ContentType = "application/json"
};
try
{
// Send the request to the Bedrock Runtime and wait for the response.
var response = await client.InvokeModelAsync(request);
// Decode the response body.
var modelResponse = await JsonNode.ParseAsync(response.Body);
// Extract and print the response text.
var responseText = modelResponse["text"] ?? "";
Console.WriteLine(responseText);
}
catch (AmazonBedrockRuntimeException e)
{
Console.WriteLine($"ERROR: Can't invoke '{modelId}'. Reason: {e.Message}");
throw;
}
```
+ For API details, see [InvokeModel](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/InvokeModel) in *AWS SDK for .NET API Reference*.
------
#### [ Java ]
**SDK for Java 2.x**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Use the Invoke Model API to send a text message.
```
// Use the native inference API to send a text message to Cohere Command R.
import org.json.JSONObject;
import org.json.JSONPointer;
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.core.SdkBytes;
import software.amazon.awssdk.core.exception.SdkClientException;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.bedrockruntime.BedrockRuntimeClient;
public class Command_R_InvokeModel {
public static String invokeModel() {
// Create a Bedrock Runtime client in the AWS Region you want to use.
// Replace the DefaultCredentialsProvider with your preferred credentials provider.
var client = BedrockRuntimeClient.builder()
.credentialsProvider(DefaultCredentialsProvider.create())
.region(Region.US_EAST_1)
.build();
// Set the model ID, e.g., Command R.
var modelId = "cohere.command-r-v1:0";
// The InvokeModel API uses the model's native payload.
// Learn more about the available inference parameters and response fields at:
// https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-cohere-command-r-plus.html
var nativeRequestTemplate = "{ \"message\": \"{{prompt}}\" }";
// Define the prompt for the model.
var prompt = "Describe the purpose of a 'hello world' program in one line.";
// Embed the prompt in the model's native request payload.
String nativeRequest = nativeRequestTemplate.replace("{{prompt}}", prompt);
try {
// Encode and send the request to the Bedrock Runtime.
var response = client.invokeModel(request -> request
.body(SdkBytes.fromUtf8String(nativeRequest))
.modelId(modelId)
);
// Decode the response body.
var responseBody = new JSONObject(response.body().asUtf8String());
// Retrieve the generated text from the model's response.
var text = new JSONPointer("/text").queryFrom(responseBody).toString();
System.out.println(text);
return text;
} catch (SdkClientException e) {
System.err.printf("ERROR: Can't invoke '%s'. Reason: %s", modelId, e.getMessage());
throw new RuntimeException(e);
}
}
public static void main(String[] args) {
invokeModel();
}
}
```
+ For API details, see [InvokeModel](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModel) in *AWS SDK for Java 2.x API Reference*.
------
#### [ Python ]
**SDK for Python (Boto3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Use the Invoke Model API to send a text message.
```
# Use the native inference API to send a text message to Cohere Command R and R+.
import boto3
import json
from botocore.exceptions import ClientError
# Create a Bedrock Runtime client in the AWS Region of your choice.
client = boto3.client("bedrock-runtime", region_name="us-east-1")
# Set the model ID, e.g., Command R.
model_id = "cohere.command-r-v1:0"
# Define the prompt for the model.
prompt = "Describe the purpose of a 'hello world' program in one line."
# Format the request payload using the model's native structure.
native_request = {
"message": prompt,
"max_tokens": 512,
"temperature": 0.5,
}
# Convert the native request to JSON.
request = json.dumps(native_request)
try:
# Invoke the model with the request.
response = client.invoke_model(modelId=model_id, body=request)
except (ClientError, Exception) as e:
print(f"ERROR: Can't invoke '{model_id}'. Reason: {e}")
exit(1)
# Decode the response body.
model_response = json.loads(response["body"].read())
# Extract and print the response text.
response_text = model_response["text"]
print(response_text)
```
+ For API details, see [InvokeModel](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModel) in *AWS SDK for Python (Boto3) API Reference*.
------
For a complete list of AWS SDK developer guides and code examples, see [Using Amazon Bedrock with an AWS SDK](sdk-general-information-section.md). This topic also includes information about getting started and details about previous SDK versions.
# Invoke Cohere Command R and R\$1 on Amazon Bedrock using the Invoke Model API with a response stream
The following code examples show how to send a text message to Cohere Command, using the Invoke Model API with a response stream.
------
#### [ .NET ]
**SDK for .NET**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime#code-examples).
Use the Invoke Model API to send a text message and process the response stream in real-time.
```
// Use the native inference API to send a text message to Cohere Command R
// and print the response stream.
using System;
using System.IO;
using System.Text.Json;
using System.Text.Json.Nodes;
using Amazon;
using Amazon.BedrockRuntime;
using Amazon.BedrockRuntime.Model;
// Create a Bedrock Runtime client in the AWS Region you want to use.
var client = new AmazonBedrockRuntimeClient(RegionEndpoint.USEast1);
// Set the model ID, e.g., Command R.
var modelId = "cohere.command-r-v1:0";
// Define the user message.
var userMessage = "Describe the purpose of a 'hello world' program in one line.";
//Format the request payload using the model's native structure.
var nativeRequest = JsonSerializer.Serialize(new
{
message = userMessage,
max_tokens = 512,
temperature = 0.5
});
// Create a request with the model ID and the model's native request payload.
var request = new InvokeModelWithResponseStreamRequest()
{
ModelId = modelId,
Body = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(nativeRequest)),
ContentType = "application/json"
};
try
{
// Send the request to the Bedrock Runtime and wait for the response.
var streamingResponse = await client.InvokeModelWithResponseStreamAsync(request);
// Extract and print the streamed response text in real-time.
foreach (var item in streamingResponse.Body)
{
var chunk = JsonSerializer.Deserialize((item as PayloadPart).Bytes);
var text = chunk["text"] ?? "";
Console.Write(text);
}
}
catch (AmazonBedrockRuntimeException e)
{
Console.WriteLine($"ERROR: Can't invoke '{modelId}'. Reason: {e.Message}");
throw;
}
```
+ For API details, see [InvokeModel](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/InvokeModel) in *AWS SDK for .NET API Reference*.
------
#### [ Java ]
**SDK for Java 2.x**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Use the Invoke Model API to send a text message and process the response stream in real-time.
```
// Use the native inference API to send a text message to Cohere Command R
// and print the response stream.
import org.json.JSONObject;
import org.json.JSONPointer;
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.core.SdkBytes;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.bedrockruntime.BedrockRuntimeAsyncClient;
import software.amazon.awssdk.services.bedrockruntime.model.InvokeModelWithResponseStreamRequest;
import software.amazon.awssdk.services.bedrockruntime.model.InvokeModelWithResponseStreamResponseHandler;
import java.util.concurrent.ExecutionException;
import static software.amazon.awssdk.services.bedrockruntime.model.InvokeModelWithResponseStreamResponseHandler.Visitor;
public class Command_R_InvokeModelWithResponseStream {
public static String invokeModelWithResponseStream() {
// Create a Bedrock Runtime client in the AWS Region you want to use.
// Replace the DefaultCredentialsProvider with your preferred credentials provider.
var client = BedrockRuntimeAsyncClient.builder()
.credentialsProvider(DefaultCredentialsProvider.create())
.region(Region.US_EAST_1)
.build();
// Set the model ID, e.g., Command R.
var modelId = "cohere.command-r-v1:0";
// The InvokeModelWithResponseStream API uses the model's native payload.
// Learn more about the available inference parameters and response fields at:
// https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-cohere-command-r-plus.html
var nativeRequestTemplate = "{ \"message\": \"{{prompt}}\" }";
// Define the prompt for the model.
var prompt = "Describe the purpose of a 'hello world' program in one line.";
// Embed the prompt in the model's native request payload.
String nativeRequest = nativeRequestTemplate.replace("{{prompt}}", prompt);
// Create a request with the model ID and the model's native request payload.
var request = InvokeModelWithResponseStreamRequest.builder()
.body(SdkBytes.fromUtf8String(nativeRequest))
.modelId(modelId)
.build();
// Prepare a buffer to accumulate the generated response text.
var completeResponseTextBuffer = new StringBuilder();
// Prepare a handler to extract, accumulate, and print the response text in real-time.
var responseStreamHandler = InvokeModelWithResponseStreamResponseHandler.builder()
.subscriber(Visitor.builder().onChunk(chunk -> {
// Extract and print the text from the model's native response.
var response = new JSONObject(chunk.bytes().asUtf8String());
var text = new JSONPointer("/text").queryFrom(response);
System.out.print(text);
// Append the text to the response text buffer.
completeResponseTextBuffer.append(text);
}).build()).build();
try {
// Send the request and wait for the handler to process the response.
client.invokeModelWithResponseStream(request, responseStreamHandler).get();
// Return the complete response text.
return completeResponseTextBuffer.toString();
} catch (ExecutionException | InterruptedException e) {
System.err.printf("Can't invoke '%s': %s", modelId, e.getCause().getMessage());
throw new RuntimeException(e);
}
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
invokeModelWithResponseStream();
}
}
```
+ For API details, see [InvokeModel](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModel) in *AWS SDK for Java 2.x API Reference*.
------
#### [ Python ]
**SDK for Python (Boto3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Use the Invoke Model API to send a text message and process the response stream in real-time.
```
# Use the native inference API to send a text message to Cohere Command R and R+
# and print the response stream.
import boto3
import json
from botocore.exceptions import ClientError
# Create a Bedrock Runtime client in the AWS Region of your choice.
client = boto3.client("bedrock-runtime", region_name="us-east-1")
# Set the model ID, e.g., Command R.
model_id = "cohere.command-r-v1:0"
# Define the prompt for the model.
prompt = "Describe the purpose of a 'hello world' program in one line."
# Format the request payload using the model's native structure.
native_request = {
"message": prompt,
"max_tokens": 512,
"temperature": 0.5,
}
# Convert the native request to JSON.
request = json.dumps(native_request)
try:
# Invoke the model with the request.
streaming_response = client.invoke_model_with_response_stream(
modelId=model_id, body=request
)
# Extract and print the response text in real-time.
for event in streaming_response["body"]:
chunk = json.loads(event["chunk"]["bytes"])
if "generations" in chunk:
print(chunk["generations"][0]["text"], end="")
except (ClientError, Exception) as e:
print(f"ERROR: Can't invoke '{model_id}'. Reason: {e}")
exit(1)
```
+ For API details, see [InvokeModel](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModel) in *AWS SDK for Python (Boto3) API Reference*.
------
For a complete list of AWS SDK developer guides and code examples, see [Using Amazon Bedrock with an AWS SDK](sdk-general-information-section.md). This topic also includes information about getting started and details about previous SDK versions.
# A tool use demo illustrating how to connect AI models on Amazon Bedrock with a custom tool or API
The following code example shows how to build a typical interaction between an application, a generative AI model, and connected tools or APIs to mediate interactions between the AI and the outside world. It uses the example of connecting an external weather API to the AI model so it can provide real-time weather information based on user input.
------
#### [ Python ]
**SDK for Python (Boto3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
The primary execution script of the demo. This script orchestrates the conversation between the user, the Amazon Bedrock Converse API, and a weather tool.
```
"""
This demo illustrates a tool use scenario using Amazon Bedrock's Converse API and a weather tool.
The script interacts with a foundation model on Amazon Bedrock to provide weather information based on user
input. It uses the Open-Meteo API (https://open-meteo.com) to retrieve current weather data for a given location.
"""
import boto3
import logging
from enum import Enum
import utils.tool_use_print_utils as output
import weather_tool
logging.basicConfig(level=logging.INFO, format="%(message)s")
AWS_REGION = "us-east-1"
# For the most recent list of models supported by the Converse API's tool use functionality, visit:
# https://docs.aws.amazon.com/bedrock/latest/userguide/conversation-inference.html
class SupportedModels(Enum):
CLAUDE_OPUS = "anthropic.claude-3-opus-20240229-v1:0"
CLAUDE_SONNET = "anthropic.claude-3-sonnet-20240229-v1:0"
CLAUDE_HAIKU = "anthropic.claude-3-haiku-20240307-v1:0"
COHERE_COMMAND_R = "cohere.command-r-v1:0"
COHERE_COMMAND_R_PLUS = "cohere.command-r-plus-v1:0"
# Set the model ID, e.g., Claude 3 Haiku.
MODEL_ID = SupportedModels.CLAUDE_HAIKU.value
SYSTEM_PROMPT = """
You are a weather assistant that provides current weather data for user-specified locations using only
the Weather_Tool, which expects latitude and longitude. Infer the coordinates from the location yourself.
If the user provides coordinates, infer the approximate location and refer to it in your response.
To use the tool, you strictly apply the provided tool specification.
- Explain your step-by-step process, and give brief updates before each step.
- Only use the Weather_Tool for data. Never guess or make up information.
- Repeat the tool use for subsequent requests if necessary.
- If the tool errors, apologize, explain weather is unavailable, and suggest other options.
- Report temperatures in °C (°F) and wind in km/h (mph). Keep weather reports concise. Sparingly use
emojis where appropriate.
- Only respond to weather queries. Remind off-topic users of your purpose.
- Never claim to search online, access external data, or use tools besides Weather_Tool.
- Complete the entire process until you have all required data before sending the complete response.
"""
# The maximum number of recursive calls allowed in the tool_use_demo function.
# This helps prevent infinite loops and potential performance issues.
MAX_RECURSIONS = 5
class ToolUseDemo:
"""
Demonstrates the tool use feature with the Amazon Bedrock Converse API.
"""
def __init__(self):
# Prepare the system prompt
self.system_prompt = [{"text": SYSTEM_PROMPT}]
# Prepare the tool configuration with the weather tool's specification
self.tool_config = {"tools": [weather_tool.get_tool_spec()]}
# Create a Bedrock Runtime client in the specified AWS Region.
self.bedrockRuntimeClient = boto3.client(
"bedrock-runtime", region_name=AWS_REGION
)
def run(self):
"""
Starts the conversation with the user and handles the interaction with Bedrock.
"""
# Print the greeting and a short user guide
output.header()
# Start with an emtpy conversation
conversation = []
# Get the first user input
user_input = self._get_user_input()
while user_input is not None:
# Create a new message with the user input and append it to the conversation
message = {"role": "user", "content": [{"text": user_input}]}
conversation.append(message)
# Send the conversation to Amazon Bedrock
bedrock_response = self._send_conversation_to_bedrock(conversation)
# Recursively handle the model's response until the model has returned
# its final response or the recursion counter has reached 0
self._process_model_response(
bedrock_response, conversation, max_recursion=MAX_RECURSIONS
)
# Repeat the loop until the user decides to exit the application
user_input = self._get_user_input()
output.footer()
def _send_conversation_to_bedrock(self, conversation):
"""
Sends the conversation, the system prompt, and the tool spec to Amazon Bedrock, and returns the response.
:param conversation: The conversation history including the next message to send.
:return: The response from Amazon Bedrock.
"""
output.call_to_bedrock(conversation)
# Send the conversation, system prompt, and tool configuration, and return the response
return self.bedrockRuntimeClient.converse(
modelId=MODEL_ID,
messages=conversation,
system=self.system_prompt,
toolConfig=self.tool_config,
)
def _process_model_response(
self, model_response, conversation, max_recursion=MAX_RECURSIONS
):
"""
Processes the response received via Amazon Bedrock and performs the necessary actions
based on the stop reason.
:param model_response: The model's response returned via Amazon Bedrock.
:param conversation: The conversation history.
:param max_recursion: The maximum number of recursive calls allowed.
"""
if max_recursion <= 0:
# Stop the process, the number of recursive calls could indicate an infinite loop
logging.warning(
"Warning: Maximum number of recursions reached. Please try again."
)
exit(1)
# Append the model's response to the ongoing conversation
message = model_response["output"]["message"]
conversation.append(message)
if model_response["stopReason"] == "tool_use":
# If the stop reason is "tool_use", forward everything to the tool use handler
self._handle_tool_use(message, conversation, max_recursion)
if model_response["stopReason"] == "end_turn":
# If the stop reason is "end_turn", print the model's response text, and finish the process
output.model_response(message["content"][0]["text"])
return
def _handle_tool_use(
self, model_response, conversation, max_recursion=MAX_RECURSIONS
):
"""
Handles the tool use case by invoking the specified tool and sending the tool's response back to Bedrock.
The tool response is appended to the conversation, and the conversation is sent back to Amazon Bedrock for further processing.
:param model_response: The model's response containing the tool use request.
:param conversation: The conversation history.
:param max_recursion: The maximum number of recursive calls allowed.
"""
# Initialize an empty list of tool results
tool_results = []
# The model's response can consist of multiple content blocks
for content_block in model_response["content"]:
if "text" in content_block:
# If the content block contains text, print it to the console
output.model_response(content_block["text"])
if "toolUse" in content_block:
# If the content block is a tool use request, forward it to the tool
tool_response = self._invoke_tool(content_block["toolUse"])
# Add the tool use ID and the tool's response to the list of results
tool_results.append(
{
"toolResult": {
"toolUseId": (tool_response["toolUseId"]),
"content": [{"json": tool_response["content"]}],
}
}
)
# Embed the tool results in a new user message
message = {"role": "user", "content": tool_results}
# Append the new message to the ongoing conversation
conversation.append(message)
# Send the conversation to Amazon Bedrock
response = self._send_conversation_to_bedrock(conversation)
# Recursively handle the model's response until the model has returned
# its final response or the recursion counter has reached 0
self._process_model_response(response, conversation, max_recursion - 1)
def _invoke_tool(self, payload):
"""
Invokes the specified tool with the given payload and returns the tool's response.
If the requested tool does not exist, an error message is returned.
:param payload: The payload containing the tool name and input data.
:return: The tool's response or an error message.
"""
tool_name = payload["name"]
if tool_name == "Weather_Tool":
input_data = payload["input"]
output.tool_use(tool_name, input_data)
# Invoke the weather tool with the input data provided by
response = weather_tool.fetch_weather_data(input_data)
else:
error_message = (
f"The requested tool with name '{tool_name}' does not exist."
)
response = {"error": "true", "message": error_message}
return {"toolUseId": payload["toolUseId"], "content": response}
@staticmethod
def _get_user_input(prompt="Your weather info request"):
"""
Prompts the user for input and returns the user's response.
Returns None if the user enters 'x' to exit.
:param prompt: The prompt to display to the user.
:return: The user's input or None if the user chooses to exit.
"""
output.separator()
user_input = input(f"{prompt} (x to exit): ")
if user_input == "":
prompt = "Please enter your weather info request, e.g. the name of a city"
return ToolUseDemo._get_user_input(prompt)
elif user_input.lower() == "x":
return None
else:
return user_input
if __name__ == "__main__":
tool_use_demo = ToolUseDemo()
tool_use_demo.run()
```
The weather tool used by the demo. This script defines the tool specification and implements the logic to retrieve weather data using from the Open-Meteo API.
```
import requests
from requests.exceptions import RequestException
def get_tool_spec():
"""
Returns the JSON Schema specification for the Weather tool. The tool specification
defines the input schema and describes the tool's functionality.
For more information, see https://json-schema.org/understanding-json-schema/reference.
:return: The tool specification for the Weather tool.
"""
return {
"toolSpec": {
"name": "Weather_Tool",
"description": "Get the current weather for a given location, based on its WGS84 coordinates.",
"inputSchema": {
"json": {
"type": "object",
"properties": {
"latitude": {
"type": "string",
"description": "Geographical WGS84 latitude of the location.",
},
"longitude": {
"type": "string",
"description": "Geographical WGS84 longitude of the location.",
},
},
"required": ["latitude", "longitude"],
}
},
}
}
def fetch_weather_data(input_data):
"""
Fetches weather data for the given latitude and longitude using the Open-Meteo API.
Returns the weather data or an error message if the request fails.
:param input_data: The input data containing the latitude and longitude.
:return: The weather data or an error message.
"""
endpoint = "https://api.open-meteo.com/v1/forecast"
latitude = input_data.get("latitude")
longitude = input_data.get("longitude", "")
params = {"latitude": latitude, "longitude": longitude, "current_weather": True}
try:
response = requests.get(endpoint, params=params)
weather_data = {"weather_data": response.json()}
response.raise_for_status()
return weather_data
except RequestException as e:
return e.response.json()
except Exception as e:
return {"error": type(e), "message": str(e)}
```
+ For API details, see [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) in *AWS SDK for Python (Boto3) API Reference*.
------
For a complete list of AWS SDK developer guides and code examples, see [Using Amazon Bedrock with an AWS SDK](sdk-general-information-section.md). This topic also includes information about getting started and details about previous SDK versions.
# DeepSeek for Amazon Bedrock Runtime
The following code examples show how to use Amazon Bedrock Runtime with AWS SDKs.
**Topics**
+ [Document understanding](bedrock-runtime_example_bedrock-runtime_DocumentUnderstanding_DeepSeek_section.md)
# Send and process a document with DeepSeek on Amazon Bedrock
The following code example shows how to send and process a document with DeepSeek on Amazon Bedrock.
------
#### [ Python ]
**SDK for Python (Boto3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Send and process a document with DeepSeek on Amazon Bedrock.
```
# Send and process a document with DeepSeek on Amazon Bedrock.
import boto3
from botocore.exceptions import ClientError
# Create a Bedrock Runtime client in the AWS Region you want to use.
client = boto3.client("bedrock-runtime", region_name="us-east-1")
# Set the model ID, e.g. DeepSeek-R1
model_id = "us.deepseek.r1-v1:0"
# Load the document
with open("example-data/amazon-nova-service-cards.pdf", "rb") as file:
document_bytes = file.read()
# Start a conversation with a user message and the document
conversation = [
{
"role": "user",
"content": [
{"text": "Briefly compare the models described in this document"},
{
"document": {
# Available formats: html, md, pdf, doc/docx, xls/xlsx, csv, and txt
"format": "pdf",
"name": "Amazon Nova Service Cards",
"source": {"bytes": document_bytes},
}
},
],
}
]
try:
# Send the message to the model, using a basic inference configuration.
response = client.converse(
modelId=model_id,
messages=conversation,
inferenceConfig={"maxTokens": 2000, "temperature": 0.3},
)
# Extract and print the reasoning and response text.
reasoning, response_text = "", ""
for item in response["output"]["message"]["content"]:
for key, value in item.items():
if key == "reasoningContent":
reasoning = value["reasoningText"]["text"]
elif key == "text":
response_text = value
print(f"\nReasoning:\n{reasoning}")
print(f"\nResponse:\n{response_text}")
except (ClientError, Exception) as e:
print(f"ERROR: Can't invoke '{model_id}'. Reason: {e}")
exit(1)
```
+ For API details, see [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) in *AWS SDK for Python (Boto3) API Reference*.
------
For a complete list of AWS SDK developer guides and code examples, see [Using Amazon Bedrock with an AWS SDK](sdk-general-information-section.md). This topic also includes information about getting started and details about previous SDK versions.
# Meta Llama for Amazon Bedrock Runtime
The following code examples show how to use Amazon Bedrock Runtime with AWS SDKs.
**Topics**
+ [Converse](bedrock-runtime_example_bedrock-runtime_Converse_MetaLlama_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_MetaLlama_section.md)
+ [Document understanding](bedrock-runtime_example_bedrock-runtime_DocumentUnderstanding_MetaLlama_section.md)
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_MetaLlama3_section.md)
+ [InvokeModelWithResponseStream](bedrock-runtime_example_bedrock-runtime_InvokeModelWithResponseStream_MetaLlama3_section.md)
# Invoke Meta Llama on Amazon Bedrock using Bedrock's Converse API
The following code examples show how to send a text message to Meta Llama, using Bedrock's Converse API.
------
#### [ .NET ]
**SDK for .NET (v4)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Bedrock-runtime#code-examples).
Send a text message to Meta Llama, using Bedrock's Converse API.
```
// Use the Converse API to send a text message to Meta Llama.
using System;
using System.Collections.Generic;
using Amazon;
using Amazon.BedrockRuntime;
using Amazon.BedrockRuntime.Model;
// Create a Bedrock Runtime client in the AWS Region you want to use.
var client = new AmazonBedrockRuntimeClient(RegionEndpoint.USEast1);
// Set the model ID, e.g., Llama 3 8b Instruct.
var modelId = "meta.llama3-8b-instruct-v1:0";
// Define the user message.
var userMessage = "Describe the purpose of a 'hello world' program in one line.";
// Create a request with the model ID, the user message, and an inference configuration.
var request = new ConverseRequest
{
ModelId = modelId,
Messages = new List
{
new Message
{
Role = ConversationRole.User,
Content = new List { new ContentBlock { Text = userMessage } }
}
},
InferenceConfig = new InferenceConfiguration()
{
MaxTokens = 512,
Temperature = 0.5F,
TopP = 0.9F
}
};
try
{
// Send the request to the Bedrock Runtime and wait for the result.
var response = await client.ConverseAsync(request);
// Extract and print the response text.
string responseText = response?.Output?.Message?.Content?[0]?.Text ?? "";
Console.WriteLine(responseText);
}
catch (AmazonBedrockRuntimeException e)
{
Console.WriteLine($"ERROR: Can't invoke '{modelId}'. Reason: {e.Message}");
throw;
}
```
+ For API details, see [Converse](https://docs.aws.amazon.com/goto/DotNetSDKV4/bedrock-runtime-2023-09-30/Converse) in *AWS SDK for .NET API Reference*.
------
#### [ Java ]
**SDK for Java 2.x**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Send a text message to Meta Llama, using Bedrock's Converse API.
```
// Use the Converse API to send a text message to Meta Llama.
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.core.exception.SdkClientException;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.bedrockruntime.BedrockRuntimeClient;
import software.amazon.awssdk.services.bedrockruntime.model.ContentBlock;
import software.amazon.awssdk.services.bedrockruntime.model.ConversationRole;
import software.amazon.awssdk.services.bedrockruntime.model.ConverseResponse;
import software.amazon.awssdk.services.bedrockruntime.model.Message;
public class Converse {
public static String converse() {
// Create a Bedrock Runtime client in the AWS Region you want to use.
// Replace the DefaultCredentialsProvider with your preferred credentials provider.
var client = BedrockRuntimeClient.builder()
.credentialsProvider(DefaultCredentialsProvider.create())
.region(Region.US_EAST_1)
.build();
// Set the model ID, e.g., Llama 3 8b Instruct.
var modelId = "meta.llama3-8b-instruct-v1:0";
// Create the input text and embed it in a message object with the user role.
var inputText = "Describe the purpose of a 'hello world' program in one line.";
var message = Message.builder()
.content(ContentBlock.fromText(inputText))
.role(ConversationRole.USER)
.build();
try {
// Send the message with a basic inference configuration.
ConverseResponse response = client.converse(request -> request
.modelId(modelId)
.messages(message)
.inferenceConfig(config -> config
.maxTokens(512)
.temperature(0.5F)
.topP(0.9F)));
// Retrieve the generated text from Bedrock's response object.
var responseText = response.output().message().content().get(0).text();
System.out.println(responseText);
return responseText;
} catch (SdkClientException e) {
System.err.printf("ERROR: Can't invoke '%s'. Reason: %s", modelId, e.getMessage());
throw new RuntimeException(e);
}
}
public static void main(String[] args) {
converse();
}
}
```
Send a text message to Meta Llama, using Bedrock's Converse API with the async Java client.
```
// Use the Converse API to send a text message to Meta Llama
// with the async Java client.
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.bedrockruntime.BedrockRuntimeAsyncClient;
import software.amazon.awssdk.services.bedrockruntime.model.ContentBlock;
import software.amazon.awssdk.services.bedrockruntime.model.ConversationRole;
import software.amazon.awssdk.services.bedrockruntime.model.Message;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
public class ConverseAsync {
public static String converseAsync() {
// Create a Bedrock Runtime client in the AWS Region you want to use.
// Replace the DefaultCredentialsProvider with your preferred credentials provider.
var client = BedrockRuntimeAsyncClient.builder()
.credentialsProvider(DefaultCredentialsProvider.create())
.region(Region.US_EAST_1)
.build();
// Set the model ID, e.g., Llama 3 8b Instruct.
var modelId = "meta.llama3-8b-instruct-v1:0";
// Create the input text and embed it in a message object with the user role.
var inputText = "Describe the purpose of a 'hello world' program in one line.";
var message = Message.builder()
.content(ContentBlock.fromText(inputText))
.role(ConversationRole.USER)
.build();
// Send the message with a basic inference configuration.
var request = client.converse(params -> params
.modelId(modelId)
.messages(message)
.inferenceConfig(config -> config
.maxTokens(512)
.temperature(0.5F)
.topP(0.9F))
);
// Prepare a future object to handle the asynchronous response.
CompletableFuture future = new CompletableFuture<>();
// Handle the response or error using the future object.
request.whenComplete((response, error) -> {
if (error == null) {
// Extract the generated text from Bedrock's response object.
String responseText = response.output().message().content().get(0).text();
future.complete(responseText);
} else {
future.completeExceptionally(error);
}
});
try {
// Wait for the future object to complete and retrieve the generated text.
String responseText = future.get();
System.out.println(responseText);
return responseText;
} catch (ExecutionException | InterruptedException e) {
System.err.printf("Can't invoke '%s': %s", modelId, e.getMessage());
throw new RuntimeException(e);
}
}
public static void main(String[] args) {
converseAsync();
}
}
```
+ For API details, see [Converse](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/Converse) in *AWS SDK for Java 2.x API Reference*.
------
#### [ JavaScript ]
**SDK for JavaScript (v3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Send a text message to Meta Llama, using Bedrock's Converse API.
```
// Use the Conversation API to send a text message to Meta Llama.
import {
BedrockRuntimeClient,
ConverseCommand,
} from "@aws-sdk/client-bedrock-runtime";
// Create a Bedrock Runtime client in the AWS Region you want to use.
const client = new BedrockRuntimeClient({ region: "us-east-1" });
// Set the model ID, e.g., Llama 3 8b Instruct.
const modelId = "meta.llama3-8b-instruct-v1:0";
// Start a conversation with the user message.
const userMessage =
"Describe the purpose of a 'hello world' program in one line.";
const conversation = [
{
role: "user",
content: [{ text: userMessage }],
},
];
// Create a command with the model ID, the message, and a basic configuration.
const command = new ConverseCommand({
modelId,
messages: conversation,
inferenceConfig: { maxTokens: 512, temperature: 0.5, topP: 0.9 },
});
try {
// Send the command to the model and wait for the response
const response = await client.send(command);
// Extract and print the response text.
const responseText = response.output.message.content[0].text;
console.log(responseText);
} catch (err) {
console.log(`ERROR: Can't invoke '${modelId}'. Reason: ${err}`);
process.exit(1);
}
```
+ For API details, see [Converse](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseCommand) in *AWS SDK for JavaScript API Reference*.
------
#### [ Python ]
**SDK for Python (Boto3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Send a text message to Meta Llama, using Bedrock's Converse API.
```
# Use the Conversation API to send a text message to Meta Llama.
import boto3
from botocore.exceptions import ClientError
# Create a Bedrock Runtime client in the AWS Region you want to use.
client = boto3.client("bedrock-runtime", region_name="us-east-1")
# Set the model ID, e.g., Llama 3 8b Instruct.
model_id = "meta.llama3-8b-instruct-v1:0"
# Start a conversation with the user message.
user_message = "Describe the purpose of a 'hello world' program in one line."
conversation = [
{
"role": "user",
"content": [{"text": user_message}],
}
]
try:
# Send the message to the model, using a basic inference configuration.
response = client.converse(
modelId=model_id,
messages=conversation,
inferenceConfig={"maxTokens": 512, "temperature": 0.5, "topP": 0.9},
)
# Extract and print the response text.
response_text = response["output"]["message"]["content"][0]["text"]
print(response_text)
except (ClientError, Exception) as e:
print(f"ERROR: Can't invoke '{model_id}'. Reason: {e}")
exit(1)
```
+ For API details, see [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) in *AWS SDK for Python (Boto3) API Reference*.
------
#### [ Swift ]
**SDK for Swift**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/bedrock-runtime#code-examples).
Send a text message to Meta Llama, using Bedrock's Converse API.
```
// An example demonstrating how to use the Conversation API to send
// a text message to Meta Llama.
import AWSBedrockRuntime
func converse(_ textPrompt: String) async throws -> String {
// Create a Bedrock Runtime client in the AWS Region you want to use.
let config =
try await BedrockRuntimeClient.BedrockRuntimeClientConfiguration(
region: "us-east-1"
)
let client = BedrockRuntimeClient(config: config)
// Set the model ID.
let modelId = "meta.llama3-8b-instruct-v1:0"
// Start a conversation with the user message.
let message = BedrockRuntimeClientTypes.Message(
content: [.text(textPrompt)],
role: .user
)
// Optionally use inference parameters
let inferenceConfig =
BedrockRuntimeClientTypes.InferenceConfiguration(
maxTokens: 512,
stopSequences: ["END"],
temperature: 0.5,
topp: 0.9
)
// Create the ConverseInput to send to the model
let input = ConverseInput(
inferenceConfig: inferenceConfig, messages: [message], modelId: modelId)
// Send the ConverseInput to the model
let response = try await client.converse(input: input)
// Extract and return the response text.
if case let .message(msg) = response.output {
if case let .text(textResponse) = msg.content![0] {
return textResponse
} else {
return "No text response found in message content"
}
} else {
return "No message found in converse output"
}
}
```
+ For API details, see [Converse](https://sdk.amazonaws.com/swift/api/awsbedrockruntime/latest/documentation/awsbedrockruntime/bedrockruntimeclient/converse(input:)) in *AWS SDK for Swift API reference*.
------
For a complete list of AWS SDK developer guides and code examples, see [Using Amazon Bedrock with an AWS SDK](sdk-general-information-section.md). This topic also includes information about getting started and details about previous SDK versions.
# Invoke Meta Llama on Amazon Bedrock using Bedrock's Converse API with a response stream
The following code examples show how to send a text message to Meta Llama, using Bedrock's Converse API and process the response stream in real-time.
------
#### [ .NET ]
**SDK for .NET (v4)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Bedrock-runtime#code-examples).
Send a text message to Meta Llama, using Bedrock's Converse API and process the response stream in real-time.
```
// Use the Converse API to send a text message to Meta Llama
// and print the response stream.
using System;
using System.Collections.Generic;
using System.Linq;
using Amazon;
using Amazon.BedrockRuntime;
using Amazon.BedrockRuntime.Model;
// Create a Bedrock Runtime client in the AWS Region you want to use.
var client = new AmazonBedrockRuntimeClient(RegionEndpoint.USEast1);
// Set the model ID, e.g., Llama 3 8b Instruct.
var modelId = "meta.llama3-8b-instruct-v1:0";
// Define the user message.
var userMessage = "Describe the purpose of a 'hello world' program in one line.";
// Create a request with the model ID, the user message, and an inference configuration.
var request = new ConverseStreamRequest
{
ModelId = modelId,
Messages = new List
{
new Message
{
Role = ConversationRole.User,
Content = new List { new ContentBlock { Text = userMessage } }
}
},
InferenceConfig = new InferenceConfiguration()
{
MaxTokens = 512,
Temperature = 0.5F,
TopP = 0.9F
}
};
try
{
// Send the request to the Bedrock Runtime and wait for the result.
var response = await client.ConverseStreamAsync(request);
// Extract and print the streamed response text in real-time.
foreach (var chunk in response.Stream.AsEnumerable())
{
if (chunk is ContentBlockDeltaEvent)
{
Console.Write((chunk as ContentBlockDeltaEvent).Delta.Text);
}
}
}
catch (AmazonBedrockRuntimeException e)
{
Console.WriteLine($"ERROR: Can't invoke '{modelId}'. Reason: {e.Message}");
throw;
}
```
+ For API details, see [ConverseStream](https://docs.aws.amazon.com/goto/DotNetSDKV4/bedrock-runtime-2023-09-30/ConverseStream) in *AWS SDK for .NET API Reference*.
------
#### [ Java ]
**SDK for Java 2.x**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Send a text message to Meta Llama, using Bedrock's Converse API and process the response stream in real-time.
```
// Use the Converse API to send a text message to Meta Llama
// and print the response stream.
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.bedrockruntime.BedrockRuntimeAsyncClient;
import software.amazon.awssdk.services.bedrockruntime.model.ContentBlock;
import software.amazon.awssdk.services.bedrockruntime.model.ConversationRole;
import software.amazon.awssdk.services.bedrockruntime.model.ConverseStreamResponseHandler;
import software.amazon.awssdk.services.bedrockruntime.model.Message;
import java.util.concurrent.ExecutionException;
public class ConverseStream {
public static void main(String[] args) {
// Create a Bedrock Runtime client in the AWS Region you want to use.
// Replace the DefaultCredentialsProvider with your preferred credentials provider.
var client = BedrockRuntimeAsyncClient.builder()
.credentialsProvider(DefaultCredentialsProvider.create())
.region(Region.US_EAST_1)
.build();
// Set the model ID, e.g., Llama 3 8b Instruct.
var modelId = "meta.llama3-8b-instruct-v1:0";
// Create the input text and embed it in a message object with the user role.
var inputText = "Describe the purpose of a 'hello world' program in one line.";
var message = Message.builder()
.content(ContentBlock.fromText(inputText))
.role(ConversationRole.USER)
.build();
// Create a handler to extract and print the response text in real-time.
var responseStreamHandler = ConverseStreamResponseHandler.builder()
.subscriber(ConverseStreamResponseHandler.Visitor.builder()
.onContentBlockDelta(chunk -> {
String responseText = chunk.delta().text();
System.out.print(responseText);
}).build()
).onError(err ->
System.err.printf("Can't invoke '%s': %s", modelId, err.getMessage())
).build();
try {
// Send the message with a basic inference configuration and attach the handler.
client.converseStream(request -> request
.modelId(modelId)
.messages(message)
.inferenceConfig(config -> config
.maxTokens(512)
.temperature(0.5F)
.topP(0.9F)
), responseStreamHandler).get();
} catch (ExecutionException | InterruptedException e) {
System.err.printf("Can't invoke '%s': %s", modelId, e.getCause().getMessage());
}
}
}
```
+ For API details, see [ConverseStream](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/ConverseStream) in *AWS SDK for Java 2.x API Reference*.
------
#### [ JavaScript ]
**SDK for JavaScript (v3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Send a text message to Meta Llama, using Bedrock's Converse API and process the response stream in real-time.
```
// Use the Conversation API to send a text message to Meta Llama.
import {
BedrockRuntimeClient,
ConverseStreamCommand,
} from "@aws-sdk/client-bedrock-runtime";
// Create a Bedrock Runtime client in the AWS Region you want to use.
const client = new BedrockRuntimeClient({ region: "us-east-1" });
// Set the model ID, e.g., Llama 3 8b Instruct.
const modelId = "meta.llama3-8b-instruct-v1:0";
// Start a conversation with the user message.
const userMessage =
"Describe the purpose of a 'hello world' program in one line.";
const conversation = [
{
role: "user",
content: [{ text: userMessage }],
},
];
// Create a command with the model ID, the message, and a basic configuration.
const command = new ConverseStreamCommand({
modelId,
messages: conversation,
inferenceConfig: { maxTokens: 512, temperature: 0.5, topP: 0.9 },
});
try {
// Send the command to the model and wait for the response
const response = await client.send(command);
// Extract and print the streamed response text in real-time.
for await (const item of response.stream) {
if (item.contentBlockDelta) {
process.stdout.write(item.contentBlockDelta.delta?.text);
}
}
} catch (err) {
console.log(`ERROR: Can't invoke '${modelId}'. Reason: ${err}`);
process.exit(1);
}
```
+ For API details, see [ConverseStream](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseStreamCommand) in *AWS SDK for JavaScript API Reference*.
------
#### [ Python ]
**SDK for Python (Boto3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Send a text message to Meta Llama, using Bedrock's Converse API and process the response stream in real-time.
```
# Use the Conversation API to send a text message to Meta Llama
# and print the response stream.
import boto3
from botocore.exceptions import ClientError
# Create a Bedrock Runtime client in the AWS Region you want to use.
client = boto3.client("bedrock-runtime", region_name="us-east-1")
# Set the model ID, e.g., Llama 3 8b Instruct.
model_id = "meta.llama3-8b-instruct-v1:0"
# Start a conversation with the user message.
user_message = "Describe the purpose of a 'hello world' program in one line."
conversation = [
{
"role": "user",
"content": [{"text": user_message}],
}
]
try:
# Send the message to the model, using a basic inference configuration.
streaming_response = client.converse_stream(
modelId=model_id,
messages=conversation,
inferenceConfig={"maxTokens": 512, "temperature": 0.5, "topP": 0.9},
)
# Extract and print the streamed response text in real-time.
for chunk in streaming_response["stream"]:
if "contentBlockDelta" in chunk:
text = chunk["contentBlockDelta"]["delta"]["text"]
print(text, end="")
except (ClientError, Exception) as e:
print(f"ERROR: Can't invoke '{model_id}'. Reason: {e}")
exit(1)
```
+ For API details, see [ConverseStream](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/ConverseStream) in *AWS SDK for Python (Boto3) API Reference*.
------
#### [ Swift ]
**SDK for Swift**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/bedrock-runtime#code-examples).
Send a text message to Meta Llama, using Bedrock's Converse API and process the response stream in real-time.
```
// An example demonstrating how to use the Conversation API to send a text message
// to Meta Llama and print the response stream.
import AWSBedrockRuntime
func printConverseStream(_ textPrompt: String) async throws {
// Create a Bedrock Runtime client in the AWS Region you want to use.
let config =
try await BedrockRuntimeClient.BedrockRuntimeClientConfiguration(
region: "us-east-1"
)
let client = BedrockRuntimeClient(config: config)
// Set the model ID.
let modelId = "meta.llama3-8b-instruct-v1:0"
// Start a conversation with the user message.
let message = BedrockRuntimeClientTypes.Message(
content: [.text(textPrompt)],
role: .user
)
// Optionally use inference parameters.
let inferenceConfig =
BedrockRuntimeClientTypes.InferenceConfiguration(
maxTokens: 512,
stopSequences: ["END"],
temperature: 0.5,
topp: 0.9
)
// Create the ConverseStreamInput to send to the model.
let input = ConverseStreamInput(
inferenceConfig: inferenceConfig, messages: [message], modelId: modelId)
// Send the ConverseStreamInput to the model.
let response = try await client.converseStream(input: input)
// Extract the streaming response.
guard let stream = response.stream else {
print("No stream available")
return
}
// Extract and print the streamed response text in real-time.
for try await event in stream {
switch event {
case .messagestart(_):
print("\nMeta Llama:")
case .contentblockdelta(let deltaEvent):
if case .text(let text) = deltaEvent.delta {
print(text, terminator: "")
}
default:
break
}
}
}
```
+ For API details, see [ConverseStream](https://sdk.amazonaws.com/swift/api/awsbedrockruntime/latest/documentation/awsbedrockruntime/bedrockruntimeclient/conversestream(input:)) in *AWS SDK for Swift API reference*.
------
For a complete list of AWS SDK developer guides and code examples, see [Using Amazon Bedrock with an AWS SDK](sdk-general-information-section.md). This topic also includes information about getting started and details about previous SDK versions.
# Send and process a document with Llama on Amazon Bedrock
The following code example shows how to send and process a document with Llama on Amazon Bedrock.
------
#### [ Python ]
**SDK for Python (Boto3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Send and process a document with Llama on Amazon Bedrock.
```
# Send and process a document with Llama on Amazon Bedrock.
import boto3
from botocore.exceptions import ClientError
# Create a Bedrock Runtime client in the AWS Region you want to use.
client = boto3.client("bedrock-runtime", region_name="us-east-1")
# Set the model ID, e.g. Llama 3.1 8B Instruct.
model_id = "us.meta.llama3-1-8b-instruct-v1:0"
# Load the document
with open("example-data/amazon-nova-service-cards.pdf", "rb") as file:
document_bytes = file.read()
# Start a conversation with a user message and the document
conversation = [
{
"role": "user",
"content": [
{"text": "Briefly compare the models described in this document"},
{
"document": {
# Available formats: html, md, pdf, doc/docx, xls/xlsx, csv, and txt
"format": "pdf",
"name": "Amazon Nova Service Cards",
"source": {"bytes": document_bytes},
}
},
],
}
]
try:
# Send the message to the model, using a basic inference configuration.
response = client.converse(
modelId=model_id,
messages=conversation,
inferenceConfig={"maxTokens": 500, "temperature": 0.3},
)
# Extract and print the response text.
response_text = response["output"]["message"]["content"][0]["text"]
print(response_text)
except (ClientError, Exception) as e:
print(f"ERROR: Can't invoke '{model_id}'. Reason: {e}")
exit(1)
```
+ For API details, see [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) in *AWS SDK for Python (Boto3) API Reference*.
------
For a complete list of AWS SDK developer guides and code examples, see [Using Amazon Bedrock with an AWS SDK](sdk-general-information-section.md). This topic also includes information about getting started and details about previous SDK versions.
# Invoke Meta Llama on Amazon Bedrock using the Invoke Model API
The following code examples show how to send a text message to Meta Llama, using the Invoke Model API.
------
#### [ .NET ]
**SDK for .NET**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime#code-examples).
Use the Invoke Model API to send a text message.
```
// Use the native inference API to send a text message to Meta Llama 3.
using System;
using System.IO;
using System.Text.Json;
using System.Text.Json.Nodes;
using Amazon;
using Amazon.BedrockRuntime;
using Amazon.BedrockRuntime.Model;
// Create a Bedrock Runtime client in the AWS Region you want to use.
var client = new AmazonBedrockRuntimeClient(RegionEndpoint.USWest2);
// Set the model ID, e.g., Llama 3 70b Instruct.
var modelId = "meta.llama3-70b-instruct-v1:0";
// Define the prompt for the model.
var prompt = "Describe the purpose of a 'hello world' program in one line.";
// Embed the prompt in Llama 2's instruction format.
var formattedPrompt = $@"
<|begin_of_text|><|start_header_id|>user<|end_header_id|>
{prompt}
<|eot_id|>
<|start_header_id|>assistant<|end_header_id|>
";
//Format the request payload using the model's native structure.
var nativeRequest = JsonSerializer.Serialize(new
{
prompt = formattedPrompt,
max_gen_len = 512,
temperature = 0.5
});
// Create a request with the model ID and the model's native request payload.
var request = new InvokeModelRequest()
{
ModelId = modelId,
Body = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(nativeRequest)),
ContentType = "application/json"
};
try
{
// Send the request to the Bedrock Runtime and wait for the response.
var response = await client.InvokeModelAsync(request);
// Decode the response body.
var modelResponse = await JsonNode.ParseAsync(response.Body);
// Extract and print the response text.
var responseText = modelResponse["generation"] ?? "";
Console.WriteLine(responseText);
}
catch (AmazonBedrockRuntimeException e)
{
Console.WriteLine($"ERROR: Can't invoke '{modelId}'. Reason: {e.Message}");
throw;
}
```
+ For API details, see [InvokeModel](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/InvokeModel) in *AWS SDK for .NET API Reference*.
------
#### [ Java ]
**SDK for Java 2.x**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Use the Invoke Model API to send a text message.
```
// Use the native inference API to send a text message to Meta Llama 3.
import org.json.JSONObject;
import org.json.JSONPointer;
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.core.SdkBytes;
import software.amazon.awssdk.core.exception.SdkClientException;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.bedrockruntime.BedrockRuntimeClient;
public class Llama3_InvokeModel {
public static String invokeModel() {
// Create a Bedrock Runtime client in the AWS Region you want to use.
// Replace the DefaultCredentialsProvider with your preferred credentials provider.
var client = BedrockRuntimeClient.builder()
.credentialsProvider(DefaultCredentialsProvider.create())
.region(Region.US_WEST_2)
.build();
// Set the model ID, e.g., Llama 3 70b Instruct.
var modelId = "meta.llama3-70b-instruct-v1:0";
// The InvokeModel API uses the model's native payload.
// Learn more about the available inference parameters and response fields at:
// https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-meta.html
var nativeRequestTemplate = "{ \"prompt\": \"{{instruction}}\" }";
// Define the prompt for the model.
var prompt = "Describe the purpose of a 'hello world' program in one line.";
// Embed the prompt in Llama 3's instruction format.
var instruction = (
"<|begin_of_text|><|start_header_id|>user<|end_header_id|>\\n" +
"{{prompt}} <|eot_id|>\\n" +
"<|start_header_id|>assistant<|end_header_id|>\\n"
).replace("{{prompt}}", prompt);
// Embed the instruction in the the native request payload.
var nativeRequest = nativeRequestTemplate.replace("{{instruction}}", instruction);
try {
// Encode and send the request to the Bedrock Runtime.
var response = client.invokeModel(request -> request
.body(SdkBytes.fromUtf8String(nativeRequest))
.modelId(modelId)
);
// Decode the response body.
var responseBody = new JSONObject(response.body().asUtf8String());
// Retrieve the generated text from the model's response.
var text = new JSONPointer("/generation").queryFrom(responseBody).toString();
System.out.println(text);
return text;
} catch (SdkClientException e) {
System.err.printf("ERROR: Can't invoke '%s'. Reason: %s", modelId, e.getMessage());
throw new RuntimeException(e);
}
}
public static void main(String[] args) {
invokeModel();
}
}
```
+ For API details, see [InvokeModel](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModel) in *AWS SDK for Java 2.x API Reference*.
------
#### [ JavaScript ]
**SDK for JavaScript (v3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Use the Invoke Model API to send a text message.
```
// Send a prompt to Meta Llama 3 and print the response.
import {
BedrockRuntimeClient,
InvokeModelCommand,
} from "@aws-sdk/client-bedrock-runtime";
// Create a Bedrock Runtime client in the AWS Region of your choice.
const client = new BedrockRuntimeClient({ region: "us-west-2" });
// Set the model ID, e.g., Llama 3 70B Instruct.
const modelId = "meta.llama3-70b-instruct-v1:0";
// Define the user message to send.
const userMessage =
"Describe the purpose of a 'hello world' program in one sentence.";
// Embed the message in Llama 3's prompt format.
const prompt = `
<|begin_of_text|><|start_header_id|>user<|end_header_id|>
${userMessage}
<|eot_id|>
<|start_header_id|>assistant<|end_header_id|>
`;
// Format the request payload using the model's native structure.
const request = {
prompt,
// Optional inference parameters:
max_gen_len: 512,
temperature: 0.5,
top_p: 0.9,
};
// Encode and send the request.
const response = await client.send(
new InvokeModelCommand({
contentType: "application/json",
body: JSON.stringify(request),
modelId,
}),
);
// Decode the native response body.
/** @type {{ generation: string }} */
const nativeResponse = JSON.parse(new TextDecoder().decode(response.body));
// Extract and print the generated text.
const responseText = nativeResponse.generation;
console.log(responseText);
// Learn more about the Llama 3 prompt format at:
// https://llama.meta.com/docs/model-cards-and-prompt-formats/meta-llama-3/#special-tokens-used-with-meta-llama-3
```
+ For API details, see [InvokeModel](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/InvokeModelCommand) in *AWS SDK for JavaScript API Reference*.
------
#### [ Python ]
**SDK for Python (Boto3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Use the Invoke Model API to send a text message.
```
# Use the native inference API to send a text message to Meta Llama 3.
import boto3
import json
from botocore.exceptions import ClientError
# Create a Bedrock Runtime client in the AWS Region of your choice.
client = boto3.client("bedrock-runtime", region_name="us-west-2")
# Set the model ID, e.g., Llama 3 70b Instruct.
model_id = "meta.llama3-70b-instruct-v1:0"
# Define the prompt for the model.
prompt = "Describe the purpose of a 'hello world' program in one line."
# Embed the prompt in Llama 3's instruction format.
formatted_prompt = f"""
<|begin_of_text|><|start_header_id|>user<|end_header_id|>
{prompt}
<|eot_id|>
<|start_header_id|>assistant<|end_header_id|>
"""
# Format the request payload using the model's native structure.
native_request = {
"prompt": formatted_prompt,
"max_gen_len": 512,
"temperature": 0.5,
}
# Convert the native request to JSON.
request = json.dumps(native_request)
try:
# Invoke the model with the request.
response = client.invoke_model(modelId=model_id, body=request)
except (ClientError, Exception) as e:
print(f"ERROR: Can't invoke '{model_id}'. Reason: {e}")
exit(1)
# Decode the response body.
model_response = json.loads(response["body"].read())
# Extract and print the response text.
response_text = model_response["generation"]
print(response_text)
```
+ For API details, see [InvokeModel](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModel) in *AWS SDK for Python (Boto3) API Reference*.
------
For a complete list of AWS SDK developer guides and code examples, see [Using Amazon Bedrock with an AWS SDK](sdk-general-information-section.md). This topic also includes information about getting started and details about previous SDK versions.
# Invoke Meta Llama on Amazon Bedrock using the Invoke Model API with a response stream
The following code examples show how to send a text message to Meta Llama, using the Invoke Model API, and print the response stream.
------
#### [ .NET ]
**SDK for .NET**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime#code-examples).
Use the Invoke Model API to send a text message and process the response stream in real-time.
```
// Use the native inference API to send a text message to Meta Llama 3
// and print the response stream.
using System;
using System.IO;
using System.Text.Json;
using System.Text.Json.Nodes;
using Amazon;
using Amazon.BedrockRuntime;
using Amazon.BedrockRuntime.Model;
// Create a Bedrock Runtime client in the AWS Region you want to use.
var client = new AmazonBedrockRuntimeClient(RegionEndpoint.USWest2);
// Set the model ID, e.g., Llama 3 70b Instruct.
var modelId = "meta.llama3-70b-instruct-v1:0";
// Define the prompt for the model.
var prompt = "Describe the purpose of a 'hello world' program in one line.";
// Embed the prompt in Llama 2's instruction format.
var formattedPrompt = $@"
<|begin_of_text|><|start_header_id|>user<|end_header_id|>
{prompt}
<|eot_id|>
<|start_header_id|>assistant<|end_header_id|>
";
//Format the request payload using the model's native structure.
var nativeRequest = JsonSerializer.Serialize(new
{
prompt = formattedPrompt,
max_gen_len = 512,
temperature = 0.5
});
// Create a request with the model ID and the model's native request payload.
var request = new InvokeModelWithResponseStreamRequest()
{
ModelId = modelId,
Body = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(nativeRequest)),
ContentType = "application/json"
};
try
{
// Send the request to the Bedrock Runtime and wait for the response.
var streamingResponse = await client.InvokeModelWithResponseStreamAsync(request);
// Extract and print the streamed response text in real-time.
foreach (var item in streamingResponse.Body)
{
var chunk = JsonSerializer.Deserialize((item as PayloadPart).Bytes);
var text = chunk["generation"] ?? "";
Console.Write(text);
}
}
catch (AmazonBedrockRuntimeException e)
{
Console.WriteLine($"ERROR: Can't invoke '{modelId}'. Reason: {e.Message}");
throw;
}
```
+ For API details, see [InvokeModelWithResponseStream](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/InvokeModelWithResponseStream) in *AWS SDK for .NET API Reference*.
------
#### [ Java ]
**SDK for Java 2.x**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Use the Invoke Model API to send a text message and process the response stream in real-time.
```
// Use the native inference API to send a text message to Meta Llama 3
// and print the response stream.
import org.json.JSONObject;
import org.json.JSONPointer;
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.core.SdkBytes;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.bedrockruntime.BedrockRuntimeAsyncClient;
import software.amazon.awssdk.services.bedrockruntime.model.InvokeModelWithResponseStreamRequest;
import software.amazon.awssdk.services.bedrockruntime.model.InvokeModelWithResponseStreamResponseHandler;
import java.util.concurrent.ExecutionException;
import static software.amazon.awssdk.services.bedrockruntime.model.InvokeModelWithResponseStreamResponseHandler.Visitor;
public class Llama3_InvokeModelWithResponseStream {
public static String invokeModelWithResponseStream() {
// Create a Bedrock Runtime client in the AWS Region you want to use.
// Replace the DefaultCredentialsProvider with your preferred credentials provider.
var client = BedrockRuntimeAsyncClient.builder()
.credentialsProvider(DefaultCredentialsProvider.create())
.region(Region.US_WEST_2)
.build();
// Set the model ID, e.g., Llama 3 70b Instruct.
var modelId = "meta.llama3-70b-instruct-v1:0";
// The InvokeModelWithResponseStream API uses the model's native payload.
// Learn more about the available inference parameters and response fields at:
// https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-meta.html
var nativeRequestTemplate = "{ \"prompt\": \"{{instruction}}\" }";
// Define the prompt for the model.
var prompt = "Describe the purpose of a 'hello world' program in one line.";
// Embed the prompt in Llama 3's instruction format.
var instruction = (
"<|begin_of_text|><|start_header_id|>user<|end_header_id|>\\n" +
"{{prompt}} <|eot_id|>\\n" +
"<|start_header_id|>assistant<|end_header_id|>\\n"
).replace("{{prompt}}", prompt);
// Embed the instruction in the the native request payload.
var nativeRequest = nativeRequestTemplate.replace("{{instruction}}", instruction);
// Create a request with the model ID and the model's native request payload.
var request = InvokeModelWithResponseStreamRequest.builder()
.body(SdkBytes.fromUtf8String(nativeRequest))
.modelId(modelId)
.build();
// Prepare a buffer to accumulate the generated response text.
var completeResponseTextBuffer = new StringBuilder();
// Prepare a handler to extract, accumulate, and print the response text in real-time.
var responseStreamHandler = InvokeModelWithResponseStreamResponseHandler.builder()
.subscriber(Visitor.builder().onChunk(chunk -> {
// Extract and print the text from the model's native response.
var response = new JSONObject(chunk.bytes().asUtf8String());
var text = new JSONPointer("/generation").queryFrom(response);
System.out.print(text);
// Append the text to the response text buffer.
completeResponseTextBuffer.append(text);
}).build()).build();
try {
// Send the request and wait for the handler to process the response.
client.invokeModelWithResponseStream(request, responseStreamHandler).get();
// Return the complete response text.
return completeResponseTextBuffer.toString();
} catch (ExecutionException | InterruptedException e) {
System.err.printf("Can't invoke '%s': %s", modelId, e.getCause().getMessage());
throw new RuntimeException(e);
}
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
invokeModelWithResponseStream();
}
}
```
+ For API details, see [InvokeModelWithResponseStream](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModelWithResponseStream) in *AWS SDK for Java 2.x API Reference*.
------
#### [ JavaScript ]
**SDK for JavaScript (v3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Use the Invoke Model API to send a text message and process the response stream in real-time.
```
// Send a prompt to Meta Llama 3 and print the response stream in real-time.
import {
BedrockRuntimeClient,
InvokeModelWithResponseStreamCommand,
} from "@aws-sdk/client-bedrock-runtime";
// Create a Bedrock Runtime client in the AWS Region of your choice.
const client = new BedrockRuntimeClient({ region: "us-west-2" });
// Set the model ID, e.g., Llama 3 70B Instruct.
const modelId = "meta.llama3-70b-instruct-v1:0";
// Define the user message to send.
const userMessage =
"Describe the purpose of a 'hello world' program in one sentence.";
// Embed the message in Llama 3's prompt format.
const prompt = `
<|begin_of_text|><|start_header_id|>user<|end_header_id|>
${userMessage}
<|eot_id|>
<|start_header_id|>assistant<|end_header_id|>
`;
// Format the request payload using the model's native structure.
const request = {
prompt,
// Optional inference parameters:
max_gen_len: 512,
temperature: 0.5,
top_p: 0.9,
};
// Encode and send the request.
const responseStream = await client.send(
new InvokeModelWithResponseStreamCommand({
contentType: "application/json",
body: JSON.stringify(request),
modelId,
}),
);
// Extract and print the response stream in real-time.
for await (const event of responseStream.body) {
/** @type {{ generation: string }} */
const chunk = JSON.parse(new TextDecoder().decode(event.chunk.bytes));
if (chunk.generation) {
process.stdout.write(chunk.generation);
}
}
// Learn more about the Llama 3 prompt format at:
// https://llama.meta.com/docs/model-cards-and-prompt-formats/meta-llama-3/#special-tokens-used-with-meta-llama-3
```
+ For API details, see [InvokeModelWithResponseStream](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/InvokeModelWithResponseStreamCommand) in *AWS SDK for JavaScript API Reference*.
------
#### [ Python ]
**SDK for Python (Boto3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Use the Invoke Model API to send a text message and process the response stream in real-time.
```
# Use the native inference API to send a text message to Meta Llama 3
# and print the response stream.
import boto3
import json
from botocore.exceptions import ClientError
# Create a Bedrock Runtime client in the AWS Region of your choice.
client = boto3.client("bedrock-runtime", region_name="us-west-2")
# Set the model ID, e.g., Llama 3 70b Instruct.
model_id = "meta.llama3-70b-instruct-v1:0"
# Define the prompt for the model.
prompt = "Describe the purpose of a 'hello world' program in one line."
# Embed the prompt in Llama 3's instruction format.
formatted_prompt = f"""
<|begin_of_text|><|start_header_id|>user<|end_header_id|>
{prompt}
<|eot_id|>
<|start_header_id|>assistant<|end_header_id|>
"""
# Format the request payload using the model's native structure.
native_request = {
"prompt": formatted_prompt,
"max_gen_len": 512,
"temperature": 0.5,
}
# Convert the native request to JSON.
request = json.dumps(native_request)
try:
# Invoke the model with the request.
streaming_response = client.invoke_model_with_response_stream(
modelId=model_id, body=request
)
# Extract and print the response text in real-time.
for event in streaming_response["body"]:
chunk = json.loads(event["chunk"]["bytes"])
if "generation" in chunk:
print(chunk["generation"], end="")
except (ClientError, Exception) as e:
print(f"ERROR: Can't invoke '{model_id}'. Reason: {e}")
exit(1)
```
+ For API details, see [InvokeModelWithResponseStream](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModelWithResponseStream) in *AWS SDK for Python (Boto3) API Reference*.
------
For a complete list of AWS SDK developer guides and code examples, see [Using Amazon Bedrock with an AWS SDK](sdk-general-information-section.md). This topic also includes information about getting started and details about previous SDK versions.
# Mistral AI for Amazon Bedrock Runtime
The following code examples show how to use Amazon Bedrock Runtime with AWS SDKs.
**Topics**
+ [Converse](bedrock-runtime_example_bedrock-runtime_Converse_Mistral_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_Mistral_section.md)
+ [Document understanding](bedrock-runtime_example_bedrock-runtime_DocumentUnderstanding_Mistral_section.md)
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_MistralAi_section.md)
+ [InvokeModelWithResponseStream](bedrock-runtime_example_bedrock-runtime_InvokeModelWithResponseStream_MistralAi_section.md)
# Invoke Mistral on Amazon Bedrock using Bedrock's Converse API
The following code examples show how to send a text message to Mistral, using Bedrock's Converse API.
------
#### [ .NET ]
**SDK for .NET (v4)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Bedrock-runtime#code-examples).
Send a text message to Mistral, using Bedrock's Converse API.
```
// Use the Converse API to send a text message to Mistral.
using System;
using System.Collections.Generic;
using Amazon;
using Amazon.BedrockRuntime;
using Amazon.BedrockRuntime.Model;
// Create a Bedrock Runtime client in the AWS Region you want to use.
var client = new AmazonBedrockRuntimeClient(RegionEndpoint.USEast1);
// Set the model ID, e.g., Mistral Large.
var modelId = "mistral.mistral-large-2402-v1:0";
// Define the user message.
var userMessage = "Describe the purpose of a 'hello world' program in one line.";
// Create a request with the model ID, the user message, and an inference configuration.
var request = new ConverseRequest
{
ModelId = modelId,
Messages = new List
{
new Message
{
Role = ConversationRole.User,
Content = new List { new ContentBlock { Text = userMessage } }
}
},
InferenceConfig = new InferenceConfiguration()
{
MaxTokens = 512,
Temperature = 0.5F,
TopP = 0.9F
}
};
try
{
// Send the request to the Bedrock Runtime and wait for the result.
var response = await client.ConverseAsync(request);
// Extract and print the response text.
string responseText = response?.Output?.Message?.Content?[0]?.Text ?? "";
Console.WriteLine(responseText);
}
catch (AmazonBedrockRuntimeException e)
{
Console.WriteLine($"ERROR: Can't invoke '{modelId}'. Reason: {e.Message}");
throw;
}
```
+ For API details, see [Converse](https://docs.aws.amazon.com/goto/DotNetSDKV4/bedrock-runtime-2023-09-30/Converse) in *AWS SDK for .NET API Reference*.
------
#### [ Java ]
**SDK for Java 2.x**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Send a text message to Mistral, using Bedrock's Converse API.
```
// Use the Converse API to send a text message to Mistral.
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.core.exception.SdkClientException;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.bedrockruntime.BedrockRuntimeClient;
import software.amazon.awssdk.services.bedrockruntime.model.ContentBlock;
import software.amazon.awssdk.services.bedrockruntime.model.ConversationRole;
import software.amazon.awssdk.services.bedrockruntime.model.ConverseResponse;
import software.amazon.awssdk.services.bedrockruntime.model.Message;
public class Converse {
public static String converse() {
// Create a Bedrock Runtime client in the AWS Region you want to use.
// Replace the DefaultCredentialsProvider with your preferred credentials provider.
var client = BedrockRuntimeClient.builder()
.credentialsProvider(DefaultCredentialsProvider.create())
.region(Region.US_EAST_1)
.build();
// Set the model ID, e.g., Mistral Large.
var modelId = "mistral.mistral-large-2402-v1:0";
// Create the input text and embed it in a message object with the user role.
var inputText = "Describe the purpose of a 'hello world' program in one line.";
var message = Message.builder()
.content(ContentBlock.fromText(inputText))
.role(ConversationRole.USER)
.build();
try {
// Send the message with a basic inference configuration.
ConverseResponse response = client.converse(request -> request
.modelId(modelId)
.messages(message)
.inferenceConfig(config -> config
.maxTokens(512)
.temperature(0.5F)
.topP(0.9F)));
// Retrieve the generated text from Bedrock's response object.
var responseText = response.output().message().content().get(0).text();
System.out.println(responseText);
return responseText;
} catch (SdkClientException e) {
System.err.printf("ERROR: Can't invoke '%s'. Reason: %s", modelId, e.getMessage());
throw new RuntimeException(e);
}
}
public static void main(String[] args) {
converse();
}
}
```
Send a text message to Mistral, using Bedrock's Converse API with the async Java client.
```
// Use the Converse API to send a text message to Mistral
// with the async Java client.
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.bedrockruntime.BedrockRuntimeAsyncClient;
import software.amazon.awssdk.services.bedrockruntime.model.ContentBlock;
import software.amazon.awssdk.services.bedrockruntime.model.ConversationRole;
import software.amazon.awssdk.services.bedrockruntime.model.Message;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
public class ConverseAsync {
public static String converseAsync() {
// Create a Bedrock Runtime client in the AWS Region you want to use.
// Replace the DefaultCredentialsProvider with your preferred credentials provider.
var client = BedrockRuntimeAsyncClient.builder()
.credentialsProvider(DefaultCredentialsProvider.create())
.region(Region.US_EAST_1)
.build();
// Set the model ID, e.g., Mistral Large.
var modelId = "mistral.mistral-large-2402-v1:0";
// Create the input text and embed it in a message object with the user role.
var inputText = "Describe the purpose of a 'hello world' program in one line.";
var message = Message.builder()
.content(ContentBlock.fromText(inputText))
.role(ConversationRole.USER)
.build();
// Send the message with a basic inference configuration.
var request = client.converse(params -> params
.modelId(modelId)
.messages(message)
.inferenceConfig(config -> config
.maxTokens(512)
.temperature(0.5F)
.topP(0.9F))
);
// Prepare a future object to handle the asynchronous response.
CompletableFuture future = new CompletableFuture<>();
// Handle the response or error using the future object.
request.whenComplete((response, error) -> {
if (error == null) {
// Extract the generated text from Bedrock's response object.
String responseText = response.output().message().content().get(0).text();
future.complete(responseText);
} else {
future.completeExceptionally(error);
}
});
try {
// Wait for the future object to complete and retrieve the generated text.
String responseText = future.get();
System.out.println(responseText);
return responseText;
} catch (ExecutionException | InterruptedException e) {
System.err.printf("Can't invoke '%s': %s", modelId, e.getMessage());
throw new RuntimeException(e);
}
}
public static void main(String[] args) {
converseAsync();
}
}
```
+ For API details, see [Converse](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/Converse) in *AWS SDK for Java 2.x API Reference*.
------
#### [ JavaScript ]
**SDK for JavaScript (v3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Send a text message to Mistral, using Bedrock's Converse API.
```
// Use the Conversation API to send a text message to Mistral.
import {
BedrockRuntimeClient,
ConverseCommand,
} from "@aws-sdk/client-bedrock-runtime";
// Create a Bedrock Runtime client in the AWS Region you want to use.
const client = new BedrockRuntimeClient({ region: "us-east-1" });
// Set the model ID, e.g., Mistral Large.
const modelId = "mistral.mistral-large-2402-v1:0";
// Start a conversation with the user message.
const userMessage =
"Describe the purpose of a 'hello world' program in one line.";
const conversation = [
{
role: "user",
content: [{ text: userMessage }],
},
];
// Create a command with the model ID, the message, and a basic configuration.
const command = new ConverseCommand({
modelId,
messages: conversation,
inferenceConfig: { maxTokens: 512, temperature: 0.5, topP: 0.9 },
});
try {
// Send the command to the model and wait for the response
const response = await client.send(command);
// Extract and print the response text.
const responseText = response.output.message.content[0].text;
console.log(responseText);
} catch (err) {
console.log(`ERROR: Can't invoke '${modelId}'. Reason: ${err}`);
process.exit(1);
}
```
+ For API details, see [Converse](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseCommand) in *AWS SDK for JavaScript API Reference*.
------
#### [ Python ]
**SDK for Python (Boto3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Send a text message to Mistral, using Bedrock's Converse API.
```
# Use the Conversation API to send a text message to Mistral.
import boto3
from botocore.exceptions import ClientError
# Create a Bedrock Runtime client in the AWS Region you want to use.
client = boto3.client("bedrock-runtime", region_name="us-east-1")
# Set the model ID, e.g., Mistral Large.
model_id = "mistral.mistral-large-2402-v1:0"
# Start a conversation with the user message.
user_message = "Describe the purpose of a 'hello world' program in one line."
conversation = [
{
"role": "user",
"content": [{"text": user_message}],
}
]
try:
# Send the message to the model, using a basic inference configuration.
response = client.converse(
modelId=model_id,
messages=conversation,
inferenceConfig={"maxTokens": 512, "temperature": 0.5, "topP": 0.9},
)
# Extract and print the response text.
response_text = response["output"]["message"]["content"][0]["text"]
print(response_text)
except (ClientError, Exception) as e:
print(f"ERROR: Can't invoke '{model_id}'. Reason: {e}")
exit(1)
```
+ For API details, see [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) in *AWS SDK for Python (Boto3) API Reference*.
------
For a complete list of AWS SDK developer guides and code examples, see [Using Amazon Bedrock with an AWS SDK](sdk-general-information-section.md). This topic also includes information about getting started and details about previous SDK versions.
# Invoke Mistral on Amazon Bedrock using Bedrock's Converse API with a response stream
The following code examples show how to send a text message to Mistral, using Bedrock's Converse API and process the response stream in real-time.
------
#### [ .NET ]
**SDK for .NET (v4)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Bedrock-runtime#code-examples).
Send a text message to Mistral, using Bedrock's Converse API and process the response stream in real-time.
```
// Use the Converse API to send a text message to Mistral
// and print the response stream.
using System;
using System.Collections.Generic;
using System.Linq;
using Amazon;
using Amazon.BedrockRuntime;
using Amazon.BedrockRuntime.Model;
// Create a Bedrock Runtime client in the AWS Region you want to use.
var client = new AmazonBedrockRuntimeClient(RegionEndpoint.USEast1);
// Set the model ID, e.g., Mistral Large.
var modelId = "mistral.mistral-large-2402-v1:0";
// Define the user message.
var userMessage = "Describe the purpose of a 'hello world' program in one line.";
// Create a request with the model ID, the user message, and an inference configuration.
var request = new ConverseStreamRequest
{
ModelId = modelId,
Messages = new List
{
new Message
{
Role = ConversationRole.User,
Content = new List { new ContentBlock { Text = userMessage } }
}
},
InferenceConfig = new InferenceConfiguration()
{
MaxTokens = 512,
Temperature = 0.5F,
TopP = 0.9F
}
};
try
{
// Send the request to the Bedrock Runtime and wait for the result.
var response = await client.ConverseStreamAsync(request);
// Extract and print the streamed response text in real-time.
foreach (var chunk in response.Stream.AsEnumerable())
{
if (chunk is ContentBlockDeltaEvent)
{
Console.Write((chunk as ContentBlockDeltaEvent).Delta.Text);
}
}
}
catch (AmazonBedrockRuntimeException e)
{
Console.WriteLine($"ERROR: Can't invoke '{modelId}'. Reason: {e.Message}");
throw;
}
```
+ For API details, see [ConverseStream](https://docs.aws.amazon.com/goto/DotNetSDKV4/bedrock-runtime-2023-09-30/ConverseStream) in *AWS SDK for .NET API Reference*.
------
#### [ Java ]
**SDK for Java 2.x**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Send a text message to Mistral, using Bedrock's Converse API and process the response stream in real-time.
```
// Use the Converse API to send a text message to Mistral
// and print the response stream.
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.bedrockruntime.BedrockRuntimeAsyncClient;
import software.amazon.awssdk.services.bedrockruntime.model.ContentBlock;
import software.amazon.awssdk.services.bedrockruntime.model.ConversationRole;
import software.amazon.awssdk.services.bedrockruntime.model.ConverseStreamResponseHandler;
import software.amazon.awssdk.services.bedrockruntime.model.Message;
import java.util.concurrent.ExecutionException;
public class ConverseStream {
public static void main(String[] args) {
// Create a Bedrock Runtime client in the AWS Region you want to use.
// Replace the DefaultCredentialsProvider with your preferred credentials provider.
var client = BedrockRuntimeAsyncClient.builder()
.credentialsProvider(DefaultCredentialsProvider.create())
.region(Region.US_EAST_1)
.build();
// Set the model ID, e.g., Mistral Large.
var modelId = "mistral.mistral-large-2402-v1:0";
// Create the input text and embed it in a message object with the user role.
var inputText = "Describe the purpose of a 'hello world' program in one line.";
var message = Message.builder()
.content(ContentBlock.fromText(inputText))
.role(ConversationRole.USER)
.build();
// Create a handler to extract and print the response text in real-time.
var responseStreamHandler = ConverseStreamResponseHandler.builder()
.subscriber(ConverseStreamResponseHandler.Visitor.builder()
.onContentBlockDelta(chunk -> {
String responseText = chunk.delta().text();
System.out.print(responseText);
}).build()
).onError(err ->
System.err.printf("Can't invoke '%s': %s", modelId, err.getMessage())
).build();
try {
// Send the message with a basic inference configuration and attach the handler.
client.converseStream(request -> request.modelId(modelId)
.messages(message)
.inferenceConfig(config -> config
.maxTokens(512)
.temperature(0.5F)
.topP(0.9F)
), responseStreamHandler).get();
} catch (ExecutionException | InterruptedException e) {
System.err.printf("Can't invoke '%s': %s", modelId, e.getCause().getMessage());
}
}
}
```
+ For API details, see [ConverseStream](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/ConverseStream) in *AWS SDK for Java 2.x API Reference*.
------
#### [ JavaScript ]
**SDK for JavaScript (v3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Send a text message to Mistral, using Bedrock's Converse API and process the response stream in real-time.
```
// Use the Conversation API to send a text message to Mistral.
import {
BedrockRuntimeClient,
ConverseStreamCommand,
} from "@aws-sdk/client-bedrock-runtime";
// Create a Bedrock Runtime client in the AWS Region you want to use.
const client = new BedrockRuntimeClient({ region: "us-east-1" });
// Set the model ID, e.g., Mistral Large.
const modelId = "mistral.mistral-large-2402-v1:0";
// Start a conversation with the user message.
const userMessage =
"Describe the purpose of a 'hello world' program in one line.";
const conversation = [
{
role: "user",
content: [{ text: userMessage }],
},
];
// Create a command with the model ID, the message, and a basic configuration.
const command = new ConverseStreamCommand({
modelId,
messages: conversation,
inferenceConfig: { maxTokens: 512, temperature: 0.5, topP: 0.9 },
});
try {
// Send the command to the model and wait for the response
const response = await client.send(command);
// Extract and print the streamed response text in real-time.
for await (const item of response.stream) {
if (item.contentBlockDelta) {
process.stdout.write(item.contentBlockDelta.delta?.text);
}
}
} catch (err) {
console.log(`ERROR: Can't invoke '${modelId}'. Reason: ${err}`);
process.exit(1);
}
```
+ For API details, see [ConverseStream](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseStreamCommand) in *AWS SDK for JavaScript API Reference*.
------
#### [ Python ]
**SDK for Python (Boto3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Send a text message to Mistral, using Bedrock's Converse API and process the response stream in real-time.
```
# Use the Conversation API to send a text message to Mistral
# and print the response stream.
import boto3
from botocore.exceptions import ClientError
# Create a Bedrock Runtime client in the AWS Region you want to use.
client = boto3.client("bedrock-runtime", region_name="us-east-1")
# Set the model ID, e.g., Mistral Large.
model_id = "mistral.mistral-large-2402-v1:0"
# Start a conversation with the user message.
user_message = "Describe the purpose of a 'hello world' program in one line."
conversation = [
{
"role": "user",
"content": [{"text": user_message}],
}
]
try:
# Send the message to the model, using a basic inference configuration.
streaming_response = client.converse_stream(
modelId=model_id,
messages=conversation,
inferenceConfig={"maxTokens": 512, "temperature": 0.5, "topP": 0.9},
)
# Extract and print the streamed response text in real-time.
for chunk in streaming_response["stream"]:
if "contentBlockDelta" in chunk:
text = chunk["contentBlockDelta"]["delta"]["text"]
print(text, end="")
except (ClientError, Exception) as e:
print(f"ERROR: Can't invoke '{model_id}'. Reason: {e}")
exit(1)
```
+ For API details, see [ConverseStream](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/ConverseStream) in *AWS SDK for Python (Boto3) API Reference*.
------
For a complete list of AWS SDK developer guides and code examples, see [Using Amazon Bedrock with an AWS SDK](sdk-general-information-section.md). This topic also includes information about getting started and details about previous SDK versions.
# Send and process a document with Mistral models on Amazon Bedrock
The following code example shows how to send and process a document with Mistral models on Amazon Bedrock.
------
#### [ Python ]
**SDK for Python (Boto3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Send and process a document with Mistral models on Amazon Bedrock.
```
# Send and process a document with Mistral models on Amazon Bedrock.
import boto3
from botocore.exceptions import ClientError
# Create a Bedrock Runtime client in the AWS Region you want to use.
client = boto3.client("bedrock-runtime", region_name="us-east-1")
# Set the model ID, e.g., Mistral Large.
model_id = "mistral.mistral-large-2402-v1:0"
# Load the document
with open("example-data/amazon-nova-service-cards.pdf", "rb") as file:
document_bytes = file.read()
# Start a conversation with a user message and the document
conversation = [
{
"role": "user",
"content": [
{"text": "Briefly compare the models described in this document"},
{
"document": {
# Available formats: html, md, pdf, doc/docx, xls/xlsx, csv, and txt
"format": "pdf",
"name": "Amazon Nova Service Cards",
"source": {"bytes": document_bytes},
}
},
],
}
]
try:
# Send the message to the model, using a basic inference configuration.
response = client.converse(
modelId=model_id,
messages=conversation,
inferenceConfig={"maxTokens": 500, "temperature": 0.3},
)
# Extract and print the response text.
response_text = response["output"]["message"]["content"][0]["text"]
print(response_text)
except (ClientError, Exception) as e:
print(f"ERROR: Can't invoke '{model_id}'. Reason: {e}")
exit(1)
```
+ For API details, see [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) in *AWS SDK for Python (Boto3) API Reference*.
------
For a complete list of AWS SDK developer guides and code examples, see [Using Amazon Bedrock with an AWS SDK](sdk-general-information-section.md). This topic also includes information about getting started and details about previous SDK versions.
# Invoke Mistral AI models on Amazon Bedrock using the Invoke Model API
The following code examples show how to send a text message to Mistral models, using the Invoke Model API.
------
#### [ .NET ]
**SDK for .NET**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime#code-examples).
Use the Invoke Model API to send a text message.
```
// Use the native inference API to send a text message to Mistral.
using System;
using System.IO;
using System.Text.Json;
using System.Text.Json.Nodes;
using Amazon;
using Amazon.BedrockRuntime;
using Amazon.BedrockRuntime.Model;
// Create a Bedrock Runtime client in the AWS Region you want to use.
var client = new AmazonBedrockRuntimeClient(RegionEndpoint.USEast1);
// Set the model ID, e.g., Mistral Large.
var modelId = "mistral.mistral-large-2402-v1:0";
// Define the prompt for the model.
var prompt = "Describe the purpose of a 'hello world' program in one line.";
// Embed the prompt in Mistral's instruction format.
var formattedPrompt = $"[INST] {prompt} [/INST]";
//Format the request payload using the model's native structure.
var nativeRequest = JsonSerializer.Serialize(new
{
prompt = formattedPrompt,
max_tokens = 512,
temperature = 0.5
});
// Create a request with the model ID and the model's native request payload.
var request = new InvokeModelRequest()
{
ModelId = modelId,
Body = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(nativeRequest)),
ContentType = "application/json"
};
try
{
// Send the request to the Bedrock Runtime and wait for the response.
var response = await client.InvokeModelAsync(request);
// Decode the response body.
var modelResponse = await JsonNode.ParseAsync(response.Body);
// Extract and print the response text.
var responseText = modelResponse["outputs"]?[0]?["text"] ?? "";
Console.WriteLine(responseText);
}
catch (AmazonBedrockRuntimeException e)
{
Console.WriteLine($"ERROR: Can't invoke '{modelId}'. Reason: {e.Message}");
throw;
}
```
+ For API details, see [InvokeModel](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/InvokeModel) in *AWS SDK for .NET API Reference*.
------
#### [ Java ]
**SDK for Java 2.x**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Use the Invoke Model API to send a text message.
```
// Use the native inference API to send a text message to Mistral.
import org.json.JSONObject;
import org.json.JSONPointer;
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.core.SdkBytes;
import software.amazon.awssdk.core.exception.SdkClientException;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.bedrockruntime.BedrockRuntimeClient;
public class InvokeModel {
public static String invokeModel() {
// Create a Bedrock Runtime client in the AWS Region you want to use.
// Replace the DefaultCredentialsProvider with your preferred credentials provider.
var client = BedrockRuntimeClient.builder()
.credentialsProvider(DefaultCredentialsProvider.create())
.region(Region.US_EAST_1)
.build();
// Set the model ID, e.g., Mistral Large.
var modelId = "mistral.mistral-large-2402-v1:0";
// The InvokeModel API uses the model's native payload.
// Learn more about the available inference parameters and response fields at:
// https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-mistral-text-completion.html
var nativeRequestTemplate = "{ \"prompt\": \"{{instruction}}\" }";
// Define the prompt for the model.
var prompt = "Describe the purpose of a 'hello world' program in one line.";
// Embed the prompt in Mistral's instruction format.
var instruction = "[INST] {{prompt}} [/INST]\\n".replace("{{prompt}}", prompt);
// Embed the instruction in the the native request payload.
var nativeRequest = nativeRequestTemplate.replace("{{instruction}}", instruction);
try {
// Encode and send the request to the Bedrock Runtime.
var response = client.invokeModel(request -> request
.body(SdkBytes.fromUtf8String(nativeRequest))
.modelId(modelId)
);
// Decode the response body.
var responseBody = new JSONObject(response.body().asUtf8String());
// Retrieve the generated text from the model's response.
var text = new JSONPointer("/outputs/0/text").queryFrom(responseBody).toString();
System.out.println(text);
return text;
} catch (SdkClientException e) {
System.err.printf("ERROR: Can't invoke '%s'. Reason: %s", modelId, e.getMessage());
throw new RuntimeException(e);
}
}
public static void main(String[] args) {
invokeModel();
}
}
```
+ For API details, see [InvokeModel](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModel) in *AWS SDK for Java 2.x API Reference*.
------
#### [ JavaScript ]
**SDK for JavaScript (v3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Use the Invoke Model API to send a text message.
```
import { fileURLToPath } from "node:url";
import { FoundationModels } from "../../config/foundation_models.js";
import {
BedrockRuntimeClient,
InvokeModelCommand,
} from "@aws-sdk/client-bedrock-runtime";
/**
* @typedef {Object} Output
* @property {string} text
*
* @typedef {Object} ResponseBody
* @property {Output[]} outputs
*/
/**
* Invokes a Mistral 7B Instruct model.
*
* @param {string} prompt - The input text prompt for the model to complete.
* @param {string} [modelId] - The ID of the model to use. Defaults to "mistral.mistral-7b-instruct-v0:2".
*/
export const invokeModel = async (
prompt,
modelId = "mistral.mistral-7b-instruct-v0:2",
) => {
// Create a new Bedrock Runtime client instance.
const client = new BedrockRuntimeClient({ region: "us-east-1" });
// Mistral instruct models provide optimal results when embedding
// the prompt into the following template:
const instruction = `[INST] ${prompt} [/INST]`;
// Prepare the payload.
const payload = {
prompt: instruction,
max_tokens: 500,
temperature: 0.5,
};
// Invoke the model with the payload and wait for the response.
const command = new InvokeModelCommand({
contentType: "application/json",
body: JSON.stringify(payload),
modelId,
});
const apiResponse = await client.send(command);
// Decode and return the response.
const decodedResponseBody = new TextDecoder().decode(apiResponse.body);
/** @type {ResponseBody} */
const responseBody = JSON.parse(decodedResponseBody);
return responseBody.outputs[0].text;
};
// Invoke the function if this file was run directly.
if (process.argv[1] === fileURLToPath(import.meta.url)) {
const prompt =
'Complete the following in one sentence: "Once upon a time..."';
const modelId = FoundationModels.MISTRAL_7B.modelId;
console.log(`Prompt: ${prompt}`);
console.log(`Model ID: ${modelId}`);
try {
console.log("-".repeat(53));
const response = await invokeModel(prompt, modelId);
console.log(response);
} catch (err) {
console.log(err);
}
}
```
+ For API details, see [InvokeModel](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/InvokeModelCommand) in *AWS SDK for JavaScript API Reference*.
------
#### [ Python ]
**SDK for Python (Boto3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Use the Invoke Model API to send a text message.
```
# Use the native inference API to send a text message to Mistral.
import boto3
import json
from botocore.exceptions import ClientError
# Create a Bedrock Runtime client in the AWS Region of your choice.
client = boto3.client("bedrock-runtime", region_name="us-east-1")
# Set the model ID, e.g., Mistral Large.
model_id = "mistral.mistral-large-2402-v1:0"
# Define the prompt for the model.
prompt = "Describe the purpose of a 'hello world' program in one line."
# Embed the prompt in Mistral's instruction format.
formatted_prompt = f"[INST] {prompt} [/INST]"
# Format the request payload using the model's native structure.
native_request = {
"prompt": formatted_prompt,
"max_tokens": 512,
"temperature": 0.5,
}
# Convert the native request to JSON.
request = json.dumps(native_request)
try:
# Invoke the model with the request.
response = client.invoke_model(modelId=model_id, body=request)
except (ClientError, Exception) as e:
print(f"ERROR: Can't invoke '{model_id}'. Reason: {e}")
exit(1)
# Decode the response body.
model_response = json.loads(response["body"].read())
# Extract and print the response text.
response_text = model_response["outputs"][0]["text"]
print(response_text)
```
+ For API details, see [InvokeModel](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModel) in *AWS SDK for Python (Boto3) API Reference*.
------
For a complete list of AWS SDK developer guides and code examples, see [Using Amazon Bedrock with an AWS SDK](sdk-general-information-section.md). This topic also includes information about getting started and details about previous SDK versions.
# Invoke Mistral AI models on Amazon Bedrock using the Invoke Model API with a response stream
The following code examples show how to send a text message to Mistral AI models, using the Invoke Model API, and print the response stream.
------
#### [ .NET ]
**SDK for .NET**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime#code-examples).
Use the Invoke Model API to send a text message and process the response stream in real-time.
```
// Use the native inference API to send a text message to Mistral
// and print the response stream.
using System;
using System.IO;
using System.Text.Json;
using System.Text.Json.Nodes;
using Amazon;
using Amazon.BedrockRuntime;
using Amazon.BedrockRuntime.Model;
// Create a Bedrock Runtime client in the AWS Region you want to use.
var client = new AmazonBedrockRuntimeClient(RegionEndpoint.USEast1);
// Set the model ID, e.g., Mistral Large.
var modelId = "mistral.mistral-large-2402-v1:0";
// Define the prompt for the model.
var prompt = "Describe the purpose of a 'hello world' program in one line.";
// Embed the prompt in Mistral's instruction format.
var formattedPrompt = $"[INST] {prompt} [/INST]";
//Format the request payload using the model's native structure.
var nativeRequest = JsonSerializer.Serialize(new
{
prompt = formattedPrompt,
max_tokens = 512,
temperature = 0.5
});
// Create a request with the model ID and the model's native request payload.
var request = new InvokeModelWithResponseStreamRequest()
{
ModelId = modelId,
Body = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(nativeRequest)),
ContentType = "application/json"
};
try
{
// Send the request to the Bedrock Runtime and wait for the response.
var streamingResponse = await client.InvokeModelWithResponseStreamAsync(request);
// Extract and print the streamed response text in real-time.
foreach (var item in streamingResponse.Body)
{
var chunk = JsonSerializer.Deserialize((item as PayloadPart).Bytes);
var text = chunk["outputs"]?[0]?["text"] ?? "";
Console.Write(text);
}
}
catch (AmazonBedrockRuntimeException e)
{
Console.WriteLine($"ERROR: Can't invoke '{modelId}'. Reason: {e.Message}");
throw;
}
```
+ For API details, see [InvokeModelWithResponseStream](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/InvokeModelWithResponseStream) in *AWS SDK for .NET API Reference*.
------
#### [ Java ]
**SDK for Java 2.x**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Use the Invoke Model API to send a text message and process the response stream in real-time.
```
// Use the native inference API to send a text message to Mistral
// and print the response stream.
import org.json.JSONObject;
import org.json.JSONPointer;
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.core.SdkBytes;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.bedrockruntime.BedrockRuntimeAsyncClient;
import software.amazon.awssdk.services.bedrockruntime.model.InvokeModelWithResponseStreamRequest;
import software.amazon.awssdk.services.bedrockruntime.model.InvokeModelWithResponseStreamResponseHandler;
import java.util.concurrent.ExecutionException;
import static software.amazon.awssdk.services.bedrockruntime.model.InvokeModelWithResponseStreamResponseHandler.Visitor;
public class InvokeModelWithResponseStream {
public static String invokeModelWithResponseStream() {
// Create a Bedrock Runtime client in the AWS Region you want to use.
// Replace the DefaultCredentialsProvider with your preferred credentials provider.
var client = BedrockRuntimeAsyncClient.builder()
.credentialsProvider(DefaultCredentialsProvider.create())
.region(Region.US_EAST_1)
.build();
// Set the model ID, e.g., Mistral Large.
var modelId = "mistral.mistral-large-2402-v1:0";
// The InvokeModelWithResponseStream API uses the model's native payload.
// Learn more about the available inference parameters and response fields at:
// https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-mistral-text-completion.html
var nativeRequestTemplate = "{ \"prompt\": \"{{instruction}}\" }";
// Define the prompt for the model.
var prompt = "Describe the purpose of a 'hello world' program in one line.";
// Embed the prompt in Mistral's instruction format.
var instruction = "[INST] {{prompt}} [/INST]\\n".replace("{{prompt}}", prompt);
// Embed the instruction in the the native request payload.
var nativeRequest = nativeRequestTemplate.replace("{{instruction}}", instruction);
// Create a request with the model ID and the model's native request payload.
var request = InvokeModelWithResponseStreamRequest.builder()
.body(SdkBytes.fromUtf8String(nativeRequest))
.modelId(modelId)
.build();
// Prepare a buffer to accumulate the generated response text.
var completeResponseTextBuffer = new StringBuilder();
// Prepare a handler to extract, accumulate, and print the response text in real-time.
var responseStreamHandler = InvokeModelWithResponseStreamResponseHandler.builder()
.subscriber(Visitor.builder().onChunk(chunk -> {
// Extract and print the text from the model's native response.
var response = new JSONObject(chunk.bytes().asUtf8String());
var text = new JSONPointer("/outputs/0/text").queryFrom(response);
System.out.print(text);
// Append the text to the response text buffer.
completeResponseTextBuffer.append(text);
}).build()).build();
try {
// Send the request and wait for the handler to process the response.
client.invokeModelWithResponseStream(request, responseStreamHandler).get();
// Return the complete response text.
return completeResponseTextBuffer.toString();
} catch (ExecutionException | InterruptedException e) {
System.err.printf("Can't invoke '%s': %s", modelId, e.getCause().getMessage());
throw new RuntimeException(e);
}
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
invokeModelWithResponseStream();
}
}
```
+ For API details, see [InvokeModelWithResponseStream](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModelWithResponseStream) in *AWS SDK for Java 2.x API Reference*.
------
#### [ Python ]
**SDK for Python (Boto3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Use the Invoke Model API to send a text message and process the response stream in real-time.
```
# Use the native inference API to send a text message to Mistral
# and print the response stream.
import boto3
import json
from botocore.exceptions import ClientError
# Create a Bedrock Runtime client in the AWS Region of your choice.
client = boto3.client("bedrock-runtime", region_name="us-east-1")
# Set the model ID, e.g., Mistral Large.
model_id = "mistral.mistral-large-2402-v1:0"
# Define the prompt for the model.
prompt = "Describe the purpose of a 'hello world' program in one line."
# Embed the prompt in Mistral's instruction format.
formatted_prompt = f"[INST] {prompt} [/INST]"
# Format the request payload using the model's native structure.
native_request = {
"prompt": formatted_prompt,
"max_tokens": 512,
"temperature": 0.5,
}
# Convert the native request to JSON.
request = json.dumps(native_request)
try:
# Invoke the model with the request.
streaming_response = client.invoke_model_with_response_stream(
modelId=model_id, body=request
)
# Extract and print the response text in real-time.
for event in streaming_response["body"]:
chunk = json.loads(event["chunk"]["bytes"])
if "outputs" in chunk:
print(chunk["outputs"][0].get("text"), end="")
except (ClientError, Exception) as e:
print(f"ERROR: Can't invoke '{model_id}''. Reason: {e}")
exit(1)
```
+ For API details, see [InvokeModelWithResponseStream](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModelWithResponseStream) in *AWS SDK for Python (Boto3) API Reference*.
------
For a complete list of AWS SDK developer guides and code examples, see [Using Amazon Bedrock with an AWS SDK](sdk-general-information-section.md). This topic also includes information about getting started and details about previous SDK versions.
# Stable Diffusion for Amazon Bedrock Runtime
The following code examples show how to use Amazon Bedrock Runtime with AWS SDKs.
**Topics**
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_StableDiffusion_section.md)
# Invoke Stability.ai Stable Diffusion XL on Amazon Bedrock to generate an image
The following code examples show how to invoke Stability.ai Stable Diffusion XL on Amazon Bedrock to generate an image.
------
#### [ Java ]
**SDK for Java 2.x**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Create an image with Stable Diffusion.
```
// Create an image with Stable Diffusion.
import org.json.JSONObject;
import org.json.JSONPointer;
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.core.SdkBytes;
import software.amazon.awssdk.core.exception.SdkClientException;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.bedrockruntime.BedrockRuntimeClient;
import java.math.BigInteger;
import java.security.SecureRandom;
import static com.example.bedrockruntime.libs.ImageTools.displayImage;
public class InvokeModel {
public static String invokeModel() {
// Create a Bedrock Runtime client in the AWS Region you want to use.
// Replace the DefaultCredentialsProvider with your preferred credentials provider.
var client = BedrockRuntimeClient.builder()
.credentialsProvider(DefaultCredentialsProvider.create())
.region(Region.US_EAST_1)
.build();
// Set the model ID, e.g., Stable Diffusion XL v1.
var modelId = "stability.stable-diffusion-xl-v1";
// The InvokeModel API uses the model's native payload.
// Learn more about the available inference parameters and response fields at:
// https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-diffusion-1-0-text-image.html
var nativeRequestTemplate = """
{
"text_prompts": [{ "text": "{{prompt}}" }],
"style_preset": "{{style}}",
"seed": {{seed}}
}""";
// Define the prompt for the image generation.
var prompt = "A stylized picture of a cute old steampunk robot";
// Get a random 32-bit seed for the image generation (max. 4,294,967,295).
var seed = new BigInteger(31, new SecureRandom());
// Choose a style preset.
var style = "cinematic";
// Embed the prompt, seed, and style in the model's native request payload.
String nativeRequest = nativeRequestTemplate
.replace("{{prompt}}", prompt)
.replace("{{seed}}", seed.toString())
.replace("{{style}}", style);
try {
// Encode and send the request to the Bedrock Runtime.
var response = client.invokeModel(request -> request
.body(SdkBytes.fromUtf8String(nativeRequest))
.modelId(modelId)
);
// Decode the response body.
var responseBody = new JSONObject(response.body().asUtf8String());
// Retrieve the generated image data from the model's response.
var base64ImageData = new JSONPointer("/artifacts/0/base64")
.queryFrom(responseBody)
.toString();
return base64ImageData;
} catch (SdkClientException e) {
System.err.printf("ERROR: Can't invoke '%s'. Reason: %s", modelId, e.getMessage());
throw new RuntimeException(e);
}
}
public static void main(String[] args) {
System.out.println("Generating image. This may take a few seconds...");
String base64ImageData = invokeModel();
displayImage(base64ImageData);
}
}
```
+ For API details, see [InvokeModel](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModel) in *AWS SDK for Java 2.x API Reference*.
------
#### [ PHP ]
**SDK for PHP**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/bedrock-runtime#code-examples).
Create an image with Stable Diffusion.
```
public function invokeStableDiffusion(string $prompt, int $seed, string $style_preset)
{
// The different model providers have individual request and response formats.
// For the format, ranges, and available style_presets of Stable Diffusion models refer to:
// https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-stability-diffusion.html
$base64_image_data = "";
try {
$modelId = 'stability.stable-diffusion-xl-v1';
$body = [
'text_prompts' => [
['text' => $prompt]
],
'seed' => $seed,
'cfg_scale' => 10,
'steps' => 30
];
if ($style_preset) {
$body['style_preset'] = $style_preset;
}
$result = $this->bedrockRuntimeClient->invokeModel([
'contentType' => 'application/json',
'body' => json_encode($body),
'modelId' => $modelId,
]);
$response_body = json_decode($result['body']);
$base64_image_data = $response_body->artifacts[0]->base64;
} catch (Exception $e) {
echo "Error: ({$e->getCode()}) - {$e->getMessage()}\n";
}
return $base64_image_data;
}
```
+ For API details, see [InvokeModel](https://docs.aws.amazon.com/goto/SdkForPHPV3/bedrock-runtime-2023-09-30/InvokeModel) in *AWS SDK for PHP API Reference*.
------
#### [ Python ]
**SDK for Python (Boto3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Create an image with Stable Diffusion.
```
# Use the native inference API to create an image with Stability.ai Stable Diffusion
import base64
import boto3
import json
import os
import random
# Create a Bedrock Runtime client in the AWS Region of your choice.
client = boto3.client("bedrock-runtime", region_name="us-east-1")
# Set the model ID, e.g., Stable Diffusion XL 1.
model_id = "stability.stable-diffusion-xl-v1"
# Define the image generation prompt for the model.
prompt = "A stylized picture of a cute old steampunk robot."
# Generate a random seed.
seed = random.randint(0, 4294967295)
# Format the request payload using the model's native structure.
native_request = {
"text_prompts": [{"text": prompt}],
"style_preset": "photographic",
"seed": seed,
"cfg_scale": 10,
"steps": 30,
}
# Convert the native request to JSON.
request = json.dumps(native_request)
# Invoke the model with the request.
response = client.invoke_model(modelId=model_id, body=request)
# Decode the response body.
model_response = json.loads(response["body"].read())
# Extract the image data.
base64_image_data = model_response["artifacts"][0]["base64"]
# Save the generated image to a local folder.
i, output_dir = 1, "output"
if not os.path.exists(output_dir):
os.makedirs(output_dir)
while os.path.exists(os.path.join(output_dir, f"stability_{i}.png")):
i += 1
image_data = base64.b64decode(base64_image_data)
image_path = os.path.join(output_dir, f"stability_{i}.png")
with open(image_path, "wb") as file:
file.write(image_data)
print(f"The generated image has been saved to {image_path}")
```
+ For API details, see [InvokeModel](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModel) in *AWS SDK for Python (Boto3) API Reference*.
------
#### [ SAP ABAP ]
**SDK for SAP ABAP**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/bdr#code-examples).
Create an image with Stable Diffusion.
```
"Stable Diffusion Input Parameters should be in a format like this:
* {
* "text_prompts": [
* {"text":"Draw a dolphin with a mustache"},
* {"text":"Make it photorealistic"}
* ],
* "cfg_scale":10,
* "seed":0,
* "steps":50
* }
TYPES: BEGIN OF prompt_ts,
text TYPE /aws1/rt_shape_string,
END OF prompt_ts.
DATA: BEGIN OF ls_input,
text_prompts TYPE STANDARD TABLE OF prompt_ts,
cfg_scale TYPE /aws1/rt_shape_integer,
seed TYPE /aws1/rt_shape_integer,
steps TYPE /aws1/rt_shape_integer,
END OF ls_input.
APPEND VALUE prompt_ts( text = iv_prompt ) TO ls_input-text_prompts.
ls_input-cfg_scale = 10.
ls_input-seed = 0. "or better, choose a random integer.
ls_input-steps = 50.
DATA(lv_json) = /ui2/cl_json=>serialize(
data = ls_input
pretty_name = /ui2/cl_json=>pretty_mode-low_case ).
TRY.
DATA(lo_response) = lo_bdr->invokemodel(
iv_body = /aws1/cl_rt_util=>string_to_xstring( lv_json )
iv_modelid = 'stability.stable-diffusion-xl-v1'
iv_accept = 'application/json'
iv_contenttype = 'application/json' ).
"Stable Diffusion Result Format:
* {
* "result": "success",
* "artifacts": [
* {
* "seed": 0,
* "base64": "iVBORw0KGgoAAAANSUhEUgAAAgAAA....
* "finishReason": "SUCCESS"
* }
* ]
* }
TYPES: BEGIN OF artifact_ts,
seed TYPE /aws1/rt_shape_integer,
base64 TYPE /aws1/rt_shape_string,
finishreason TYPE /aws1/rt_shape_string,
END OF artifact_ts.
DATA: BEGIN OF ls_response,
result TYPE /aws1/rt_shape_string,
artifacts TYPE STANDARD TABLE OF artifact_ts,
END OF ls_response.
/ui2/cl_json=>deserialize(
EXPORTING jsonx = lo_response->get_body( )
pretty_name = /ui2/cl_json=>pretty_mode-camel_case
CHANGING data = ls_response ).
IF ls_response-artifacts IS NOT INITIAL.
DATA(lv_image) = cl_http_utility=>if_http_utility~decode_x_base64( ls_response-artifacts[ 1 ]-base64 ).
ENDIF.
CATCH /aws1/cx_bdraccessdeniedex INTO DATA(lo_ex).
WRITE / lo_ex->get_text( ).
WRITE / |Don't forget to enable model access at https://console.aws.amazon.com/bedrock/home?#/modelaccess|.
ENDTRY.
```
Invoke the Stability.ai Stable Diffusion XL foundation model to generate images using L2 high level client.
```
TRY.
DATA(lo_bdr_l2_sd) = /aws1/cl_bdr_l2_factory=>create_stable_diffusion_xl_1( lo_bdr ).
" iv_prompt contains a prompt like 'Show me a picture of a unicorn reading an enterprise financial report'.
DATA(lv_image) = lo_bdr_l2_sd->text_to_image( iv_prompt ).
CATCH /aws1/cx_bdraccessdeniedex INTO DATA(lo_ex).
WRITE / lo_ex->get_text( ).
WRITE / |Don't forget to enable model access at https://console.aws.amazon.com/bedrock/home?#/modelaccess|.
ENDTRY.
```
+ For API details, see [InvokeModel](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html) in *AWS SDK for SAP ABAP API reference*.
------
For a complete list of AWS SDK developer guides and code examples, see [Using Amazon Bedrock with an AWS SDK](sdk-general-information-section.md). This topic also includes information about getting started and details about previous SDK versions.