D'autres exemples de AWS SDK sont disponibles dans le référentiel [AWS Doc SDK Examples](https://github.com/awsdocs/aws-doc-sdk-examples) GitHub .
Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Exemples de code pour Amazon Bedrock Runtime utilisant AWS SDKs
Les exemples de code suivants vous montrent comment utiliser Amazon Bedrock Runtime avec un kit de développement AWS logiciel (SDK).
Les *scénarios* sont des exemples de code qui vous montrent comment accomplir des tâches spécifiques en appelant plusieurs fonctions au sein d’un même service ou combinés à d’autres Services AWS.
**Ressources supplémentaires**
+ **[Guide de l’utilisateur Amazon Bedrock Runtime](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html)** : plus d’informations sur Amazon Bedrock Runtime.
+ **[Référence des API Amazon Bedrock Runtime](https://docs.aws.amazon.com/bedrock/latest/APIReference/welcome.html)** : détails sur toutes les actions Amazon Bedrock Runtime disponibles.
+ **[AWS Centre pour les développeurs](https://aws.amazon.com/developer/code-examples/?awsf.sdk-code-examples-product=product%23bedrock)** : exemples de code que vous pouvez filtrer par catégorie ou par recherche en texte intégral.
+ **[AWS Exemples de SDK](https://github.com/awsdocs/aws-doc-sdk-examples)** : GitHub dépôt avec code complet dans les langues préférées. Inclut des instructions sur la configuration et l’exécution du code.
**Contents**
+ [Principes de base](bedrock-runtime_code_examples_basics.md)
+ [Bonjour Amazon Bedrock](bedrock-runtime_example_bedrock-runtime_Hello_section.md)
+ [Scénarios](bedrock-runtime_code_examples_scenarios.md)
+ [Création d’une application de terrain de jeu pour interagir avec les modèles de fondation Amazon Bedrock](bedrock-runtime_example_cross_FMPlayground_section.md)
+ [Création et invocation d’une invite gérée](bedrock-runtime_example_bedrock-agent_GettingStartedWithBedrockPrompts_section.md)
+ [Génération de vidéos à partir d’invites textuelles avec Amazon Bedrock](bedrock-runtime_example_bedrock-runtime_Scenario_GenerateVideos_NovaReel_section.md)
+ [Invocation de plusieurs modèles de fondation sur Amazon Bedrock](bedrock-runtime_example_bedrock-runtime_Scenario_InvokeModels_section.md)
+ [Orchestration des applications d’IA génératives avec Step Functions](bedrock-runtime_example_cross_ServerlessPromptChaining_section.md)
+ [Utilisation de l’outil avec l’API Converse](bedrock-runtime_example_bedrock-runtime_Scenario_ToolUse_section.md)
+ [Amazon Nova](bedrock-runtime_code_examples_amazon_nova.md)
+ [Converse](bedrock-runtime_example_bedrock-runtime_Converse_AmazonNovaText_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_AmazonNovaText_section.md)
+ [Compréhension des documents](bedrock-runtime_example_bedrock-runtime_DocumentUnderstanding_AmazonNova_section.md)
+ [Scénario : utilisation de l’outil avec l’API Converse](bedrock-runtime_example_bedrock-runtime_Scenario_ToolUseDemo_AmazonNova_section.md)
+ [Amazon Nova Canvas](bedrock-runtime_code_examples_amazon_nova_canvas.md)
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_AmazonNovaImageGeneration_section.md)
+ [Amazon Nova Reel](bedrock-runtime_code_examples_amazon_nova_reel.md)
+ [T ext-to-video](bedrock-runtime_example_bedrock-runtime_Scenario_AmazonNova_TextToVideo_section.md)
+ [Générateur d’images Amazon Titan](bedrock-runtime_code_examples_amazon_titan_image_generator.md)
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_TitanImageGenerator_section.md)
+ [Amazon Titan Text](bedrock-runtime_code_examples_amazon_titan_text.md)
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_TitanText_section.md)
+ [Plongement lexical Amazon Titan](bedrock-runtime_code_examples_amazon_titan_text_embeddings.md)
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModelWithResponseStream_TitanTextEmbeddings_section.md)
+ [Anthropic Claude](bedrock-runtime_code_examples_anthropic_claude.md)
+ [Converse](bedrock-runtime_example_bedrock-runtime_Converse_AnthropicClaude_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_AnthropicClaude_section.md)
+ [Compréhension des documents](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)
+ [Raisonnement](bedrock-runtime_example_bedrock-runtime_Converse_AnthropicClaudeReasoning_section.md)
+ [Raisonnement avec une réponse en streaming](bedrock-runtime_example_bedrock-runtime_ConverseStream_AnthropicClaudeReasoning_section.md)
+ [Scénario : utilisation de l’outil avec l’API Converse](bedrock-runtime_example_bedrock-runtime_Scenario_ToolUseDemo_AnthropicClaude_section.md)
+ [Cohere Command](bedrock-runtime_code_examples_cohere_command.md)
+ [Converse](bedrock-runtime_example_bedrock-runtime_Converse_CohereCommand_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_CohereCommand_section.md)
+ [Compréhension des documents](bedrock-runtime_example_bedrock-runtime_DocumentUnderstanding_CohereCommand_section.md)
+ [InvokeModel: Command R et R\$1](bedrock-runtime_example_bedrock-runtime_InvokeModel_CohereCommandR_section.md)
+ [InvokeModelWithResponseStream: Command R et R\$1](bedrock-runtime_example_bedrock-runtime_InvokeModelWithResponseStream_CohereCommandR_section.md)
+ [Scénario : utilisation de l’outil avec l’API Converse](bedrock-runtime_example_bedrock-runtime_Scenario_ToolUseDemo_CohereCommand_section.md)
+ [DeepSeek](bedrock-runtime_code_examples_deepseek.md)
+ [Compréhension des documents](bedrock-runtime_example_bedrock-runtime_DocumentUnderstanding_DeepSeek_section.md)
+ [Meta Llama](bedrock-runtime_code_examples_meta_llama.md)
+ [Converse](bedrock-runtime_example_bedrock-runtime_Converse_MetaLlama_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_MetaLlama_section.md)
+ [Compréhension des documents](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](bedrock-runtime_code_examples_mistral_ai.md)
+ [Converse](bedrock-runtime_example_bedrock-runtime_Converse_Mistral_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_Mistral_section.md)
+ [Compréhension des documents](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](bedrock-runtime_code_examples_stable_diffusion.md)
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_StableDiffusion_section.md)
# Exemples de base pour l'utilisation d'Amazon Bedrock Runtime AWS SDKs
Les exemples de code suivants montrent comment utiliser les bases d'Amazon Bedrock Runtime avec AWS SDKs.
**Contents**
+ [Bonjour Amazon Bedrock](bedrock-runtime_example_bedrock-runtime_Hello_section.md)
# Bonjour Amazon Bedrock
Les exemples de code suivants montrent comment démarrer avec Amazon Bedrock.
------
#### [ Go ]
**Kit SDK pour Go V2**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](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)
}
```
+ Pour plus de détails sur l'API, voir [InvokeModel](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/bedrockruntime#Client.InvokeModel)la section *Référence des AWS SDK pour Go API*.
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](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();
}
```
+ Pour plus de détails sur l'API, voir [InvokeModel](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/InvokeModelCommand)la section *Référence des AWS SDK pour JavaScript API*.
------
# Scénarios d'utilisation d'Amazon Bedrock Runtime AWS SDKs
Les exemples de code suivants vous montrent comment implémenter des scénarios courants dans Amazon Bedrock Runtime avec AWS SDKs. Ces scénarios vous montrent comment accomplir des tâches spécifiques en appelant plusieurs fonctions d’exécution d’Amazon Bedrock ou en les combinant avec d’autres Services AWS. Chaque exemple inclut un lien vers le code source complet, où vous trouverez des instructions sur la configuration et l’exécution du code.
Les scénarios ciblent un niveau d’expérience intermédiaire pour vous aider à comprendre les actions de service dans leur contexte.
**Topics**
+ [Création d’une application de terrain de jeu pour interagir avec les modèles de fondation Amazon Bedrock](bedrock-runtime_example_cross_FMPlayground_section.md)
+ [Création et invocation d’une invite gérée](bedrock-runtime_example_bedrock-agent_GettingStartedWithBedrockPrompts_section.md)
+ [Génération de vidéos à partir d’invites textuelles avec Amazon Bedrock](bedrock-runtime_example_bedrock-runtime_Scenario_GenerateVideos_NovaReel_section.md)
+ [Invocation de plusieurs modèles de fondation sur Amazon Bedrock](bedrock-runtime_example_bedrock-runtime_Scenario_InvokeModels_section.md)
+ [Orchestration des applications d’IA génératives avec Step Functions](bedrock-runtime_example_cross_ServerlessPromptChaining_section.md)
+ [Utilisation de l’outil avec l’API Converse](bedrock-runtime_example_bedrock-runtime_Scenario_ToolUse_section.md)
# Créez un exemple d'application proposant des terrains de jeu pour interagir avec les modèles de fondation Amazon Bedrock à l'aide d'un SDK AWS
Les exemples de code suivants montrent comment créer des terrains de jeu pour interagir avec les modèles de fondation Amazon Bedrock selon différentes modalités.
------
#### [ .NET ]
**SDK pour .NET**
Le terrain de jeu du modèle de fondation (FM) .NET est un exemple d’application .NET MAUI Blazor qui montre comment utiliser Amazon Bedrock à partir du code C\$1. Cet exemple montre comment les développeurs .NET et C\$1 peuvent utiliser Amazon Bedrock pour créer des applications basées sur l’IA générative. Vous pouvez tester les modèles de fondation Amazon Bedrock et interagir avec en utilisant les quatre terrains de jeu suivants :
+ un terrain de jeu de texte ;
+ un terrain de jeu de chat ;
+ un terrain de jeu de chat vocal ;
+ un terrain de jeu d’images.
L’exemple répertorie et affiche également les modèles de fondation auxquels vous avez accès ainsi que leurs caractéristiques. Pour le code source et les instructions de déploiement, consultez le projet dans [GitHub](https://github.com/build-on-aws/dotnet-fm-playground).
**Les services utilisés dans cet exemple**
+ Exécution d’Amazon Bedrock
------
#### [ Java ]
**SDK pour Java 2.x**
Le terrain de jeu du modèle de fondation (FM) Java est un exemple d’application Spring Boot qui montre comment utiliser Amazon Bedrock avec Java. Cet exemple montre comment les développeurs Java peuvent utiliser Amazon Bedrock pour créer des applications basées sur l’IA générative. Vous pouvez tester les modèles de fondation Amazon Bedrock et interagir avec en utilisant les trois terrains de jeu suivants :
+ un terrain de jeu de texte ;
+ un terrain de jeu de chat ;
+ un terrain de jeu d’images.
L’exemple répertorie et affiche également les modèles de fondation auxquels vous avez accès ainsi que leurs caractéristiques. Pour le code source et les instructions de déploiement, consultez le projet dans [GitHub](https://github.com/build-on-aws/java-fm-playground).
**Les services utilisés dans cet exemple**
+ Exécution d’Amazon Bedrock
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Le Python Foundation Model (FM) Playground est un Python/FastAPI exemple d'application qui montre comment utiliser Amazon Bedrock avec Python. Cet exemple montre comment les développeurs Python peuvent utiliser Amazon Bedrock pour créer des applications basées sur l’IA générative. Vous pouvez tester les modèles de fondation Amazon Bedrock et interagir avec en utilisant les trois terrains de jeu suivants :
+ un terrain de jeu de texte ;
+ un terrain de jeu de chat ;
+ un terrain de jeu d’images.
L’exemple répertorie et affiche également les modèles de fondation auxquels vous avez accès ainsi que leurs caractéristiques. Pour le code source et les instructions de déploiement, consultez le projet dans [GitHub](https://github.com/build-on-aws/python-fm-playground).
**Les services utilisés dans cet exemple**
+ Exécution d’Amazon Bedrock
------
# end-to-endExemple illustrant comment créer et invoquer des invites gérées par Amazon Bedrock à l'aide d'un SDK AWS
L’exemple de code suivant illustre comment :
+ Créez une invite gérée.
+ Créez une version de l’invite.
+ Invoquez l’invite à l’aide de la version.
+ Nettoyez vos ressources (facultatif).
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples).
Créez et invoquez une invite gérée.
```
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()
```
+ Pour plus de détails sur l’API, consultez les rubriques suivantes dans la *Référence des API du kit AWS SDK for Python (Boto3)*.
+ [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)
------
# Génération de vidéos à partir d’invites textuelles à l’aide d’Amazon Bedrock et de Nova-Reel
L’exemple de code suivant montre comment utiliser une application Spring Boot qui génère des vidéos à partir d’invites textuelles à l’aide d’Amazon Bedrock et du modèle Nova-Reel.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Générez des vidéos à partir d’invites textuelles à l’aide d’Amazon Bedrock et de 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;
}
}
```
+ Pour plus de détails sur l’API consultez les rubriques suivantes dans la *Référence des API du kit AWS SDK for Java 2.x *.
+ [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)
------
# Invocation de plusieurs modèles de fondation sur Amazon Bedrock
Les exemples de code suivants montrent comment préparer et envoyer une invite à une variété de modèles en langage large (LLMs) sur Amazon Bedrock
------
#### [ Go ]
**Kit SDK pour Go V2**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/bedrock-runtime#code-examples).
Invoquez plusieurs modèles de fondation sur 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)
}
```
+ Pour plus de détails sur l’API, consultez les rubriques suivantes dans la *Référence des API du kit AWS SDK pour Go *.
+ [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 pour JavaScript (v3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](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();
}
```
+ Pour plus de détails sur l’API, consultez les rubriques suivantes dans la *Référence des API du kit AWS SDK pour JavaScript *.
+ [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 ]
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/bedrock-runtime/#code-examples).
Invoquez plusieurs LLMs sur 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;
}
}
```
+ Pour plus de détails sur l’API, consultez les rubriques suivantes dans la *Référence des API du kit AWS SDK pour PHP *.
+ [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)
------
# Création et orchestration d’applications d’IA générative avec Amazon Bedrock et Step Functions
L’exemple de code suivant montre comment créer et orchestrer des applications d’IA générative avec Amazon Bedrock et Step Functions.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Le scénario d’enchaînement des invites Amazon Bedrock sans serveur montre comment [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) et [https://docs.aws.amazon.com/bedrock/latest/userguide/agents.html](https://docs.aws.amazon.com/bedrock/latest/userguide/agents.html) peuvent être utilisés pour créer et orchestrer des applications d’IA générative complexes, sans serveur et hautement évolutives. Il contient les exemples pratiques suivants :
+ Rédigez une analyse d’un roman donné pour un blog littéraire. Cet exemple illustre une chaîne d’invites simple et séquentielle.
+ Générez une courte histoire sur un sujet donné. Cet exemple illustre comment l’IA peut traiter de manière itérative une liste d’éléments qu’elle a précédemment générée.
+ Créez un itinéraire pour un week-end de vacances vers une destination donnée. Cet exemple illustre comment paralléliser plusieurs invites distinctes.
+ Présentez des idées de films à un utilisateur humain agissant en tant que producteur de films. Cet exemple illustre comment paralléliser la même invite avec différents paramètres d’inférence, comment revenir à une étape précédente de la chaîne et comment inclure une entrée humaine dans le flux de travail.
+ Planifiez un repas en fonction des ingrédients que l’utilisateur a à portée de main. Cet exemple illustre comment les enchaînements des invites peuvent intégrer deux conversations distinctes basées sur l’IA, avec deux personnages d’IA engageant un débat entre eux pour améliorer le résultat final.
+ Trouvez et résumez le GitHub référentiel le plus populaire du moment. Cet exemple illustre le chaînage de plusieurs agents d'IA qui interagissent avec des agents externes APIs.
Pour le code source complet et les instructions de configuration et d'exécution, consultez le projet complet sur [GitHub](https://github.com/aws-samples/amazon-bedrock-serverless-prompt-chaining).
**Les services utilisés dans cet exemple**
+ Amazon Bedrock
+ Exécution d’Amazon Bedrock
+ Agents Amazon Bedrock
+ Exécution des agents Amazon Bedrock
+ Step Functions
------
# Exemple d’utilisation d’un outil illustrant comment connecter des modèles d’IA sur Amazon Bedrock à un outil personnalisé ou à une API
Les exemples de code suivants montrent comment créer une interaction typique entre une application, un modèle d'IA génératif et des outils connectés ou APIs comment faciliter les interactions entre l'IA et le monde extérieur. Il utilise comme exemple la connexion d’une API de météorologie externe au modèle d’IA afin de fournir des informations météorologiques en temps réel en fonction des données saisies par l’utilisateur.
------
#### [ .NET ]
**SDK pour .NET**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime/Scenarios/ConverseToolScenario#code-examples).
Exécution principale du flux de scénario. Ce scénario orchestre la conversation entre l’utilisateur, l’API Converse Amazon Bedrock et un outil météo.
```
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();
}
}
```
Outil météo utilisé par la démonstration. Ce fichier définit les spécifications de l’outil et met en œuvre la logique permettant de récupérer les données météorologiques à l’aide de l’API Open-Meteo.
```
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;
}
}
}
```
Action de l’API Converse avec une configuration d’outil.
```
///
/// 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;
}
}
}
```
+ Pour plus de détails sur l’API, consultez [Converse](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/Converse) dans la *Référence des API du kit AWS SDK pour .NET *.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Exécution principale du flux de scénario. Ce scénario orchestre la conversation entre l’utilisateur, l’API Converse Amazon Bedrock et un outil météo.
```
/*
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
=================================================
""");
}
}
```
Outil météo utilisé par la démonstration. Ce fichier définit les spécifications de l’outil et met en œuvre la logique permettant de récupérer les données météorologiques à l’aide de l’API Open-Meteo.
```
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
}
}
```
Action de l’API Converse avec une configuration d’outil.
```
/**
* 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);
}
}
```
+ Pour plus de détails sur l’API, consultez [Converse](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/Converse) dans la *Référence des API du kit AWS SDK for Java 2.x *.
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime/scenarios/converse_tool_scenario#code-examples).
Exécution principale du flux de scénario. Ce scénario orchestre la conversation entre l’utilisateur, l’API Converse Amazon Bedrock et un outil météo.
```
/* 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 });
}
```
+ Pour plus de détails sur l’API, consultez [Converse](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseCommand) dans la *Référence des API du kit AWS SDK pour JavaScript *.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Script d’exécution principal de la démo. Ce script orchestre la conversation entre l’utilisateur, l’API Converse Amazon Bedrock et un outil météo.
```
"""
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()
```
Outil météo utilisé par la démonstration. Ce script définit les spécifications de l’outil et met en œuvre la logique permettant de récupérer les données météorologiques à l’aide de l’API Open-Meteo.
```
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)}
```
+ Pour plus de détails sur l’API, consultez [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) dans la *Référence des API du kit AWS SDK for Python (Boto3)*.
------
#### [ Rust ]
**SDK pour Rust**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/bedrock-runtime#code-examples).
Scénario principal et logique de la démo. Ceci orchestre la conversation entre l’utilisateur, l’API Converse Amazon Bedrock et un outil météo.
```
#[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();
}
```
Outil météo utilisé par la démonstration. Ce script définit les spécifications de l’outil et met en œuvre la logique permettant de récupérer les données météorologiques à l’aide de l’API Open-Meteo.
```
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()?)
}
```
Utilitaires pour imprimer les blocs de contenu des messages.
```
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:?})"
)))
}
}
```
Utilisez des instructions, l’utilitaire Error et des constantes.
```
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(),
})
}
}
```
+ Pour plus de détails sur l’API, consultez [Converse](https://docs.rs/aws-sdk-bedrockruntime/latest/aws_sdk_bedrockruntime/client/struct.Client.html#method.converse) dans la *Référence des API du kit AWS SDK pour Rust*.
------
# Amazon Nova pour Amazon Bedrock Runtime
Les exemples de code suivants montrent comment utiliser Amazon Bedrock Runtime avec AWS SDKs.
**Topics**
+ [Converse](bedrock-runtime_example_bedrock-runtime_Converse_AmazonNovaText_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_AmazonNovaText_section.md)
+ [Compréhension des documents](bedrock-runtime_example_bedrock-runtime_DocumentUnderstanding_AmazonNova_section.md)
+ [Scénario : utilisation de l’outil avec l’API Converse](bedrock-runtime_example_bedrock-runtime_Scenario_ToolUseDemo_AmazonNova_section.md)
# Invocation d’Amazon Nova sur Amazon Bedrock à l’aide de l’API Converse de Bedrock
Les exemples de code suivants montrent comment envoyer un message texte à Amazon Nova à l’aide de l’API Converse de Bedrock.
------
#### [ .NET ]
**SDK pour .NET**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime#code-examples).
Envoyez un message texte à Amazon Nova à l’aide de l’API Converse de Bedrock.
```
// 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;
}
```
Envoyez une conversation de messages à Amazon Nova à l’aide de l’API Converse de Bedrock avec une configuration d’outil.
```
///
/// 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;
}
}
}
```
+ Pour plus de détails sur l’API, consultez [Converse](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/Converse) dans la *Référence des API du kit AWS SDK pour .NET *.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Envoyez un message texte à Amazon Nova à l’aide de l’API Converse de Bedrock avec le client Java asynchrone.
```
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);
}
}
```
Envoyez un message texte à Amazon Nova à l’aide de l’API Converse de Bedrock.
```
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);
}
}
```
+ Pour plus de détails sur l’API, consultez [Converse](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/Converse) dans la *Référence des API du kit AWS SDK for Java 2.x *.
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Envoyez un message texte à Amazon Nova à l’aide de l’API Converse de Bedrock.
```
// 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;
}
```
Envoyez une conversation de messages à Amazon Nova à l’aide de l’API Converse de Bedrock avec une configuration d’outil.
```
// 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);
```
+ Pour plus de détails sur l’API, consultez [Converse](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseCommand) dans la *Référence des API du kit AWS SDK pour JavaScript *.
------
#### [ Kotlin ]
**SDK pour Kotlin**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/bedrock-runtime#code-examples).
Envoyez un message texte à Amazon Nova à l’aide de l’API Converse de Bedrock.
```
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)
}
}
}
```
+ Pour plus de détails sur l’API, consultez [Converse](https://sdk.amazonaws.com/kotlin/api/latest/index.html) dans la *Référence des API du kit AWS SDK pour Kotlin*.
------
#### [ PHP ]
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/bedrock-runtime#code-examples).
Envoyez un message texte à Amazon Nova à l’aide de l’API Converse de Bedrock.
```
// 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();
```
+ Pour plus de détails sur l’API, consultez [Converse](https://docs.aws.amazon.com/goto/SdkForPHPV3/bedrock-runtime-2023-09-30/Converse) dans la *Référence des API du kit AWS SDK pour PHP *.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Envoyez un message texte à Amazon Nova à l’aide de l’API Converse de Bedrock.
```
# 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)
```
+ Pour plus de détails sur l’API, consultez [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) dans la *Référence des API du kit AWS SDK for Python (Boto3)*.
------
#### [ Swift ]
**Kit SDK pour Swift**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/bedrock-runtime#code-examples).
Envoyez un message texte à Amazon Nova à l’aide de l’API Converse de Bedrock.
```
// 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"
}
}
```
+ Pour plus de détails sur l’API, consultez [Converse](https://sdk.amazonaws.com/swift/api/awsbedrockruntime/latest/documentation/awsbedrockruntime/bedrockruntimeclient/converse(input:)) dans la *Référence des API du kit AWS SDK pour Swift*.
------
# Invocation d’Amazon Nova sur Amazon Bedrock à l’aide de l’API Converse de Bedrock avec un flux de réponses
Les exemples de code suivants montrent comment envoyer un message texte à Amazon Nova à l’aide de l’API Converse de Bedrock et comment traiter le flux de réponses en temps réel.
------
#### [ .NET ]
**SDK pour .NET**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime#code-examples).
Envoyez un message texte à Amazon Nova à l’aide de l’API Converse de Bedrock et traitez le flux de réponses en temps réel.
```
// 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;
}
```
+ Pour plus de détails sur l'API, voir [ConverseStream](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/ConverseStream)la section *Référence des AWS SDK pour .NET API*.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Envoyez un message texte à Amazon Nova à l’aide de l’API Converse de Bedrock et traitez le flux de réponses en temps réel.
```
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();
}
}
```
+ Pour plus de détails sur l'API, voir [ConverseStream](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/ConverseStream)la section *Référence des AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Envoyez un message texte à Amazon Nova à l’aide de l’API Converse de Bedrock et traitez le flux de réponses en temps réel.
```
// 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;
}
```
+ Pour plus de détails sur l'API, voir [ConverseStream](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseStreamCommand)la section *Référence des AWS SDK pour JavaScript API*.
------
#### [ Kotlin ]
**SDK pour Kotlin**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/bedrock-runtime#code-examples).
Envoyez un message texte à Amazon Nova à l’aide de l’API Converse de Bedrock et traitez le flux de réponses en temps réel.
```
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()
}
```
+ Pour plus de détails sur l'API, reportez-vous [ConverseStream](https://sdk.amazonaws.com/kotlin/api/latest/index.html)à la section *AWS SDK pour la référence de l'API Kotlin*.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Envoyez un message texte à Amazon Nova à l’aide de l’API Converse de Bedrock et traitez le flux de réponses en temps réel.
```
# 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)
```
+ Pour plus de détails sur l'API, consultez [ConverseStream](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/ConverseStream)le *AWS manuel de référence de l'API SDK for Python (Boto3*).
------
#### [ Swift ]
**Kit SDK pour Swift**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/bedrock-runtime#code-examples).
Envoyez un message texte à Amazon Nova à l’aide de l’API Converse de Bedrock et traitez le flux de réponses en temps réel.
```
// 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
}
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [ConverseStream](https://sdk.amazonaws.com/swift/api/awsbedrockruntime/latest/documentation/awsbedrockruntime/bedrockruntimeclient/conversestream(input:))à la section *AWS SDK pour la référence de l'API Swift*.
------
# Envoi et traitement d’un document avec Amazon Nova sur Amazon Bedrock
L’exemple de code suivant montre comment envoyer et traiter un document avec Amazon Nova sur Amazon Bedrock.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Envoyez et traitez un document avec Amazon Nova sur 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)
```
+ Pour plus de détails sur l’API, consultez [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) dans la *Référence des API du kit AWS SDK for Python (Boto3)*.
------
# Une démonstration d’utilisation d’outil illustrant comment connecter des modèles d’IA sur Amazon Bedrock à un outil personnalisé ou à une API
Les exemples de code suivants montrent comment créer une interaction typique entre une application, un modèle d'IA génératif et des outils connectés ou APIs comment faciliter les interactions entre l'IA et le monde extérieur. Il utilise comme exemple la connexion d’une API de météorologie externe au modèle d’IA afin de fournir des informations météorologiques en temps réel en fonction des données saisies par l’utilisateur.
------
#### [ .NET ]
**SDK pour .NET**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime/Scenarios/ConverseToolScenario#code-examples).
Exécution principale du flux de scénario. Ce scénario orchestre la conversation entre l’utilisateur, l’API Converse Amazon Bedrock et un outil météo.
```
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();
}
}
```
Outil météo utilisé par la démonstration. Ce fichier définit les spécifications de l’outil et met en œuvre la logique permettant de récupérer les données météorologiques à l’aide de l’API Open-Meteo.
```
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;
}
}
}
```
Action de l’API Converse avec une configuration d’outil.
```
///
/// 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;
}
}
}
```
+ Pour plus de détails sur l’API, consultez [Converse](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/Converse) dans la *Référence des API du kit AWS SDK pour .NET *.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Exécution principale du flux de scénario. Ce scénario orchestre la conversation entre l’utilisateur, l’API Converse Amazon Bedrock et un outil météo.
```
/*
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
=================================================
""");
}
}
```
Outil météo utilisé par la démonstration. Ce fichier définit les spécifications de l’outil et met en œuvre la logique permettant de récupérer les données météorologiques à l’aide de l’API Open-Meteo.
```
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
}
}
```
Action de l’API Converse avec une configuration d’outil.
```
/**
* 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);
}
}
```
+ Pour plus de détails sur l’API, consultez [Converse](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/Converse) dans la *Référence des API du kit AWS SDK for Java 2.x *.
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime/scenarios/converse_tool_scenario#code-examples).
Exécution principale du flux de scénario. Ce scénario orchestre la conversation entre l’utilisateur, l’API Converse Amazon Bedrock et un outil météo.
```
/* 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 });
}
```
+ Pour plus de détails sur l’API, consultez [Converse](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseCommand) dans la *Référence des API du kit AWS SDK pour JavaScript *.
------
# Amazon Nova Canvas pour Amazon Bedrock Runtime
Les exemples de code suivants montrent comment utiliser Amazon Bedrock Runtime avec AWS SDKs.
**Topics**
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_AmazonNovaImageGeneration_section.md)
# Invocation d’Amazon Nova Canvas sur Amazon Bedrock pour générer une image
Les exemples de code suivants montrent comment invoquer Amazon Nova Canvas sur Amazon Bedrock pour générer une image.
------
#### [ .NET ]
**SDK pour .NET**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime#code-examples).
Créez une image avec 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;
}
```
+ Pour plus de détails sur l'API, voir [InvokeModel](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/InvokeModel)la section *Référence des AWS SDK pour .NET API*.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Créez une image avec 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);
}
}
```
+ Pour plus de détails sur l'API, voir [InvokeModel](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModel)la section *Référence des AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Créez une image avec 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;
});
}
```
+ Pour plus de détails sur l'API, voir [InvokeModel](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/InvokeModelCommand)la section *Référence des AWS SDK pour JavaScript API*.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Créez une image avec 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}")
```
+ Pour plus de détails sur l'API, consultez [InvokeModel](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModel)le *AWS manuel de référence de l'API SDK for Python (Boto3*).
------
#### [ Swift ]
**Kit SDK pour Swift**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/bedrock-runtime#code-examples).
Créez une image avec 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)")
}
```
+ Pour plus de détails sur l'API, reportez-vous [InvokeModel](https://sdk.amazonaws.com/swift/api/awsbedrockruntime/latest/documentation/awsbedrockruntime/bedrockruntimeclient/invokemodel(input:))à la section *AWS SDK pour la référence de l'API Swift*.
------
# Amazon Nova Reel pour Amazon Bedrock Runtime
Les exemples de code suivants montrent comment utiliser Amazon Bedrock Runtime avec AWS SDKs.
**Topics**
+ [T ext-to-video](bedrock-runtime_example_bedrock-runtime_Scenario_AmazonNova_TextToVideo_section.md)
# Utilisation d’Amazon Nova Reel pour générer une vidéo à partir d’une invite de texte
Les exemples de code suivants montrent comment utiliser Amazon Nova Reel pour générer une vidéo à partir d’une invite de texte.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Utilisez Amazon Nova Reel pour générer une vidéo à partir d’une invite de texte.
```
"""
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()
```
+ Pour plus de détails sur l’API, consultez les rubriques suivantes dans la *Référence des API du kit AWS SDK for Python (Boto3)*.
+ [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 ]
**Kit SDK pour Swift**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/bedrock-runtime#code-examples).
Utilisez Amazon Nova Reel pour générer une vidéo à partir d’une invite de texte.
```
// 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)")
}
```
+ Pour plus de détails sur l’API, consultez les rubriques suivantes dans la *Référence des API du kit AWS SDK pour Swift*.
+ [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:))
------
# Générateur d’images Amazon Titan pour Amazon Bedrock Runtime
Les exemples de code suivants montrent comment utiliser Amazon Bedrock Runtime avec AWS SDKs.
**Topics**
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_TitanImageGenerator_section.md)
# Invocation d’Amazon Titan Image sur Amazon Bedrock pour générer une image
Les exemples de code suivants montrent comment invoquer Amazon Titan Image sur Amazon Bedrock pour générer une image.
------
#### [ Go ]
**Kit SDK pour Go V2**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/bedrock-runtime#code-examples).
Créez une image avec le générateur d’images Amazon Titan.
```
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
}
```
+ Pour plus de détails sur l'API, voir [InvokeModel](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/bedrockruntime#Client.InvokeModel)la section *Référence des AWS SDK pour Go API*.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Créez une image avec le générateur d’images Amazon Titan.
```
// 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);
}
}
```
+ Pour plus de détails sur l'API, voir [InvokeModel](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModel)la section *Référence des AWS SDK for Java 2.x API*.
------
#### [ PHP ]
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/bedrock-runtime#code-examples).
Créez une image avec le générateur d’images Amazon Titan.
```
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;
}
```
+ Pour plus de détails sur l'API, voir [InvokeModel](https://docs.aws.amazon.com/goto/SdkForPHPV3/bedrock-runtime-2023-09-30/InvokeModel)la section *Référence des AWS SDK pour PHP API*.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Créez une image avec le générateur d’images Amazon Titan.
```
# 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}")
```
+ Pour plus de détails sur l'API, consultez [InvokeModel](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModel)le *AWS manuel de référence de l'API SDK for Python (Boto3*).
------
# Amazon Titan Text pour Amazon Bedrock Runtime
Les exemples de code suivants montrent comment utiliser Amazon Bedrock Runtime avec AWS SDKs.
**Topics**
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_TitanText_section.md)
# Invocation de modèles Amazon Titan Text sur Amazon Bedrock à l’aide de l’API Invoke Model
L’exemple de code suivant montre comment envoyer un message texte à Amazon Titan Text à l’aide de l’API Invoke Model.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Utilisez l’API Invoke Model pour envoyer un message texte.
```
# 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)
```
+ Pour plus de détails sur l'API, consultez [InvokeModel](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModel)le *AWS manuel de référence de l'API SDK for Python (Boto3*).
------
# Plongement lexical Amazon Titan pour Amazon Bedrock Runtime
Les exemples de code suivants montrent comment utiliser Amazon Bedrock Runtime avec AWS SDKs.
**Topics**
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModelWithResponseStream_TitanTextEmbeddings_section.md)
# Invocation du plongement lexical Amazon Titan sur Amazon Bedrock
Les exemples de code suivants montrent comment :
+ Commencez à créer votre première vectorisation.
+ créer des vectorisations configurant le nombre de dimensions et la normalisation (V2 uniquement).
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Créez votre première vectorisation avec le plongement lexical Titan 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();
}
}
```
Invoquez le plongement lexical Titan V2 pour configurer le nombre de dimensions et la normalisation.
```
/**
* 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;
}
```
+ Pour plus de détails sur l'API, voir [InvokeModel](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModel)la section *Référence des AWS SDK for Java 2.x API*.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Créez votre première vectorisation avec le plongement lexical Amazon Titan.
```
# 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)
```
+ Pour plus de détails sur l'API, consultez [InvokeModel](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModel)le *AWS manuel de référence de l'API SDK for Python (Boto3*).
------
# Anthropic Claude pour Amazon Bedrock Runtime
Les exemples de code suivants montrent comment utiliser Amazon Bedrock Runtime avec AWS SDKs.
**Topics**
+ [Converse](bedrock-runtime_example_bedrock-runtime_Converse_AnthropicClaude_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_AnthropicClaude_section.md)
+ [Compréhension des documents](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)
+ [Raisonnement](bedrock-runtime_example_bedrock-runtime_Converse_AnthropicClaudeReasoning_section.md)
+ [Raisonnement avec une réponse en streaming](bedrock-runtime_example_bedrock-runtime_ConverseStream_AnthropicClaudeReasoning_section.md)
+ [Scénario : utilisation de l’outil avec l’API Converse](bedrock-runtime_example_bedrock-runtime_Scenario_ToolUseDemo_AnthropicClaude_section.md)
# Invocation d’Anthropic Claude sur Amazon Bedrock à l’aide de l’API Converse de Bedrock
Les exemples de code suivants montrent comment envoyer un message texte à Anthropic Claude, à l’aide de l’API Converse de Bedrock.
------
#### [ .NET ]
**SDK pour .NET (v4)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Bedrock-runtime#code-examples).
Envoyez un message texte à Anthropic Claude à l’aide de l’API Converse de Bedrock.
```
// 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;
}
```
+ Pour plus de détails sur l’API, consultez [Converse](https://docs.aws.amazon.com/goto/DotNetSDKV4/bedrock-runtime-2023-09-30/Converse) dans la *Référence des API du kit AWS SDK pour .NET *.
------
#### [ Go ]
**Kit SDK pour Go V2**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/bedrock-runtime#code-examples).
Envoyez un message texte à Anthropic Claude à l’aide de l’API Converse de Bedrock.
```
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
}
```
+ Pour plus de détails sur l’API, consultez [Converse](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/bedrockruntime#Client.Converse) dans la *Référence des API du kit AWS SDK pour Go *.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Envoyez un message texte à Anthropic Claude à l’aide de l’API Converse de Bedrock.
```
// 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();
}
}
```
Envoyez un message texte à Anthropic Claude à l’aide de l’API Converse de Bedrock avec le client Java asynchrone.
```
// 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();
}
}
```
+ Pour plus de détails sur l’API, consultez [Converse](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/Converse) dans la *Référence des API du kit AWS SDK for Java 2.x *.
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Envoyez un message texte à Anthropic Claude à l’aide de l’API Converse de Bedrock.
```
// 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);
}
```
+ Pour plus de détails sur l’API, consultez [Converse](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseCommand) dans la *Référence des API du kit AWS SDK pour JavaScript *.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Envoyez un message texte à Anthropic Claude à l’aide de l’API Converse de Bedrock.
```
# 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)
```
+ Pour plus de détails sur l’API, consultez [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) dans la *Référence des API du kit AWS SDK for Python (Boto3)*.
------
#### [ Rust ]
**SDK pour Rust**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/bedrock-runtime#code-examples).
Envoyez un message texte à Anthropic Claude à l’aide de l’API Converse de Bedrock.
```
#[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)
}
```
Utilisez des instructions, l’utilitaire Error et des constantes.
```
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",
})
}
}
```
+ Pour plus de détails sur l’API, consultez [Converse](https://docs.rs/aws-sdk-bedrockruntime/latest/aws_sdk_bedrockruntime/client/struct.Client.html#method.converse) dans la *Référence des API du kit AWS SDK pour Rust*.
------
#### [ Swift ]
**Kit SDK pour Swift**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/bedrock-runtime#code-examples).
Envoyez un message texte à Anthropic Claude à l’aide de l’API Converse de Bedrock.
```
// 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"
}
}
```
+ Pour plus de détails sur l’API, consultez [Converse](https://sdk.amazonaws.com/swift/api/awsbedrockruntime/latest/documentation/awsbedrockruntime/bedrockruntimeclient/converse(input:)) dans la *Référence des API du kit AWS SDK pour Swift*.
------
# Invocation d’Anthropic Claude sur Amazon Bedrock à l’aide de l’API Converse de Bedrock avec un flux de réponses
Les exemples de code suivants montrent comment envoyer un message texte à Anthropic Claude à l’aide de l’API Converse de Bedrock et comment traiter le flux de réponses en temps réel.
------
#### [ .NET ]
**SDK pour .NET (v4)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Bedrock-runtime#code-examples).
Envoyez un message texte à Anthropic Claude à l’aide de l’API Converse de Bedrock et traitez le flux de réponses en temps réel.
```
// 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;
}
```
+ Pour plus de détails sur l'API, voir [ConverseStream](https://docs.aws.amazon.com/goto/DotNetSDKV4/bedrock-runtime-2023-09-30/ConverseStream)la section *Référence des AWS SDK pour .NET API*.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Envoyez un message texte à Anthropic Claude à l’aide de l’API Converse de Bedrock et traitez le flux de réponses en temps réel.
```
// 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());
}
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [ConverseStream](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/ConverseStream)à la section *Référence des AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Envoyez un message texte à Anthropic Claude à l’aide de l’API Converse de Bedrock et traitez le flux de réponses en temps réel.
```
// 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);
}
```
+ Pour plus de détails sur l'API, reportez-vous [ConverseStream](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseStreamCommand)à la section *Référence des AWS SDK pour JavaScript API*.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Envoyez un message texte à Anthropic Claude à l’aide de l’API Converse de Bedrock et traitez le flux de réponses en temps réel.
```
# 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)
```
+ Pour plus de détails sur l'API, consultez [ConverseStream](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/ConverseStream)le *AWS manuel de référence de l'API SDK for Python (Boto3*).
------
#### [ Rust ]
**SDK pour Rust**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/bedrock-runtime#code-examples).
Envoyez un SMS à Anthropic Claude et diffusez des jetons de réponse à l'aide de l'API de ConverseStream Bedrock.
```
#[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(),
})
}
```
Utilisez des instructions, l’utilitaire Error et des constantes.
```
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(),
),
}
}
}
```
+ Pour plus de détails sur l'API, voir [ConverseStream](https://docs.rs/aws-sdk-bedrockruntime/latest/aws_sdk_bedrockruntime/client/struct.Client.html#method.converse_stream)la section de *référence de l'API AWS SDK for Rust*.
------
#### [ Swift ]
**Kit SDK pour Swift**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/bedrock-runtime#code-examples).
Envoyez un message texte à Anthropic Claude à l’aide de l’API Converse de Bedrock et traitez le flux de réponses en temps réel.
```
// 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
}
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [ConverseStream](https://sdk.amazonaws.com/swift/api/awsbedrockruntime/latest/documentation/awsbedrockruntime/bedrockruntimeclient/conversestream(input:))à la section *AWS SDK pour la référence de l'API Swift*.
------
# Envoi et traitement d’un document avec Anthropic Claude sur Amazon Bedrock
L’exemple de code suivant montre comment envoyer et traiter un document avec Anthropic Claude sur Amazon Bedrock.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Envoyez et traitez un document avec Anthropic Claude sur 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)
```
+ Pour plus de détails sur l’API, consultez [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) dans la *Référence des API du kit AWS SDK for Python (Boto3)*.
------
# Invocation d’Anthropic Claude sur Amazon Bedrock à l’aide de l’API Invoke Model
Les exemples de code suivants montrent comment envoyer un message texte à Anthropic Claude à l’aide de l’API Invoke Model.
------
#### [ .NET ]
**SDK pour .NET (v4)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Bedrock-runtime#code-examples).
Utilisez l’API Invoke Model pour envoyer un message texte.
```
// 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;
}
```
+ Pour plus de détails sur l'API, reportez-vous [InvokeModel](https://docs.aws.amazon.com/goto/DotNetSDKV4/bedrock-runtime-2023-09-30/InvokeModel)à la section *Référence des AWS SDK pour .NET API*.
------
#### [ Go ]
**Kit SDK pour Go V2**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/bedrock-runtime#code-examples).
Invoquez le modèle de fondation Anthropic Claude 2 pour générer du texte.
```
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
}
```
+ Pour plus de détails sur l'API, reportez-vous [InvokeModel](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/bedrockruntime#Client.InvokeModel)à la section *Référence des AWS SDK pour Go API*.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Utilisez l’API Invoke Model pour envoyer un message texte.
```
// 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();
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [InvokeModel](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModel)à la section *Référence des AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Utilisez l’API Invoke Model pour envoyer un message texte.
```
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}`);
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [InvokeModel](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/InvokeModelCommand)à la section *Référence des AWS SDK pour JavaScript API*.
------
#### [ PHP ]
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/bedrock-runtime#code-examples).
Invoquez le modèle de fondation Anthropic Claude 2 pour générer du texte.
```
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;
}
```
+ Pour plus de détails sur l'API, reportez-vous [InvokeModel](https://docs.aws.amazon.com/goto/SdkForPHPV3/bedrock-runtime-2023-09-30/InvokeModel)à la section *Référence des AWS SDK pour PHP API*.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Utilisez l’API Invoke Model pour envoyer un message texte.
```
# 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)
```
+ Pour plus de détails sur l'API, consultez [InvokeModel](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModel)le *AWS manuel de référence de l'API SDK for Python (Boto3*).
------
#### [ SAP ABAP ]
**Kit SDK pour SAP ABAP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/bdr#code-examples).
Invoquez le modèle de fondation Anthropic Claude 2 pour générer du texte. Cet exemple utilise les fonctionnalités de/US2/CL\$1JSON qui peuvent ne pas être disponibles sur certaines versions. NetWeaver
```
"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.
```
Invoquez le modèle de fondation Anthropic Claude 2 pour générer du texte à l’aide du client de haut niveau L2.
```
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.
```
Invoquez le modèle de fondation Anthropic Claude 3 pour générer du texte à l’aide du client de haut niveau L2.
```
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.
```
+ Pour plus de détails sur l'API, consultez [InvokeModel](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)la section de référence du *AWS SDK pour l'API SAP ABAP*.
------
# Invoquez des modèles Anthropic Claude sur Amazon Bedrock à l’aide de l’API Invoke Model avec un flux de réponse
Les exemples de code suivants montrent comment envoyer un message texte aux modèles Anthropic Claude à l’aide de l’API Invoke Model et comment imprimer le flux de réponses.
------
#### [ .NET ]
**SDK pour .NET**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime#code-examples).
Utilisez l’API Invoke Model pour envoyer un message texte et traiter le flux de réponses en temps réel.
```
// 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;
}
```
+ Pour plus de détails sur l'API, reportez-vous [InvokeModelWithResponseStream](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/InvokeModelWithResponseStream)à la section *Référence des AWS SDK pour .NET API*.
------
#### [ Go ]
**Kit SDK pour Go V2**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/bedrock-runtime#code-examples).
Utilisez l’API Invoke Model pour envoyer un message texte et traiter le flux de réponses en temps réel.
```
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
}
```
+ Pour plus de détails sur l'API, reportez-vous [InvokeModelWithResponseStream](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/bedrockruntime#Client.InvokeModelWithResponseStream)à la section *Référence des AWS SDK pour Go API*.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Utilisez l’API Invoke Model pour envoyer un message texte et traiter le flux de réponses en temps réel.
```
// 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();
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [InvokeModelWithResponseStream](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModelWithResponseStream)à la section *Référence des AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Utilisez l’API Invoke Model pour envoyer un message texte et traiter le flux de réponses en temps réel.
```
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}`);
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [InvokeModelWithResponseStream](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/InvokeModelWithResponseStreamCommand)à la section *Référence des AWS SDK pour JavaScript API*.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Utilisez l’API Invoke Model pour envoyer un message texte et traiter le flux de réponses en temps réel.
```
# 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="")
```
+ Pour plus de détails sur l'API, consultez [InvokeModelWithResponseStream](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModelWithResponseStream)le *AWS manuel de référence de l'API SDK for Python (Boto3*).
------
# Utilisation de la capacité de raisonnement d’Anthropic Claude 3.7 Sonnet sur Amazon Bedrock
L’exemple de code suivant montre comment utiliser la capacité de raisonnement d’Anthropic Claude 3.7 Sonnet sur Amazon Bedrock.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Utilisez la capacité de raisonnement d’Anthropic Claude 3.7 Sonnet avec le client d’exécution asynchrone Bedrock.
```
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());
}
}
```
Utilisez la capacité de raisonnement d’Anthropic Claude 3.7 Sonnet avec le client d’exécution synchrone Bedrock.
```
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());
}
}
```
+ Pour plus de détails sur l’API, consultez [Converse](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/Converse) dans la *Référence des API du kit AWS SDK for Java 2.x *.
------
# Utilisation de la capacité de raisonnement d’Anthropic Claude 3.7 Sonnet sur Amazon Bedrock
L’exemple de code suivant montre comment utiliser la capacité de raisonnement d’Anthropic Claude 3.7 Sonnet sur Amazon Bedrock.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Utilisez la capacité de raisonnement d’Anthropic Claude 3.7 Sonnet pour générer des réponses textuelles en streaming.
```
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();
}
}
```
+ Pour plus de détails sur l’API, consultez [Converse](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/Converse) dans la *Référence des API du kit AWS SDK for Java 2.x *.
------
# Une démonstration d’utilisation d’outil illustrant comment connecter des modèles d’IA sur Amazon Bedrock à un outil personnalisé ou à une API
Les exemples de code suivants montrent comment créer une interaction typique entre une application, un modèle d'IA génératif et des outils connectés ou APIs comment faciliter les interactions entre l'IA et le monde extérieur. Il utilise comme exemple la connexion d’une API de météorologie externe au modèle d’IA afin de fournir des informations météorologiques en temps réel en fonction des données saisies par l’utilisateur.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Script d’exécution principal de la démo. Ce script orchestre la conversation entre l’utilisateur, l’API Converse Amazon Bedrock et un outil météo.
```
"""
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()
```
Outil météo utilisé par la démonstration. Ce script définit les spécifications de l’outil et met en œuvre la logique permettant de récupérer les données météorologiques à l’aide de l’API Open-Meteo.
```
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)}
```
+ Pour plus de détails sur l’API, consultez [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) dans la *Référence des API du kit AWS SDK for Python (Boto3)*.
------
#### [ Rust ]
**SDK pour Rust**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/bedrock-runtime#code-examples).
Scénario principal et logique de la démo. Ceci orchestre la conversation entre l’utilisateur, l’API Converse Amazon Bedrock et un outil météo.
```
#[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();
}
```
Outil météo utilisé par la démonstration. Ce script définit les spécifications de l’outil et met en œuvre la logique permettant de récupérer les données météorologiques à l’aide de l’API Open-Meteo.
```
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()?)
}
```
Utilitaires pour imprimer les blocs de contenu des messages.
```
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:?})"
)))
}
}
```
Utilisez des instructions, l’utilitaire Error et des constantes.
```
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(),
})
}
}
```
+ Pour plus de détails sur l’API, consultez [Converse](https://docs.rs/aws-sdk-bedrockruntime/latest/aws_sdk_bedrockruntime/client/struct.Client.html#method.converse) dans la *Référence des API du kit AWS SDK pour Rust*.
------
# Cohere Command pour Amazon Bedrock Runtime
Les exemples de code suivants montrent comment utiliser Amazon Bedrock Runtime avec AWS SDKs.
**Topics**
+ [Converse](bedrock-runtime_example_bedrock-runtime_Converse_CohereCommand_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_CohereCommand_section.md)
+ [Compréhension des documents](bedrock-runtime_example_bedrock-runtime_DocumentUnderstanding_CohereCommand_section.md)
+ [InvokeModel: Command R et R\$1](bedrock-runtime_example_bedrock-runtime_InvokeModel_CohereCommandR_section.md)
+ [InvokeModelWithResponseStream: Command R et R\$1](bedrock-runtime_example_bedrock-runtime_InvokeModelWithResponseStream_CohereCommandR_section.md)
+ [Scénario : utilisation de l’outil avec l’API Converse](bedrock-runtime_example_bedrock-runtime_Scenario_ToolUseDemo_CohereCommand_section.md)
# Invocation de Cohere Command sur Amazon Bedrock à l’aide de l’API Converse de Bedrock
Les exemples de code suivants montrent comment envoyer un message texte à Cohere Command à l’aide de l’API Converse de Bedrock.
------
#### [ .NET ]
**SDK pour .NET (v4)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Bedrock-runtime#code-examples).
Envoyez un message texte à Cohere Command à l’aide de l’API Converse de Bedrock.
```
// 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;
}
```
+ Pour plus de détails sur l’API, consultez [Converse](https://docs.aws.amazon.com/goto/DotNetSDKV4/bedrock-runtime-2023-09-30/Converse) dans la *Référence des API du kit AWS SDK pour .NET *.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Envoyez un message texte à Cohere Command à l’aide de l’API Converse de Bedrock.
```
// 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();
}
}
```
Envoyez un message texte à Cohere Command, en utilisant l’API Converse de Bedrock avec le client Java asynchrone.
```
// 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();
}
}
```
+ Pour plus de détails sur l’API, consultez [Converse](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/Converse) dans la *Référence des API du kit AWS SDK for Java 2.x *.
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Envoyez un message texte à Cohere Command à l’aide de l’API Converse de Bedrock.
```
// 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);
}
```
+ Pour plus de détails sur l’API, consultez [Converse](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseCommand) dans la *Référence des API du kit AWS SDK pour JavaScript *.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Envoyez un message texte à Cohere Command à l’aide de l’API Converse de Bedrock.
```
# 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)
```
+ Pour plus de détails sur l’API, consultez [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) dans la *Référence des API du kit AWS SDK for Python (Boto3)*.
------
# Invocation de Cohere Command sur Amazon Bedrock à l’aide de l’API Converse de Bedrock avec un flux de réponses
Les exemples de code suivants montrent comment envoyer un message texte à Cohere Command à l’aide de l’API Converse de Bedrock et comment traiter le flux de réponses en temps réel.
------
#### [ .NET ]
**SDK pour .NET (v4)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Bedrock-runtime#code-examples).
Envoyez un message texte à Cohere Command à l’aide de l’API Converse de Bedrock et traitez le flux de réponses en temps réel.
```
// 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;
}
```
+ Pour plus de détails sur l'API, reportez-vous [ConverseStream](https://docs.aws.amazon.com/goto/DotNetSDKV4/bedrock-runtime-2023-09-30/ConverseStream)à la section *Référence des AWS SDK pour .NET API*.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Envoyez un message texte à Cohere Command à l’aide de l’API Converse de Bedrock et traitez le flux de réponses en temps réel.
```
// 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());
}
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [ConverseStream](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/ConverseStream)à la section *Référence des AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Envoyez un message texte à Cohere Command à l’aide de l’API Converse de Bedrock et traitez le flux de réponses en temps réel.
```
// 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);
}
```
+ Pour plus de détails sur l'API, reportez-vous [ConverseStream](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseStreamCommand)à la section *Référence des AWS SDK pour JavaScript API*.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Envoyez un message texte à Cohere Command à l’aide de l’API Converse de Bedrock et traitez le flux de réponses en temps réel.
```
# 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)
```
+ Pour plus de détails sur l'API, consultez [ConverseStream](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/ConverseStream)le *AWS manuel de référence de l'API SDK for Python (Boto3*).
------
# Envoi et traitement d’un document avec les modèles Cohere Command sur Amazon Bedrock
L’exemple de code suivant montre comment envoyer et traiter un document avec des modèles Cohere Command sur Amazon Bedrock.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Envoyez et traitez un document avec les modèles Cohere Command sur 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)
```
+ Pour plus de détails sur l’API, consultez [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) dans la *Référence des API du kit AWS SDK for Python (Boto3)*.
------
# Invocation de Cohere Command R et R\$1 sur Amazon Bedrock à l’aide de l’API Invoke Model
Les exemples de code suivants montrent comment envoyer un message texte à Cohere Command R et R\$1 à l’aide de l’API Invoke Model.
------
#### [ .NET ]
**SDK pour .NET**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime#code-examples).
Utilisez l’API Invoke Model pour envoyer un message texte.
```
// 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;
}
```
+ Pour plus de détails sur l'API, reportez-vous [InvokeModel](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/InvokeModel)à la section *Référence des AWS SDK pour .NET API*.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Utilisez l’API Invoke Model pour envoyer un message texte.
```
// 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();
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [InvokeModel](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModel)à la section *Référence des AWS SDK for Java 2.x API*.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Utilisez l’API Invoke Model pour envoyer un message texte.
```
# 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)
```
+ Pour plus de détails sur l'API, consultez [InvokeModel](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModel)le *AWS manuel de référence de l'API SDK for Python (Boto3*).
------
# Invocation de Cohere Command R et R\$1 sur Amazon Bedrock à l’aide de l’API Invoke Model avec un flux de réponses
Les exemples de code suivants montrent comment envoyer un message texte à Cohere Command à l’aide de l’API Invoke Model avec un flux de réponses.
------
#### [ .NET ]
**SDK pour .NET**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime#code-examples).
Utilisez l’API Invoke Model pour envoyer un message texte et traiter le flux de réponses en temps réel.
```
// 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;
}
```
+ Pour plus de détails sur l'API, reportez-vous [InvokeModel](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/InvokeModel)à la section *Référence des AWS SDK pour .NET API*.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Utilisez l’API Invoke Model pour envoyer un message texte et traiter le flux de réponses en temps réel.
```
// 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();
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [InvokeModel](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModel)à la section *Référence des AWS SDK for Java 2.x API*.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Utilisez l’API Invoke Model pour envoyer un message texte et traiter le flux de réponses en temps réel.
```
# 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)
```
+ Pour plus de détails sur l'API, consultez [InvokeModel](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModel)le *AWS manuel de référence de l'API SDK for Python (Boto3*).
------
# Une démonstration d’utilisation d’outil illustrant comment connecter des modèles d’IA sur Amazon Bedrock à un outil personnalisé ou à une API
L'exemple de code suivant montre comment créer une interaction typique entre une application, un modèle d'IA génératif et des outils connectés ou comment APIs arbitrer les interactions entre l'IA et le monde extérieur. Il utilise comme exemple la connexion d’une API de météorologie externe au modèle d’IA afin de fournir des informations météorologiques en temps réel en fonction des données saisies par l’utilisateur.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Script d’exécution principal de la démo. Ce script orchestre la conversation entre l’utilisateur, l’API Converse Amazon Bedrock et un outil météo.
```
"""
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()
```
Outil météo utilisé par la démonstration. Ce script définit les spécifications de l’outil et met en œuvre la logique permettant de récupérer les données météorologiques à l’aide de l’API Open-Meteo.
```
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)}
```
+ Pour plus de détails sur l’API, consultez [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) dans la *Référence des API du kit AWS SDK for Python (Boto3)*.
------
# DeepSeek pour Amazon Bedrock Runtime
Les exemples de code suivants montrent comment utiliser Amazon Bedrock Runtime avec AWS SDKs.
**Topics**
+ [Compréhension des documents](bedrock-runtime_example_bedrock-runtime_DocumentUnderstanding_DeepSeek_section.md)
# Envoyez et traitez un document avec DeepSeek Amazon Bedrock
L'exemple de code suivant montre comment envoyer et traiter un document avec DeepSeek Amazon Bedrock.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Envoyez et traitez un document avec DeepSeek 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)
```
+ Pour plus de détails sur l’API, consultez [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) dans la *Référence des API du kit AWS SDK for Python (Boto3)*.
------
# Meta Llama pour Amazon Bedrock Runtime
Les exemples de code suivants montrent comment utiliser Amazon Bedrock Runtime avec AWS SDKs.
**Topics**
+ [Converse](bedrock-runtime_example_bedrock-runtime_Converse_MetaLlama_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_MetaLlama_section.md)
+ [Compréhension des documents](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)
# Invocation de Meta Llama sur Amazon Bedrock à l’aide de l’API Converse de Bedrock
Les exemples de code suivants montrent comment envoyer un message texte à Meta Llama, en utilisant l’API Converse de Bedrock.
------
#### [ .NET ]
**SDK pour .NET (v4)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Bedrock-runtime#code-examples).
Envoyez un message texte à Meta Llama à l’aide de l’API Converse de Bedrock.
```
// 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;
}
```
+ Pour plus de détails sur l’API, consultez [Converse](https://docs.aws.amazon.com/goto/DotNetSDKV4/bedrock-runtime-2023-09-30/Converse) dans la *Référence des API du kit AWS SDK pour .NET *.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Envoyez un message texte à Meta Llama à l’aide de l’API Converse de Bedrock.
```
// 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();
}
}
```
Envoyez un message texte à Meta Llama en utilisant l’API Converse de Bedrock avec le client Java asynchrone.
```
// 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();
}
}
```
+ Pour plus de détails sur l’API, consultez [Converse](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/Converse) dans la *Référence des API du kit AWS SDK for Java 2.x *.
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Envoyez un message texte à Meta Llama à l’aide de l’API Converse de Bedrock.
```
// 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);
}
```
+ Pour plus de détails sur l’API, consultez [Converse](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseCommand) dans la *Référence des API du kit AWS SDK pour JavaScript *.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Envoyez un message texte à Meta Llama à l’aide de l’API Converse de Bedrock.
```
# 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)
```
+ Pour plus de détails sur l’API, consultez [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) dans la *Référence des API du kit AWS SDK for Python (Boto3)*.
------
#### [ Swift ]
**Kit SDK pour Swift**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/bedrock-runtime#code-examples).
Envoyez un message texte à Meta Llama à l’aide de l’API Converse de Bedrock.
```
// 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"
}
}
```
+ Pour plus de détails sur l’API, consultez [Converse](https://sdk.amazonaws.com/swift/api/awsbedrockruntime/latest/documentation/awsbedrockruntime/bedrockruntimeclient/converse(input:)) dans la *Référence des API du kit AWS SDK pour Swift*.
------
# Invocation de Meta Llama sur Amazon Bedrock à l’aide de l’API Converse de Bedrock avec un flux de réponses
Les exemples de code suivants montrent comment envoyer un message texte à Meta Llama à l’aide de l’API Converse de Bedrock et comment traiter le flux de réponses en temps réel.
------
#### [ .NET ]
**SDK pour .NET (v4)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Bedrock-runtime#code-examples).
Envoyez un message texte à Meta Llama à l’aide de l’API Converse de Bedrock et traitez le flux de réponses en temps réel.
```
// 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;
}
```
+ Pour plus de détails sur l'API, reportez-vous [ConverseStream](https://docs.aws.amazon.com/goto/DotNetSDKV4/bedrock-runtime-2023-09-30/ConverseStream)à la section *Référence des AWS SDK pour .NET API*.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Envoyez un message texte à Meta Llama à l’aide de l’API Converse de Bedrock et traitez le flux de réponses en temps réel.
```
// 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());
}
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [ConverseStream](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/ConverseStream)à la section *Référence des AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Envoyez un message texte à Meta Llama à l’aide de l’API Converse de Bedrock et traitez le flux de réponses en temps réel.
```
// 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);
}
```
+ Pour plus de détails sur l'API, reportez-vous [ConverseStream](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseStreamCommand)à la section *Référence des AWS SDK pour JavaScript API*.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Envoyez un message texte à Meta Llama à l’aide de l’API Converse de Bedrock et traitez le flux de réponses en temps réel.
```
# 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)
```
+ Pour plus de détails sur l'API, consultez [ConverseStream](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/ConverseStream)le *AWS manuel de référence de l'API SDK for Python (Boto3*).
------
#### [ Swift ]
**Kit SDK pour Swift**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/bedrock-runtime#code-examples).
Envoyez un message texte à Meta Llama à l’aide de l’API Converse de Bedrock et traitez le flux de réponses en temps réel.
```
// 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
}
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [ConverseStream](https://sdk.amazonaws.com/swift/api/awsbedrockruntime/latest/documentation/awsbedrockruntime/bedrockruntimeclient/conversestream(input:))à la section *AWS SDK pour la référence de l'API Swift*.
------
# Envoi et traitement d’un document avec Llama sur Amazon Bedrock
L’exemple de code suivant montre comment envoyer et traiter un document avec Llama sur Amazon Bedrock.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Envoyez et traitez un document avec Llama sur 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)
```
+ Pour plus de détails sur l’API, consultez [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) dans la *Référence des API du kit AWS SDK for Python (Boto3)*.
------
# Invocation de Meta Llama sur Amazon Bedrock à l’aide de l’API Invoke Model
Les exemples de code suivants montrent comment envoyer un message texte à Meta Llama à l’aide de l’API Invoke Model.
------
#### [ .NET ]
**SDK pour .NET**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime#code-examples).
Utilisez l’API Invoke Model pour envoyer un message texte.
```
// 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;
}
```
+ Pour plus de détails sur l'API, reportez-vous [InvokeModel](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/InvokeModel)à la section *Référence des AWS SDK pour .NET API*.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Utilisez l’API Invoke Model pour envoyer un message texte.
```
// 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();
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [InvokeModel](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModel)à la section *Référence des AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Utilisez l’API Invoke Model pour envoyer un message texte.
```
// 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
```
+ Pour plus de détails sur l'API, reportez-vous [InvokeModel](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/InvokeModelCommand)à la section *Référence des AWS SDK pour JavaScript API*.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Utilisez l’API Invoke Model pour envoyer un message texte.
```
# 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)
```
+ Pour plus de détails sur l'API, consultez [InvokeModel](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModel)le *AWS manuel de référence de l'API SDK for Python (Boto3*).
------
# Invocation Meta Llama sur Amazon Bedrock à l’aide de l’API Invoke Model avec un flux de réponse
Les exemples de code suivants montrent comment envoyer un message texte à Meta Llama à l’aide de l’API Invoke Model, puis comment imprimer le flux de réponses.
------
#### [ .NET ]
**SDK pour .NET**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime#code-examples).
Utilisez l’API Invoke Model pour envoyer un message texte et traiter le flux de réponses en temps réel.
```
// 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;
}
```
+ Pour plus de détails sur l'API, reportez-vous [InvokeModelWithResponseStream](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/InvokeModelWithResponseStream)à la section *Référence des AWS SDK pour .NET API*.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Utilisez l’API Invoke Model pour envoyer un message texte et traiter le flux de réponses en temps réel.
```
// 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();
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [InvokeModelWithResponseStream](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModelWithResponseStream)à la section *Référence des AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Utilisez l’API Invoke Model pour envoyer un message texte et traiter le flux de réponses en temps réel.
```
// 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
```
+ Pour plus de détails sur l'API, reportez-vous [InvokeModelWithResponseStream](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/InvokeModelWithResponseStreamCommand)à la section *Référence des AWS SDK pour JavaScript API*.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Utilisez l’API Invoke Model pour envoyer un message texte et traiter le flux de réponses en temps réel.
```
# 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)
```
+ Pour plus de détails sur l'API, consultez [InvokeModelWithResponseStream](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModelWithResponseStream)le *AWS manuel de référence de l'API SDK for Python (Boto3*).
------
# Mistral AI pour Amazon Bedrock Runtime
Les exemples de code suivants montrent comment utiliser Amazon Bedrock Runtime avec AWS SDKs.
**Topics**
+ [Converse](bedrock-runtime_example_bedrock-runtime_Converse_Mistral_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_Mistral_section.md)
+ [Compréhension des documents](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)
# Invocation de Mistral sur Amazon Bedrock à l’aide de l’API Converse de Bedrock
Les exemples de code suivants montrent comment envoyer un message texte à Mistral avec l’API Converse de Bedrock.
------
#### [ .NET ]
**SDK pour .NET (v4)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Bedrock-runtime#code-examples).
Envoyez un message texte à Mistral à l’aide de l’API Converse de Bedrock.
```
// 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;
}
```
+ Pour plus de détails sur l’API, consultez [Converse](https://docs.aws.amazon.com/goto/DotNetSDKV4/bedrock-runtime-2023-09-30/Converse) dans la *Référence des API du kit AWS SDK pour .NET *.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Envoyez un message texte à Mistral à l’aide de l’API Converse de Bedrock.
```
// 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();
}
}
```
Envoyez un message texte à Mistral à l’aide de l’API Converse de Bedrock avec le client Java asynchrone.
```
// 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();
}
}
```
+ Pour plus de détails sur l’API, consultez [Converse](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/Converse) dans la *Référence des API du kit AWS SDK for Java 2.x *.
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Envoyez un message texte à Mistral à l’aide de l’API Converse de Bedrock.
```
// 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);
}
```
+ Pour plus de détails sur l’API, consultez [Converse](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseCommand) dans la *Référence des API du kit AWS SDK pour JavaScript *.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Envoyez un message texte à Mistral à l’aide de l’API Converse de Bedrock.
```
# 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)
```
+ Pour plus de détails sur l’API, consultez [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) dans la *Référence des API du kit AWS SDK for Python (Boto3)*.
------
# Invocation de Mistral sur Amazon Bedrock à l’aide de l’API Converse de Bedrock avec un flux de réponses
Les exemples de code suivants montrent comment envoyer un message texte à Mistral à l’aide de l’API Converse de Bedrock et comment traiter le flux de réponses en temps réel.
------
#### [ .NET ]
**SDK pour .NET (v4)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Bedrock-runtime#code-examples).
Envoyez un message texte à Mistral à l’aide de l’API Converse de Bedrock et traitez le flux de réponses en temps réel.
```
// 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;
}
```
+ Pour plus de détails sur l'API, reportez-vous [ConverseStream](https://docs.aws.amazon.com/goto/DotNetSDKV4/bedrock-runtime-2023-09-30/ConverseStream)à la section *Référence des AWS SDK pour .NET API*.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Envoyez un message texte à Mistral à l’aide de l’API Converse de Bedrock et traitez le flux de réponses en temps réel.
```
// 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());
}
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [ConverseStream](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/ConverseStream)à la section *Référence des AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Envoyez un message texte à Mistral à l’aide de l’API Converse de Bedrock et traitez le flux de réponses en temps réel.
```
// 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);
}
```
+ Pour plus de détails sur l'API, reportez-vous [ConverseStream](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseStreamCommand)à la section *Référence des AWS SDK pour JavaScript API*.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Envoyez un message texte à Mistral à l’aide de l’API Converse de Bedrock et traitez le flux de réponses en temps réel.
```
# 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)
```
+ Pour plus de détails sur l'API, consultez [ConverseStream](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/ConverseStream)le *AWS manuel de référence de l'API SDK for Python (Boto3*).
------
# Envoi et traitement d’un document avec des modèles Mistral sur Amazon Bedrock
L’exemple de code suivant montre comment envoyer et traiter un document avec des modèles Mistral sur Amazon Bedrock.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Envoyez et traitez un document avec des modèles Mistral sur 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)
```
+ Pour plus de détails sur l’API, consultez [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) dans la *Référence des API du kit AWS SDK for Python (Boto3)*.
------
# Invocation de modèles Mistral AI sur Amazon Bedrock à l’aide de l’API Invoke Model
Les exemples de code suivants montrent comment envoyer un message texte aux modèles Mistral à l’aide de l’API Invoke Model.
------
#### [ .NET ]
**SDK pour .NET**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime#code-examples).
Utilisez l’API Invoke Model pour envoyer un message texte.
```
// 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;
}
```
+ Pour plus de détails sur l'API, reportez-vous [InvokeModel](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/InvokeModel)à la section *Référence des AWS SDK pour .NET API*.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Utilisez l’API Invoke Model pour envoyer un message texte.
```
// 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();
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [InvokeModel](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModel)à la section *Référence des AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Utilisez l’API Invoke Model pour envoyer un message texte.
```
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);
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [InvokeModel](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/InvokeModelCommand)à la section *Référence des AWS SDK pour JavaScript API*.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Utilisez l’API Invoke Model pour envoyer un message texte.
```
# 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)
```
+ Pour plus de détails sur l'API, consultez [InvokeModel](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModel)le *AWS manuel de référence de l'API SDK for Python (Boto3*).
------
# Invocation de modèles Mistral AI sur Amazon Bedrock à l’aide de l’API Invoke Model avec un flux de réponses
L’exemple de code suivant montre comment envoyer un message texte aux modèles Mistral AI à l’aide de l’API Invoke Model et comment imprimer le flux de réponses.
------
#### [ .NET ]
**SDK pour .NET**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime#code-examples).
Utilisez l’API Invoke Model pour envoyer un message texte et traiter le flux de réponses en temps réel.
```
// 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;
}
```
+ Pour plus de détails sur l'API, reportez-vous [InvokeModelWithResponseStream](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/InvokeModelWithResponseStream)à la section *Référence des AWS SDK pour .NET API*.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Utilisez l’API Invoke Model pour envoyer un message texte et traiter le flux de réponses en temps réel.
```
// 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();
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [InvokeModelWithResponseStream](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModelWithResponseStream)à la section *Référence des AWS SDK for Java 2.x API*.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Utilisez l’API Invoke Model pour envoyer un message texte et traiter le flux de réponses en temps réel.
```
# 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)
```
+ Pour plus de détails sur l'API, consultez [InvokeModelWithResponseStream](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModelWithResponseStream)le *AWS manuel de référence de l'API SDK for Python (Boto3*).
------
# Stable Diffusion pour Amazon Bedrock Runtime
Les exemples de code suivants montrent comment utiliser Amazon Bedrock Runtime avec AWS SDKs.
**Topics**
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_StableDiffusion_section.md)
# Invocation de Stability.ai Stable Diffusion XL sur Amazon Bedrock pour générer une image
Les exemples de code suivants montrent comment invoquer Stability.ai Stable Diffusion XL sur Amazon Bedrock pour générer une image.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Créez une image avec 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);
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [InvokeModel](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModel)à la section *Référence des AWS SDK for Java 2.x API*.
------
#### [ PHP ]
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/bedrock-runtime#code-examples).
Créez une image avec 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;
}
```
+ Pour plus de détails sur l'API, reportez-vous [InvokeModel](https://docs.aws.amazon.com/goto/SdkForPHPV3/bedrock-runtime-2023-09-30/InvokeModel)à la section *Référence des AWS SDK pour PHP API*.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Créez une image avec 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}")
```
+ Pour plus de détails sur l'API, consultez [InvokeModel](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModel)le *AWS manuel de référence de l'API SDK for Python (Boto3*).
------
#### [ SAP ABAP ]
**Kit SDK pour SAP ABAP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/bdr#code-examples).
Créez une image avec 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.
```
Invoquez le modèle de fondation Stability.ai Stable Diffusion XL pour générer des images à l’aide du client de haut niveau L2.
```
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.
```
+ Pour plus de détails sur l'API, consultez [InvokeModel](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)la section de référence du *AWS SDK pour l'API SAP ABAP*.
------