As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Exemplos de código para o Amazon Bedrock usando AWS SDKs
Os exemplos de código a seguir mostram como usar o Amazon Bedrock com um kit de desenvolvimento de AWS software (SDK).
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
**Contents**
+ [Amazon Bedrock](service_code_examples_bedrock.md)
+ [Conceitos básicos](service_code_examples_bedrock_basics.md)
+ [Olá, Amazon Bedrock](bedrock_example_bedrock_Hello_section.md)
+ [Ações](service_code_examples_bedrock_actions.md)
+ [`GetFoundationModel`](bedrock_example_bedrock_GetFoundationModel_section.md)
+ [`ListFoundationModels`](bedrock_example_bedrock_ListFoundationModels_section.md)
+ [Cenários](service_code_examples_bedrock_scenarios.md)
+ [Orquestrar aplicações de IA generativa com o Step Functions](bedrock_example_cross_ServerlessPromptChaining_section.md)
+ [Amazon Bedrock Runtime](service_code_examples_bedrock-runtime.md)
+ [Conceitos básicos](service_code_examples_bedrock-runtime_basics.md)
+ [Olá, Amazon Bedrock](bedrock-runtime_example_bedrock-runtime_Hello_section.md)
+ [Cenários](service_code_examples_bedrock-runtime_scenarios.md)
+ [Criar um aplicativo playground para interagir com os modelos de base do Amazon Bedrock](bedrock-runtime_example_cross_FMPlayground_section.md)
+ [Criar e invocar um prompt gerenciado](bedrock-runtime_example_bedrock-agent_GettingStartedWithBedrockPrompts_section.md)
+ [Gerar vídeos com base em prompts de texto usando o Amazon Bedrock](bedrock-runtime_example_bedrock-runtime_Scenario_GenerateVideos_NovaReel_section.md)
+ [Invocar vários modelos de base no Amazon Bedrock](bedrock-runtime_example_bedrock-runtime_Scenario_InvokeModels_section.md)
+ [Orquestrar aplicações de IA generativa com o Step Functions](bedrock-runtime_example_cross_ServerlessPromptChaining_section.md)
+ [Uso de ferramenta com a API Converse](bedrock-runtime_example_bedrock-runtime_Scenario_ToolUse_section.md)
+ [Amazon Nova](service_code_examples_bedrock-runtime_amazon_nova.md)
+ [Converse](bedrock-runtime_example_bedrock-runtime_Converse_AmazonNovaText_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_AmazonNovaText_section.md)
+ [Compreensão do documento](bedrock-runtime_example_bedrock-runtime_DocumentUnderstanding_AmazonNova_section.md)
+ [Cenário: uso de ferramentas com a API Converse](bedrock-runtime_example_bedrock-runtime_Scenario_ToolUseDemo_AmazonNova_section.md)
+ [Amazon Nova Canvas](service_code_examples_bedrock-runtime_amazon_nova_canvas.md)
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_AmazonNovaImageGeneration_section.md)
+ [Amazon Nova Reel](service_code_examples_bedrock-runtime_amazon_nova_reel.md)
+ [T ext-to-video](bedrock-runtime_example_bedrock-runtime_Scenario_AmazonNova_TextToVideo_section.md)
+ [Gerador de Imagens do Amazon Titan](service_code_examples_bedrock-runtime_amazon_titan_image_generator.md)
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_TitanImageGenerator_section.md)
+ [Amazon Titan Text](service_code_examples_bedrock-runtime_amazon_titan_text.md)
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_TitanText_section.md)
+ [Incorporações de texto Amazon Titan](service_code_examples_bedrock-runtime_amazon_titan_text_embeddings.md)
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModelWithResponseStream_TitanTextEmbeddings_section.md)
+ [Claude da Anthropic](service_code_examples_bedrock-runtime_anthropic_claude.md)
+ [Converse](bedrock-runtime_example_bedrock-runtime_Converse_AnthropicClaude_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_AnthropicClaude_section.md)
+ [Compreensão do documento](bedrock-runtime_example_bedrock-runtime_DocumentUnderstanding_AnthropicClaude_section.md)
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_AnthropicClaude_section.md)
+ [InvokeModelWithResponseStream](bedrock-runtime_example_bedrock-runtime_InvokeModelWithResponseStream_AnthropicClaude_section.md)
+ [Reasoning](bedrock-runtime_example_bedrock-runtime_Converse_AnthropicClaudeReasoning_section.md)
+ [Raciocínio com uma resposta em streaming](bedrock-runtime_example_bedrock-runtime_ConverseStream_AnthropicClaudeReasoning_section.md)
+ [Cenário: uso de ferramentas com a API Converse](bedrock-runtime_example_bedrock-runtime_Scenario_ToolUseDemo_AnthropicClaude_section.md)
+ [Command da Cohere](service_code_examples_bedrock-runtime_cohere_command.md)
+ [Converse](bedrock-runtime_example_bedrock-runtime_Converse_CohereCommand_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_CohereCommand_section.md)
+ [Compreensão do documento](bedrock-runtime_example_bedrock-runtime_DocumentUnderstanding_CohereCommand_section.md)
+ [InvokeModel: Comando R e R\$1](bedrock-runtime_example_bedrock-runtime_InvokeModel_CohereCommandR_section.md)
+ [InvokeModelWithResponseStream: Comando R e R\$1](bedrock-runtime_example_bedrock-runtime_InvokeModelWithResponseStream_CohereCommandR_section.md)
+ [Cenário: uso de ferramentas com a API Converse](bedrock-runtime_example_bedrock-runtime_Scenario_ToolUseDemo_CohereCommand_section.md)
+ [DeepSeek](service_code_examples_bedrock-runtime_deepseek.md)
+ [Compreensão do documento](bedrock-runtime_example_bedrock-runtime_DocumentUnderstanding_DeepSeek_section.md)
+ [Llama da Meta](service_code_examples_bedrock-runtime_meta_llama.md)
+ [Converse](bedrock-runtime_example_bedrock-runtime_Converse_MetaLlama_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_MetaLlama_section.md)
+ [Compreensão do documento](bedrock-runtime_example_bedrock-runtime_DocumentUnderstanding_MetaLlama_section.md)
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_MetaLlama3_section.md)
+ [InvokeModelWithResponseStream](bedrock-runtime_example_bedrock-runtime_InvokeModelWithResponseStream_MetaLlama3_section.md)
+ [Mistral AI](service_code_examples_bedrock-runtime_mistral_ai.md)
+ [Converse](bedrock-runtime_example_bedrock-runtime_Converse_Mistral_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_Mistral_section.md)
+ [Compreensão do documento](bedrock-runtime_example_bedrock-runtime_DocumentUnderstanding_Mistral_section.md)
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_MistralAi_section.md)
+ [InvokeModelWithResponseStream](bedrock-runtime_example_bedrock-runtime_InvokeModelWithResponseStream_MistralAi_section.md)
+ [Stable Diffusion](service_code_examples_bedrock-runtime_stable_diffusion.md)
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_StableDiffusion_section.md)
+ [Amazon Bedrock Agents](service_code_examples_bedrock-agent.md)
+ [Conceitos básicos](service_code_examples_bedrock-agent_basics.md)
+ [Olá, agentes do Amazon Bedrock](bedrock-agent_example_bedrock-agent_Hello_section.md)
+ [Ações](service_code_examples_bedrock-agent_actions.md)
+ [`CreateAgent`](bedrock-agent_example_bedrock-agent_CreateAgent_section.md)
+ [`CreateAgentActionGroup`](bedrock-agent_example_bedrock-agent_CreateAgentActionGroup_section.md)
+ [`CreateAgentAlias`](bedrock-agent_example_bedrock-agent_CreateAgentAlias_section.md)
+ [`CreateFlow`](bedrock-agent_example_bedrock-agent_CreateFlow_section.md)
+ [`CreateFlowAlias`](bedrock-agent_example_bedrock-agent_CreateFlowAlias_section.md)
+ [`CreateFlowVersion`](bedrock-agent_example_bedrock-agent_CreateFlowVersion_section.md)
+ [`CreateKnowledgeBase`](bedrock-agent_example_bedrock-agent_CreateKnowledgeBase_section.md)
+ [`CreatePrompt`](bedrock-agent_example_bedrock-agent_CreatePrompt_section.md)
+ [`CreatePromptVersion`](bedrock-agent_example_bedrock-agent_CreatePromptVersion_section.md)
+ [`DeleteAgent`](bedrock-agent_example_bedrock-agent_DeleteAgent_section.md)
+ [`DeleteAgentAlias`](bedrock-agent_example_bedrock-agent_DeleteAgentAlias_section.md)
+ [`DeleteFlow`](bedrock-agent_example_bedrock-agent_DeleteFlow_section.md)
+ [`DeleteFlowAlias`](bedrock-agent_example_bedrock-agent_DeleteFlowAlias_section.md)
+ [`DeleteFlowVersion`](bedrock-agent_example_bedrock-agent_DeleteFlowVersion_section.md)
+ [`DeleteKnowledgeBase`](bedrock-agent_example_bedrock-agent_DeleteKnowledgeBase_section.md)
+ [`DeletePrompt`](bedrock-agent_example_bedrock-agent_DeletePrompt_section.md)
+ [`GetAgent`](bedrock-agent_example_bedrock-agent_GetAgent_section.md)
+ [`GetFlow`](bedrock-agent_example_bedrock-agent_GetFlow_section.md)
+ [`GetFlowVersion`](bedrock-agent_example_bedrock-agent_GetFlowVersion_section.md)
+ [`GetKnowledgeBase`](bedrock-agent_example_bedrock-agent_GetKnowledgeBase_section.md)
+ [`GetPrompt`](bedrock-agent_example_bedrock-agent_GetPrompt_section.md)
+ [`ListAgentActionGroups`](bedrock-agent_example_bedrock-agent_ListAgentActionGroups_section.md)
+ [`ListAgentKnowledgeBases`](bedrock-agent_example_bedrock-agent_ListAgentKnowledgeBases_section.md)
+ [`ListAgents`](bedrock-agent_example_bedrock-agent_ListAgents_section.md)
+ [`ListFlowAliases`](bedrock-agent_example_bedrock-agent_ListFlowAliases_section.md)
+ [`ListFlowVersions`](bedrock-agent_example_bedrock-agent_ListFlowVersions_section.md)
+ [`ListFlows`](bedrock-agent_example_bedrock-agent_ListFlows_section.md)
+ [`ListKnowledgeBases`](bedrock-agent_example_bedrock-agent_ListKnowledgeBases_section.md)
+ [`ListPrompts`](bedrock-agent_example_bedrock-agent_ListPrompts_section.md)
+ [`PrepareAgent`](bedrock-agent_example_bedrock-agent_PrepareAgent_section.md)
+ [`PrepareFlow`](bedrock-agent_example_bedrock-agent_PrepareFlow_section.md)
+ [`UpdateFlow`](bedrock-agent_example_bedrock-agent_UpdateFlow_section.md)
+ [`UpdateFlowAlias`](bedrock-agent_example_bedrock-agent_UpdateFlowAlias_section.md)
+ [`UpdateKnowledgeBase`](bedrock-agent_example_bedrock-agent_UpdateKnowledgeBase_section.md)
+ [Cenários](service_code_examples_bedrock-agent_scenarios.md)
+ [Criar e invocar um fluxo](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockFlows_section.md)
+ [Criar e invocar um prompt gerenciado](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockPrompts_section.md)
+ [Criar e invocar um agente](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockAgents_section.md)
+ [Orquestrar aplicações de IA generativa com o Step Functions](bedrock-agent_example_cross_ServerlessPromptChaining_section.md)
+ [Amazon Bedrock Agents Runtime](service_code_examples_bedrock-agent-runtime.md)
+ [Conceitos básicos](service_code_examples_bedrock-agent-runtime_basics.md)
+ [Conheça os conceitos básicos](bedrock-agent-runtime_example_bedrock-agent-runtime_Scenario_ConverseWithFlow_section.md)
+ [Ações](service_code_examples_bedrock-agent-runtime_actions.md)
+ [`InvokeAgent`](bedrock-agent-runtime_example_bedrock-agent-runtime_InvokeAgent_section.md)
+ [`InvokeFlow`](bedrock-agent-runtime_example_bedrock-agent-runtime_InvokeFlow_section.md)
+ [Cenários](service_code_examples_bedrock-agent-runtime_scenarios.md)
+ [Criar e invocar um fluxo](bedrock-agent-runtime_example_bedrock-agent_GettingStartedWithBedrockFlows_section.md)
+ [Orquestrar aplicações de IA generativa com o Step Functions](bedrock-agent-runtime_example_cross_ServerlessPromptChaining_section.md)
# Exemplos de código para o Amazon Bedrock usando AWS SDKs
Os exemplos de código a seguir mostram como usar o Amazon Bedrock com um kit de desenvolvimento de AWS software (SDK).
*Ações* são trechos de código de programas maiores e devem ser executadas em contexto. Embora as ações mostrem como chamar perfis de serviço individuais, você pode ver as ações no contexto em seus cenários relacionados.
*Cenários* são exemplos de código que mostram como realizar tarefas específicas chamando várias funções dentro de um serviço ou combinadas com outros Serviços da AWS.
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
**Contents**
+ [Conceitos básicos](service_code_examples_bedrock_basics.md)
+ [Olá, Amazon Bedrock](bedrock_example_bedrock_Hello_section.md)
+ [Ações](service_code_examples_bedrock_actions.md)
+ [`GetFoundationModel`](bedrock_example_bedrock_GetFoundationModel_section.md)
+ [`ListFoundationModels`](bedrock_example_bedrock_ListFoundationModels_section.md)
+ [Cenários](service_code_examples_bedrock_scenarios.md)
+ [Orquestrar aplicações de IA generativa com o Step Functions](bedrock_example_cross_ServerlessPromptChaining_section.md)
# Exemplos básicos para o uso do Amazon Bedrock AWS SDKs
Os exemplos de código a seguir mostram como usar o básico do Amazon Bedrock com. AWS SDKs
**Contents**
+ [Olá, Amazon Bedrock](bedrock_example_bedrock_Hello_section.md)
+ [Ações](service_code_examples_bedrock_actions.md)
+ [`GetFoundationModel`](bedrock_example_bedrock_GetFoundationModel_section.md)
+ [`ListFoundationModels`](bedrock_example_bedrock_ListFoundationModels_section.md)
# Olá, Amazon Bedrock
Os exemplos de código a seguir mostram como começar a usar o Amazon Bedrock.
------
#### [ .NET ]
**SDK para .NET (v4)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Bedrock#code-examples).
```
using Amazon;
using Amazon.Bedrock;
using Amazon.Bedrock.Model;
namespace BedrockActions;
///
/// This example shows how to list foundation models.
///
internal class HelloBedrock
{
///
/// Main method to call the ListFoundationModelsAsync method.
///
/// The command line arguments.
static async Task Main(string[] args)
{
// Specify a region endpoint where Amazon Bedrock is available. For a list of supported region see https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html#bedrock-regions
AmazonBedrockClient bedrockClient = new(RegionEndpoint.USWest2);
await ListFoundationModelsAsync(bedrockClient);
}
///
/// List foundation models.
///
/// The Amazon Bedrock client.
private static async Task ListFoundationModelsAsync(AmazonBedrockClient bedrockClient)
{
Console.WriteLine("List foundation models with no filter.");
try
{
var response = await bedrockClient.ListFoundationModelsAsync(new ListFoundationModelsRequest()
{
});
if (response?.HttpStatusCode == System.Net.HttpStatusCode.OK)
{
foreach (var fm in response.ModelSummaries)
{
WriteToConsole(fm);
}
}
else
{
Console.WriteLine("Something wrong happened");
}
}
catch (AmazonBedrockException e)
{
Console.WriteLine(e.Message);
}
}
///
/// Write the foundation model summary to console.
///
/// The foundation model summary to write to console.
private static void WriteToConsole(FoundationModelSummary foundationModel)
{
Console.WriteLine($"{foundationModel.ModelId}, Customization: {string.Join(", ", foundationModel.CustomizationsSupported)}, Stream: {foundationModel.ResponseStreamingSupported}, Input: {string.Join(", ", foundationModel.InputModalities)}, Output: {string.Join(", ", foundationModel.OutputModalities)}");
}
}
```
+ Para obter detalhes da API, consulte [ListFoundationModels](https://docs.aws.amazon.com/goto/DotNetSDKV4/bedrock-2023-04-20/ListFoundationModels)a *Referência AWS SDK para .NET da API*.
------
#### [ Go ]
**SDK para Go V2**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/bedrock#code-examples).
```
package main
import (
"context"
"fmt"
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/service/bedrock"
)
const region = "us-east-1"
// main uses the AWS SDK for Go (v2) to create an Amazon Bedrock client and
// list the available foundation models in your account and the chosen region.
// This example uses the default settings specified in your shared credentials
// and config files.
func main() {
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
}
bedrockClient := bedrock.NewFromConfig(sdkConfig)
result, err := bedrockClient.ListFoundationModels(ctx, &bedrock.ListFoundationModelsInput{})
if err != nil {
fmt.Printf("Couldn't list foundation models. Here's why: %v\n", err)
return
}
if len(result.ModelSummaries) == 0 {
fmt.Println("There are no foundation models.")
}
for _, modelSummary := range result.ModelSummaries {
fmt.Println(*modelSummary.ModelId)
}
}
```
+ Para obter detalhes da API, consulte [ListFoundationModels](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/bedrock#Client.ListFoundationModels)a *Referência AWS SDK para Go da API*.
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock#code-examples).
```
import { fileURLToPath } from "node:url";
import {
BedrockClient,
ListFoundationModelsCommand,
} from "@aws-sdk/client-bedrock";
const REGION = "us-east-1";
const client = new BedrockClient({ region: REGION });
export const main = async () => {
const command = new ListFoundationModelsCommand({});
const response = await client.send(command);
const models = response.modelSummaries;
console.log("Listing the available Bedrock foundation models:");
for (const model of models) {
console.log("=".repeat(42));
console.log(` Model: ${model.modelId}`);
console.log("-".repeat(42));
console.log(` Name: ${model.modelName}`);
console.log(` Provider: ${model.providerName}`);
console.log(` Model ARN: ${model.modelArn}`);
console.log(` Input modalities: ${model.inputModalities}`);
console.log(` Output modalities: ${model.outputModalities}`);
console.log(` Supported customizations: ${model.customizationsSupported}`);
console.log(` Supported inference types: ${model.inferenceTypesSupported}`);
console.log(` Lifecycle status: ${model.modelLifecycle.status}`);
console.log(`${"=".repeat(42)}\n`);
}
const active = models.filter(
(m) => m.modelLifecycle.status === "ACTIVE",
).length;
const legacy = models.filter(
(m) => m.modelLifecycle.status === "LEGACY",
).length;
console.log(
`There are ${active} active and ${legacy} legacy foundation models in ${REGION}.`,
);
return response;
};
// Invoke main function if this file was run directly.
if (process.argv[1] === fileURLToPath(import.meta.url)) {
await main();
}
```
+ Para obter detalhes da API, consulte [ListFoundationModels](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock/command/ListFoundationModelsCommand)a *Referência AWS SDK para JavaScript da API*.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock#code-examples).
```
"""
Lists the available Amazon Bedrock models.
"""
import logging
import json
import boto3
from botocore.exceptions import ClientError
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
def list_foundation_models(bedrock_client):
"""
Gets a list of available Amazon Bedrock foundation models.
:return: The list of available bedrock foundation models.
"""
try:
response = bedrock_client.list_foundation_models()
models = response["modelSummaries"]
logger.info("Got %s foundation models.", len(models))
return models
except ClientError:
logger.error("Couldn't list foundation models.")
raise
def main():
"""Entry point for the example. Uses the AWS SDK for Python (Boto3)
to create an Amazon Bedrock client. Then lists the available Bedrock models
in the region set in the callers profile and credentials.
"""
bedrock_client = boto3.client(service_name="bedrock")
fm_models = list_foundation_models(bedrock_client)
for model in fm_models:
print(f"Model: {model['modelName']}")
print(json.dumps(model, indent=2))
print("---------------------------\n")
logger.info("Done.")
if __name__ == "__main__":
main()
```
+ Para obter detalhes da API, consulte a [ListFoundationModels](https://docs.aws.amazon.com/goto/boto3/bedrock-2023-04-20/ListFoundationModels)Referência da API *AWS SDK for Python (Boto3*).
------
#### [ Swift ]
**SDK para Swift**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/bedrock#code-examples).
```
import ArgumentParser
import AWSClientRuntime
import Foundation
import AWSBedrock
struct ExampleCommand: ParsableCommand {
static var configuration = CommandConfiguration(
commandName: "ListFoundationModels",
abstract: """
This example demonstrates how to retrieve a list of the available
foundation models from Amazon Bedrock.
""",
discussion: """
"""
)
/// Construct a string listing the specified modalities.
///
/// - Parameter modalities: An array of the modalities to list.
///
/// - Returns: A string with a human-readable list of modalities.
func buildModalityList(modalities: [BedrockClientTypes.ModelModality]?) -> String {
var first = true
var str = ""
if modalities == nil {
return ""
}
for modality in modalities! {
if !first {
str += ", "
}
first = false
str += modality.rawValue
}
return str
}
/// Construct a string listing the specified customizations.
///
/// - Parameter customizations: An array of the customizations to list.
///
/// - Returns: A string listing the customizations.
func buildCustomizationList(customizations: [BedrockClientTypes.ModelCustomization]?) -> String {
var first = true
var str = ""
if customizations == nil {
return ""
}
for customization in customizations! {
if !first {
str += ", "
}
first = false
str += customization.rawValue
}
return str
}
/// Construct a string listing the specified inferences.
///
/// - Parameter inferences: An array of inferences to list.
///
/// - Returns: A string listing the specified inferences.
func buildInferenceList(inferences: [BedrockClientTypes.InferenceType]?) -> String {
var first = true
var str = ""
if inferences == nil {
return ""
}
for inference in inferences! {
if !first {
str += ", "
}
first = false
str += inference.rawValue
}
return str
}
/// Called by ``main()`` to run the bulk of the example.
func runAsync() async throws {
// Always use the Region "us-east-1" to have access to the most models.
let config = try await BedrockClient.BedrockClientConfiguration(region: "us-east-1")
let bedrockClient = BedrockClient(config: config)
let output = try await bedrockClient.listFoundationModels(
input: ListFoundationModelsInput()
)
guard let summaries = output.modelSummaries else {
print("No models returned.")
return
}
// Output a list of the models with their details.
for summary in summaries {
print("==========================================")
print(" Model ID: \(summary.modelId ?? "")")
print("------------------------------------------")
print(" Name: \(summary.modelName ?? "")")
print(" Provider: \(summary.providerName ?? "")")
print(" Input modalities: \(buildModalityList(modalities: summary.inputModalities))")
print(" Output modalities: \(buildModalityList(modalities: summary.outputModalities))")
print(" Supported customizations: \(buildCustomizationList(customizations: summary.customizationsSupported ))")
print(" Supported inference types: \(buildInferenceList(inferences: summary.inferenceTypesSupported))")
print("------------------------------------------\n")
}
print("\(summaries.count) models available.")
}
}
/// The program's asynchronous entry point.
@main
struct Main {
static func main() async {
let args = Array(CommandLine.arguments.dropFirst())
do {
let command = try ExampleCommand.parse(args)
try await command.runAsync()
} catch {
ExampleCommand.exit(withError: error)
}
}
}
```
+ Para obter detalhes da API, consulte [ListFoundationModels](https://sdk.amazonaws.com/swift/api/awsbedrock/latest/documentation/awsbedrock/bedrockclient/listfoundationmodels(input:))a *referência da API AWS SDK for Swift*.
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Ações para o Amazon Bedrock usando AWS SDKs
Os exemplos de código a seguir demonstram como realizar ações individuais do Amazon Bedrock com AWS SDKs. Cada exemplo inclui um link para GitHub, onde você pode encontrar instruções para configurar e executar o código.
Esses trechos chamam a API do Amazon Bedrock e são trechos de código de programas maiores que devem ser executados em contexto. É possível ver as ações em contexto em [Cenários para o uso do Amazon Bedrock AWS SDKs](service_code_examples_bedrock_scenarios.md).
Os exemplos a seguir incluem apenas as ações mais utilizadas. Para obter uma lista completa, consulte a [Amazon Bedrock API Reference](https://docs.aws.amazon.com/bedrock/latest/APIReference/welcome.html).
**Topics**
+ [`GetFoundationModel`](bedrock_example_bedrock_GetFoundationModel_section.md)
+ [`ListFoundationModels`](bedrock_example_bedrock_ListFoundationModels_section.md)
# Use `GetFoundationModel` com um AWS SDK
Os exemplos de código a seguir mostram como usar o `GetFoundationModel`.
------
#### [ Java ]
**SDK para Java 2.x**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock#code-examples).
Obtenha detalhes de um modelo de base usando o cliente síncrono Amazon Bedrock.
```
/**
* Get details about an Amazon Bedrock foundation model.
*
* @param bedrockClient The service client for accessing Amazon Bedrock.
* @param modelIdentifier The model identifier.
* @return An object containing the foundation model's details.
*/
public static FoundationModelDetails getFoundationModel(BedrockClient bedrockClient, String modelIdentifier) {
try {
GetFoundationModelResponse response = bedrockClient.getFoundationModel(
r -> r.modelIdentifier(modelIdentifier)
);
FoundationModelDetails model = response.modelDetails();
System.out.println(" Model ID: " + model.modelId());
System.out.println(" Model ARN: " + model.modelArn());
System.out.println(" Model Name: " + model.modelName());
System.out.println(" Provider Name: " + model.providerName());
System.out.println(" Lifecycle status: " + model.modelLifecycle().statusAsString());
System.out.println(" Input modalities: " + model.inputModalities());
System.out.println(" Output modalities: " + model.outputModalities());
System.out.println(" Supported customizations: " + model.customizationsSupported());
System.out.println(" Supported inference types: " + model.inferenceTypesSupported());
System.out.println(" Response streaming supported: " + model.responseStreamingSupported());
return model;
} catch (ValidationException e) {
throw new IllegalArgumentException(e.getMessage());
} catch (SdkException e) {
System.err.println(e.getMessage());
throw new RuntimeException(e);
}
}
```
Obtenha detalhes de um modelo de base usando o cliente assíncrono Amazon Bedrock.
```
/**
* Get details about an Amazon Bedrock foundation model.
*
* @param bedrockClient The async service client for accessing Amazon Bedrock.
* @param modelIdentifier The model identifier.
* @return An object containing the foundation model's details.
*/
public static FoundationModelDetails getFoundationModel(BedrockAsyncClient bedrockClient, String modelIdentifier) {
try {
CompletableFuture future = bedrockClient.getFoundationModel(
r -> r.modelIdentifier(modelIdentifier)
);
FoundationModelDetails model = future.get().modelDetails();
System.out.println(" Model ID: " + model.modelId());
System.out.println(" Model ARN: " + model.modelArn());
System.out.println(" Model Name: " + model.modelName());
System.out.println(" Provider Name: " + model.providerName());
System.out.println(" Lifecycle status: " + model.modelLifecycle().statusAsString());
System.out.println(" Input modalities: " + model.inputModalities());
System.out.println(" Output modalities: " + model.outputModalities());
System.out.println(" Supported customizations: " + model.customizationsSupported());
System.out.println(" Supported inference types: " + model.inferenceTypesSupported());
System.out.println(" Response streaming supported: " + model.responseStreamingSupported());
return model;
} catch (ExecutionException e) {
if (e.getMessage().contains("ValidationException")) {
throw new IllegalArgumentException(e.getMessage());
} else {
System.err.println(e.getMessage());
throw new RuntimeException(e);
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
System.err.println(e.getMessage());
throw new RuntimeException(e);
}
}
```
+ Para obter detalhes da API, consulte [GetFoundationModel](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-2023-04-20/GetFoundationModel)a *Referência AWS SDK for Java 2.x da API*.
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock#code-examples).
Obtenha detalhes de um modelo de base.
```
import { fileURLToPath } from "node:url";
import {
BedrockClient,
GetFoundationModelCommand,
} from "@aws-sdk/client-bedrock";
/**
* Get details about an Amazon Bedrock foundation model.
*
* @return {FoundationModelDetails} - The list of available bedrock foundation models.
*/
export const getFoundationModel = async () => {
const client = new BedrockClient();
const command = new GetFoundationModelCommand({
modelIdentifier: "amazon.titan-embed-text-v1",
});
const response = await client.send(command);
return response.modelDetails;
};
// Invoke main function if this file was run directly.
if (process.argv[1] === fileURLToPath(import.meta.url)) {
const model = await getFoundationModel();
console.log(model);
}
```
+ Para obter detalhes da API, consulte [GetFoundationModel](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock/command/GetFoundationModelCommand)a *Referência AWS SDK para JavaScript da API*.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock#code-examples).
Obtenha detalhes de um modelo de base.
```
def get_foundation_model(self, model_identifier):
"""
Get details about an Amazon Bedrock foundation model.
:return: The foundation model's details.
"""
try:
return self.bedrock_client.get_foundation_model(
modelIdentifier=model_identifier
)["modelDetails"]
except ClientError:
logger.error(
f"Couldn't get foundation models details for {model_identifier}"
)
raise
```
+ Para obter detalhes da API, consulte a [GetFoundationModel](https://docs.aws.amazon.com/goto/boto3/bedrock-2023-04-20/GetFoundationModel)Referência da API *AWS SDK for Python (Boto3*).
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Use `ListFoundationModels` com um AWS SDK
Os exemplos de código a seguir mostram como usar o `ListFoundationModels`.
------
#### [ .NET ]
**SDK para .NET (v4)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Bedrock#code-examples).
Listar os modelos de base do Bedrock disponíveis.
```
///
/// List foundation models.
///
/// The Amazon Bedrock client.
private static async Task ListFoundationModelsAsync(AmazonBedrockClient bedrockClient)
{
Console.WriteLine("List foundation models with no filter.");
try
{
var response = await bedrockClient.ListFoundationModelsAsync(new ListFoundationModelsRequest()
{
});
if (response?.HttpStatusCode == System.Net.HttpStatusCode.OK)
{
foreach (var fm in response.ModelSummaries)
{
WriteToConsole(fm);
}
}
else
{
Console.WriteLine("Something wrong happened");
}
}
catch (AmazonBedrockException e)
{
Console.WriteLine(e.Message);
}
}
```
+ Para obter detalhes da API, consulte [ListFoundationModels](https://docs.aws.amazon.com/goto/DotNetSDKV4/bedrock-2023-04-20/ListFoundationModels)a *Referência AWS SDK para .NET da API*.
------
#### [ Go ]
**SDK para Go V2**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/bedrock#code-examples).
Listar os modelos de base do Bedrock disponíveis.
```
import (
"context"
"log"
"github.com/aws/aws-sdk-go-v2/service/bedrock"
"github.com/aws/aws-sdk-go-v2/service/bedrock/types"
)
// FoundationModelWrapper encapsulates Amazon Bedrock actions used in the examples.
// It contains a Bedrock service client that is used to perform foundation model actions.
type FoundationModelWrapper struct {
BedrockClient *bedrock.Client
}
// ListPolicies lists Bedrock foundation models that you can use.
func (wrapper FoundationModelWrapper) ListFoundationModels(ctx context.Context) ([]types.FoundationModelSummary, error) {
var models []types.FoundationModelSummary
result, err := wrapper.BedrockClient.ListFoundationModels(ctx, &bedrock.ListFoundationModelsInput{})
if err != nil {
log.Printf("Couldn't list foundation models. Here's why: %v\n", err)
} else {
models = result.ModelSummaries
}
return models, err
}
```
+ Para obter detalhes da API, consulte [ListFoundationModels](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/bedrock#Client.ListFoundationModels)a *Referência AWS SDK para Go da API*.
------
#### [ Java ]
**SDK para Java 2.x**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock#code-examples).
Liste os modelos de base do Amazon Bedrock disponíveis usando o cliente de base do Amazon Bedrock síncrono.
```
/**
* Lists Amazon Bedrock foundation models that you can use.
* You can filter the results with the request parameters.
*
* @param bedrockClient The service client for accessing Amazon Bedrock.
* @return A list of objects containing the foundation models' details
*/
public static List listFoundationModels(BedrockClient bedrockClient) {
try {
ListFoundationModelsResponse response = bedrockClient.listFoundationModels(r -> {});
List models = response.modelSummaries();
if (models.isEmpty()) {
System.out.println("No available foundation models in " + region.toString());
} else {
for (FoundationModelSummary model : models) {
System.out.println("Model ID: " + model.modelId());
System.out.println("Provider: " + model.providerName());
System.out.println("Name: " + model.modelName());
System.out.println();
}
}
return models;
} catch (SdkClientException e) {
System.err.println(e.getMessage());
throw new RuntimeException(e);
}
}
```
Liste os modelos de base do Amazon Bedrock disponíveis usando o cliente de base do Amazon Bedrock assíncrono.
```
/**
* Lists Amazon Bedrock foundation models that you can use.
* You can filter the results with the request parameters.
*
* @param bedrockClient The async service client for accessing Amazon Bedrock.
* @return A list of objects containing the foundation models' details
*/
public static List listFoundationModels(BedrockAsyncClient bedrockClient) {
try {
CompletableFuture future = bedrockClient.listFoundationModels(r -> {});
List models = future.get().modelSummaries();
if (models.isEmpty()) {
System.out.println("No available foundation models in " + region.toString());
} else {
for (FoundationModelSummary model : models) {
System.out.println("Model ID: " + model.modelId());
System.out.println("Provider: " + model.providerName());
System.out.println("Name: " + model.modelName());
System.out.println();
}
}
return models;
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
System.err.println(e.getMessage());
throw new RuntimeException(e);
} catch (ExecutionException e) {
System.err.println(e.getMessage());
throw new RuntimeException(e);
}
}
```
+ Para obter detalhes da API, consulte [ListFoundationModels](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-2023-04-20/ListFoundationModels)a *Referência AWS SDK for Java 2.x da API*.
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock#code-examples).
Liste os modelos de base disponíveis.
```
import { fileURLToPath } from "node:url";
import {
BedrockClient,
ListFoundationModelsCommand,
} from "@aws-sdk/client-bedrock";
/**
* List the available Amazon Bedrock foundation models.
*
* @return {FoundationModelSummary[]} - The list of available bedrock foundation models.
*/
export const listFoundationModels = async () => {
const client = new BedrockClient();
const input = {
// byProvider: 'STRING_VALUE',
// byCustomizationType: 'FINE_TUNING' || 'CONTINUED_PRE_TRAINING',
// byOutputModality: 'TEXT' || 'IMAGE' || 'EMBEDDING',
// byInferenceType: 'ON_DEMAND' || 'PROVISIONED',
};
const command = new ListFoundationModelsCommand(input);
const response = await client.send(command);
return response.modelSummaries;
};
// Invoke main function if this file was run directly.
if (process.argv[1] === fileURLToPath(import.meta.url)) {
const models = await listFoundationModels();
console.log(models);
}
```
+ Para obter detalhes da API, consulte [ListFoundationModels](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock/command/ListFoundationModelsCommand)a *Referência AWS SDK para JavaScript da API*.
------
#### [ Kotlin ]
**SDK para Kotlin**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/bedrock#code-examples).
Listar os modelos de base do Amazon Bedrock disponíveis.
```
suspend fun listFoundationModels(): List? {
BedrockClient.fromEnvironment { region = "us-east-1" }.use { bedrockClient ->
val response = bedrockClient.listFoundationModels(ListFoundationModelsRequest {})
response.modelSummaries?.forEach { model ->
println("==========================================")
println(" Model ID: ${model.modelId}")
println("------------------------------------------")
println(" Name: ${model.modelName}")
println(" Provider: ${model.providerName}")
println(" Input modalities: ${model.inputModalities}")
println(" Output modalities: ${model.outputModalities}")
println(" Supported customizations: ${model.customizationsSupported}")
println(" Supported inference types: ${model.inferenceTypesSupported}")
println("------------------------------------------\n")
}
return response.modelSummaries
}
}
```
+ Para obter detalhes da API, consulte a [ListFoundationModels](https://sdk.amazonaws.com/kotlin/api/latest/index.html)referência da API *AWS SDK for Kotlin*.
------
#### [ PHP ]
**SDK para PHP**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/bedrock#code-examples).
Listar os modelos de base do Amazon Bedrock disponíveis.
```
public function listFoundationModels()
{
$bedrockClient = new BedrockClient([
'region' => 'us-west-2',
'profile' => 'default'
]);
$response = $bedrockClient->listFoundationModels();
return $response['modelSummaries'];
}
```
+ Para obter detalhes da API, consulte [ListFoundationModels](https://docs.aws.amazon.com/goto/SdkForPHPV3/bedrock-2023-04-20/ListFoundationModels)a *Referência AWS SDK para PHP da API*.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock#code-examples).
Listar os modelos de base do Amazon Bedrock disponíveis.
```
def list_foundation_models(self):
"""
List the available Amazon Bedrock foundation models.
:return: The list of available bedrock foundation models.
"""
try:
response = self.bedrock_client.list_foundation_models()
models = response["modelSummaries"]
logger.info("Got %s foundation models.", len(models))
return models
except ClientError:
logger.error("Couldn't list foundation models.")
raise
```
+ Para obter detalhes da API, consulte a [ListFoundationModels](https://docs.aws.amazon.com/goto/boto3/bedrock-2023-04-20/ListFoundationModels)Referência da API *AWS SDK for Python (Boto3*).
------
#### [ Swift ]
**SDK para Swift**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/bedrock#code-examples).
```
import AWSBedrock
// Always use the Region "us-east-1" to have access to the most models.
let config = try await BedrockClient.BedrockClientConfiguration(region: "us-east-1")
let bedrockClient = BedrockClient(config: config)
let output = try await bedrockClient.listFoundationModels(
input: ListFoundationModelsInput()
)
guard let summaries = output.modelSummaries else {
print("No models returned.")
return
}
// Output a list of the models with their details.
for summary in summaries {
print("==========================================")
print(" Model ID: \(summary.modelId ?? "")")
print("------------------------------------------")
print(" Name: \(summary.modelName ?? "")")
print(" Provider: \(summary.providerName ?? "")")
print(" Input modalities: \(buildModalityList(modalities: summary.inputModalities))")
print(" Output modalities: \(buildModalityList(modalities: summary.outputModalities))")
print(" Supported customizations: \(buildCustomizationList(customizations: summary.customizationsSupported ))")
print(" Supported inference types: \(buildInferenceList(inferences: summary.inferenceTypesSupported))")
print("------------------------------------------\n")
}
```
+ Para obter detalhes da API, consulte [ListFoundationModels](https://sdk.amazonaws.com/swift/api/awsbedrock/latest/documentation/awsbedrock/bedrockclient/listfoundationmodels(input:))a *referência da API AWS SDK for Swift*.
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Cenários para o uso do Amazon Bedrock AWS SDKs
Os exemplos de código a seguir mostram como implementar cenários comuns no Amazon Bedrock com AWS SDKs. Esses casos mostram como executar tarefas específicas chamando várias funções no Amazon Bedrock ou em combinação com outros Serviços da AWS. Cada cenário inclui um link para o código-fonte completo, onde podem ser encontradas instruções sobre como configurar e executar o código.
Os cenários têm como alvo um nível intermediário de experiência para ajudar você a compreender ações de serviço em contexto.
**Topics**
+ [Orquestrar aplicações de IA generativa com o Step Functions](bedrock_example_cross_ServerlessPromptChaining_section.md)
# Construir e orquestrar aplicações de IA generativa com o Amazon Bedrock e o Step Functions
O exemplo de código a seguir mostra como criar e orquestrar aplicações de IA generativa com o Amazon Bedrock e o Step Functions.
------
#### [ Python ]
**SDK para Python (Boto3)**
O cenário de encadeamento de prompts do Amazon Bedrock Sem Servidor demonstra como o [AWS Step Functions](https://docs.aws.amazon.com/step-functions/latest/dg/welcome.html), o [Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html) e a documentação [https://docs.aws.amazon.com/bedrock/latest/userguide/agents.html](https://docs.aws.amazon.com/bedrock/latest/userguide/agents.html) podem ser usados para criar e orquestrar aplicações de IA generativa complexas, sem servidor e altamente escaláveis. Ele contém os seguintes exemplos de trabalho:
+ Escrever uma análise de um determinado romance para um blog de literatura. Este exemplo ilustra uma cadeia de prompts simples e sequencial.
+ Gerar uma história curta sobre um determinado tópico. Este exemplo ilustra como a IA pode processar uma lista de itens gerada anteriormente de forma iterativa.
+ Criar um itinerário para férias de fim de semana em um determinado destino. Este exemplo ilustra como paralelizar vários prompts distintos.
+ Lançar ideias de filmes para um usuário humano que atua como produtor de filmes. Este exemplo ilustra como paralelizar o mesmo prompt com diferentes parâmetros de inferência, como voltar a uma etapa anterior na cadeia e como incluir a entrada humana como parte do fluxo de trabalho.
+ Planejar uma refeição com base nos ingredientes que o usuário tem em mãos. Este exemplo ilustra como as cadeias de prompts podem incorporar duas conversas distintas de IA, com duas personas de IA participando de um debate entre si para melhorar o resultado final.
+ Encontre e resuma o repositório mais popular GitHub da atualidade. Este exemplo ilustra o encadeamento de vários agentes de IA que interagem com agentes externos. APIs
Para obter o código-fonte completo e as instruções de configuração e execução, consulte o projeto completo em [GitHub](https://github.com/aws-samples/amazon-bedrock-serverless-prompt-chaining).
**Serviços usados neste exemplo**
+ Amazon Bedrock
+ Amazon Bedrock Runtime
+ Amazon Bedrock Agents
+ Amazon Bedrock Agents Runtime
+ Step Functions
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Exemplos de código para o Amazon Bedrock Runtime usando AWS SDKs
Os exemplos de código a seguir mostram como usar o Amazon Bedrock Runtime com um kit de desenvolvimento de AWS software (SDK).
*Cenários* são exemplos de código que mostram como realizar tarefas específicas chamando várias funções dentro de um serviço ou combinadas com outros Serviços da AWS.
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
**Contents**
+ [Conceitos básicos](service_code_examples_bedrock-runtime_basics.md)
+ [Olá, Amazon Bedrock](bedrock-runtime_example_bedrock-runtime_Hello_section.md)
+ [Cenários](service_code_examples_bedrock-runtime_scenarios.md)
+ [Criar um aplicativo playground para interagir com os modelos de base do Amazon Bedrock](bedrock-runtime_example_cross_FMPlayground_section.md)
+ [Criar e invocar um prompt gerenciado](bedrock-runtime_example_bedrock-agent_GettingStartedWithBedrockPrompts_section.md)
+ [Gerar vídeos com base em prompts de texto usando o Amazon Bedrock](bedrock-runtime_example_bedrock-runtime_Scenario_GenerateVideos_NovaReel_section.md)
+ [Invocar vários modelos de base no Amazon Bedrock](bedrock-runtime_example_bedrock-runtime_Scenario_InvokeModels_section.md)
+ [Orquestrar aplicações de IA generativa com o Step Functions](bedrock-runtime_example_cross_ServerlessPromptChaining_section.md)
+ [Uso de ferramenta com a API Converse](bedrock-runtime_example_bedrock-runtime_Scenario_ToolUse_section.md)
+ [Amazon Nova](service_code_examples_bedrock-runtime_amazon_nova.md)
+ [Converse](bedrock-runtime_example_bedrock-runtime_Converse_AmazonNovaText_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_AmazonNovaText_section.md)
+ [Compreensão do documento](bedrock-runtime_example_bedrock-runtime_DocumentUnderstanding_AmazonNova_section.md)
+ [Cenário: uso de ferramentas com a API Converse](bedrock-runtime_example_bedrock-runtime_Scenario_ToolUseDemo_AmazonNova_section.md)
+ [Amazon Nova Canvas](service_code_examples_bedrock-runtime_amazon_nova_canvas.md)
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_AmazonNovaImageGeneration_section.md)
+ [Amazon Nova Reel](service_code_examples_bedrock-runtime_amazon_nova_reel.md)
+ [T ext-to-video](bedrock-runtime_example_bedrock-runtime_Scenario_AmazonNova_TextToVideo_section.md)
+ [Gerador de Imagens do Amazon Titan](service_code_examples_bedrock-runtime_amazon_titan_image_generator.md)
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_TitanImageGenerator_section.md)
+ [Amazon Titan Text](service_code_examples_bedrock-runtime_amazon_titan_text.md)
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_TitanText_section.md)
+ [Incorporações de texto Amazon Titan](service_code_examples_bedrock-runtime_amazon_titan_text_embeddings.md)
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModelWithResponseStream_TitanTextEmbeddings_section.md)
+ [Claude da Anthropic](service_code_examples_bedrock-runtime_anthropic_claude.md)
+ [Converse](bedrock-runtime_example_bedrock-runtime_Converse_AnthropicClaude_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_AnthropicClaude_section.md)
+ [Compreensão do documento](bedrock-runtime_example_bedrock-runtime_DocumentUnderstanding_AnthropicClaude_section.md)
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_AnthropicClaude_section.md)
+ [InvokeModelWithResponseStream](bedrock-runtime_example_bedrock-runtime_InvokeModelWithResponseStream_AnthropicClaude_section.md)
+ [Reasoning](bedrock-runtime_example_bedrock-runtime_Converse_AnthropicClaudeReasoning_section.md)
+ [Raciocínio com uma resposta em streaming](bedrock-runtime_example_bedrock-runtime_ConverseStream_AnthropicClaudeReasoning_section.md)
+ [Cenário: uso de ferramentas com a API Converse](bedrock-runtime_example_bedrock-runtime_Scenario_ToolUseDemo_AnthropicClaude_section.md)
+ [Command da Cohere](service_code_examples_bedrock-runtime_cohere_command.md)
+ [Converse](bedrock-runtime_example_bedrock-runtime_Converse_CohereCommand_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_CohereCommand_section.md)
+ [Compreensão do documento](bedrock-runtime_example_bedrock-runtime_DocumentUnderstanding_CohereCommand_section.md)
+ [InvokeModel: Comando R e R\$1](bedrock-runtime_example_bedrock-runtime_InvokeModel_CohereCommandR_section.md)
+ [InvokeModelWithResponseStream: Comando R e R\$1](bedrock-runtime_example_bedrock-runtime_InvokeModelWithResponseStream_CohereCommandR_section.md)
+ [Cenário: uso de ferramentas com a API Converse](bedrock-runtime_example_bedrock-runtime_Scenario_ToolUseDemo_CohereCommand_section.md)
+ [DeepSeek](service_code_examples_bedrock-runtime_deepseek.md)
+ [Compreensão do documento](bedrock-runtime_example_bedrock-runtime_DocumentUnderstanding_DeepSeek_section.md)
+ [Llama da Meta](service_code_examples_bedrock-runtime_meta_llama.md)
+ [Converse](bedrock-runtime_example_bedrock-runtime_Converse_MetaLlama_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_MetaLlama_section.md)
+ [Compreensão do documento](bedrock-runtime_example_bedrock-runtime_DocumentUnderstanding_MetaLlama_section.md)
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_MetaLlama3_section.md)
+ [InvokeModelWithResponseStream](bedrock-runtime_example_bedrock-runtime_InvokeModelWithResponseStream_MetaLlama3_section.md)
+ [Mistral AI](service_code_examples_bedrock-runtime_mistral_ai.md)
+ [Converse](bedrock-runtime_example_bedrock-runtime_Converse_Mistral_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_Mistral_section.md)
+ [Compreensão do documento](bedrock-runtime_example_bedrock-runtime_DocumentUnderstanding_Mistral_section.md)
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_MistralAi_section.md)
+ [InvokeModelWithResponseStream](bedrock-runtime_example_bedrock-runtime_InvokeModelWithResponseStream_MistralAi_section.md)
+ [Stable Diffusion](service_code_examples_bedrock-runtime_stable_diffusion.md)
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_StableDiffusion_section.md)
# Exemplos básicos para o Amazon Bedrock Runtime usando AWS SDKs
Os exemplos de código a seguir mostram como usar os conceitos básicos do Amazon Bedrock Runtime com. AWS SDKs
**Contents**
+ [Olá, Amazon Bedrock](bedrock-runtime_example_bedrock-runtime_Hello_section.md)
# Olá, Amazon Bedrock
Os exemplos de código a seguir mostram como começar a usar o Amazon Bedrock.
------
#### [ Go ]
**SDK para Go V2**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/bedrock-runtime#code-examples).
```
package main
import (
"context"
"encoding/json"
"flag"
"fmt"
"log"
"os"
"strings"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/service/bedrockruntime"
)
// Each model provider defines their own individual request and response formats.
// For the format, ranges, and default values for the different models, refer to:
// https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters.html
type ClaudeRequest struct {
Prompt string `json:"prompt"`
MaxTokensToSample int `json:"max_tokens_to_sample"`
// Omitting optional request parameters
}
type ClaudeResponse struct {
Completion string `json:"completion"`
}
// main uses the AWS SDK for Go (v2) to create an Amazon Bedrock Runtime client
// and invokes Anthropic Claude 2 inside your account and the chosen region.
// This example uses the default settings specified in your shared credentials
// and config files.
func main() {
region := flag.String("region", "us-east-1", "The AWS region")
flag.Parse()
fmt.Printf("Using AWS region: %s\n", *region)
ctx := context.Background()
sdkConfig, err := config.LoadDefaultConfig(ctx, config.WithRegion(*region))
if err != nil {
fmt.Println("Couldn't load default configuration. Have you set up your AWS account?")
fmt.Println(err)
return
}
client := bedrockruntime.NewFromConfig(sdkConfig)
modelId := "anthropic.claude-v2"
prompt := "Hello, how are you today?"
// Anthropic Claude requires you to enclose the prompt as follows:
prefix := "Human: "
postfix := "\n\nAssistant:"
wrappedPrompt := prefix + prompt + postfix
request := ClaudeRequest{
Prompt: wrappedPrompt,
MaxTokensToSample: 200,
}
body, err := json.Marshal(request)
if err != nil {
log.Panicln("Couldn't marshal the request: ", err)
}
result, err := client.InvokeModel(ctx, &bedrockruntime.InvokeModelInput{
ModelId: aws.String(modelId),
ContentType: aws.String("application/json"),
Body: body,
})
if err != nil {
errMsg := err.Error()
if strings.Contains(errMsg, "no such host") {
fmt.Printf("Error: The Bedrock service is not available in the selected region. Please double-check the service availability for your region at https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/.\n")
} else if strings.Contains(errMsg, "Could not resolve the foundation model") {
fmt.Printf("Error: Could not resolve the foundation model from model identifier: \"%v\". Please verify that the requested model exists and is accessible within the specified region.\n", modelId)
} else {
fmt.Printf("Error: Couldn't invoke Anthropic Claude. Here's why: %v\n", err)
}
os.Exit(1)
}
var response ClaudeResponse
err = json.Unmarshal(result.Body, &response)
if err != nil {
log.Fatal("failed to unmarshal", err)
}
fmt.Println("Prompt:\n", prompt)
fmt.Println("Response from Anthropic Claude:\n", response.Completion)
}
```
+ Para obter detalhes da API, consulte [InvokeModel](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/bedrockruntime#Client.InvokeModel)a *Referência AWS SDK para Go da API*.
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
```
/**
* @typedef {Object} Content
* @property {string} text
*
* @typedef {Object} Usage
* @property {number} input_tokens
* @property {number} output_tokens
*
* @typedef {Object} ResponseBody
* @property {Content[]} content
* @property {Usage} usage
*/
import { fileURLToPath } from "node:url";
import {
BedrockRuntimeClient,
InvokeModelCommand,
} from "@aws-sdk/client-bedrock-runtime";
const AWS_REGION = "us-east-1";
const MODEL_ID = "anthropic.claude-3-haiku-20240307-v1:0";
const PROMPT = "Hi. In a short paragraph, explain what you can do.";
const hello = async () => {
console.log("=".repeat(35));
console.log("Welcome to the Amazon Bedrock demo!");
console.log("=".repeat(35));
console.log("Model: Anthropic Claude 3 Haiku");
console.log(`Prompt: ${PROMPT}\n`);
console.log("Invoking model...\n");
// Create a new Bedrock Runtime client instance.
const client = new BedrockRuntimeClient({ region: AWS_REGION });
// Prepare the payload for the model.
const payload = {
anthropic_version: "bedrock-2023-05-31",
max_tokens: 1000,
messages: [{ role: "user", content: [{ type: "text", text: PROMPT }] }],
};
// Invoke Claude with the payload and wait for the response.
const apiResponse = await client.send(
new InvokeModelCommand({
contentType: "application/json",
body: JSON.stringify(payload),
modelId: MODEL_ID,
}),
);
// Decode and return the response(s)
const decodedResponseBody = new TextDecoder().decode(apiResponse.body);
/** @type {ResponseBody} */
const responseBody = JSON.parse(decodedResponseBody);
const responses = responseBody.content;
if (responses.length === 1) {
console.log(`Response: ${responses[0].text}`);
} else {
console.log("Haiku returned multiple responses:");
console.log(responses);
}
console.log(`\nNumber of input tokens: ${responseBody.usage.input_tokens}`);
console.log(`Number of output tokens: ${responseBody.usage.output_tokens}`);
};
if (process.argv[1] === fileURLToPath(import.meta.url)) {
await hello();
}
```
+ Para obter detalhes da API, consulte [InvokeModel](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/InvokeModelCommand)a *Referência AWS SDK para JavaScript da API*.
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Cenários para o Amazon Bedrock Runtime usando AWS SDKs
Os exemplos de código a seguir mostram como implementar cenários comuns no Amazon Bedrock Runtime com AWS SDKs. Esses cenários mostram como executar tarefas específicas chamando vários perfis no Amazon Bedrock Runtime ou em conjunto com outros Serviços da AWS. Cada cenário inclui um link para o código-fonte completo, onde podem ser encontradas instruções sobre como configurar e executar o código.
Os cenários têm como alvo um nível intermediário de experiência para ajudar você a compreender ações de serviço em contexto.
**Topics**
+ [Criar um aplicativo playground para interagir com os modelos de base do Amazon Bedrock](bedrock-runtime_example_cross_FMPlayground_section.md)
+ [Criar e invocar um prompt gerenciado](bedrock-runtime_example_bedrock-agent_GettingStartedWithBedrockPrompts_section.md)
+ [Gerar vídeos com base em prompts de texto usando o Amazon Bedrock](bedrock-runtime_example_bedrock-runtime_Scenario_GenerateVideos_NovaReel_section.md)
+ [Invocar vários modelos de base no Amazon Bedrock](bedrock-runtime_example_bedrock-runtime_Scenario_InvokeModels_section.md)
+ [Orquestrar aplicações de IA generativa com o Step Functions](bedrock-runtime_example_cross_ServerlessPromptChaining_section.md)
+ [Uso de ferramenta com a API Converse](bedrock-runtime_example_bedrock-runtime_Scenario_ToolUse_section.md)
# Crie um aplicativo de amostra que ofereça playgrounds para interagir com os modelos da Amazon Bedrock Foundation usando um SDK AWS
Os exemplos de código a seguir mostram como criar playgrounds para interagir com os modelos da base do Amazon Bedrock em diferentes modalidades.
------
#### [ .NET ]
**SDK para .NET**
O .NET Foundation Model (FM) Playground é um aplicativo de amostra do .NET MAUI Blazor que mostra como usar o Amazon Bedrock a partir do código C\$1. Este exemplo mostra como os desenvolvedores de .NET e C\$1 podem usar o Amazon Bedrock para criar aplicativos habilitados para IA generativa. É possível testar e interagir com os modelos de base do Amazon Bedrock usando os quatro playgrounds a seguir:
+ Um playground de texto.
+ Um playground de chat.
+ Um playground de chat por voz.
+ Um playground de imagens.
O exemplo também lista e exibe os modelos de base aos quais você tem acesso e respectivas características. Para obter o código-fonte e as instruções de implantação, consulte o projeto em [GitHub](https://github.com/build-on-aws/dotnet-fm-playground).
**Serviços usados neste exemplo**
+ Amazon Bedrock Runtime
------
#### [ Java ]
**SDK para Java 2.x**
O Java Foundation Model (FM) Playground é um aplicativo de amostra da Spring Boot que mostra como usar o Amazon Bedrock com Java. Este exemplo mostra como os desenvolvedores Java podem usar o Amazon Bedrock para criar aplicativos habilitados para IA generativa. É possível testar e interagir com os modelos de base do Amazon Bedrock usando os três playgrounds a seguir:
+ Um playground de texto.
+ Um playground de chat.
+ Um playground de imagens.
O exemplo também lista e exibe os modelos de base aos quais você tem acesso e respectivas características. Para obter o código-fonte e as instruções de implantação, consulte o projeto em [GitHub](https://github.com/build-on-aws/java-fm-playground).
**Serviços usados neste exemplo**
+ Amazon Bedrock Runtime
------
#### [ Python ]
**SDK para Python (Boto3)**
O Python Foundation Model (FM) Playground é um aplicativo de Python/FastAPI amostra que mostra como usar o Amazon Bedrock com Python. Este exemplo mostra como os desenvolvedores de Python podem usar o Amazon Bedrock para criar aplicativos habilitados para IA generativa. É possível testar e interagir com os modelos de base do Amazon Bedrock usando os três playgrounds a seguir:
+ Um playground de texto.
+ Um playground de chat.
+ Um playground de imagens.
O exemplo também lista e exibe os modelos de base aos quais você tem acesso e respectivas características. Para obter o código-fonte e as instruções de implantação, consulte o projeto em [GitHub](https://github.com/build-on-aws/python-fm-playground).
**Serviços usados neste exemplo**
+ Amazon Bedrock Runtime
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Um end-to-end exemplo mostrando como criar e invocar prompts gerenciados do Amazon Bedrock usando um SDK AWS
O exemplo de código a seguir mostra como:
+ Criar um prompt gerenciado.
+ Criar uma versão do prompt.
+ Invocar o prompt usando a versão.
+ Limpar os recursos (opcional).
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples).
Criar e invocar um prompt gerenciado.
```
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()
```
+ Para ver detalhes da API, consulte os tópicos a seguir na *Referência da API do SDK da AWS para 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)
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Gerar vídeos com base em prompts de texto usando o Amazon Bedrock e o Nova Reel
O exemplo de código a seguir mostra como usar um aplicativo Spring Boot que gera vídeos com base em prompts de texto utilizando o Amazon Bedrock e o modelo Nova-Reel.
------
#### [ Java ]
**SDK para Java 2.x**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Gere vídeos com base em prompts de texto usando o Amazon Bedrock e o 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;
}
}
```
+ Para obter detalhes da API, consulte os tópicos a seguir na *Referência da API 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)
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Invocar vários modelos de base no Amazon Bedrock
Os exemplos de código a seguir mostram como preparar e enviar uma solicitação para uma variedade de modelos de linguagem grande (LLMs) no Amazon Bedrock
------
#### [ Go ]
**SDK para Go V2**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/bedrock-runtime#code-examples).
Invoque vários modelos de base no 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)
}
```
+ Para obter detalhes da API, consulte os tópicos a seguir na *Referência da API AWS SDK para 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 para JavaScript (v3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
```
import { fileURLToPath } from "node:url";
import {
Scenario,
ScenarioAction,
ScenarioInput,
ScenarioOutput,
} from "@aws-doc-sdk-examples/lib/scenario/index.js";
import { FoundationModels } from "../config/foundation_models.js";
/**
* @typedef {Object} ModelConfig
* @property {Function} module
* @property {Function} invoker
* @property {string} modelId
* @property {string} modelName
*/
const greeting = new ScenarioOutput(
"greeting",
"Welcome to the Amazon Bedrock Runtime client demo!",
{ header: true },
);
const selectModel = new ScenarioInput("model", "First, select a model:", {
type: "select",
choices: Object.values(FoundationModels).map((model) => ({
name: model.modelName,
value: model,
})),
});
const enterPrompt = new ScenarioInput("prompt", "Now, enter your prompt:", {
type: "input",
});
const printDetails = new ScenarioOutput(
"print details",
/**
* @param {{ model: ModelConfig, prompt: string }} c
*/
(c) => console.log(`Invoking ${c.model.modelName} with '${c.prompt}'...`),
);
const invokeModel = new ScenarioAction(
"invoke model",
/**
* @param {{ model: ModelConfig, prompt: string, response: string }} c
*/
async (c) => {
const modelModule = await c.model.module();
const invoker = c.model.invoker(modelModule);
c.response = await invoker(c.prompt, c.model.modelId);
},
);
const printResponse = new ScenarioOutput(
"print response",
/**
* @param {{ response: string }} c
*/
(c) => c.response,
);
const scenario = new Scenario("Amazon Bedrock Runtime Demo", [
greeting,
selectModel,
enterPrompt,
printDetails,
invokeModel,
printResponse,
]);
if (process.argv[1] === fileURLToPath(import.meta.url)) {
scenario.run();
}
```
+ Para obter detalhes da API, consulte os tópicos a seguir na *Referência da API AWS SDK para 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 ]
**SDK para PHP**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/bedrock-runtime/#code-examples).
Invoque vários LLMs no 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;
}
}
```
+ Para obter detalhes da API, consulte os tópicos a seguir na *Referência da API AWS SDK para 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)
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Construir e orquestrar aplicações de IA generativa com o Amazon Bedrock e o Step Functions
O exemplo de código a seguir mostra como criar e orquestrar aplicações de IA generativa com o Amazon Bedrock e o Step Functions.
------
#### [ Python ]
**SDK para Python (Boto3)**
O cenário de encadeamento de prompts do Amazon Bedrock Sem Servidor demonstra como o [AWS Step Functions](https://docs.aws.amazon.com/step-functions/latest/dg/welcome.html), o [Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html) e a documentação [https://docs.aws.amazon.com/bedrock/latest/userguide/agents.html](https://docs.aws.amazon.com/bedrock/latest/userguide/agents.html) podem ser usados para criar e orquestrar aplicações de IA generativa complexas, sem servidor e altamente escaláveis. Ele contém os seguintes exemplos de trabalho:
+ Escrever uma análise de um determinado romance para um blog de literatura. Este exemplo ilustra uma cadeia de prompts simples e sequencial.
+ Gerar uma história curta sobre um determinado tópico. Este exemplo ilustra como a IA pode processar uma lista de itens gerada anteriormente de forma iterativa.
+ Criar um itinerário para férias de fim de semana em um determinado destino. Este exemplo ilustra como paralelizar vários prompts distintos.
+ Lançar ideias de filmes para um usuário humano que atua como produtor de filmes. Este exemplo ilustra como paralelizar o mesmo prompt com diferentes parâmetros de inferência, como voltar a uma etapa anterior na cadeia e como incluir a entrada humana como parte do fluxo de trabalho.
+ Planejar uma refeição com base nos ingredientes que o usuário tem em mãos. Este exemplo ilustra como as cadeias de prompts podem incorporar duas conversas distintas de IA, com duas personas de IA participando de um debate entre si para melhorar o resultado final.
+ Encontre e resuma o repositório mais popular GitHub da atualidade. Este exemplo ilustra o encadeamento de vários agentes de IA que interagem com agentes externos. APIs
Para obter o código-fonte completo e as instruções de configuração e execução, consulte o projeto completo em [GitHub](https://github.com/aws-samples/amazon-bedrock-serverless-prompt-chaining).
**Serviços usados neste exemplo**
+ Amazon Bedrock
+ Amazon Bedrock Runtime
+ Amazon Bedrock Agents
+ Amazon Bedrock Agents Runtime
+ Step Functions
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Um exemplo de uso de ferramentas ilustrando como conectar modelos de IA no Amazon Bedrock a uma ferramenta ou API personalizada
Os exemplos de código a seguir mostram como criar uma interação típica entre um aplicativo, um modelo generativo de IA e ferramentas conectadas ou como APIs mediar interações entre a IA e o mundo externo. Ele usa o exemplo de conectar uma API de meteorologia externa ao modelo de IA para que possa fornecer informações de meteorologia em tempo real com base na entrada do usuário.
------
#### [ .NET ]
**SDK para .NET**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime/Scenarios/ConverseToolScenario#code-examples).
A execução primária do fluxo do cenário. Esse cenário orquestra a conversa entre o usuário, a API Converse do Amazon Bedrock e uma ferramenta de meteorologia.
```
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();
}
}
```
A ferramenta de meteorologia usada pela demonstração. Esse arquivo define a especificação da ferramenta e implementa a lógica para recuperar dados de meteorologia usando a 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;
}
}
}
```
A ação da API Converse com uma configuração de ferramenta.
```
///
/// 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;
}
}
}
```
+ Consulte detalhes da API em [Converse](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/Converse) na *Referência de API do AWS SDK para .NET *.
------
#### [ Java ]
**SDK para Java 2.x**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
A execução primária do fluxo do cenário. Esse cenário orquestra a conversa entre o usuário, a API Converse do Amazon Bedrock e uma ferramenta de meteorologia.
```
/*
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
=================================================
""");
}
}
```
A ferramenta de meteorologia usada pela demonstração. Esse arquivo define a especificação da ferramenta e implementa a lógica para recuperar dados de meteorologia usando a 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
}
}
```
A ação da API Converse com uma configuração de ferramenta.
```
/**
* 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);
}
}
```
+ Consulte detalhes da API em [Converse](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/Converse) na *Referência de API do AWS SDK for Java 2.x *.
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime/scenarios/converse_tool_scenario#code-examples).
A execução primária do fluxo do cenário. Esse cenário orquestra a conversa entre o usuário, a API Converse do Amazon Bedrock e uma ferramenta de meteorologia.
```
/* 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 });
}
```
+ Para obter detalhes da API, consulte [Converse](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseCommand) na *Referência da API do AWS SDK para JavaScript *.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
O script de execução principal da demonstração. Esse script orquestra a conversa entre o usuário, a API Converse do Amazon Bedrock e uma ferramenta de meteorologia.
```
"""
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()
```
A ferramenta de meteorologia usada pela demonstração. Esse script define a especificação da ferramenta e implementa a lógica para recuperar dados de meteorologia usando a 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)}
```
+ Consulte detalhes da API em [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) na *Referência de API do AWS SDK para Python (Boto3)*.
------
#### [ Rust ]
**SDK para Rust**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/bedrock-runtime#code-examples).
O cenário principal e a lógica da demonstração. Esse script orquestra a conversa entre o usuário, a API Converse do Amazon Bedrock e uma ferramenta de meteorologia.
```
#[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();
}
```
A ferramenta de meteorologia usada pela demonstração. Esse script define a especificação da ferramenta e implementa a lógica para recuperar dados de meteorologia usando a 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()?)
}
```
Utilitários para imprimir os blocos de conteúdo da mensagem.
```
fn print_model_response(block: &ContentBlock) -> Result<(), ToolUseScenarioError> {
if block.is_text() {
let text = block.as_text().unwrap();
println!("\x1b[0;90mThe model's response:\x1b[0m\n{text}");
Ok(())
} else {
Err(ToolUseScenarioError(format!(
"Content block is not text ({block:?})"
)))
}
}
```
Use instruções, utilitário de erro e 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(),
})
}
}
```
+ Consulte detalhes da API em [Converse](https://docs.rs/aws-sdk-bedrockruntime/latest/aws_sdk_bedrockruntime/client/struct.Client.html#method.converse) na *Referência de API do AWS SDK para Rust*.
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Amazon Nova para Amazon Bedrock Runtime
Os exemplos de código a seguir mostram como usar o Amazon Bedrock Runtime com AWS SDKs.
**Topics**
+ [Converse](bedrock-runtime_example_bedrock-runtime_Converse_AmazonNovaText_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_AmazonNovaText_section.md)
+ [Compreensão do documento](bedrock-runtime_example_bedrock-runtime_DocumentUnderstanding_AmazonNova_section.md)
+ [Cenário: uso de ferramentas com a API Converse](bedrock-runtime_example_bedrock-runtime_Scenario_ToolUseDemo_AmazonNova_section.md)
# Invocar o Amazon Nova no Amazon Bedrock usando a API Converse do Bedrock
Os exemplos de código a seguir mostram como enviar uma mensagem de texto para o Amazon Nova usando a API Converse do Bedrock.
------
#### [ .NET ]
**SDK para .NET**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime#code-examples).
Envie uma mensagem de texto para o Amazon Nova usando a API Converse do 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;
}
```
Envie uma conversa de mensagens para o Amazon Nova usando a API Converse do Bedrock com uma configuração de ferramenta.
```
///
/// 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;
}
}
}
```
+ Para obter detalhes da API, consulte [Converse](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/Converse) na *Referência da API do AWS SDK para .NET *.
------
#### [ Java ]
**SDK para Java 2.x**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Envie uma mensagem de texto para o Amazon Nova usando a API Converse do Bedrock com o cliente Java assíncrono.
```
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);
}
}
```
Envie uma mensagem de texto para o Amazon Nova usando a API Converse do 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);
}
}
```
+ Consulte detalhes da API em [Converse](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/Converse) na *Referência de API do AWS SDK for Java 2.x *.
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Envie uma mensagem de texto para o Amazon Nova usando a API Converse do 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;
}
```
Envie uma conversa de mensagens para o Amazon Nova usando a API Converse do Bedrock com uma configuração de ferramenta.
```
// 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);
```
+ Consulte detalhes da API em [Converse](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseCommand) na *Referência de API do AWS SDK para JavaScript *.
------
#### [ Kotlin ]
**SDK para Kotlin**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/bedrock-runtime#code-examples).
Envie uma mensagem de texto para o Amazon Nova usando a API Converse do 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)
}
}
}
```
+ Consulte detalhes da API em [Converse](https://sdk.amazonaws.com/kotlin/api/latest/index.html) na *Referência da API do AWS SDK para Kotlin*.
------
#### [ PHP ]
**SDK para PHP**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/bedrock-runtime#code-examples).
Envie uma mensagem de texto para o Amazon Nova usando a API Converse do 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();
```
+ Para obter detalhes da API, consulte [Converse](https://docs.aws.amazon.com/goto/SdkForPHPV3/bedrock-runtime-2023-09-30/Converse) na *Referência da API do AWS SDK para PHP *.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Envie uma mensagem de texto para o Amazon Nova usando a API Converse do 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)
```
+ Consulte detalhes da API em [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) na *Referência de API do AWS SDK para Python (Boto3)*.
------
#### [ Swift ]
**SDK para Swift**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/bedrock-runtime#code-examples).
Envie uma mensagem de texto para o Amazon Nova usando a API Converse do 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"
}
}
```
+ Consulte detalhes da API em [Converse](https://sdk.amazonaws.com/swift/api/awsbedrockruntime/latest/documentation/awsbedrockruntime/bedrockruntimeclient/converse(input:)) na *Referência de API do AWS SDK para Swift*.
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Invocar o Amazon Nova no Amazon Bedrock usando a API Converse do Bedrock com um fluxo de respostas
Os exemplos de código a seguir mostram como enviar uma mensagem de texto para o Amazon Nova usando a API Converse do Bedrock e processar o fluxo de respostas em tempo real.
------
#### [ .NET ]
**SDK para .NET**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime#code-examples).
Envie uma mensagem de texto para o Amazon Nova usando a API Converse do Bedrock e processe o fluxo de respostas em tempo real.
```
// 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;
}
```
+ Para obter detalhes da API, consulte [ConverseStream](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/ConverseStream)a *Referência AWS SDK para .NET da API*.
------
#### [ Java ]
**SDK para Java 2.x**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Envie uma mensagem de texto para o Amazon Nova usando a API Converse do Bedrock e processe o fluxo de respostas em tempo real.
```
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();
}
}
```
+ Para obter detalhes da API, consulte [ConverseStream](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/ConverseStream)a *Referência AWS SDK for Java 2.x da API*.
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Envie uma mensagem de texto para o Amazon Nova usando a API Converse do Bedrock e processe o fluxo de respostas em tempo real.
```
// 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;
}
```
+ Para obter detalhes da API, consulte [ConverseStream](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseStreamCommand)a *Referência AWS SDK para JavaScript da API*.
------
#### [ Kotlin ]
**SDK para Kotlin**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/bedrock-runtime#code-examples).
Envie uma mensagem de texto para o Amazon Nova usando a API Converse do Bedrock e processe o fluxo de respostas em tempo real.
```
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()
}
```
+ Para obter detalhes da API, consulte a [ConverseStream](https://sdk.amazonaws.com/kotlin/api/latest/index.html)referência da API *AWS SDK for Kotlin*.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Envie uma mensagem de texto para o Amazon Nova usando a API Converse do Bedrock e processe o fluxo de respostas em tempo real.
```
# 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)
```
+ Para obter detalhes da API, consulte a [ConverseStream](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/ConverseStream)Referência da API *AWS SDK for Python (Boto3*).
------
#### [ Swift ]
**SDK para Swift**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/bedrock-runtime#code-examples).
Envie uma mensagem de texto para o Amazon Nova usando a API Converse do Bedrock e processe o fluxo de respostas em tempo real.
```
// 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
}
}
}
```
+ Para obter detalhes da API, consulte [ConverseStream](https://sdk.amazonaws.com/swift/api/awsbedrockruntime/latest/documentation/awsbedrockruntime/bedrockruntimeclient/conversestream(input:))a *referência da API AWS SDK for Swift*.
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Enviar e processar um documento com o Amazon Nova no Amazon Bedrock
O exemplo de código a seguir mostra como enviar e processar um documento com o Amazon Nova no Amazon Bedrock.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Envie e processe um documento com o Amazon Nova no 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)
```
+ Consulte detalhes da API em [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) na *Referência de API do AWS SDK para Python (Boto3)*.
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Demonstração do uso de ferramentas ilustrando como conectar modelos de IA no Amazon Bedrock a uma ferramenta ou API personalizada
Os exemplos de código a seguir mostram como criar uma interação típica entre um aplicativo, um modelo generativo de IA e ferramentas conectadas ou como APIs mediar interações entre a IA e o mundo externo. Ele usa o exemplo de conectar uma API de meteorologia externa ao modelo de IA para que possa fornecer informações de meteorologia em tempo real com base na entrada do usuário.
------
#### [ .NET ]
**SDK para .NET**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime/Scenarios/ConverseToolScenario#code-examples).
A execução primária do fluxo do cenário. Esse cenário orquestra a conversa entre o usuário, a API Converse do Amazon Bedrock e uma ferramenta de meteorologia.
```
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();
}
}
```
A ferramenta de meteorologia usada pela demonstração. Esse arquivo define a especificação da ferramenta e implementa a lógica para recuperar dados de meteorologia usando a 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;
}
}
}
```
A ação da API Converse com uma configuração de ferramenta.
```
///
/// 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;
}
}
}
```
+ Consulte detalhes da API em [Converse](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/Converse) na *Referência de API do AWS SDK para .NET *.
------
#### [ Java ]
**SDK para Java 2.x**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
A execução primária do fluxo do cenário. Esse cenário orquestra a conversa entre o usuário, a API Converse do Amazon Bedrock e uma ferramenta de meteorologia.
```
/*
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
=================================================
""");
}
}
```
A ferramenta de meteorologia usada pela demonstração. Esse arquivo define a especificação da ferramenta e implementa a lógica para recuperar dados de meteorologia usando a 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
}
}
```
A ação da API Converse com uma configuração de ferramenta.
```
/**
* 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);
}
}
```
+ Consulte detalhes da API em [Converse](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/Converse) na *Referência de API do AWS SDK for Java 2.x *.
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime/scenarios/converse_tool_scenario#code-examples).
A execução primária do fluxo do cenário. Esse cenário orquestra a conversa entre o usuário, a API Converse do Amazon Bedrock e uma ferramenta de meteorologia.
```
/* 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 });
}
```
+ Consulte detalhes da API em [Converse](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseCommand) na *Referência de API do AWS SDK para JavaScript *.
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Amazon Nova Canvas para Amazon Bedrock Runtime
Os exemplos de código a seguir mostram como usar o Amazon Bedrock Runtime com AWS SDKs.
**Topics**
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_AmazonNovaImageGeneration_section.md)
# Invocar o Amazon Nova Canvas no Amazon Bedrock para gerar uma imagem
Os exemplos de código a seguir mostram como invocar o Amazon Nova Canvas no Amazon Bedrock para gerar uma imagem.
------
#### [ .NET ]
**SDK para .NET**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime#code-examples).
Crie uma imagem com o 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;
}
```
+ Para obter detalhes da API, consulte [InvokeModel](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/InvokeModel)a *Referência AWS SDK para .NET da API*.
------
#### [ Java ]
**SDK para Java 2.x**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Crie uma imagem com o 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);
}
}
```
+ Para obter detalhes da API, consulte [InvokeModel](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModel)a *Referência AWS SDK for Java 2.x da API*.
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Crie uma imagem com o 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;
});
}
```
+ Para obter detalhes da API, consulte [InvokeModel](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/InvokeModelCommand)a *Referência AWS SDK para JavaScript da API*.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Crie uma imagem com o 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}")
```
+ Para obter detalhes da API, consulte a [InvokeModel](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModel)Referência da API *AWS SDK for Python (Boto3*).
------
#### [ Swift ]
**SDK para Swift**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/bedrock-runtime#code-examples).
Crie uma imagem com o 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)")
}
```
+ Para obter detalhes da API, consulte [InvokeModel](https://sdk.amazonaws.com/swift/api/awsbedrockruntime/latest/documentation/awsbedrockruntime/bedrockruntimeclient/invokemodel(input:))a *referência da API AWS SDK for Swift*.
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Amazon Nova Reel para Amazon Bedrock Runtime
Os exemplos de código a seguir mostram como usar o Amazon Bedrock Runtime com AWS SDKs.
**Topics**
+ [T ext-to-video](bedrock-runtime_example_bedrock-runtime_Scenario_AmazonNova_TextToVideo_section.md)
# Usar o Amazon Nova Reel para gerar um vídeo de um prompt de texto
Os exemplos de código a seguir mostram como usar o Amazon Nova Reel para gerar um vídeo com base em um prompt de texto.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Use o Amazon Nova Reel para gerar um vídeo de um prompt de texto.
```
"""
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()
```
+ Para ver detalhes da API, consulte os tópicos a seguir na *Referência da API do SDK da AWS para 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 ]
**SDK para Swift**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/bedrock-runtime#code-examples).
Use o Amazon Nova Reel para gerar um vídeo de um prompt de texto.
```
// 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)")
}
```
+ Consulte detalhes da API nos tópicos a seguir na *Referência de API do AWS SDK para 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:))
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Gerador de Imagens do Amazon Titan para Amazon Bedrock Runtime
Os exemplos de código a seguir mostram como usar o Amazon Bedrock Runtime com AWS SDKs.
**Topics**
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_TitanImageGenerator_section.md)
# Invocar o Amazon Titan Image no Amazon Bedrock para gerar uma imagem
Os exemplos de código a seguir mostram como invocar o Amazon Titan Image no Amazon Bedrock para gerar uma imagem.
------
#### [ Go ]
**SDK para Go V2**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/bedrock-runtime#code-examples).
Crie uma imagem com o Gerador de Imagens do 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
}
```
+ Para obter detalhes da API, consulte [InvokeModel](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/bedrockruntime#Client.InvokeModel)a *Referência AWS SDK para Go da API*.
------
#### [ Java ]
**SDK para Java 2.x**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Crie uma imagem com o Gerador de Imagens do 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);
}
}
```
+ Para obter detalhes da API, consulte [InvokeModel](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModel)a *Referência AWS SDK for Java 2.x da API*.
------
#### [ PHP ]
**SDK para PHP**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/bedrock-runtime#code-examples).
Crie uma imagem com o Gerador de Imagens do 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;
}
```
+ Para obter detalhes da API, consulte [InvokeModel](https://docs.aws.amazon.com/goto/SdkForPHPV3/bedrock-runtime-2023-09-30/InvokeModel)a *Referência AWS SDK para PHP da API*.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Crie uma imagem com o Gerador de Imagens do 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}")
```
+ Para obter detalhes da API, consulte a [InvokeModel](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModel)Referência da API *AWS SDK for Python (Boto3*).
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Amazon Titan Text para Amazon Bedrock Runtime
Os exemplos de código a seguir mostram como usar o Amazon Bedrock Runtime com AWS SDKs.
**Topics**
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_TitanText_section.md)
# Invocar modelos Amazon Titan Text no Amazon Bedrock usando a API InvokeModel
O exemplo de código a seguir mostra como enviar uma mensagem de texto ao Amazon Titan Text usando a API InvokeModel.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Use a API InvokeModel para enviar uma mensagem de texto.
```
# 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)
```
+ Para obter detalhes da API, consulte a [InvokeModel](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModel)Referência da API *AWS SDK for Python (Boto3*).
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Incorporador de Texto do Amazon Titan para Amazon Bedrock Runtime
Os exemplos de código a seguir mostram como usar o Amazon Bedrock Runtime com AWS SDKs.
**Topics**
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModelWithResponseStream_TitanTextEmbeddings_section.md)
# Invocar o Incorporador de Texto do Amazon Titan no Amazon Bedrock
Os exemplos de código a seguir mostram como:
+ Começar a criar sua primeira incorporação.
+ Criar incorporações configurando o número de dimensões e a normalização (somente v2).
------
#### [ Java ]
**SDK para Java 2.x**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Crie a primeira incorporação com o Incorporador de Texto do 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();
}
}
```
Invoque o Incorporador de Texto do Titan v2 configurando o número de dimensões e a normalização.
```
/**
* 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;
}
```
+ Para obter detalhes da API, consulte [InvokeModel](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModel)a *Referência AWS SDK for Java 2.x da API*.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Crie a primeira incorporação com o Incorporador de Texto do 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)
```
+ Para obter detalhes da API, consulte a [InvokeModel](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModel)Referência da API *AWS SDK for Python (Boto3*).
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Claude da Anthropic para Amazon Bedrock Runtime
Os exemplos de código a seguir mostram como usar o Amazon Bedrock Runtime com AWS SDKs.
**Topics**
+ [Converse](bedrock-runtime_example_bedrock-runtime_Converse_AnthropicClaude_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_AnthropicClaude_section.md)
+ [Compreensão do documento](bedrock-runtime_example_bedrock-runtime_DocumentUnderstanding_AnthropicClaude_section.md)
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_AnthropicClaude_section.md)
+ [InvokeModelWithResponseStream](bedrock-runtime_example_bedrock-runtime_InvokeModelWithResponseStream_AnthropicClaude_section.md)
+ [Reasoning](bedrock-runtime_example_bedrock-runtime_Converse_AnthropicClaudeReasoning_section.md)
+ [Raciocínio com uma resposta em streaming](bedrock-runtime_example_bedrock-runtime_ConverseStream_AnthropicClaudeReasoning_section.md)
+ [Cenário: uso de ferramentas com a API Converse](bedrock-runtime_example_bedrock-runtime_Scenario_ToolUseDemo_AnthropicClaude_section.md)
# Invocar o Claude da Anthropic no Amazon Bedrock usando a API Converse do Bedrock
Os exemplos de código a seguir mostram como enviar uma mensagem de texto ao Claude da Anthropic usando a API Converse do Bedrock.
------
#### [ .NET ]
**SDK para .NET (v4)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Bedrock-runtime#code-examples).
Envie uma mensagem de texto ao Claude da Anthropic usando a API Converse do 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;
}
```
+ Consulte detalhes da API em [Converse](https://docs.aws.amazon.com/goto/DotNetSDKV4/bedrock-runtime-2023-09-30/Converse) na *Referência de API do AWS SDK para .NET *.
------
#### [ Go ]
**SDK para Go V2**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/bedrock-runtime#code-examples).
Envie uma mensagem de texto ao Claude da Anthropic usando a API Converse do 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
}
```
+ Para obter detalhes da API, consulte [Converse](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/bedrockruntime#Client.Converse) na *Referência da API do AWS SDK para Go *.
------
#### [ Java ]
**SDK para Java 2.x**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Envie uma mensagem de texto ao Claude da Anthropic usando a API Converse do 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();
}
}
```
Envie uma mensagem de texto ao Claude da Anthropic usando a API Converse do Bedrock com o cliente Java assíncrono.
```
// 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();
}
}
```
+ Consulte detalhes da API em [Converse](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/Converse) na *Referência de API do AWS SDK for Java 2.x *.
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Envie uma mensagem de texto ao Claude da Anthropic usando a API Converse do 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);
}
```
+ Para obter detalhes da API, consulte [Converse](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseCommand) na *Referência da API do AWS SDK para JavaScript *.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Envie uma mensagem de texto ao Claude da Anthropic usando a API Converse do 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)
```
+ Consulte detalhes da API em [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) na *Referência de API do AWS SDK para Python (Boto3)*.
------
#### [ Rust ]
**SDK para Rust**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/bedrock-runtime#code-examples).
Envie uma mensagem de texto ao Claude da Anthropic usando a API Converse do 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)
}
```
Use instruções, utilitário de erro e 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",
})
}
}
```
+ Consulte detalhes da API em [Converse](https://docs.rs/aws-sdk-bedrockruntime/latest/aws_sdk_bedrockruntime/client/struct.Client.html#method.converse) na *Referência de API do AWS SDK para Rust*.
------
#### [ Swift ]
**SDK para Swift**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/bedrock-runtime#code-examples).
Envie uma mensagem de texto ao Claude da Anthropic usando a API Converse do 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"
}
}
```
+ Consulte detalhes da API em [Converse](https://sdk.amazonaws.com/swift/api/awsbedrockruntime/latest/documentation/awsbedrockruntime/bedrockruntimeclient/converse(input:)) na *Referência de API do AWS SDK para Swift*.
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Invocar o Claude da Anthropic no Amazon Bedrock usando a API Converse do Bedrock com um fluxo de resposta
Os exemplos de código a seguir mostram como enviar uma mensagem de texto ao Claude da Anthropic usando a API Converse do Bedrock e processar o fluxo de resposta em tempo real.
------
#### [ .NET ]
**SDK para .NET (v4)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Bedrock-runtime#code-examples).
Envie uma mensagem de texto ao Claude da Anthropic usando a API Converse do Bedrock e processe o fluxo de resposta em tempo real.
```
// 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;
}
```
+ Para obter detalhes da API, consulte [ConverseStream](https://docs.aws.amazon.com/goto/DotNetSDKV4/bedrock-runtime-2023-09-30/ConverseStream)a *Referência AWS SDK para .NET da API*.
------
#### [ Java ]
**SDK para Java 2.x**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Envie uma mensagem de texto ao Claude da Anthropic usando a API Converse do Bedrock e processe o fluxo de resposta em tempo real.
```
// 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());
}
}
}
```
+ Para obter detalhes da API, consulte [ConverseStream](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/ConverseStream)a *Referência AWS SDK for Java 2.x da API*.
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Envie uma mensagem de texto ao Claude da Anthropic usando a API Converse do Bedrock e processe o fluxo de resposta em tempo real.
```
// 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);
}
```
+ Para obter detalhes da API, consulte [ConverseStream](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseStreamCommand)a *Referência AWS SDK para JavaScript da API*.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Envie uma mensagem de texto ao Claude da Anthropic usando a API Converse do Bedrock e processe o fluxo de resposta em tempo real.
```
# 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)
```
+ Para obter detalhes da API, consulte a [ConverseStream](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/ConverseStream)Referência da API *AWS SDK for Python (Boto3*).
------
#### [ Rust ]
**SDK para Rust**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/bedrock-runtime#code-examples).
Envie uma mensagem de texto para Anthropic Claude e transmita tokens de resposta usando a API do Bedrock. ConverseStream
```
#[tokio::main]
async fn main() -> Result<(), BedrockConverseStreamError> {
tracing_subscriber::fmt::init();
let sdk_config = aws_config::defaults(BehaviorVersion::latest())
.region(CLAUDE_REGION)
.load()
.await;
let client = Client::new(&sdk_config);
let response = client
.converse_stream()
.model_id(MODEL_ID)
.messages(
Message::builder()
.role(ConversationRole::User)
.content(ContentBlock::Text(USER_MESSAGE.to_string()))
.build()
.map_err(|_| "failed to build message")?,
)
.send()
.await;
let mut stream = match response {
Ok(output) => Ok(output.stream),
Err(e) => Err(BedrockConverseStreamError::from(
e.as_service_error().unwrap(),
)),
}?;
loop {
let token = stream.recv().await;
match token {
Ok(Some(text)) => {
let next = get_converse_output_text(text)?;
print!("{}", next);
Ok(())
}
Ok(None) => break,
Err(e) => Err(e
.as_service_error()
.map(BedrockConverseStreamError::from)
.unwrap_or(BedrockConverseStreamError(
"Unknown error receiving stream".into(),
))),
}?
}
println!();
Ok(())
}
fn get_converse_output_text(
output: ConverseStreamOutputType,
) -> Result {
Ok(match output {
ConverseStreamOutputType::ContentBlockDelta(event) => match event.delta() {
Some(delta) => delta.as_text().cloned().unwrap_or_else(|_| "".into()),
None => "".into(),
},
_ => "".into(),
})
}
```
Use instruções, utilitário de erro e 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(),
),
}
}
}
```
+ Para obter detalhes da API, consulte a [ConverseStream](https://docs.rs/aws-sdk-bedrockruntime/latest/aws_sdk_bedrockruntime/client/struct.Client.html#method.converse_stream)referência da *API AWS SDK for Rust*.
------
#### [ Swift ]
**SDK para Swift**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/bedrock-runtime#code-examples).
Envie uma mensagem de texto ao Claude da Anthropic usando a API Converse do Bedrock e processe o fluxo de resposta em tempo real.
```
// 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
}
}
}
```
+ Para obter detalhes da API, consulte [ConverseStream](https://sdk.amazonaws.com/swift/api/awsbedrockruntime/latest/documentation/awsbedrockruntime/bedrockruntimeclient/conversestream(input:))a *referência da API AWS SDK for Swift*.
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Enviar e processar um documento com o Claude da Anthropic no Amazon Bedrock
O exemplo de código a seguir mostra como enviar e processar um documento com o Claude da Anthropic no Amazon Bedrock.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Enviar e processar um documento com o Claude da Anthropic no 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)
```
+ Consulte detalhes da API em [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) na *Referência de API do AWS SDK para Python (Boto3)*.
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Invocar o Claude da Anthropic no Amazon Bedrock usando a API InvokeModel
Os exemplos de código a seguir mostram como enviar uma mensagem de texto ao Claude da Anthropic usando a API InvokeModel.
------
#### [ .NET ]
**SDK para .NET (v4)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Bedrock-runtime#code-examples).
Use a API InvokeModel para enviar uma mensagem de texto.
```
// 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;
}
```
+ Para obter detalhes da API, consulte [InvokeModel](https://docs.aws.amazon.com/goto/DotNetSDKV4/bedrock-runtime-2023-09-30/InvokeModel)a *Referência AWS SDK para .NET da API*.
------
#### [ Go ]
**SDK para Go V2**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/bedrock-runtime#code-examples).
Invoque o modelo de base Claude 2 da Anthropic para gerar texto.
```
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
}
```
+ Para obter detalhes da API, consulte [InvokeModel](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/bedrockruntime#Client.InvokeModel)a *Referência AWS SDK para Go da API*.
------
#### [ Java ]
**SDK para Java 2.x**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Use a API InvokeModel para enviar uma mensagem de texto.
```
// 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();
}
}
```
+ Para obter detalhes da API, consulte [InvokeModel](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModel)a *Referência AWS SDK for Java 2.x da API*.
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Use a API InvokeModel para enviar uma mensagem de texto.
```
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}`);
}
}
```
+ Para obter detalhes da API, consulte [InvokeModel](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/InvokeModelCommand)a *Referência AWS SDK para JavaScript da API*.
------
#### [ PHP ]
**SDK para PHP**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/bedrock-runtime#code-examples).
Invoque o modelo de base Claude 2 da Anthropic para gerar texto.
```
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;
}
```
+ Para obter detalhes da API, consulte [InvokeModel](https://docs.aws.amazon.com/goto/SdkForPHPV3/bedrock-runtime-2023-09-30/InvokeModel)a *Referência AWS SDK para PHP da API*.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Use a API InvokeModel para enviar uma mensagem de texto.
```
# 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)
```
+ Para obter detalhes da API, consulte a [InvokeModel](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModel)Referência da API *AWS SDK for Python (Boto3*).
------
#### [ SAP ABAP ]
**SDK para SAP ABAP**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/bdr#code-examples).
Invoque o modelo de base Claude 2 da Anthropic para gerar texto. Este exemplo usa recursos de/US2/CL\$1JSON que podem não estar disponíveis em algumas versões. 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.
```
Invoque o modelo de base Claude da Anthropic 2 para gerar texto usando um cliente de nível alto de 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.
```
Invoque o modelo de base Claude da Anthropic 3 para gerar texto usando um cliente de nível alto de 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.
```
+ Para obter detalhes da API, consulte a [InvokeModel](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)referência da *API AWS SDK for SAP ABAP*.
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Invocar os modelos Claude da Anthropic no Amazon Bedrock usando a API InvokeModel com um fluxo de resposta
Os exemplos de código a seguir mostram como enviar uma mensagem de texto para modelos Claude da Anthropic usando a API InvokeModel e imprimir o fluxo de resposta.
------
#### [ .NET ]
**SDK para .NET**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime#code-examples).
Use a API InvokeModel para enviar uma mensagem de texto e processar o fluxo de resposta em tempo real.
```
// 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;
}
```
+ Para obter detalhes da API, consulte [InvokeModelWithResponseStream](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/InvokeModelWithResponseStream)a *Referência AWS SDK para .NET da API*.
------
#### [ Go ]
**SDK para Go V2**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/bedrock-runtime#code-examples).
Use a API InvokeModel para enviar uma mensagem de texto e processar o fluxo de resposta em tempo real.
```
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
}
```
+ Para obter detalhes da API, consulte [InvokeModelWithResponseStream](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/bedrockruntime#Client.InvokeModelWithResponseStream)a *Referência AWS SDK para Go da API*.
------
#### [ Java ]
**SDK para Java 2.x**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Use a API InvokeModel para enviar uma mensagem de texto e processar o fluxo de resposta em tempo real.
```
// 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();
}
}
```
+ Para obter detalhes da API, consulte [InvokeModelWithResponseStream](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModelWithResponseStream)a *Referência AWS SDK for Java 2.x da API*.
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Use a API InvokeModel para enviar uma mensagem de texto e processar o fluxo de resposta em tempo real.
```
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}`);
}
}
```
+ Para obter detalhes da API, consulte [InvokeModelWithResponseStream](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/InvokeModelWithResponseStreamCommand)a *Referência AWS SDK para JavaScript da API*.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Use a API InvokeModel para enviar uma mensagem de texto e processar o fluxo de resposta em tempo real.
```
# 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="")
```
+ Para obter detalhes da API, consulte a [InvokeModelWithResponseStream](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModelWithResponseStream)Referência da API *AWS SDK for Python (Boto3*).
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Usar a capacidade de raciocínio do Claude 3.7 Sonnet da Anthropic no Amazon Bedrock
O exemplo de código a seguir mostra como usar a capacidade de raciocínio do Claude 3.7 Sonnet da Anthropic no Amazon Bedrock.
------
#### [ Java ]
**SDK para Java 2.x**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Use a capacidade de raciocínio do Anthropic Claude 3.7 Sonnet com o cliente de runtime assíncrono do 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());
}
}
```
Use a capacidade de raciocínio do Anthropic Claude 3.7 Sonnet com o cliente de runtime síncrono do 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());
}
}
```
+ Consulte detalhes da API em [Converse](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/Converse) na *Referência de API do AWS SDK for Java 2.x *.
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Usar a capacidade de raciocínio do Claude 3.7 Sonnet da Anthropic no Amazon Bedrock
O exemplo de código a seguir mostra como usar a capacidade de raciocínio do Claude 3.7 Sonnet da Anthropic no Amazon Bedrock.
------
#### [ Java ]
**SDK para Java 2.x**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Use a capacidade de raciocínio do Anthropic Claude 3.7 Sonnet para gerar respostas de streaming de texto.
```
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();
}
}
```
+ Consulte detalhes da API em [Converse](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/Converse) na *Referência de API do AWS SDK for Java 2.x *.
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Demonstração do uso de ferramentas ilustrando como conectar modelos de IA no Amazon Bedrock a uma ferramenta ou API personalizada
Os exemplos de código a seguir mostram como criar uma interação típica entre um aplicativo, um modelo generativo de IA e ferramentas conectadas ou como APIs mediar interações entre a IA e o mundo externo. Ele usa o exemplo de conectar uma API de meteorologia externa ao modelo de IA para que possa fornecer informações de meteorologia em tempo real com base na entrada do usuário.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
O script de execução principal da demonstração. Esse script orquestra a conversa entre o usuário, a API Converse do Amazon Bedrock e uma ferramenta de meteorologia.
```
"""
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()
```
A ferramenta de meteorologia usada pela demonstração. Esse script define a especificação da ferramenta e implementa a lógica para recuperar dados de meteorologia usando a 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)}
```
+ Consulte detalhes da API em [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) na *Referência de API do AWS SDK para Python (Boto3)*.
------
#### [ Rust ]
**SDK para Rust**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/bedrock-runtime#code-examples).
O cenário principal e a lógica da demonstração. Esse script orquestra a conversa entre o usuário, a API Converse do Amazon Bedrock e uma ferramenta de meteorologia.
```
#[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();
}
```
A ferramenta de meteorologia usada pela demonstração. Esse script define a especificação da ferramenta e implementa a lógica para recuperar dados de meteorologia usando a 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()?)
}
```
Utilitários para imprimir os blocos de conteúdo da mensagem.
```
fn print_model_response(block: &ContentBlock) -> Result<(), ToolUseScenarioError> {
if block.is_text() {
let text = block.as_text().unwrap();
println!("\x1b[0;90mThe model's response:\x1b[0m\n{text}");
Ok(())
} else {
Err(ToolUseScenarioError(format!(
"Content block is not text ({block:?})"
)))
}
}
```
Use instruções, utilitário de erro e 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(),
})
}
}
```
+ Consulte detalhes da API em [Converse](https://docs.rs/aws-sdk-bedrockruntime/latest/aws_sdk_bedrockruntime/client/struct.Client.html#method.converse) na *Referência de API do AWS SDK para Rust*.
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Command da Cohere para Amazon Bedrock Runtime
Os exemplos de código a seguir mostram como usar o Amazon Bedrock Runtime com AWS SDKs.
**Topics**
+ [Converse](bedrock-runtime_example_bedrock-runtime_Converse_CohereCommand_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_CohereCommand_section.md)
+ [Compreensão do documento](bedrock-runtime_example_bedrock-runtime_DocumentUnderstanding_CohereCommand_section.md)
+ [InvokeModel: Comando R e R\$1](bedrock-runtime_example_bedrock-runtime_InvokeModel_CohereCommandR_section.md)
+ [InvokeModelWithResponseStream: Comando R e R\$1](bedrock-runtime_example_bedrock-runtime_InvokeModelWithResponseStream_CohereCommandR_section.md)
+ [Cenário: uso de ferramentas com a API Converse](bedrock-runtime_example_bedrock-runtime_Scenario_ToolUseDemo_CohereCommand_section.md)
# Invocar o Command da Cohere no Amazon Bedrock usando a API Converse do Bedrock
Os exemplos de código a seguir mostram como enviar uma mensagem de texto ao Command da Cohere usando a API Converse do Bedrock.
------
#### [ .NET ]
**SDK para .NET (v4)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Bedrock-runtime#code-examples).
Envie uma mensagem de texto ao Cohere Command usando a API Converse do 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;
}
```
+ Para obter detalhes da API, consulte [Converse](https://docs.aws.amazon.com/goto/DotNetSDKV4/bedrock-runtime-2023-09-30/Converse) na *Referência da API do AWS SDK para .NET *.
------
#### [ Java ]
**SDK para Java 2.x**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Envie uma mensagem de texto ao Cohere Command usando a API Converse do 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();
}
}
```
Envie uma mensagem de texto ao Command da Cohere usando a API Converse do Bedrock com o cliente Java assíncrono.
```
// 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();
}
}
```
+ Consulte detalhes da API em [Converse](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/Converse) na *Referência de API do AWS SDK for Java 2.x *.
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Envie uma mensagem de texto ao Cohere Command usando a API Converse do 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);
}
```
+ Para obter detalhes da API, consulte [Converse](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseCommand) na *Referência da API do AWS SDK para JavaScript *.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Envie uma mensagem de texto ao Cohere Command usando a API Converse do 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)
```
+ Consulte detalhes da API em [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) na *Referência de API do AWS SDK para Python (Boto3)*.
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Invocar o Command da Cohere no Amazon Bedrock usando a API Converse do Bedrock com um fluxo de resposta
Os exemplos de código a seguir mostram como enviar uma mensagem de texto ao Command da Cohere usando a API Converse do Bedrock e processar o fluxo de resposta em tempo real.
------
#### [ .NET ]
**SDK para .NET (v4)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Bedrock-runtime#code-examples).
Envie uma mensagem de texto ao Command da Cohere usando a API Converse do Bedrock e processe o fluxo de resposta em tempo real.
```
// 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;
}
```
+ Para obter detalhes da API, consulte [ConverseStream](https://docs.aws.amazon.com/goto/DotNetSDKV4/bedrock-runtime-2023-09-30/ConverseStream)a *Referência AWS SDK para .NET da API*.
------
#### [ Java ]
**SDK para Java 2.x**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Envie uma mensagem de texto ao Command da Cohere usando a API Converse do Bedrock e processe o fluxo de resposta em tempo real.
```
// 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());
}
}
}
```
+ Para obter detalhes da API, consulte [ConverseStream](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/ConverseStream)a *Referência AWS SDK for Java 2.x da API*.
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Envie uma mensagem de texto ao Command da Cohere usando a API Converse do Bedrock e processe o fluxo de resposta em tempo real.
```
// 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);
}
```
+ Para obter detalhes da API, consulte [ConverseStream](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseStreamCommand)a *Referência AWS SDK para JavaScript da API*.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Envie uma mensagem de texto ao Command da Cohere usando a API Converse do Bedrock e processe o fluxo de resposta em tempo real.
```
# 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)
```
+ Para obter detalhes da API, consulte a [ConverseStream](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/ConverseStream)Referência da API *AWS SDK for Python (Boto3*).
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Enviar e processar um documento com modelos Cohere Command no Amazon Bedrock
O exemplo de código a seguir mostra como enviar e processar um documento com modelos Command da Cohere no Amazon Bedrock.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Envie e processe um documento com modelos Cohere Command no 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)
```
+ Consulte detalhes da API em [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) na *Referência de API do AWS SDK para Python (Boto3)*.
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Invocar os Cohere Command R e R\$1 no Amazon Bedrock usando a API InvokeModel
Os exemplos de código a seguir mostram como enviar uma mensagem de texto ao Cohere Command R e R\$1 usando a API InvokeModel.
------
#### [ .NET ]
**SDK para .NET**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime#code-examples).
Use a API InvokeModel para enviar uma mensagem de texto.
```
// 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;
}
```
+ Para obter detalhes da API, consulte [InvokeModel](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/InvokeModel)a *Referência AWS SDK para .NET da API*.
------
#### [ Java ]
**SDK para Java 2.x**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Use a API InvokeModel para enviar uma mensagem de texto.
```
// 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();
}
}
```
+ Para obter detalhes da API, consulte [InvokeModel](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModel)a *Referência AWS SDK for Java 2.x da API*.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Use a API InvokeModel para enviar uma mensagem de texto.
```
# 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)
```
+ Para obter detalhes da API, consulte a [InvokeModel](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModel)Referência da API *AWS SDK for Python (Boto3*).
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Invocar o Cohere Command R e R\$1 no Amazon Bedrock usando a API InvokeModel com um fluxo de resposta
Os exemplos de código a seguir mostram como enviar uma mensagem de texto ao Cohere Command, usando a API InvokeModel com um fluxo de resposta.
------
#### [ .NET ]
**SDK para .NET**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime#code-examples).
Use a API InvokeModel para enviar uma mensagem de texto e processar o fluxo de resposta em tempo real.
```
// 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;
}
```
+ Para obter detalhes da API, consulte [InvokeModel](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/InvokeModel)a *Referência AWS SDK para .NET da API*.
------
#### [ Java ]
**SDK para Java 2.x**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Use a API InvokeModel para enviar uma mensagem de texto e processar o fluxo de resposta em tempo real.
```
// 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();
}
}
```
+ Para obter detalhes da API, consulte [InvokeModel](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModel)a *Referência AWS SDK for Java 2.x da API*.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Use a API InvokeModel para enviar uma mensagem de texto e processar o fluxo de resposta em tempo real.
```
# 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)
```
+ Para obter detalhes da API, consulte a [InvokeModel](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModel)Referência da API *AWS SDK for Python (Boto3*).
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Demonstração do uso de ferramentas ilustrando como conectar modelos de IA no Amazon Bedrock a uma ferramenta ou API personalizada
O exemplo de código a seguir mostra como criar uma interação típica entre um aplicativo, um modelo generativo de IA e ferramentas conectadas ou como APIs mediar interações entre a IA e o mundo externo. Ele usa o exemplo de conectar uma API de meteorologia externa ao modelo de IA para que possa fornecer informações de meteorologia em tempo real com base na entrada do usuário.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
O script de execução principal da demonstração. Esse script orquestra a conversa entre o usuário, a API Converse do Amazon Bedrock e uma ferramenta de meteorologia.
```
"""
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()
```
A ferramenta de meteorologia usada pela demonstração. Esse script define a especificação da ferramenta e implementa a lógica para recuperar dados de meteorologia usando a 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)}
```
+ Consulte detalhes da API em [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) na *Referência de API do AWS SDK para Python (Boto3)*.
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# DeepSeek para Amazon Bedrock Runtime
Os exemplos de código a seguir mostram como usar o Amazon Bedrock Runtime com AWS SDKs.
**Topics**
+ [Compreensão do documento](bedrock-runtime_example_bedrock-runtime_DocumentUnderstanding_DeepSeek_section.md)
# Envie e processe um documento com o DeepSeek Amazon Bedrock
O exemplo de código a seguir mostra como enviar e processar um documento DeepSeek no Amazon Bedrock.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Envie e processe um documento DeepSeek no 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)
```
+ Consulte detalhes da API em [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) na *Referência de API do AWS SDK para Python (Boto3)*.
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Llama da Meta para Amazon Bedrock Runtime
Os exemplos de código a seguir mostram como usar o Amazon Bedrock Runtime com AWS SDKs.
**Topics**
+ [Converse](bedrock-runtime_example_bedrock-runtime_Converse_MetaLlama_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_MetaLlama_section.md)
+ [Compreensão do documento](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)
# Invocar o Llama da Meta no Amazon Bedrock usando a API Converse do Bedrock
Os exemplos de código a seguir mostram como enviar uma mensagem de texto ao Llama da Meta usando a API Converse do Bedrock.
------
#### [ .NET ]
**SDK para .NET (v4)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Bedrock-runtime#code-examples).
Envie uma mensagem de texto ao Llama da Meta usando a API Converse do 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;
}
```
+ Para obter detalhes da API, consulte [Converse](https://docs.aws.amazon.com/goto/DotNetSDKV4/bedrock-runtime-2023-09-30/Converse) na *Referência da API do AWS SDK para .NET *.
------
#### [ Java ]
**SDK para Java 2.x**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Envie uma mensagem de texto ao Llama da Meta usando a API Converse do 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();
}
}
```
Envie uma mensagem de texto ao Llama da Meta usando a API Converse do Bedrock com o cliente Java assíncrono.
```
// 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();
}
}
```
+ Consulte detalhes da API em [Converse](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/Converse) na *Referência de API do AWS SDK for Java 2.x *.
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Envie uma mensagem de texto ao Llama da Meta usando a API Converse do 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);
}
```
+ Para obter detalhes da API, consulte [Converse](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseCommand) na *Referência da API do AWS SDK para JavaScript *.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Envie uma mensagem de texto ao Llama da Meta usando a API Converse do 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)
```
+ Consulte detalhes da API em [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) na *Referência de API do AWS SDK para Python (Boto3)*.
------
#### [ Swift ]
**SDK para Swift**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/bedrock-runtime#code-examples).
Envie uma mensagem de texto ao Llama da Meta usando a API Converse do 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"
}
}
```
+ Consulte detalhes da API em [Converse](https://sdk.amazonaws.com/swift/api/awsbedrockruntime/latest/documentation/awsbedrockruntime/bedrockruntimeclient/converse(input:)) na *Referência de API do AWS SDK para Swift*.
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Invocar o Llama da Meta no Amazon Bedrock usando a API Converse do Bedrock com um fluxo de resposta
Os exemplos de código a seguir mostram como enviar uma mensagem de texto ao Llama da Meta usando a API Converse do Bedrock e processar o fluxo de resposta em tempo real.
------
#### [ .NET ]
**SDK para .NET (v4)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Bedrock-runtime#code-examples).
Envie uma mensagem de texto ao Llama da Meta usando a API Converse do Bedrock e processe o fluxo de resposta em tempo real.
```
// 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;
}
```
+ Para obter detalhes da API, consulte [ConverseStream](https://docs.aws.amazon.com/goto/DotNetSDKV4/bedrock-runtime-2023-09-30/ConverseStream)a *Referência AWS SDK para .NET da API*.
------
#### [ Java ]
**SDK para Java 2.x**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Envie uma mensagem de texto ao Llama da Meta usando a API Converse do Bedrock e processe o fluxo de resposta em tempo real.
```
// 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());
}
}
}
```
+ Para obter detalhes da API, consulte [ConverseStream](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/ConverseStream)a *Referência AWS SDK for Java 2.x da API*.
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Envie uma mensagem de texto ao Llama da Meta usando a API Converse do Bedrock e processe o fluxo de resposta em tempo real.
```
// 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);
}
```
+ Para obter detalhes da API, consulte [ConverseStream](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseStreamCommand)a *Referência AWS SDK para JavaScript da API*.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Envie uma mensagem de texto ao Llama da Meta usando a API Converse do Bedrock e processe o fluxo de resposta em tempo real.
```
# 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)
```
+ Para obter detalhes da API, consulte a [ConverseStream](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/ConverseStream)Referência da API *AWS SDK for Python (Boto3*).
------
#### [ Swift ]
**SDK para Swift**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/bedrock-runtime#code-examples).
Envie uma mensagem de texto ao Llama da Meta usando a API Converse do Bedrock e processe o fluxo de resposta em tempo real.
```
// 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
}
}
}
```
+ Para obter detalhes da API, consulte [ConverseStream](https://sdk.amazonaws.com/swift/api/awsbedrockruntime/latest/documentation/awsbedrockruntime/bedrockruntimeclient/conversestream(input:))a *referência da API AWS SDK for Swift*.
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Enviar e processar um documento com o Llama no Amazon Bedrock
O exemplo de código a seguir mostra como enviar e processar um documento com o Llama no Amazon Bedrock.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Envie e processe um documento com o Llama no 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)
```
+ Consulte detalhes da API em [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) na *Referência de API do AWS SDK para Python (Boto3)*.
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Invocar o Llama da Meta no Amazon Bedrock usando a API InvokeModel
Os exemplos de código a seguir mostram como enviar uma mensagem de texto ao Llama da Meta usando a API InvokeModel.
------
#### [ .NET ]
**SDK para .NET**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime#code-examples).
Use a API InvokeModel para enviar uma mensagem de texto.
```
// 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;
}
```
+ Para obter detalhes da API, consulte [InvokeModel](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/InvokeModel)a *Referência AWS SDK para .NET da API*.
------
#### [ Java ]
**SDK para Java 2.x**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Use a API InvokeModel para enviar uma mensagem de texto.
```
// 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();
}
}
```
+ Para obter detalhes da API, consulte [InvokeModel](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModel)a *Referência AWS SDK for Java 2.x da API*.
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Use a API InvokeModel para enviar uma mensagem de texto.
```
// 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
```
+ Para obter detalhes da API, consulte [InvokeModel](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/InvokeModelCommand)a *Referência AWS SDK para JavaScript da API*.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Use a API InvokeModel para enviar uma mensagem de texto.
```
# 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)
```
+ Para obter detalhes da API, consulte a [InvokeModel](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModel)Referência da API *AWS SDK for Python (Boto3*).
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Invocar o Llama da Meta no Amazon Bedrock usando a API InvokeModel com um fluxo de resposta
Os exemplos de código a seguir mostram como enviar uma mensagem de texto ao Llama da Meta usando a API InvokeModel e imprimir o fluxo de resposta.
------
#### [ .NET ]
**SDK para .NET**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime#code-examples).
Use a API InvokeModel para enviar uma mensagem de texto e processar o fluxo de resposta em tempo real.
```
// 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;
}
```
+ Para obter detalhes da API, consulte [InvokeModelWithResponseStream](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/InvokeModelWithResponseStream)a *Referência AWS SDK para .NET da API*.
------
#### [ Java ]
**SDK para Java 2.x**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Use a API InvokeModel para enviar uma mensagem de texto e processar o fluxo de resposta em tempo real.
```
// 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();
}
}
```
+ Para obter detalhes da API, consulte [InvokeModelWithResponseStream](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModelWithResponseStream)a *Referência AWS SDK for Java 2.x da API*.
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Use a API InvokeModel para enviar uma mensagem de texto e processar o fluxo de resposta em tempo real.
```
// 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
```
+ Para obter detalhes da API, consulte [InvokeModelWithResponseStream](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/InvokeModelWithResponseStreamCommand)a *Referência AWS SDK para JavaScript da API*.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Use a API InvokeModel para enviar uma mensagem de texto e processar o fluxo de resposta em tempo real.
```
# 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)
```
+ Para obter detalhes da API, consulte a [InvokeModelWithResponseStream](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModelWithResponseStream)Referência da API *AWS SDK for Python (Boto3*).
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Mistral AI para Amazon Bedrock Runtime
Os exemplos de código a seguir mostram como usar o Amazon Bedrock Runtime com AWS SDKs.
**Topics**
+ [Converse](bedrock-runtime_example_bedrock-runtime_Converse_Mistral_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_Mistral_section.md)
+ [Compreensão do documento](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)
# Invocar a Mistral no Amazon Bedrock usando a API Converse do Bedrock
Os exemplos de código a seguir mostram como enviar uma mensagem de texto à Mistral usando a API Converse do Bedrock.
------
#### [ .NET ]
**SDK para .NET (v4)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Bedrock-runtime#code-examples).
Envie uma mensagem de texto à Mistral usando a API Converse do 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;
}
```
+ Para obter detalhes da API, consulte [Converse](https://docs.aws.amazon.com/goto/DotNetSDKV4/bedrock-runtime-2023-09-30/Converse) na *Referência da API do AWS SDK para .NET *.
------
#### [ Java ]
**SDK para Java 2.x**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Envie uma mensagem de texto à Mistral usando a API Converse do 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();
}
}
```
Envie uma mensagem de texto à Mistral usando a API Converse do Bedrock com o cliente Java assíncrono.
```
// 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();
}
}
```
+ Para obter detalhes da API, consulte [Converse](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/Converse) na *Referência da API do AWS SDK for Java 2.x *.
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Envie uma mensagem de texto à Mistral usando a API Converse do 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);
}
```
+ Para obter detalhes da API, consulte [Converse](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseCommand) na *Referência da API do AWS SDK para JavaScript *.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Envie uma mensagem de texto à Mistral usando a API Converse do 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)
```
+ Consulte detalhes da API em [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) na *Referência de API do AWS SDK para Python (Boto3)*.
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Invocar a Mistral no Amazon Bedrock usando a API Converse do Bedrock com um fluxo de resposta
Os exemplos de código a seguir mostram como enviar uma mensagem de texto à Mistral usando a API Converse do Bedrock e processar o fluxo de resposta em tempo real.
------
#### [ .NET ]
**SDK para .NET (v4)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Bedrock-runtime#code-examples).
Envie uma mensagem de texto para a Mistral usando a API Converse do Bedrock e processe o fluxo de resposta em tempo real.
```
// 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;
}
```
+ Para obter detalhes da API, consulte [ConverseStream](https://docs.aws.amazon.com/goto/DotNetSDKV4/bedrock-runtime-2023-09-30/ConverseStream)a *Referência AWS SDK para .NET da API*.
------
#### [ Java ]
**SDK para Java 2.x**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Envie uma mensagem de texto para a Mistral usando a API Converse do Bedrock e processe o fluxo de resposta em tempo real.
```
// 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());
}
}
}
```
+ Para obter detalhes da API, consulte [ConverseStream](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/ConverseStream)a *Referência AWS SDK for Java 2.x da API*.
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Envie uma mensagem de texto para a Mistral usando a API Converse do Bedrock e processe o fluxo de resposta em tempo real.
```
// 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);
}
```
+ Para obter detalhes da API, consulte [ConverseStream](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseStreamCommand)a *Referência AWS SDK para JavaScript da API*.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Envie uma mensagem de texto para a Mistral usando a API Converse do Bedrock e processe o fluxo de resposta em tempo real.
```
# 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)
```
+ Para obter detalhes da API, consulte a [ConverseStream](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/ConverseStream)Referência da API *AWS SDK for Python (Boto3*).
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Enviar e processar um documento com modelos da Mistral no Amazon Bedrock
O exemplo de código a seguir mostra como enviar e processar um documento com modelos da Mistral no Amazon Bedrock.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Envie e processe um documento com modelos Mistral no 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)
```
+ Consulte detalhes da API em [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) na *Referência de API do AWS SDK para Python (Boto3)*.
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Invocar modelos da Mistral AI no Amazon Bedrock usando a API InvokeModel
Os exemplos de código a seguir mostram como enviar uma mensagem de texto aos modelos da Mistral usando a API InvokeModel.
------
#### [ .NET ]
**SDK para .NET**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime#code-examples).
Use a API InvokeModel para enviar uma mensagem de texto.
```
// 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;
}
```
+ Para obter detalhes da API, consulte [InvokeModel](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/InvokeModel)a *Referência AWS SDK para .NET da API*.
------
#### [ Java ]
**SDK para Java 2.x**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Use a API InvokeModel para enviar uma mensagem de texto.
```
// 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();
}
}
```
+ Para obter detalhes da API, consulte [InvokeModel](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModel)a *Referência AWS SDK for Java 2.x da API*.
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Use a API InvokeModel para enviar uma mensagem de texto.
```
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);
}
}
```
+ Para obter detalhes da API, consulte [InvokeModel](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/InvokeModelCommand)a *Referência AWS SDK para JavaScript da API*.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Use a API InvokeModel para enviar uma mensagem de texto.
```
# 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)
```
+ Para obter detalhes da API, consulte a [InvokeModel](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModel)Referência da API *AWS SDK for Python (Boto3*).
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Invocar os modelos da Mistral AI no Amazon Bedrock usando a API InvokeModel com um fluxo de resposta
Os exemplos de código a seguir mostram como enviar uma mensagem de texto aos modelos da Mistral AI, usando a API InvokeModel, e imprimir o fluxo de resposta.
------
#### [ .NET ]
**SDK para .NET**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime#code-examples).
Use a API InvokeModel para enviar uma mensagem de texto e processar o fluxo de resposta em tempo real.
```
// 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;
}
```
+ Para obter detalhes da API, consulte [InvokeModelWithResponseStream](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/InvokeModelWithResponseStream)a *Referência AWS SDK para .NET da API*.
------
#### [ Java ]
**SDK para Java 2.x**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Use a API InvokeModel para enviar uma mensagem de texto e processar o fluxo de resposta em tempo real.
```
// 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();
}
}
```
+ Para obter detalhes da API, consulte [InvokeModelWithResponseStream](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModelWithResponseStream)a *Referência AWS SDK for Java 2.x da API*.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Use a API InvokeModel para enviar uma mensagem de texto e processar o fluxo de resposta em tempo real.
```
# 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)
```
+ Para obter detalhes da API, consulte a [InvokeModelWithResponseStream](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModelWithResponseStream)Referência da API *AWS SDK for Python (Boto3*).
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Stable Diffusion para Amazon Bedrock Runtime
Os exemplos de código a seguir mostram como usar o Amazon Bedrock Runtime com AWS SDKs.
**Topics**
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_StableDiffusion_section.md)
# Invocar o Stable Diffusion XL da Stability AI no Amazon Bedrock para gerar uma imagem
O exemplo de código a seguir mostra como invocar o Stable Diffusion XL da Stability AI no Amazon Bedrock para gerar uma imagem.
------
#### [ Java ]
**SDK para Java 2.x**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Crie uma imagem com o 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);
}
}
```
+ Para obter detalhes da API, consulte [InvokeModel](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModel)a *Referência AWS SDK for Java 2.x da API*.
------
#### [ PHP ]
**SDK para PHP**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/bedrock-runtime#code-examples).
Crie uma imagem com o 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;
}
```
+ Para obter detalhes da API, consulte [InvokeModel](https://docs.aws.amazon.com/goto/SdkForPHPV3/bedrock-runtime-2023-09-30/InvokeModel)a *Referência AWS SDK para PHP da API*.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Crie uma imagem com o 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}")
```
+ Para obter detalhes da API, consulte a [InvokeModel](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModel)Referência da API *AWS SDK for Python (Boto3*).
------
#### [ SAP ABAP ]
**SDK para SAP ABAP**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/bdr#code-examples).
Crie uma imagem com o 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.
```
Invoque o modelo de base Stable Diffusion XL da Stability AI para gerar imagens usando um cliente L2 de alto nível.
```
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.
```
+ Para obter detalhes da API, consulte a [InvokeModel](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)referência da *API AWS SDK for SAP ABAP*.
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Exemplos de código para Amazon Bedrock Agents usando AWS SDKs
Os exemplos de código a seguir mostram como usar o Amazon Bedrock Agents com um kit de desenvolvimento de AWS software (SDK).
*Ações* são trechos de código de programas maiores e devem ser executadas em contexto. Embora as ações mostrem como chamar perfis de serviço individuais, você pode ver as ações no contexto em seus cenários relacionados.
*Cenários* são exemplos de código que mostram como realizar tarefas específicas chamando várias funções dentro de um serviço ou combinadas com outros Serviços da AWS.
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
**Contents**
+ [Conceitos básicos](service_code_examples_bedrock-agent_basics.md)
+ [Olá, agentes do Amazon Bedrock](bedrock-agent_example_bedrock-agent_Hello_section.md)
+ [Ações](service_code_examples_bedrock-agent_actions.md)
+ [`CreateAgent`](bedrock-agent_example_bedrock-agent_CreateAgent_section.md)
+ [`CreateAgentActionGroup`](bedrock-agent_example_bedrock-agent_CreateAgentActionGroup_section.md)
+ [`CreateAgentAlias`](bedrock-agent_example_bedrock-agent_CreateAgentAlias_section.md)
+ [`CreateFlow`](bedrock-agent_example_bedrock-agent_CreateFlow_section.md)
+ [`CreateFlowAlias`](bedrock-agent_example_bedrock-agent_CreateFlowAlias_section.md)
+ [`CreateFlowVersion`](bedrock-agent_example_bedrock-agent_CreateFlowVersion_section.md)
+ [`CreateKnowledgeBase`](bedrock-agent_example_bedrock-agent_CreateKnowledgeBase_section.md)
+ [`CreatePrompt`](bedrock-agent_example_bedrock-agent_CreatePrompt_section.md)
+ [`CreatePromptVersion`](bedrock-agent_example_bedrock-agent_CreatePromptVersion_section.md)
+ [`DeleteAgent`](bedrock-agent_example_bedrock-agent_DeleteAgent_section.md)
+ [`DeleteAgentAlias`](bedrock-agent_example_bedrock-agent_DeleteAgentAlias_section.md)
+ [`DeleteFlow`](bedrock-agent_example_bedrock-agent_DeleteFlow_section.md)
+ [`DeleteFlowAlias`](bedrock-agent_example_bedrock-agent_DeleteFlowAlias_section.md)
+ [`DeleteFlowVersion`](bedrock-agent_example_bedrock-agent_DeleteFlowVersion_section.md)
+ [`DeleteKnowledgeBase`](bedrock-agent_example_bedrock-agent_DeleteKnowledgeBase_section.md)
+ [`DeletePrompt`](bedrock-agent_example_bedrock-agent_DeletePrompt_section.md)
+ [`GetAgent`](bedrock-agent_example_bedrock-agent_GetAgent_section.md)
+ [`GetFlow`](bedrock-agent_example_bedrock-agent_GetFlow_section.md)
+ [`GetFlowVersion`](bedrock-agent_example_bedrock-agent_GetFlowVersion_section.md)
+ [`GetKnowledgeBase`](bedrock-agent_example_bedrock-agent_GetKnowledgeBase_section.md)
+ [`GetPrompt`](bedrock-agent_example_bedrock-agent_GetPrompt_section.md)
+ [`ListAgentActionGroups`](bedrock-agent_example_bedrock-agent_ListAgentActionGroups_section.md)
+ [`ListAgentKnowledgeBases`](bedrock-agent_example_bedrock-agent_ListAgentKnowledgeBases_section.md)
+ [`ListAgents`](bedrock-agent_example_bedrock-agent_ListAgents_section.md)
+ [`ListFlowAliases`](bedrock-agent_example_bedrock-agent_ListFlowAliases_section.md)
+ [`ListFlowVersions`](bedrock-agent_example_bedrock-agent_ListFlowVersions_section.md)
+ [`ListFlows`](bedrock-agent_example_bedrock-agent_ListFlows_section.md)
+ [`ListKnowledgeBases`](bedrock-agent_example_bedrock-agent_ListKnowledgeBases_section.md)
+ [`ListPrompts`](bedrock-agent_example_bedrock-agent_ListPrompts_section.md)
+ [`PrepareAgent`](bedrock-agent_example_bedrock-agent_PrepareAgent_section.md)
+ [`PrepareFlow`](bedrock-agent_example_bedrock-agent_PrepareFlow_section.md)
+ [`UpdateFlow`](bedrock-agent_example_bedrock-agent_UpdateFlow_section.md)
+ [`UpdateFlowAlias`](bedrock-agent_example_bedrock-agent_UpdateFlowAlias_section.md)
+ [`UpdateKnowledgeBase`](bedrock-agent_example_bedrock-agent_UpdateKnowledgeBase_section.md)
+ [Cenários](service_code_examples_bedrock-agent_scenarios.md)
+ [Criar e invocar um fluxo](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockFlows_section.md)
+ [Criar e invocar um prompt gerenciado](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockPrompts_section.md)
+ [Criar e invocar um agente](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockAgents_section.md)
+ [Orquestrar aplicações de IA generativa com o Step Functions](bedrock-agent_example_cross_ServerlessPromptChaining_section.md)
# Exemplos básicos para Amazon Bedrock Agents usando AWS SDKs
Os exemplos de código a seguir mostram como usar os conceitos básicos do Amazon Bedrock Agents com. AWS SDKs
**Contents**
+ [Olá, agentes do Amazon Bedrock](bedrock-agent_example_bedrock-agent_Hello_section.md)
+ [Ações](service_code_examples_bedrock-agent_actions.md)
+ [`CreateAgent`](bedrock-agent_example_bedrock-agent_CreateAgent_section.md)
+ [`CreateAgentActionGroup`](bedrock-agent_example_bedrock-agent_CreateAgentActionGroup_section.md)
+ [`CreateAgentAlias`](bedrock-agent_example_bedrock-agent_CreateAgentAlias_section.md)
+ [`CreateFlow`](bedrock-agent_example_bedrock-agent_CreateFlow_section.md)
+ [`CreateFlowAlias`](bedrock-agent_example_bedrock-agent_CreateFlowAlias_section.md)
+ [`CreateFlowVersion`](bedrock-agent_example_bedrock-agent_CreateFlowVersion_section.md)
+ [`CreateKnowledgeBase`](bedrock-agent_example_bedrock-agent_CreateKnowledgeBase_section.md)
+ [`CreatePrompt`](bedrock-agent_example_bedrock-agent_CreatePrompt_section.md)
+ [`CreatePromptVersion`](bedrock-agent_example_bedrock-agent_CreatePromptVersion_section.md)
+ [`DeleteAgent`](bedrock-agent_example_bedrock-agent_DeleteAgent_section.md)
+ [`DeleteAgentAlias`](bedrock-agent_example_bedrock-agent_DeleteAgentAlias_section.md)
+ [`DeleteFlow`](bedrock-agent_example_bedrock-agent_DeleteFlow_section.md)
+ [`DeleteFlowAlias`](bedrock-agent_example_bedrock-agent_DeleteFlowAlias_section.md)
+ [`DeleteFlowVersion`](bedrock-agent_example_bedrock-agent_DeleteFlowVersion_section.md)
+ [`DeleteKnowledgeBase`](bedrock-agent_example_bedrock-agent_DeleteKnowledgeBase_section.md)
+ [`DeletePrompt`](bedrock-agent_example_bedrock-agent_DeletePrompt_section.md)
+ [`GetAgent`](bedrock-agent_example_bedrock-agent_GetAgent_section.md)
+ [`GetFlow`](bedrock-agent_example_bedrock-agent_GetFlow_section.md)
+ [`GetFlowVersion`](bedrock-agent_example_bedrock-agent_GetFlowVersion_section.md)
+ [`GetKnowledgeBase`](bedrock-agent_example_bedrock-agent_GetKnowledgeBase_section.md)
+ [`GetPrompt`](bedrock-agent_example_bedrock-agent_GetPrompt_section.md)
+ [`ListAgentActionGroups`](bedrock-agent_example_bedrock-agent_ListAgentActionGroups_section.md)
+ [`ListAgentKnowledgeBases`](bedrock-agent_example_bedrock-agent_ListAgentKnowledgeBases_section.md)
+ [`ListAgents`](bedrock-agent_example_bedrock-agent_ListAgents_section.md)
+ [`ListFlowAliases`](bedrock-agent_example_bedrock-agent_ListFlowAliases_section.md)
+ [`ListFlowVersions`](bedrock-agent_example_bedrock-agent_ListFlowVersions_section.md)
+ [`ListFlows`](bedrock-agent_example_bedrock-agent_ListFlows_section.md)
+ [`ListKnowledgeBases`](bedrock-agent_example_bedrock-agent_ListKnowledgeBases_section.md)
+ [`ListPrompts`](bedrock-agent_example_bedrock-agent_ListPrompts_section.md)
+ [`PrepareAgent`](bedrock-agent_example_bedrock-agent_PrepareAgent_section.md)
+ [`PrepareFlow`](bedrock-agent_example_bedrock-agent_PrepareFlow_section.md)
+ [`UpdateFlow`](bedrock-agent_example_bedrock-agent_UpdateFlow_section.md)
+ [`UpdateFlowAlias`](bedrock-agent_example_bedrock-agent_UpdateFlowAlias_section.md)
+ [`UpdateKnowledgeBase`](bedrock-agent_example_bedrock-agent_UpdateKnowledgeBase_section.md)
# Olá, agentes do Amazon Bedrock
O exemplo de código a seguir mostra como começar a usar o Amazon Bedrock Agents.
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-agent#code-examples).
```
import { fileURLToPath } from "node:url";
import {
BedrockAgentClient,
GetAgentCommand,
paginateListAgents,
} from "@aws-sdk/client-bedrock-agent";
/**
* @typedef {Object} AgentSummary
*/
/**
* A simple scenario to demonstrate basic setup and interaction with the Bedrock Agents Client.
*
* This function first initializes the Amazon Bedrock Agents client for a specific region.
* It then retrieves a list of existing agents using the streamlined paginator approach.
* For each agent found, it retrieves detailed information using a command object.
*
* Demonstrates:
* - Use of the Bedrock Agents client to initialize and communicate with the AWS service.
* - Listing resources in a paginated response pattern.
* - Accessing an individual resource using a command object.
*
* @returns {Promise} A promise that resolves when the function has completed execution.
*/
export const main = async () => {
const region = "us-east-1";
console.log("=".repeat(68));
console.log(`Initializing Amazon Bedrock Agents client for ${region}...`);
const client = new BedrockAgentClient({ region });
console.log("Retrieving the list of existing agents...");
const paginatorConfig = { client };
const pages = paginateListAgents(paginatorConfig, {});
/** @type {AgentSummary[]} */
const agentSummaries = [];
for await (const page of pages) {
agentSummaries.push(...page.agentSummaries);
}
console.log(`Found ${agentSummaries.length} agents in ${region}.`);
if (agentSummaries.length > 0) {
for (const agentSummary of agentSummaries) {
const agentId = agentSummary.agentId;
console.log("=".repeat(68));
console.log(`Retrieving agent with ID: ${agentId}:`);
console.log("-".repeat(68));
const command = new GetAgentCommand({ agentId });
const response = await client.send(command);
const agent = response.agent;
console.log(` Name: ${agent.agentName}`);
console.log(` Status: ${agent.agentStatus}`);
console.log(` ARN: ${agent.agentArn}`);
console.log(` Foundation model: ${agent.foundationModel}`);
}
}
console.log("=".repeat(68));
};
// Invoke main function if this file was run directly.
if (process.argv[1] === fileURLToPath(import.meta.url)) {
await main();
}
```
+ Para obter detalhes da API, consulte os tópicos a seguir na *Referência da API AWS SDK para JavaScript *.
+ [GetAgent](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-agent/command/GetAgentCommand)
+ [ListAgents](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-agent/command/ListAgentsCommand)
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Ações para Amazon Bedrock Agents usando AWS SDKs
Os exemplos de código a seguir demonstram como realizar ações individuais do Amazon Bedrock Agents com AWS SDKs. Cada exemplo inclui um link para GitHub, onde você pode encontrar instruções para configurar e executar o código.
Esses trechos chamam a API do Amazon Bedrock Agents e são trechos de código de programas maiores que devem ser executados em contexto. É possível ver as ações em contexto em [Cenários para Amazon Bedrock Agents usando AWS SDKs](service_code_examples_bedrock-agent_scenarios.md).
Os exemplos a seguir incluem apenas as ações mais utilizadas. Para obter uma lista completa, consulte a [Amazon Bedrock Agents API Reference](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_Operations_Agents_for_Amazon_Bedrock.html).
**Topics**
+ [`CreateAgent`](bedrock-agent_example_bedrock-agent_CreateAgent_section.md)
+ [`CreateAgentActionGroup`](bedrock-agent_example_bedrock-agent_CreateAgentActionGroup_section.md)
+ [`CreateAgentAlias`](bedrock-agent_example_bedrock-agent_CreateAgentAlias_section.md)
+ [`CreateFlow`](bedrock-agent_example_bedrock-agent_CreateFlow_section.md)
+ [`CreateFlowAlias`](bedrock-agent_example_bedrock-agent_CreateFlowAlias_section.md)
+ [`CreateFlowVersion`](bedrock-agent_example_bedrock-agent_CreateFlowVersion_section.md)
+ [`CreateKnowledgeBase`](bedrock-agent_example_bedrock-agent_CreateKnowledgeBase_section.md)
+ [`CreatePrompt`](bedrock-agent_example_bedrock-agent_CreatePrompt_section.md)
+ [`CreatePromptVersion`](bedrock-agent_example_bedrock-agent_CreatePromptVersion_section.md)
+ [`DeleteAgent`](bedrock-agent_example_bedrock-agent_DeleteAgent_section.md)
+ [`DeleteAgentAlias`](bedrock-agent_example_bedrock-agent_DeleteAgentAlias_section.md)
+ [`DeleteFlow`](bedrock-agent_example_bedrock-agent_DeleteFlow_section.md)
+ [`DeleteFlowAlias`](bedrock-agent_example_bedrock-agent_DeleteFlowAlias_section.md)
+ [`DeleteFlowVersion`](bedrock-agent_example_bedrock-agent_DeleteFlowVersion_section.md)
+ [`DeleteKnowledgeBase`](bedrock-agent_example_bedrock-agent_DeleteKnowledgeBase_section.md)
+ [`DeletePrompt`](bedrock-agent_example_bedrock-agent_DeletePrompt_section.md)
+ [`GetAgent`](bedrock-agent_example_bedrock-agent_GetAgent_section.md)
+ [`GetFlow`](bedrock-agent_example_bedrock-agent_GetFlow_section.md)
+ [`GetFlowVersion`](bedrock-agent_example_bedrock-agent_GetFlowVersion_section.md)
+ [`GetKnowledgeBase`](bedrock-agent_example_bedrock-agent_GetKnowledgeBase_section.md)
+ [`GetPrompt`](bedrock-agent_example_bedrock-agent_GetPrompt_section.md)
+ [`ListAgentActionGroups`](bedrock-agent_example_bedrock-agent_ListAgentActionGroups_section.md)
+ [`ListAgentKnowledgeBases`](bedrock-agent_example_bedrock-agent_ListAgentKnowledgeBases_section.md)
+ [`ListAgents`](bedrock-agent_example_bedrock-agent_ListAgents_section.md)
+ [`ListFlowAliases`](bedrock-agent_example_bedrock-agent_ListFlowAliases_section.md)
+ [`ListFlowVersions`](bedrock-agent_example_bedrock-agent_ListFlowVersions_section.md)
+ [`ListFlows`](bedrock-agent_example_bedrock-agent_ListFlows_section.md)
+ [`ListKnowledgeBases`](bedrock-agent_example_bedrock-agent_ListKnowledgeBases_section.md)
+ [`ListPrompts`](bedrock-agent_example_bedrock-agent_ListPrompts_section.md)
+ [`PrepareAgent`](bedrock-agent_example_bedrock-agent_PrepareAgent_section.md)
+ [`PrepareFlow`](bedrock-agent_example_bedrock-agent_PrepareFlow_section.md)
+ [`UpdateFlow`](bedrock-agent_example_bedrock-agent_UpdateFlow_section.md)
+ [`UpdateFlowAlias`](bedrock-agent_example_bedrock-agent_UpdateFlowAlias_section.md)
+ [`UpdateKnowledgeBase`](bedrock-agent_example_bedrock-agent_UpdateKnowledgeBase_section.md)
# Use `CreateAgent` com um AWS SDK
Os exemplos de código a seguir mostram como usar o `CreateAgent`.
Exemplos de ações são trechos de código de programas maiores e devem ser executados em contexto. É possível ver essa ação em contexto no seguinte exemplo de código:
+ [Criar e invocar um agente](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockAgents_section.md)
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-agent#code-examples).
Crie um agente do .
```
import { fileURLToPath } from "node:url";
import { checkForPlaceholders } from "../lib/utils.js";
import {
BedrockAgentClient,
CreateAgentCommand,
} from "@aws-sdk/client-bedrock-agent";
/**
* Creates an Amazon Bedrock Agent.
*
* @param {string} agentName - A name for the agent that you create.
* @param {string} foundationModel - The foundation model to be used by the agent you create.
* @param {string} agentResourceRoleArn - The ARN of the IAM role with permissions required by the agent.
* @param {string} [region='us-east-1'] - The AWS region in use.
* @returns {Promise} An object containing details of the created agent.
*/
export const createAgent = async (
agentName,
foundationModel,
agentResourceRoleArn,
region = "us-east-1",
) => {
const client = new BedrockAgentClient({ region });
const command = new CreateAgentCommand({
agentName,
foundationModel,
agentResourceRoleArn,
});
const response = await client.send(command);
return response.agent;
};
// Invoke main function if this file was run directly.
if (process.argv[1] === fileURLToPath(import.meta.url)) {
// Replace the placeholders for agentName and accountId, and roleName with a unique name for the new agent,
// the id of your AWS account, and the name of an existing execution role that the agent can use inside your account.
// For foundationModel, specify the desired model. Ensure to remove the brackets '[]' before adding your data.
// A string (max 100 chars) that can include letters, numbers, dashes '-', and underscores '_'.
const agentName = "[your-bedrock-agent-name]";
// Your AWS account id.
const accountId = "[123456789012]";
// The name of the agent's execution role. It must be prefixed by `AmazonBedrockExecutionRoleForAgents_`.
const roleName = "[AmazonBedrockExecutionRoleForAgents_your-role-name]";
// The ARN for the agent's execution role.
// Follow the ARN format: 'arn:aws:iam::account-id:role/role-name'
const roleArn = `arn:aws:iam::${accountId}:role/${roleName}`;
// Specify the model for the agent. Change if a different model is preferred.
const foundationModel = "anthropic.claude-v2";
// Check for unresolved placeholders in agentName and roleArn.
checkForPlaceholders([agentName, roleArn]);
console.log("Creating a new agent...");
const agent = await createAgent(agentName, foundationModel, roleArn);
console.log(agent);
}
```
+ Para obter detalhes da API, consulte [CreateAgent](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-agent/command/CreateAgentCommand)a *Referência AWS SDK para JavaScript da API*.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples).
Crie um agente do .
```
def create_agent(self, agent_name, foundation_model, role_arn, instruction):
"""
Creates an agent that orchestrates interactions between foundation models,
data sources, software applications, user conversations, and APIs to carry
out tasks to help customers.
:param agent_name: A name for the agent.
:param foundation_model: The foundation model to be used for orchestration by the agent.
:param role_arn: The ARN of the IAM role with permissions needed by the agent.
:param instruction: Instructions that tell the agent what it should do and how it should
interact with users.
:return: The response from Amazon Bedrock Agents if successful, otherwise raises an exception.
"""
try:
response = self.client.create_agent(
agentName=agent_name,
foundationModel=foundation_model,
agentResourceRoleArn=role_arn,
instruction=instruction,
)
except ClientError as e:
logger.error(f"Error: Couldn't create agent. Here's why: {e}")
raise
else:
return response["agent"]
```
+ Para obter detalhes da API, consulte a [CreateAgent](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/CreateAgent)Referência da API *AWS SDK for Python (Boto3*).
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Use `CreateAgentActionGroup` com um AWS SDK
O código de exemplo a seguir mostra como usar `CreateAgentActionGroup`.
Exemplos de ações são trechos de código de programas maiores e devem ser executados em contexto. É possível ver essa ação em contexto no seguinte exemplo de código:
+ [Criar e invocar um agente](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockAgents_section.md)
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples).
Crie um grupo de ação do agente.
```
def create_agent_action_group(
self, name, description, agent_id, agent_version, function_arn, api_schema
):
"""
Creates an action group for an agent. An action group defines a set of actions that an
agent should carry out for the customer.
:param name: The name to give the action group.
:param description: The description of the action group.
:param agent_id: The unique identifier of the agent for which to create the action group.
:param agent_version: The version of the agent for which to create the action group.
:param function_arn: The ARN of the Lambda function containing the business logic that is
carried out upon invoking the action.
:param api_schema: Contains the OpenAPI schema for the action group.
:return: Details about the action group that was created.
"""
try:
response = self.client.create_agent_action_group(
actionGroupName=name,
description=description,
agentId=agent_id,
agentVersion=agent_version,
actionGroupExecutor={"lambda": function_arn},
apiSchema={"payload": api_schema},
)
agent_action_group = response["agentActionGroup"]
except ClientError as e:
logger.error(f"Error: Couldn't create agent action group. Here's why: {e}")
raise
else:
return agent_action_group
```
+ Para obter detalhes da API, consulte a [CreateAgentActionGroup](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/CreateAgentActionGroup)Referência da API *AWS SDK for Python (Boto3*).
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Use `CreateAgentAlias` com um AWS SDK
O código de exemplo a seguir mostra como usar `CreateAgentAlias`.
Exemplos de ações são trechos de código de programas maiores e devem ser executados em contexto. É possível ver essa ação em contexto no seguinte exemplo de código:
+ [Criar e invocar um agente](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockAgents_section.md)
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples).
Crie um alias de agente.
```
def create_agent_alias(self, name, agent_id):
"""
Creates an alias of an agent that can be used to deploy the agent.
:param name: The name of the alias.
:param agent_id: The unique identifier of the agent.
:return: Details about the alias that was created.
"""
try:
response = self.client.create_agent_alias(
agentAliasName=name, agentId=agent_id
)
agent_alias = response["agentAlias"]
except ClientError as e:
logger.error(f"Couldn't create agent alias. {e}")
raise
else:
return agent_alias
```
+ Para obter detalhes da API, consulte a [CreateAgentAlias](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/CreateAgentAlias)Referência da API *AWS SDK for Python (Boto3*).
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Use `CreateFlow` com um AWS SDK
O código de exemplo a seguir mostra como usar `CreateFlow`.
Exemplos de ações são trechos de código de programas maiores e devem ser executados em contexto. É possível ver essa ação em contexto no seguinte exemplo de código:
+ [Criar e invocar um fluxo](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockFlows_section.md)
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples).
Crie um fluxo do Amazon Bedrock.
```
def create_flow(client, flow_name, flow_description, role_arn, flow_def):
"""
Creates an Amazon Bedrock flow.
Args:
client: Amazon Bedrock agent boto3 client.
flow_name (str): The name for the new flow.
role_arn (str): The ARN for the IAM role that use flow uses.
flow_def (json): The JSON definition of the flow that you want to create.
Returns:
dict: The response from CreateFlow.
"""
try:
logger.info("Creating flow: %s.", flow_name)
response = client.create_flow(
name=flow_name,
description=flow_description,
executionRoleArn=role_arn,
definition=flow_def
)
logger.info("Successfully created flow: %s. ID: %s",
flow_name,
{response['id']})
return response
except ClientError as e:
logger.exception("Client error creating flow: %s", {str(e)})
raise
except Exception as e:
logger.exception("Unexepcted error creating flow: %s", {str(e)})
raise
```
+ Para obter detalhes da API, consulte a [CreateFlow](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/CreateFlow)Referência da API *AWS SDK for Python (Boto3*).
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Use `CreateFlowAlias` com um AWS SDK
O código de exemplo a seguir mostra como usar `CreateFlowAlias`.
Exemplos de ações são trechos de código de programas maiores e devem ser executados em contexto. É possível ver essa ação em contexto no seguinte exemplo de código:
+ [Criar e invocar um fluxo](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockFlows_section.md)
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples).
Crie um alias para um fluxo do Amazon Bedrock.
```
def create_flow_alias(client, flow_id, flow_version, name, description):
"""
Creates an alias for an Amazon Bedrock flow.
Args:
client: bedrock agent boto3 client.
flow_id (str): The identifier of the flow.
Returns:
str: The ID for the flow alias.
"""
try:
logger.info("Creating flow alias for flow: %s.", flow_id)
response = client.create_flow_alias(
flowIdentifier=flow_id,
name=name,
description=description,
routingConfiguration=[
{
"flowVersion": flow_version
}
]
)
logger.info("Successfully created flow alias for %s.", flow_id)
return response['id']
except ClientError as e:
logging.exception("Client error creating alias for flow: %s - %s",
flow_id, str(e))
raise
except Exception as e:
logging.exception("Unexpected error creating alias for flow : %s - %s",
flow_id, str(e))
raise
```
+ Para obter detalhes da API, consulte a [CreateFlowAlias](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/CreateFlowAlias)Referência da API *AWS SDK for Python (Boto3*).
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Use `CreateFlowVersion` com um AWS SDK
O código de exemplo a seguir mostra como usar `CreateFlowVersion`.
Exemplos de ações são trechos de código de programas maiores e devem ser executados em contexto. É possível ver essa ação em contexto no seguinte exemplo de código:
+ [Criar e invocar um fluxo](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockFlows_section.md)
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples).
Crie uma versão de um fluxo do Amazon Bedrock.
```
def create_flow_version(client, flow_id, description):
"""
Creates a version of an Amazon Bedrock flow.
Args:
client: Amazon Bedrock agent boto3 client.
flow_id (str): The identifier of the flow.
description (str) : A description for the flow.
Returns:
str: The version for the flow.
"""
try:
logger.info("Creating flow version for flow: %s.", flow_id)
# Call CreateFlowVersion operation
response = client.create_flow_version(
flowIdentifier=flow_id,
description=description
)
logging.info("Successfully created flow version %s for flow %s.",
response['version'], flow_id)
return response['version']
except ClientError as e:
logging.exception("Client error creating flow: %s", str(e))
raise
except Exception as e:
logging.exception("Unexpected error creating flow : %s", str(e))
raise
```
+ Para obter detalhes da API, consulte a [CreateFlowVersion](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/CreateFlowVersion)Referência da API *AWS SDK for Python (Boto3*).
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Use `CreateKnowledgeBase` com um AWS SDK
O código de exemplo a seguir mostra como usar `CreateKnowledgeBase`.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples).
Criar uma base de conhecimento do Amazon Bedrock.
```
def create_knowledge_base(bedrock_agent_client, name, role_arn, description=None):
"""
Creates a new knowledge base.
Args:
bedrock_agent_client: The Boto3 Bedrock Agent client.
name (str): The name of the knowledge base.
role_arn (str): The ARN of the IAM role that the knowledge base assumes to access resources.
description (str, optional): A description of the knowledge base.
Returns:
dict: The details of the created knowledge base.
"""
try:
kwargs = {
"name": name,
"roleArn": role_arn,
"knowledgeBaseConfiguration": {
"type": "VECTOR",
"vectorKnowledgeBaseConfiguration": {
"embeddingModelArn": "arn:aws:bedrock:us-east-1::foundation-model/amazon.titan-embed-text-v1"
}
},
"storageConfiguration": {
"type": "OPENSEARCH_SERVERLESS",
# Note: You will need to create an OpenSearch Serverless collection first and replace this ARN
# with your actual collection ARN from the OpenSearch console. If you use the console instead,
# you can use the quick-create flow to have Knowledge Bases create the collection for you.
"opensearchServerlessConfiguration": {
"collectionArn": "arn:aws:aoss:us-east-1::123456789012:collection/abcdefgh12345678defgh",
"fieldMapping": {
"metadataField": "metadata",
"textField": "text",
"vectorField": "vector"
},
"vectorIndexName": "test-uuid"
},
},
"clientToken": "test-client-token-" + str(uuid.uuid4())
}
if description:
kwargs["description"] = description
response = bedrock_agent_client.create_knowledge_base(**kwargs)
logger.info("Created knowledge base with ID: %s", response["knowledgeBase"]["knowledgeBaseId"])
return response["knowledgeBase"]
except ClientError as err:
logger.error(
"Couldn't create knowledge base. Here's why: %s: %s",
err.response["Error"]["Code"],
err.response["Error"]["Message"],
)
raise
```
+ Para obter detalhes da API, consulte a [CreateKnowledgeBase](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/CreateKnowledgeBase)Referência da API *AWS SDK for Python (Boto3*).
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Use `CreatePrompt` com um AWS SDK
O código de exemplo a seguir mostra como usar `CreatePrompt`.
Exemplos de ações são trechos de código de programas maiores e devem ser executados em contexto. É possível ver essa ação em contexto no seguinte exemplo de código:
+ [Criar e invocar um prompt gerenciado](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockPrompts_section.md)
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples).
Crie um prompt gerenciado do Amazon Bedrock.
```
def create_prompt(client, prompt_name, prompt_description, prompt_template, model_id=None):
"""
Creates an Amazon Bedrock managed prompt.
Args:
client: Amazon Bedrock Agent boto3 client.
prompt_name (str): The name for the new prompt.
prompt_description (str): The description for the new prompt.
prompt_template (str): The template for the prompt.
model_id (str, optional): The model ID to associate with the prompt.
Returns:
dict: The response from CreatePrompt.
"""
try:
logger.info("Creating prompt: %s.", prompt_name)
# Create a variant with the template
variant = {
"name": "default",
"templateType": "TEXT",
"templateConfiguration": {
"text": {
"text": prompt_template,
"inputVariables": []
}
}
}
# Extract input variables from the template
# Look for patterns like {{variable_name}}
variables = re.findall(r'{{(.*?)}}', prompt_template)
for var in variables:
variant["templateConfiguration"]["text"]["inputVariables"].append({"name": var.strip()})
# Add model ID if provided
if model_id:
variant["modelId"] = model_id
# Create the prompt with the variant
create_params = {
'name': prompt_name,
'description': prompt_description,
'variants': [variant]
}
response = client.create_prompt(**create_params)
logger.info("Successfully created prompt: %s. ID: %s",
prompt_name,
response['id'])
return response
except ClientError as e:
logger.exception("Client error creating prompt: %s", str(e))
raise
except Exception as e:
logger.exception("Unexpected error creating prompt: %s", str(e))
raise
```
+ Para obter detalhes da API, consulte a [CreatePrompt](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/CreatePrompt)Referência da API *AWS SDK for Python (Boto3*).
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Use `CreatePromptVersion` com um AWS SDK
O código de exemplo a seguir mostra como usar `CreatePromptVersion`.
Exemplos de ações são trechos de código de programas maiores e devem ser executados em contexto. É possível ver essa ação em contexto no seguinte exemplo de código:
+ [Criar e invocar um prompt gerenciado](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockPrompts_section.md)
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples).
Crie uma versão de um prompt gerenciado do Amazon Bedrock.
```
def create_prompt_version(client, prompt_id, description=None):
"""
Creates a version of an Amazon Bedrock managed prompt.
Args:
client: Amazon Bedrock Agent boto3 client.
prompt_id (str): The identifier of the prompt to create a version for.
description (str, optional): A description for the version.
Returns:
dict: The response from CreatePromptVersion.
"""
try:
logger.info("Creating version for prompt ID: %s.", prompt_id)
create_params = {
'promptIdentifier': prompt_id
}
if description:
create_params['description'] = description
response = client.create_prompt_version(**create_params)
logger.info("Successfully created prompt version: %s", response['version'])
logger.info("Prompt version ARN: %s", response['arn'])
return response
except ClientError as e:
logger.exception("Client error creating prompt version: %s", str(e))
raise
except Exception as e:
logger.exception("Unexpected error creating prompt version: %s", str(e))
raise
```
+ Para obter detalhes da API, consulte a [CreatePromptVersion](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/CreatePromptVersion)Referência da API *AWS SDK for Python (Boto3*).
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Use `DeleteAgent` com um AWS SDK
Os exemplos de código a seguir mostram como usar o `DeleteAgent`.
Exemplos de ações são trechos de código de programas maiores e devem ser executados em contexto. É possível ver essa ação em contexto no seguinte exemplo de código:
+ [Criar e invocar um agente](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockAgents_section.md)
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-agent#code-examples).
Exclua um agente.
```
import { fileURLToPath } from "node:url";
import { checkForPlaceholders } from "../lib/utils.js";
import {
BedrockAgentClient,
DeleteAgentCommand,
} from "@aws-sdk/client-bedrock-agent";
/**
* Deletes an Amazon Bedrock Agent.
*
* @param {string} agentId - The unique identifier of the agent to delete.
* @param {string} [region='us-east-1'] - The AWS region in use.
* @returns {Promise} An object containing the agent id, the status, and some additional metadata.
*/
export const deleteAgent = (agentId, region = "us-east-1") => {
const client = new BedrockAgentClient({ region });
const command = new DeleteAgentCommand({ agentId });
return client.send(command);
};
// Invoke main function if this file was run directly.
if (process.argv[1] === fileURLToPath(import.meta.url)) {
// Replace the placeholders for agentId with an existing agent's id.
// Ensure to remove the brackets (`[]`) before adding your data.
// The agentId must be an alphanumeric string with exactly 10 characters.
const agentId = "[ABC123DE45]";
// Check for unresolved placeholders in agentId.
checkForPlaceholders([agentId]);
console.log(`Deleting agent with ID ${agentId}...`);
const response = await deleteAgent(agentId);
console.log(response);
}
```
+ Para obter detalhes da API, consulte [DeleteAgent](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-agent/command/DeleteAgentCommand)a *Referência AWS SDK para JavaScript da API*.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples).
Exclua um agente.
```
def delete_agent(self, agent_id):
"""
Deletes an Amazon Bedrock agent.
:param agent_id: The unique identifier of the agent to delete.
:return: The response from Amazon Bedrock Agents if successful, otherwise raises an exception.
"""
try:
response = self.client.delete_agent(
agentId=agent_id, skipResourceInUseCheck=False
)
except ClientError as e:
logger.error(f"Couldn't delete agent. {e}")
raise
else:
return response
```
+ Para obter detalhes da API, consulte a [DeleteAgent](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/DeleteAgent)Referência da API *AWS SDK for Python (Boto3*).
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Use `DeleteAgentAlias` com um AWS SDK
O código de exemplo a seguir mostra como usar `DeleteAgentAlias`.
Exemplos de ações são trechos de código de programas maiores e devem ser executados em contexto. É possível ver essa ação em contexto no seguinte exemplo de código:
+ [Criar e invocar um agente](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockAgents_section.md)
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples).
Exclua um alias de agente.
```
def delete_agent_alias(self, agent_id, agent_alias_id):
"""
Deletes an alias of an Amazon Bedrock agent.
:param agent_id: The unique identifier of the agent that the alias belongs to.
:param agent_alias_id: The unique identifier of the alias to delete.
:return: The response from Amazon Bedrock Agents if successful, otherwise raises an exception.
"""
try:
response = self.client.delete_agent_alias(
agentId=agent_id, agentAliasId=agent_alias_id
)
except ClientError as e:
logger.error(f"Couldn't delete agent alias. {e}")
raise
else:
return response
```
+ Para obter detalhes da API, consulte a [DeleteAgentAlias](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/DeleteAgentAlias)Referência da API *AWS SDK for Python (Boto3*).
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Use `DeleteFlow` com um AWS SDK
O código de exemplo a seguir mostra como usar `DeleteFlow`.
Exemplos de ações são trechos de código de programas maiores e devem ser executados em contexto. É possível ver essa ação em contexto no seguinte exemplo de código:
+ [Criar e invocar um fluxo](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockFlows_section.md)
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples).
Exclua um fluxo do Amazon Bedrock.
```
def delete_flow(client, flow_id):
"""
Deletes an Amazon Bedrock flow.
Args:
client: Amazon Bedrock agent boto3 client.
flow_id (str): The identifier of the flow that you want to delete.
Returns:
dict: The response from the DeleteFLow operation.
"""
try:
logger.info("Deleting flow ID: %s.",
flow_id)
# Call DeleteFlow operation
response = client.delete_flow(
flowIdentifier=flow_id,
skipResourceInUseCheck=True
)
logger.info("Finished deleting flow ID: %s", flow_id)
return response
except ClientError as e:
logger.exception("Client error deleting flow: %s", {str(e)})
raise
except Exception as e:
logger.exception("Unexepcted error deleting flow: %s", {str(e)})
raise
```
+ Para obter detalhes da API, consulte a [DeleteFlow](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/DeleteFlow)Referência da API *AWS SDK for Python (Boto3*).
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Use `DeleteFlowAlias` com um AWS SDK
O código de exemplo a seguir mostra como usar `DeleteFlowAlias`.
Exemplos de ações são trechos de código de programas maiores e devem ser executados em contexto. É possível ver essa ação em contexto no seguinte exemplo de código:
+ [Criar e invocar um fluxo](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockFlows_section.md)
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples).
Exclua um alias de um fluxo do Amazon Bedrock.
```
def delete_flow_alias(client, flow_id, flow_alias_id):
"""
Deletes an Amazon Bedrock flow alias.
Args:
client: bedrock agent boto3 client.
flow_id (str): The identifier of the flow.
Returns:
dict: The response from the call to DetectFLowAlias
"""
try:
logger.info("Deleting flow alias %s for flow: %s.", flow_alias_id, flow_id)
# Delete the flow alias.
response = client.delete_flow_alias(
aliasIdentifier=flow_alias_id,
flowIdentifier=flow_id
)
logging.info("Successfully deleted flow version for %s.", flow_id)
return response
except ClientError as e:
logging.exception("Client error deleting flow version: %s", str(e))
raise
except Exception as e:
logging.exception("Unexpected deleting flow version: %s", str(e))
raise
```
+ Para obter detalhes da API, consulte a [DeleteFlowAlias](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/DeleteFlowAlias)Referência da API *AWS SDK for Python (Boto3*).
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Use `DeleteFlowVersion` com um AWS SDK
O código de exemplo a seguir mostra como usar `DeleteFlowVersion`.
Exemplos de ações são trechos de código de programas maiores e devem ser executados em contexto. É possível ver essa ação em contexto no seguinte exemplo de código:
+ [Criar e invocar um fluxo](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockFlows_section.md)
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples).
Exclua uma versão de um fluxo do Amazon Bedrock.
```
def delete_flow_version(client, flow_id, flow_version):
"""
Deletes a version of an Amazon Bedrock flow.
Args:
client: Amazon Bedrock agent boto3 client.
flow_id (str): The identifier of the flow.
Returns:
dict: The response from DeleteFlowVersion.
"""
try:
logger.info("Deleting flow version %s for flow: %s.",flow_version, flow_id)
# Call DeleteFlowVersion operation
response = client.delete_flow_version(
flowIdentifier=flow_id,
flowVersion=flow_version
)
logging.info("Successfully deleted flow version %s for %s.",
flow_version,
flow_id)
return response
except ClientError as e:
logging.exception("Client error deleting flow version: %s ", str(e))
raise
except Exception as e:
logging.exception("Unexpected deleting flow version: %s", str(e))
raise
```
+ Para obter detalhes da API, consulte a [DeleteFlowVersion](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/DeleteFlowVersion)Referência da API *AWS SDK for Python (Boto3*).
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Use `DeleteKnowledgeBase` com um AWS SDK
O código de exemplo a seguir mostra como usar `DeleteKnowledgeBase`.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples).
Excluir uma base de conhecimento do Amazon Bedrock.
```
def delete_knowledge_base(bedrock_agent_client, knowledge_base_id):
"""
Deletes a knowledge base.
Args:
bedrock_agent_client: The Boto3 Bedrock Agent client.
knowledge_base_id (str): The ID of the knowledge base to delete.
Returns:
bool: True if the deletion was successful.
"""
try:
bedrock_agent_client.delete_knowledge_base(
knowledgeBaseId=knowledge_base_id
)
logger.info("Deleted knowledge base: %s", knowledge_base_id)
return True
except ClientError as err:
logger.error(
"Couldn't delete knowledge base %s. Here's why: %s: %s",
knowledge_base_id,
err.response["Error"]["Code"],
err.response["Error"]["Message"],
)
raise
```
+ Para obter detalhes da API, consulte a [DeleteKnowledgeBase](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/DeleteKnowledgeBase)Referência da API *AWS SDK for Python (Boto3*).
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Use `DeletePrompt` com um AWS SDK
O código de exemplo a seguir mostra como usar `DeletePrompt`.
Exemplos de ações são trechos de código de programas maiores e devem ser executados em contexto. É possível ver essa ação em contexto no seguinte exemplo de código:
+ [Criar e invocar um prompt gerenciado](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockPrompts_section.md)
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples).
Exclua um prompt gerenciado do Amazon Bedrock.
```
def delete_prompt(client, prompt_id):
"""
Deletes an Amazon Bedrock managed prompt.
Args:
client: Amazon Bedrock Agent boto3 client.
prompt_id (str): The identifier of the prompt that you want to delete.
Returns:
dict: The response from the DeletePrompt operation.
"""
try:
logger.info("Deleting prompt ID: %s.", prompt_id)
response = client.delete_prompt(
promptIdentifier=prompt_id
)
logger.info("Finished deleting prompt ID: %s", prompt_id)
return response
except ClientError as e:
logger.exception("Client error deleting prompt: %s", str(e))
raise
except Exception as e:
logger.exception("Unexpected error deleting prompt: %s", str(e))
raise
```
+ Para obter detalhes da API, consulte a [DeletePrompt](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/DeletePrompt)Referência da API *AWS SDK for Python (Boto3*).
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Use `GetAgent` com um AWS SDK
Os exemplos de código a seguir mostram como usar o `GetAgent`.
Exemplos de ações são trechos de código de programas maiores e devem ser executados em contexto. É possível ver essa ação em contexto no seguinte exemplo de código:
+ [Criar e invocar um agente](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockAgents_section.md)
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-agent#code-examples).
Obtenha um agente.
```
import { fileURLToPath } from "node:url";
import { checkForPlaceholders } from "../lib/utils.js";
import {
BedrockAgentClient,
GetAgentCommand,
} from "@aws-sdk/client-bedrock-agent";
/**
* Retrieves the details of an Amazon Bedrock Agent.
*
* @param {string} agentId - The unique identifier of the agent.
* @param {string} [region='us-east-1'] - The AWS region in use.
* @returns {Promise} An object containing the agent details.
*/
export const getAgent = async (agentId, region = "us-east-1") => {
const client = new BedrockAgentClient({ region });
const command = new GetAgentCommand({ agentId });
const response = await client.send(command);
return response.agent;
};
// Invoke main function if this file was run directly.
if (process.argv[1] === fileURLToPath(import.meta.url)) {
// Replace the placeholders for agentId with an existing agent's id.
// Ensure to remove the brackets '[]' before adding your data.
// The agentId must be an alphanumeric string with exactly 10 characters.
const agentId = "[ABC123DE45]";
// Check for unresolved placeholders in agentId.
checkForPlaceholders([agentId]);
console.log(`Retrieving agent with ID ${agentId}...`);
const agent = await getAgent(agentId);
console.log(agent);
}
```
+ Para obter detalhes da API, consulte [GetAgent](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-agent/command/GetAgentCommand)a *Referência AWS SDK para JavaScript da API*.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples).
Obtenha um agente.
```
def get_agent(self, agent_id, log_error=True):
"""
Gets information about an agent.
:param agent_id: The unique identifier of the agent.
:param log_error: Whether to log any errors that occur when getting the agent.
If True, errors will be logged to the logger. If False, errors
will still be raised, but not logged.
:return: The information about the requested agent.
"""
try:
response = self.client.get_agent(agentId=agent_id)
agent = response["agent"]
except ClientError as e:
if log_error:
logger.error(f"Couldn't get agent {agent_id}. {e}")
raise
else:
return agent
```
+ Para obter detalhes da API, consulte a [GetAgent](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/GetAgent)Referência da API *AWS SDK for Python (Boto3*).
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Use `GetFlow` com um AWS SDK
O código de exemplo a seguir mostra como usar `GetFlow`.
Exemplos de ações são trechos de código de programas maiores e devem ser executados em contexto. É possível ver essa ação em contexto no seguinte exemplo de código:
+ [Criar e invocar um fluxo](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockFlows_section.md)
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples).
Obtenha um fluxo do Amazon Bedrock.
```
def get_flow(client, flow_id):
"""
Gets an Amazon Bedrock flow.
Args:
client: bedrock agent boto3 client.
flow_id (str): The identifier of the flow that you want to get.
Returns:
dict: The response from the GetFlow operation.
"""
try:
logger.info("Getting flow ID: %s.",
flow_id)
# Call GetFlow operation.
response = client.get_flow(
flowIdentifier=flow_id
)
logger.info("Retrieved flow ID: %s. Name: %s", flow_id,
response['name'])
return response
except ClientError as e:
logger.exception("Client error getting flow: %s", {str(e)})
raise
except Exception as e:
logger.exception("Unexepcted error getting flow: %s", {str(e)})
raise
```
+ Para obter detalhes da API, consulte a [GetFlow](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/GetFlow)Referência da API *AWS SDK for Python (Boto3*).
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Use `GetFlowVersion` com um AWS SDK
O código de exemplo a seguir mostra como usar `GetFlowVersion`.
Exemplos de ações são trechos de código de programas maiores e devem ser executados em contexto. É possível ver essa ação em contexto no seguinte exemplo de código:
+ [Criar e invocar um fluxo](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockFlows_section.md)
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples).
Obtenha uma versão de um fluxo do Amazon Bedrock.
```
def get_flow_version(client, flow_id, flow_version):
"""
Gets information about a version of an Amazon Bedrock flow.
Args:
client: Amazon Bedrock agent boto3 client.
flow_id (str): The identifier of the flow.
flow_version (str): The flow version of the flow.
Returns:
dict: The response from the call to GetFlowVersion.
"""
try:
logger.info("Deleting flow version for flow: %s.", flow_id)
# Call GetFlowVersion operation
response = client.get_flow_version(
flowIdentifier=flow_id,
flowVersion=flow_version
)
logging.info("Successfully got flow version %s information for flow %s.",
flow_version,
flow_id)
return response
except ClientError as e:
logging.exception("Client error getting flow version: %s", str(e))
raise
except Exception as e:
logging.exception("Unexpected error getting flow version: %s", str(e))
raise
```
+ Para obter detalhes da API, consulte a [GetFlowVersion](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/GetFlowVersion)Referência da API *AWS SDK for Python (Boto3*).
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Use `GetKnowledgeBase` com um AWS SDK
O código de exemplo a seguir mostra como usar `GetKnowledgeBase`.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples).
Obtenha uma base de conhecimento do Amazon Bedrock.
```
def get_knowledge_base(bedrock_agent_client, knowledge_base_id):
"""
Gets details about a specific knowledge base.
Args:
bedrock_agent_client: The Boto3 Bedrock Agent client.
knowledge_base_id (str): The ID of the knowledge base.
Returns:
dict: The details of the knowledge base.
"""
try:
response = bedrock_agent_client.get_knowledge_base(
knowledgeBaseId=knowledge_base_id
)
logger.info("Retrieved knowledge base: %s", knowledge_base_id)
return response["knowledgeBase"]
except ClientError as err:
logger.error(
"Couldn't get knowledge base %s. Here's why: %s: %s",
knowledge_base_id,
err.response["Error"]["Code"],
err.response["Error"]["Message"],
)
raise
```
+ Para obter detalhes da API, consulte a [GetKnowledgeBase](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/GetKnowledgeBase)Referência da API *AWS SDK for Python (Boto3*).
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Use `GetPrompt` com um AWS SDK
O código de exemplo a seguir mostra como usar `GetPrompt`.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples).
Obtenha um prompt gerenciado do Amazon Bedrock.
```
def get_prompt(client, prompt_id):
"""
Gets an Amazon Bedrock managed prompt.
Args:
client: Amazon Bedrock Agent boto3 client.
prompt_id (str): The identifier of the prompt that you want to get.
Returns:
dict: The response from the GetPrompt operation.
"""
try:
logger.info("Getting prompt ID: %s.", prompt_id)
response = client.get_prompt(
promptIdentifier=prompt_id
)
logger.info("Retrieved prompt ID: %s. Name: %s",
prompt_id,
response['name'])
return response
except ClientError as e:
logger.exception("Client error getting prompt: %s", str(e))
raise
except Exception as e:
logger.exception("Unexpected error getting prompt: %s", str(e))
raise
```
+ Para obter detalhes da API, consulte a [GetPrompt](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/GetPrompt)Referência da API *AWS SDK for Python (Boto3*).
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Use `ListAgentActionGroups` com um AWS SDK
Os exemplos de código a seguir mostram como usar o `ListAgentActionGroups`.
Exemplos de ações são trechos de código de programas maiores e devem ser executados em contexto. É possível ver essa ação em contexto no seguinte exemplo de código:
+ [Criar e invocar um agente](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockAgents_section.md)
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-agent#code-examples).
Liste os grupos de ação de um agente.
```
import { fileURLToPath } from "node:url";
import { checkForPlaceholders } from "../lib/utils.js";
import {
BedrockAgentClient,
ListAgentActionGroupsCommand,
paginateListAgentActionGroups,
} from "@aws-sdk/client-bedrock-agent";
/**
* Retrieves a list of Action Groups of an agent utilizing the paginator function.
*
* This function leverages a paginator, which abstracts the complexity of pagination, providing
* a straightforward way to handle paginated results inside a `for await...of` loop.
*
* @param {string} agentId - The unique identifier of the agent.
* @param {string} agentVersion - The version of the agent.
* @param {string} [region='us-east-1'] - The AWS region in use.
* @returns {Promise} An array of action group summaries.
*/
export const listAgentActionGroupsWithPaginator = async (
agentId,
agentVersion,
region = "us-east-1",
) => {
const client = new BedrockAgentClient({ region });
// Create a paginator configuration
const paginatorConfig = {
client,
pageSize: 10, // optional, added for demonstration purposes
};
const params = { agentId, agentVersion };
const pages = paginateListAgentActionGroups(paginatorConfig, params);
// Paginate until there are no more results
const actionGroupSummaries = [];
for await (const page of pages) {
actionGroupSummaries.push(...page.actionGroupSummaries);
}
return actionGroupSummaries;
};
/**
* Retrieves a list of Action Groups of an agent utilizing the ListAgentActionGroupsCommand.
*
* This function demonstrates the manual approach, sending a command to the client and processing the response.
* Pagination must manually be managed. For a simplified approach that abstracts away pagination logic, see
* the `listAgentActionGroupsWithPaginator()` example below.
*
* @param {string} agentId - The unique identifier of the agent.
* @param {string} agentVersion - The version of the agent.
* @param {string} [region='us-east-1'] - The AWS region in use.
* @returns {Promise} An array of action group summaries.
*/
export const listAgentActionGroupsWithCommandObject = async (
agentId,
agentVersion,
region = "us-east-1",
) => {
const client = new BedrockAgentClient({ region });
let nextToken;
const actionGroupSummaries = [];
do {
const command = new ListAgentActionGroupsCommand({
agentId,
agentVersion,
nextToken,
maxResults: 10, // optional, added for demonstration purposes
});
/** @type {{actionGroupSummaries: ActionGroupSummary[], nextToken?: string}} */
const response = await client.send(command);
for (const actionGroup of response.actionGroupSummaries || []) {
actionGroupSummaries.push(actionGroup);
}
nextToken = response.nextToken;
} while (nextToken);
return actionGroupSummaries;
};
// Invoke main function if this file was run directly.
if (process.argv[1] === fileURLToPath(import.meta.url)) {
// Replace the placeholders for agentId and agentVersion with an existing agent's id and version.
// Ensure to remove the brackets '[]' before adding your data.
// The agentId must be an alphanumeric string with exactly 10 characters.
const agentId = "[ABC123DE45]";
// A string either containing `DRAFT` or a number with 1-5 digits (e.g., '123' or 'DRAFT').
const agentVersion = "[DRAFT]";
// Check for unresolved placeholders in agentId and agentVersion.
checkForPlaceholders([agentId, agentVersion]);
console.log("=".repeat(68));
console.log(
"Listing agent action groups using ListAgentActionGroupsCommand:",
);
for (const actionGroup of await listAgentActionGroupsWithCommandObject(
agentId,
agentVersion,
)) {
console.log(actionGroup);
}
console.log("=".repeat(68));
console.log(
"Listing agent action groups using the paginateListAgents function:",
);
for (const actionGroup of await listAgentActionGroupsWithPaginator(
agentId,
agentVersion,
)) {
console.log(actionGroup);
}
}
```
+ Para obter detalhes da API, consulte [ListAgentActionGroups](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-agent/command/ListAgentActionGroupsCommand)a *Referência AWS SDK para JavaScript da API*.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples).
Liste os grupos de ação de um agente.
```
def list_agent_action_groups(self, agent_id, agent_version):
"""
List the action groups for a version of an Amazon Bedrock Agent.
:param agent_id: The unique identifier of the agent.
:param agent_version: The version of the agent.
:return: The list of action group summaries for the version of the agent.
"""
try:
action_groups = []
paginator = self.client.get_paginator("list_agent_action_groups")
for page in paginator.paginate(
agentId=agent_id,
agentVersion=agent_version,
PaginationConfig={"PageSize": 10},
):
action_groups.extend(page["actionGroupSummaries"])
except ClientError as e:
logger.error(f"Couldn't list action groups. {e}")
raise
else:
return action_groups
```
+ Para obter detalhes da API, consulte a [ListAgentActionGroups](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/ListAgentActionGroups)Referência da API *AWS SDK for Python (Boto3*).
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Use `ListAgentKnowledgeBases` com um AWS SDK
O código de exemplo a seguir mostra como usar `ListAgentKnowledgeBases`.
Exemplos de ações são trechos de código de programas maiores e devem ser executados em contexto. É possível ver essa ação em contexto no seguinte exemplo de código:
+ [Criar e invocar um agente](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockAgents_section.md)
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples).
Liste as bases de conhecimento associadas a um agente.
```
def list_agent_knowledge_bases(self, agent_id, agent_version):
"""
List the knowledge bases associated with a version of an Amazon Bedrock Agent.
:param agent_id: The unique identifier of the agent.
:param agent_version: The version of the agent.
:return: The list of knowledge base summaries for the version of the agent.
"""
try:
knowledge_bases = []
paginator = self.client.get_paginator("list_agent_knowledge_bases")
for page in paginator.paginate(
agentId=agent_id,
agentVersion=agent_version,
PaginationConfig={"PageSize": 10},
):
knowledge_bases.extend(page["agentKnowledgeBaseSummaries"])
except ClientError as e:
logger.error(f"Couldn't list knowledge bases. {e}")
raise
else:
return knowledge_bases
```
+ Para obter detalhes da API, consulte a [ListAgentKnowledgeBases](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/ListAgentKnowledgeBases)Referência da API *AWS SDK for Python (Boto3*).
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Use `ListAgents` com um AWS SDK
Os exemplos de código a seguir mostram como usar o `ListAgents`.
Exemplos de ações são trechos de código de programas maiores e devem ser executados em contexto. É possível ver essa ação em contexto no seguinte exemplo de código:
+ [Criar e invocar um agente](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockAgents_section.md)
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-agent#code-examples).
Liste os agentes que pertencem a uma conta.
```
import { fileURLToPath } from "node:url";
import {
BedrockAgentClient,
ListAgentsCommand,
paginateListAgents,
} from "@aws-sdk/client-bedrock-agent";
/**
* Retrieves a list of available Amazon Bedrock agents utilizing the paginator function.
*
* This function leverages a paginator, which abstracts the complexity of pagination, providing
* a straightforward way to handle paginated results inside a `for await...of` loop.
*
* @param {string} [region='us-east-1'] - The AWS region in use.
* @returns {Promise} An array of agent summaries.
*/
export const listAgentsWithPaginator = async (region = "us-east-1") => {
const client = new BedrockAgentClient({ region });
const paginatorConfig = {
client,
pageSize: 10, // optional, added for demonstration purposes
};
const pages = paginateListAgents(paginatorConfig, {});
// Paginate until there are no more results
const agentSummaries = [];
for await (const page of pages) {
agentSummaries.push(...page.agentSummaries);
}
return agentSummaries;
};
/**
* Retrieves a list of available Amazon Bedrock agents utilizing the ListAgentsCommand.
*
* This function demonstrates the manual approach, sending a command to the client and processing the response.
* Pagination must manually be managed. For a simplified approach that abstracts away pagination logic, see
* the `listAgentsWithPaginator()` example below.
*
* @param {string} [region='us-east-1'] - The AWS region in use.
* @returns {Promise} An array of agent summaries.
*/
export const listAgentsWithCommandObject = async (region = "us-east-1") => {
const client = new BedrockAgentClient({ region });
let nextToken;
const agentSummaries = [];
do {
const command = new ListAgentsCommand({
nextToken,
maxResults: 10, // optional, added for demonstration purposes
});
/** @type {{agentSummaries: AgentSummary[], nextToken?: string}} */
const paginatedResponse = await client.send(command);
agentSummaries.push(...(paginatedResponse.agentSummaries || []));
nextToken = paginatedResponse.nextToken;
} while (nextToken);
return agentSummaries;
};
// Invoke main function if this file was run directly.
if (process.argv[1] === fileURLToPath(import.meta.url)) {
console.log("=".repeat(68));
console.log("Listing agents using ListAgentsCommand:");
for (const agent of await listAgentsWithCommandObject()) {
console.log(agent);
}
console.log("=".repeat(68));
console.log("Listing agents using the paginateListAgents function:");
for (const agent of await listAgentsWithPaginator()) {
console.log(agent);
}
}
```
+ Para obter detalhes da API, consulte [ListAgents](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-agent/command/ListAgentsCommand)a *Referência AWS SDK para JavaScript da API*.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples).
Liste os agentes que pertencem a uma conta.
```
def list_agents(self):
"""
List the available Amazon Bedrock Agents.
:return: The list of available bedrock agents.
"""
try:
all_agents = []
paginator = self.client.get_paginator("list_agents")
for page in paginator.paginate(PaginationConfig={"PageSize": 10}):
all_agents.extend(page["agentSummaries"])
except ClientError as e:
logger.error(f"Couldn't list agents. {e}")
raise
else:
return all_agents
```
+ Para obter detalhes da API, consulte a [ListAgents](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/ListAgents)Referência da API *AWS SDK for Python (Boto3*).
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Use `ListFlowAliases` com um AWS SDK
O código de exemplo a seguir mostra como usar `ListFlowAliases`.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples).
Liste os aliases de um fluxo do Amazon Bedrock.
```
def list_flow_aliases(client, flow_id):
"""
Lists the aliases of an Amazon Bedrock flow.
Args:
client: bedrock agent boto3 client.
flow_id (str): The identifier of the flow.
Returns:
dict: The response from ListFlowAliases.
"""
try:
finished = False
logger.info("Listing flow aliases for flow: %s.", flow_id)
print(f"Aliases for flow: {flow_id}")
response = client.list_flow_aliases(
flowIdentifier=flow_id,
maxResults=10)
while finished is False:
for alias in response['flowAliasSummaries']:
print(f"Alias Name: {alias['name']}")
print(f"ID: {alias['id']}")
print(f"Description: {alias.get('description', 'No description')}\n")
if 'nextToken' in response:
next_token = response['nextToken']
response = client.list_flow_aliases(maxResults=10,
nextToken=next_token)
else:
finished = True
logging.info("Successfully listed flow aliases for flow %s.",
flow_id)
return response
except ClientError as e:
logging.exception("Client error listing flow aliases: %s", str(e))
raise
except Exception as e:
logging.exception("Unexpected error listing flow aliases: %s", str(e))
raise
```
+ Para obter detalhes da API, consulte a [ListFlowAliases](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/ListFlowAliases)Referência da API *AWS SDK for Python (Boto3*).
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Use `ListFlowVersions` com um AWS SDK
O código de exemplo a seguir mostra como usar `ListFlowVersions`.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples).
Liste as versões de um fluxo do Amazon Bedrock.
```
def list_flow_versions(client, flow_id):
"""
Lists the versions of an Amazon Bedrock flow.
Args:
client: Amazon bedrock agent boto3 client.
flow_id (str): The identifier of the flow.
Returns:
dict: The response from ListFlowVersions.
"""
try:
finished = False
logger.info("Listing flow versions for flow: %s.", flow_id)
response = client.list_flow_versions(
flowIdentifier=flow_id,
maxResults=10)
while finished is False:
print(f"Versions for flow:{flow_id}")
for version in response['flowVersionSummaries']:
print(f"Version: {version['version']}")
print(f"Status: {version['status']}\n")
if 'nextToken' in response:
next_token = response['nextToken']
response = client.list_flow_versions(maxResults=10,
nextToken=next_token)
else:
finished = True
logging.info("Successfully listed flow versions for flow %s.",
flow_id)
return response
except ClientError as e:
logging.exception("Client error listing flow versions: %s", str(e))
raise
except Exception as e:
logging.exception("Unexpected error listing flow versions: %s", str(e))
raise
```
+ Para obter detalhes da API, consulte a [ListFlowVersions](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/ListFlowVersions)Referência da API *AWS SDK for Python (Boto3*).
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Use `ListFlows` com um AWS SDK
O código de exemplo a seguir mostra como usar `ListFlows`.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples).
Liste os fluxos do Amazon Bedrock.
```
def list_flows(client):
"""
Lists versions of an Amazon Bedrock flow.
Args:
client: Amazon Bedrock agent boto3 client.
flow_id (str): The identifier of the flow.
Returns:
Nothing.
"""
try:
finished = False
logger.info("Listing flows:")
response = client.list_flows(maxResults=10)
while finished is False:
for flow in response['flowSummaries']:
print(f"ID: {flow['id']}")
print(f"Name: {flow['name']}")
print(
f"Description: {flow.get('description', 'No description')}")
print(f"Latest version: {flow['version']}")
print(f"Status: {flow['status']}\n")
if 'nextToken' in response:
next_token = response['nextToken']
response = client.list_flows(maxResults=10,
nextToken=next_token)
else:
finished = True
logging.info("Successfully listed flows.")
except ClientError as e:
logging.exception("Client error listing flow versions: %s", str(e))
raise
except Exception as e:
logging.exception("Unexpected error listing flow versions: %s", str(e))
raise
```
+ Para obter detalhes da API, consulte a [ListFlows](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/ListFlows)Referência da API *AWS SDK for Python (Boto3*).
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Use `ListKnowledgeBases` com um AWS SDK
O código de exemplo a seguir mostra como usar `ListKnowledgeBases`.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples).
Liste as bases de conhecimento do Amazon Bedrock.
```
def list_knowledge_bases(bedrock_agent_client, max_results=None):
"""
Lists the knowledge bases in your AWS account.
Args:
bedrock_agent_client: The Boto3 Bedrock Agent client.
max_results (int, optional): The maximum number of knowledge bases to return.
Returns:
list: A list of knowledge base details.
"""
try:
kwargs = {}
if max_results is not None:
kwargs["maxResults"] = max_results
# Initialize an empty list to store all knowledge bases
all_knowledge_bases = []
# Use paginator to handle pagination automatically
paginator = bedrock_agent_client.get_paginator('list_knowledge_bases')
page_iterator = paginator.paginate(**kwargs)
# Iterate through each page of results
for page in page_iterator:
all_knowledge_bases.extend(page.get('knowledgeBaseSummaries', []))
logger.info("Found %s knowledge bases.", len(all_knowledge_bases))
return all_knowledge_bases
except ClientError as err:
logger.error(
"Couldn't list knowledge bases. Here's why: %s: %s",
err.response["Error"]["Code"],
err.response["Error"]["Message"],
)
raise
```
+ Para obter detalhes da API, consulte a [ListKnowledgeBases](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/ListKnowledgeBases)Referência da API *AWS SDK for Python (Boto3*).
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Use `ListPrompts` com um AWS SDK
O código de exemplo a seguir mostra como usar `ListPrompts`.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples).
Liste os prompts gerenciados do Amazon Bedrock.
```
def list_prompts(client, max_results=10):
"""
Lists Amazon Bedrock managed prompts.
Args:
client: Amazon Bedrock Agent boto3 client.
max_results (int): Maximum number of results to return per page.
Returns:
list: A list of prompt summaries.
"""
try:
logger.info("Listing prompts:")
# Create a paginator for the list_prompts operation
paginator = client.get_paginator('list_prompts')
# Create the pagination parameters
pagination_config = {
'maxResults': max_results
}
# Initialize an empty list to store all prompts
all_prompts = []
# Iterate through all pages
for page in paginator.paginate(**pagination_config):
all_prompts.extend(page.get('promptSummaries', []))
logger.info("Successfully listed %s prompts.", len(all_prompts))
return all_prompts
except ClientError as e:
logger.exception("Client error listing prompts: %s", str(e))
raise
except Exception as e:
logger.exception("Unexpected error listing prompts: %s", str(e))
raise
```
+ Para obter detalhes da API, consulte a [ListPrompts](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/ListPrompts)Referência da API *AWS SDK for Python (Boto3*).
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Use `PrepareAgent` com um AWS SDK
O código de exemplo a seguir mostra como usar `PrepareAgent`.
Exemplos de ações são trechos de código de programas maiores e devem ser executados em contexto. É possível ver essa ação em contexto no seguinte exemplo de código:
+ [Criar e invocar um agente](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockAgents_section.md)
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples).
Prepare um agente para testes internos.
```
def prepare_agent(self, agent_id):
"""
Creates a DRAFT version of the agent that can be used for internal testing.
:param agent_id: The unique identifier of the agent to prepare.
:return: The response from Amazon Bedrock Agents if successful, otherwise raises an exception.
"""
try:
prepared_agent_details = self.client.prepare_agent(agentId=agent_id)
except ClientError as e:
logger.error(f"Couldn't prepare agent. {e}")
raise
else:
return prepared_agent_details
```
+ Para obter detalhes da API, consulte a [PrepareAgent](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/PrepareAgent)Referência da API *AWS SDK for Python (Boto3*).
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Use `PrepareFlow` com um AWS SDK
O código de exemplo a seguir mostra como usar `PrepareFlow`.
Exemplos de ações são trechos de código de programas maiores e devem ser executados em contexto. É possível ver essa ação em contexto no seguinte exemplo de código:
+ [Criar e invocar um fluxo](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockFlows_section.md)
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples).
Prepare um fluxo do Amazon Bedrock.
```
def prepare_flow(client, flow_id):
"""
Prepares an Amazon Bedrock Flow.
Args:
client: Amazon Bedrock agent boto3 client.
flow_id (str): The identifier of the flow that you want to prepare.
Returns:
str: The status of the flow preparation
"""
try:
# Prepare the flow.
logger.info("Preparing flow ID: %s",
flow_id)
response = client.prepare_flow(
flowIdentifier=flow_id
)
status = response.get('status')
while status == "Preparing":
logger.info("Preparing flow ID: %s. Status %s",
flow_id, status)
sleep(5)
response = client.get_flow(
flowIdentifier=flow_id
)
status = response.get('status')
print(f"Flow Status: {status}")
if status == "Prepared":
logger.info("Finished preparing flow ID: %s. Status %s",
flow_id, status)
else:
logger.warning("flow ID: %s not prepared. Status %s",
flow_id, status)
return status
except ClientError as e:
logger.exception("Client error preparing flow: %s", {str(e)})
raise
except Exception as e:
logger.exception("Unexepcted error preparing flow: %s", {str(e)})
raise
```
+ Para obter detalhes da API, consulte a [PrepareFlow](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/PrepareFlow)Referência da API *AWS SDK for Python (Boto3*).
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Use `UpdateFlow` com um AWS SDK
O código de exemplo a seguir mostra como usar `UpdateFlow`.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples).
Atualize um fluxo do Amazon Bedrock.
```
def update_flow(client, flow_id, flow_name, flow_description, role_arn, flow_def):
"""
Updates an Amazon Bedrock flow.
Args:
client: bedrock agent boto3 client.
flow_id (str): The ID for the flow that you want to update.
flow_name (str): The name for the flow.
role_arn (str): The ARN for the IAM role that use flow uses.
flow_def (json): The JSON definition of the flow that you want to create.
Returns:
dict: Flow information if successful.
"""
try:
logger.info("Updating flow: %s.", flow_id)
response = client.update_flow(
flowIdentifier=flow_id,
name=flow_name,
description=flow_description,
executionRoleArn=role_arn,
definition=flow_def
)
logger.info("Successfully updated flow: %s. ID: %s",
flow_name,
{response['id']})
return response
except ClientError as e:
logger.exception("Client error updating flow: %s", {str(e)})
raise
except Exception as e:
logger.exception("Unexepcted error updating flow: %s", {str(e)})
raise
```
+ Para obter detalhes da API, consulte a [UpdateFlow](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/UpdateFlow)Referência da API *AWS SDK for Python (Boto3*).
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Use `UpdateFlowAlias` com um AWS SDK
O código de exemplo a seguir mostra como usar `UpdateFlowAlias`.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples).
Atualize um alias para um fluxo do Amazon Bedrock.
```
def update_flow_alias(client, flow_id, alias_id, flow_version, name, description):
"""
Updates an alias for an Amazon Bedrock flow.
Args:
client: bedrock agent boto3 client.
flow_id (str): The identifier of the flow.
Returns:
str: The response from UpdateFlowAlias.
"""
try:
logger.info("Updating flow alias %s for flow: %s.", alias_id, flow_id)
response = client.update_flow_alias(
aliasIdentifier=alias_id,
flowIdentifier=flow_id,
name=name,
description=description,
routingConfiguration=[
{
"flowVersion": flow_version
}
]
)
logger.info("Successfully updated flow alias %s for %s.", alias_id, flow_id)
return response
except ClientError as e:
logging.exception("Client error updating alias %s for flow: %s - %s",
alias_id, flow_id, str(e))
raise
except Exception as e:
logging.exception("Unexpected error updating alias %s for flow : %s - %s",
alias_id, flow_id, str(e))
raise
```
+ Para obter detalhes da API, consulte a [UpdateFlowAlias](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/UpdateFlowAlias)Referência da API *AWS SDK for Python (Boto3*).
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Use `UpdateKnowledgeBase` com um AWS SDK
O código de exemplo a seguir mostra como usar `UpdateKnowledgeBase`.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples).
Atualize uma base de conhecimento do Amazon Bedrock.
```
def update_knowledge_base(bedrock_agent_client, knowledge_base_id, name=None, description=None, role_arn=None):
"""
Updates an existing knowledge base.
Args:
bedrock_agent_client: The Boto3 Bedrock Agent client.
knowledge_base_id (str): The ID of the knowledge base to update.
name (str, optional): The new name for the knowledge base.
description (str, optional): The new description for the knowledge base.
role_arn (str, optional): The new IAM role ARN for the knowledge base.
Returns:
dict: The details of the updated knowledge base.
"""
try:
kwargs = {
"knowledgeBaseId": knowledge_base_id,
"knowledgeBaseConfiguration": {
"type": "VECTOR",
"vectorKnowledgeBaseConfiguration": {
"embeddingModelArn": "arn:aws:bedrock:us-east-1::foundation-model/amazon.titan-embed-text-v1"
}
}
}
if name:
kwargs["name"] = name
if description:
kwargs["description"] = description
if role_arn:
kwargs["roleArn"] = role_arn
response = bedrock_agent_client.update_knowledge_base(**kwargs)
logger.info("Updated knowledge base: %s", knowledge_base_id)
return response["knowledgeBase"]
except ClientError as err:
logger.error(
"Couldn't update knowledge base %s. Here's why: %s: %s",
knowledge_base_id,
err.response["Error"]["Code"],
err.response["Error"]["Message"],
)
raise
```
+ Para obter detalhes da API, consulte a [UpdateKnowledgeBase](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/UpdateKnowledgeBase)Referência da API *AWS SDK for Python (Boto3*).
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Cenários para Amazon Bedrock Agents usando AWS SDKs
Os exemplos de código a seguir mostram como implementar cenários comuns no Amazon Bedrock Agents com AWS SDKs. Esses cenários mostram como executar tarefas específicas chamando vários perfis no Amazon Bedrock Agents ou outros Serviços da AWS em conjunto. Cada cenário inclui um link para o código-fonte completo, onde podem ser encontradas instruções sobre como configurar e executar o código.
Os cenários têm como alvo um nível intermediário de experiência para ajudar você a compreender ações de serviço em contexto.
**Topics**
+ [Criar e invocar um fluxo](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockFlows_section.md)
+ [Criar e invocar um prompt gerenciado](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockPrompts_section.md)
+ [Criar e invocar um agente](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockAgents_section.md)
+ [Orquestrar aplicações de IA generativa com o Step Functions](bedrock-agent_example_cross_ServerlessPromptChaining_section.md)
# Um end-to-end exemplo mostrando como criar e invocar um fluxo do Amazon Bedrock usando um SDK AWS
O exemplo de código a seguir mostra como:
+ Criar um perfil de execução para o fluxo.
+ Criar o fluxo.
+ Implantar o fluxo totalmente configurado.
+ Invocar o fluxo com prompts fornecidos pelo usuário.
+ Excluir todos os recursos criados.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples).
Gera uma playlist de música com base no gênero e no número de músicas especificados pelo usuário.
```
from datetime import datetime
import logging
import boto3
from botocore.exceptions import ClientError
from roles import create_flow_role, delete_flow_role, update_role_policy
from flow import create_flow, prepare_flow, delete_flow
from run_flow import run_playlist_flow
from flow_version import create_flow_version, delete_flow_version
from flow_alias import create_flow_alias, delete_flow_alias
logging.basicConfig(
level=logging.INFO
)
logger = logging.getLogger(__name__)
def create_input_node(name):
"""
Creates an input node configuration for an Amazon Bedrock flow.
The input node serves as the entry point for the flow and defines
the initial document structure that will be passed to subsequent nodes.
Args:
name (str): The name of the input node.
Returns:
dict: The input node configuration.
"""
return {
"type": "Input",
"name": name,
"outputs": [
{
"name": "document",
"type": "Object"
}
]
}
def create_prompt_node(name, model_id):
"""
Creates a prompt node configuration for a Bedrock flow that generates music playlists.
The prompt node defines an inline prompt template that creates a music playlist based on
a specified genre and number of songs. The prompt uses two variables that are mapped from
the input JSON object:
- {{genre}}: The genre of music to create a playlist for
- {{number}}: The number of songs to include in the playlist
Args:
name (str): The name of the prompt node.
model_id (str): The identifier of the foundation model to use for the prompt.
Returns:
dict: The prompt node.
"""
return {
"type": "Prompt",
"name": name,
"configuration": {
"prompt": {
"sourceConfiguration": {
"inline": {
"modelId": model_id,
"templateType": "TEXT",
"inferenceConfiguration": {
"text": {
"temperature": 0.8
}
},
"templateConfiguration": {
"text": {
"text": "Make me a {{genre}} playlist consisting of the following number of songs: {{number}}."
}
}
}
}
}
},
"inputs": [
{
"name": "genre",
"type": "String",
"expression": "$.data.genre"
},
{
"name": "number",
"type": "Number",
"expression": "$.data.number"
}
],
"outputs": [
{
"name": "modelCompletion",
"type": "String"
}
]
}
def create_output_node(name):
"""
Creates an output node configuration for a Bedrock flow.
The output node validates that the output from the last node is a string
and returns it unmodified. The input name must be "document".
Args:
name (str): The name of the output node.
Returns:
dict: The output node configuration containing the output node:
"""
return {
"type": "Output",
"name": name,
"inputs": [
{
"name": "document",
"type": "String",
"expression": "$.data"
}
]
}
def create_playlist_flow(client, flow_name, flow_description, role_arn, prompt_model_id):
"""
Creates the playlist generator flow.
Args:
client: bedrock agent boto3 client.
role_arn (str): Name for the new IAM role.
prompt_model_id (str): The id of the model to use in the prompt node.
Returns:
dict: The response from the create_flow operation.
"""
input_node = create_input_node("FlowInput")
prompt_node = create_prompt_node("MakePlaylist", prompt_model_id)
output_node = create_output_node("FlowOutput")
# Create connections between the nodes
connections = []
# First, create connections between the output of the flow
# input node and each input of the prompt node.
for prompt_node_input in prompt_node["inputs"]:
connections.append(
{
"name": "_".join([input_node["name"], prompt_node["name"],
prompt_node_input["name"]]),
"source": input_node["name"],
"target": prompt_node["name"],
"type": "Data",
"configuration": {
"data": {
"sourceOutput": input_node["outputs"][0]["name"],
"targetInput": prompt_node_input["name"]
}
}
}
)
# Then, create a connection between the output of the prompt node and the input of the flow output node
connections.append(
{
"name": "_".join([prompt_node["name"], output_node["name"]]),
"source": prompt_node["name"],
"target": output_node["name"],
"type": "Data",
"configuration": {
"data": {
"sourceOutput": prompt_node["outputs"][0]["name"],
"targetInput": output_node["inputs"][0]["name"]
}
}
}
)
flow_def = {
"nodes": [input_node, prompt_node, output_node],
"connections": connections
}
# Create the flow.
response = create_flow(
client, flow_name, flow_description, role_arn, flow_def)
return response
def get_model_arn(client, model_id):
"""
Gets the Amazon Resource Name (ARN) for a model.
Args:
client (str): Amazon Bedrock boto3 client.
model_id (str): The id of the model.
Returns:
str: The ARN of the model.
"""
try:
# Call GetFoundationModelDetails operation
response = client.get_foundation_model(modelIdentifier=model_id)
# Extract model ARN from the response
model_arn = response['modelDetails']['modelArn']
return model_arn
except ClientError as e:
logger.exception("Client error getting model ARN: %s", {str(e)})
raise
except Exception as e:
logger.exception("Unexpected error getting model ARN: %s", {str(e)})
raise
def prepare_flow_version_and_alias(bedrock_agent_client,
flow_id):
"""
Prepares the flow and then creates a flow version and flow alias.
Args:
bedrock_agent_client: Amazon Bedrock Agent boto3 client.
flowd_id (str): The ID of the flow that you want to prepare.
Returns: The flow_version and flow_alias.
"""
status = prepare_flow(bedrock_agent_client, flow_id)
flow_version = None
flow_alias = None
if status == 'Prepared':
# Create the flow version and alias.
flow_version = create_flow_version(bedrock_agent_client,
flow_id,
f"flow version for flow {flow_id}.")
flow_alias = create_flow_alias(bedrock_agent_client,
flow_id,
flow_version,
"latest",
f"Alias for flow {flow_id}, version {flow_version}")
return flow_version, flow_alias
def delete_role_resources(bedrock_agent_client,
iam_client,
role_name,
flow_id,
flow_version,
flow_alias):
"""
Deletes the flow, flow alias, flow version, and IAM roles.
Args:
bedrock_agent_client: Amazon Bedrock Agent boto3 client.
iam_client: Amazon IAM boto3 client.
role_name (str): The name of the IAM role.
flow_id (str): The id of the flow.
flow_version (str): The version of the flow.
flow_alias (str): The alias of the flow.
"""
if flow_id is not None:
if flow_alias is not None:
delete_flow_alias(bedrock_agent_client, flow_id, flow_alias)
if flow_version is not None:
delete_flow_version(bedrock_agent_client,
flow_id, flow_version)
delete_flow(bedrock_agent_client, flow_id)
if role_name is not None:
delete_flow_role(iam_client, role_name)
def main():
"""
Creates, runs, and optionally deletes a Bedrock flow for generating music playlists.
Note:
Requires valid AWS credentials in the default profile
"""
delete_choice = "y"
try:
# Get various boto3 clients.
session = boto3.Session(profile_name='default')
bedrock_agent_runtime_client = session.client('bedrock-agent-runtime')
bedrock_agent_client = session.client('bedrock-agent')
bedrock_client = session.client('bedrock')
iam_client = session.client('iam')
role_name = None
flow_id = None
flow_version = None
flow_alias = None
#Change the model as needed.
prompt_model_id = "amazon.nova-pro-v1:0"
# Base the flow name on the current date and time
current_time = datetime.now()
timestamp = current_time.strftime("%Y-%m-%d-%H-%M-%S")
flow_name = f"FlowPlayList_{timestamp}"
flow_description = "A flow to generate a music playlist."
# Create a role for the flow.
role_name = f"BedrockFlowRole-{flow_name}"
role = create_flow_role(iam_client, role_name)
role_arn = role['Arn']
# Create the flow.
response = create_playlist_flow(
bedrock_agent_client, flow_name, flow_description, role_arn, prompt_model_id)
flow_id = response.get('id')
if flow_id:
# Update accessible resources in the role.
model_arn = get_model_arn(bedrock_client, prompt_model_id)
update_role_policy(iam_client, role_name, [
response.get('arn'), model_arn])
# Prepare the flow and flow version.
flow_version, flow_alias = prepare_flow_version_and_alias(
bedrock_agent_client, flow_id)
# Run the flow.
if flow_version and flow_alias:
run_playlist_flow(bedrock_agent_runtime_client,
flow_id, flow_alias)
delete_choice = input("Delete flow? y or n : ").lower()
else:
print("Couldn't run. Deleting flow and role.")
delete_flow(bedrock_agent_client, flow_id)
delete_flow_role(iam_client, role_name)
else:
print("Couldn't create flow.")
except Exception as e:
print(f"Fatal error: {str(e)}")
finally:
if delete_choice == 'y':
delete_role_resources(bedrock_agent_client,
iam_client,
role_name,
flow_id,
flow_version,
flow_alias)
else:
print("Flow not deleted. ")
print(f"\tFlow ID: {flow_id}")
print(f"\tFlow version: {flow_version}")
print(f"\tFlow alias: {flow_alias}")
print(f"\tRole ARN: {role_arn}")
print("Done!")
if __name__ == "__main__":
main()
def invoke_flow(client, flow_id, flow_alias_id, input_data):
"""
Invoke an Amazon Bedrock flow and handle the response stream.
Args:
client: Boto3 client for Amazon Bedrock agent runtime.
flow_id: The ID of the flow to invoke.
flow_alias_id: The alias ID of the flow.
input_data: Input data for the flow.
Returns:
Dict containing flow status and flow output.
"""
response = None
request_params = None
request_params = {
"flowIdentifier": flow_id,
"flowAliasIdentifier": flow_alias_id,
"inputs": [input_data],
"enableTrace": True
}
response = client.invoke_flow(**request_params)
flow_status = ""
output= ""
# Process the streaming response
for event in response['responseStream']:
# Check if flow is complete.
if 'flowCompletionEvent' in event:
flow_status = event['flowCompletionEvent']['completionReason']
# Save the model output.
elif 'flowOutputEvent' in event:
output = event['flowOutputEvent']['content']['document']
logger.info("Output : %s", output)
# Log trace events.
elif 'flowTraceEvent' in event:
logger.info("Flow trace: %s", event['flowTraceEvent'])
return {
"flow_status": flow_status,
"output": output
}
def run_playlist_flow(bedrock_agent_client, flow_id, flow_alias_id):
"""
Runs the playlist generator flow.
Args:
bedrock_agent_client: Boto3 client for Amazon Bedrock agent runtime.
flow_id: The ID of the flow to run.
flow_alias_id: The alias ID of the flow.
"""
print ("Welcome to the playlist generator flow.")
# Get the initial prompt from the user.
genre = input("Enter genre: ")
number_of_songs = int(input("Enter number of songs: "))
# Use prompt to create input data for the input node.
flow_input_data = {
"content": {
"document": {
"genre" : genre,
"number" : number_of_songs
}
},
"nodeName": "FlowInput",
"nodeOutputName": "document"
}
try:
result = invoke_flow(
bedrock_agent_client, flow_id, flow_alias_id, flow_input_data)
status = result['flow_status']
if status == "SUCCESS":
# The flow completed successfully.
logger.info("The flow %s successfully completed.", flow_id)
print(result['output'])
else:
logger.warning("Flow status: %s",status)
except ClientError as e:
print(f"Client error: {str(e)}")
logger.error("Client error: %s", {str(e)})
raise
except Exception as e:
logger.error("An error occurred: %s", {str(e)})
logger.error("Error type: %s", {type(e)})
raise
def create_flow_role(client, role_name):
"""
Creates an IAM role for Amazon Bedrock with permissions to run a flow.
Args:
role_name (str): Name for the new IAM role.
Returns:
str: The role Amazon Resource Name.
"""
# Trust relationship policy - allows Amazon Bedrock service to assume this role.
trust_policy = {
"Version":"2012-10-17",
"Statement": [{
"Effect": "Allow",
"Principal": {
"Service": "bedrock.amazonaws.com"
},
"Action": "sts:AssumeRole"
}]
}
# Basic inline policy for for running a flow.
resources = "*"
bedrock_policy = {
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"bedrock:InvokeModel",
"bedrock:Retrieve",
"bedrock:RetrieveAndGenerate"
],
# Using * as placeholder - Later you update with specific ARNs.
"Resource": resources
}
]
}
try:
# Create the IAM role with trust policy
logging.info("Creating role: %s",role_name)
role = client.create_role(
RoleName=role_name,
AssumeRolePolicyDocument=json.dumps(trust_policy),
Description="Role for Amazon Bedrock operations"
)
# Attach inline policy to the role
print("Attaching inline policy")
client.put_role_policy(
RoleName=role_name,
PolicyName=f"{role_name}-policy",
PolicyDocument=json.dumps(bedrock_policy)
)
logging.info("Create Role ARN: %s", role['Role']['Arn'])
return role['Role']
except ClientError as e:
logging.warning("Error creating role: %s", str(e))
raise
except Exception as e:
logging.warning("Unexpected error: %s", str(e))
raise
def update_role_policy(client, role_name, resource_arns):
"""
Updates an IAM role's inline policy with specific resource ARNs.
Args:
role_name (str): Name of the existing role.
resource_arns (list): List of resource ARNs to allow access to.
"""
updated_policy = {
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"bedrock:GetFlow",
"bedrock:InvokeModel",
"bedrock:Retrieve",
"bedrock:RetrieveAndGenerate"
],
"Resource": resource_arns
}
]
}
try:
client.put_role_policy(
RoleName=role_name,
PolicyName=f"{role_name}-policy",
PolicyDocument=json.dumps(updated_policy)
)
logging.info("Updated policy for role: %s",role_name)
except ClientError as e:
logging.warning("Error updating role policy: %s", str(e))
raise
def delete_flow_role(client, role_name):
"""
Deletes an IAM role.
Args:
role_name (str): Name of the role to delete.
"""
try:
# Detach and delete inline policies
policies = client.list_role_policies(RoleName=role_name)['PolicyNames']
for policy_name in policies:
client.delete_role_policy(RoleName=role_name, PolicyName=policy_name)
# Delete the role
client.delete_role(RoleName=role_name)
logging.info("Deleted role: %s", role_name)
except ClientError as e:
logging.info("Error Deleting role: %s", str(e))
raise
```
+ Para ver detalhes da API, consulte os tópicos a seguir na *Referência da API do SDK da AWS para Python (Boto3)*.
+ [CreateFlow](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/CreateFlow)
+ [CreateFlowAlias](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/CreateFlowAlias)
+ [CreateFlowVersion](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/CreateFlowVersion)
+ [DeleteFlow](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/DeleteFlow)
+ [DeleteFlowAlias](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/DeleteFlowAlias)
+ [DeleteFlowVersion](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/DeleteFlowVersion)
+ [GetFlow](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/GetFlow)
+ [GetFlowAlias](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/GetFlowAlias)
+ [GetFlowVersion](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/GetFlowVersion)
+ [InvokeFlow](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-runtime-2023-12-12/InvokeFlow)
+ [PrepareFlow](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/PrepareFlow)
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Um end-to-end exemplo mostrando como criar e invocar prompts gerenciados do Amazon Bedrock usando um SDK AWS
O exemplo de código a seguir mostra como:
+ Criar um prompt gerenciado.
+ Criar uma versão do prompt.
+ Invocar o prompt usando a versão.
+ Limpar os recursos (opcional).
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples).
Criar e invocar um prompt gerenciado.
```
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()
```
+ Para ver detalhes da API, consulte os tópicos a seguir na *Referência da API do SDK da AWS para 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)
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Um end-to-end exemplo mostrando como criar e invocar Amazon Bedrock Agents usando um SDK AWS
O exemplo de código a seguir mostra como:
+ Criar um perfil de execução para o agente.
+ Criar o agente e implantar uma versão de RASCUNHO.
+ Criar uma função do Lambda que implante os recursos do agente.
+ Criar um grupo de ação que conecte o agente à função do Lambda.
+ Implantar o agente totalmente configurado.
+ Invocar o agente com prompts fornecidos pelo usuário.
+ Excluir todos os recursos criados.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples).
Crie e invoque um agente.
```
REGION = "us-east-1"
ROLE_POLICY_NAME = "agent_permissions"
class BedrockAgentScenarioWrapper:
"""Runs a scenario that shows how to get started using Amazon Bedrock Agents."""
def __init__(
self, bedrock_agent_client, runtime_client, lambda_client, iam_resource, postfix
):
self.iam_resource = iam_resource
self.lambda_client = lambda_client
self.bedrock_agent_runtime_client = runtime_client
self.postfix = postfix
self.bedrock_wrapper = BedrockAgentWrapper(bedrock_agent_client)
self.agent = None
self.agent_alias = None
self.agent_role = None
self.prepared_agent_details = None
self.lambda_role = None
self.lambda_function = None
def run_scenario(self):
print("=" * 88)
print("Welcome to the Amazon Bedrock Agents demo.")
print("=" * 88)
# Query input from user
print("Let's start with creating an agent:")
print("-" * 40)
name, foundation_model = self._request_name_and_model_from_user()
print("-" * 40)
# Create an execution role for the agent
self.agent_role = self._create_agent_role(foundation_model)
# Create the agent
self.agent = self._create_agent(name, foundation_model)
# Prepare a DRAFT version of the agent
self.prepared_agent_details = self._prepare_agent()
# Create the agent's Lambda function
self.lambda_function = self._create_lambda_function()
# Configure permissions for the agent to invoke the Lambda function
self._allow_agent_to_invoke_function()
self._let_function_accept_invocations_from_agent()
# Create an action group to connect the agent with the Lambda function
self._create_agent_action_group()
# If the agent has been modified or any components have been added, prepare the agent again
components = [self._get_agent()]
components += self._get_agent_action_groups()
components += self._get_agent_knowledge_bases()
latest_update = max(component["updatedAt"] for component in components)
if latest_update > self.prepared_agent_details["preparedAt"]:
self.prepared_agent_details = self._prepare_agent()
# Create an agent alias
self.agent_alias = self._create_agent_alias()
# Test the agent
self._chat_with_agent(self.agent_alias)
print("=" * 88)
print("Thanks for running the demo!\n")
if q.ask("Do you want to delete the created resources? [y/N] ", q.is_yesno):
self._delete_resources()
print("=" * 88)
print(
"All demo resources have been deleted. Thanks again for running the demo!"
)
else:
self._list_resources()
print("=" * 88)
print("Thanks again for running the demo!")
def _request_name_and_model_from_user(self):
existing_agent_names = [
agent["agentName"] for agent in self.bedrock_wrapper.list_agents()
]
while True:
name = q.ask("Enter an agent name: ", self.is_valid_agent_name)
if name.lower() not in [n.lower() for n in existing_agent_names]:
break
print(
f"Agent {name} conflicts with an existing agent. Please use a different name."
)
models = ["anthropic.claude-instant-v1", "anthropic.claude-v2"]
model_id = models[
q.choose("Which foundation model would you like to use? ", models)
]
return name, model_id
def _create_agent_role(self, model_id):
role_name = f"AmazonBedrockExecutionRoleForAgents_{self.postfix}"
model_arn = f"arn:aws:bedrock:{REGION}::foundation-model/{model_id}*"
print("Creating an an execution role for the agent...")
try:
role = self.iam_resource.create_role(
RoleName=role_name,
AssumeRolePolicyDocument=json.dumps(
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {"Service": "bedrock.amazonaws.com"},
"Action": "sts:AssumeRole",
}
],
}
),
)
role.Policy(ROLE_POLICY_NAME).put(
PolicyDocument=json.dumps(
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "bedrock:InvokeModel",
"Resource": model_arn,
}
],
}
)
)
except ClientError as e:
logger.error(f"Couldn't create role {role_name}. Here's why: {e}")
raise
return role
def _create_agent(self, name, model_id):
print("Creating the agent...")
instruction = """
You are a friendly chat bot. You have access to a function called that returns
information about the current date and time. When responding with date or time,
please make sure to add the timezone UTC.
"""
agent = self.bedrock_wrapper.create_agent(
agent_name=name,
foundation_model=model_id,
instruction=instruction,
role_arn=self.agent_role.arn,
)
self._wait_for_agent_status(agent["agentId"], "NOT_PREPARED")
return agent
def _prepare_agent(self):
print("Preparing the agent...")
agent_id = self.agent["agentId"]
prepared_agent_details = self.bedrock_wrapper.prepare_agent(agent_id)
self._wait_for_agent_status(agent_id, "PREPARED")
return prepared_agent_details
def _create_lambda_function(self):
print("Creating the Lambda function...")
function_name = f"AmazonBedrockExampleFunction_{self.postfix}"
self.lambda_role = self._create_lambda_role()
try:
deployment_package = self._create_deployment_package(function_name)
lambda_function = self.lambda_client.create_function(
FunctionName=function_name,
Description="Lambda function for Amazon Bedrock example",
Runtime="python3.11",
Role=self.lambda_role.arn,
Handler=f"{function_name}.lambda_handler",
Code={"ZipFile": deployment_package},
Publish=True,
)
waiter = self.lambda_client.get_waiter("function_active_v2")
waiter.wait(FunctionName=function_name)
except ClientError as e:
logger.error(
f"Couldn't create Lambda function {function_name}. Here's why: {e}"
)
raise
return lambda_function
def _create_lambda_role(self):
print("Creating an execution role for the Lambda function...")
role_name = f"AmazonBedrockExecutionRoleForLambda_{self.postfix}"
try:
role = self.iam_resource.create_role(
RoleName=role_name,
AssumeRolePolicyDocument=json.dumps(
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {"Service": "lambda.amazonaws.com"},
"Action": "sts:AssumeRole",
}
],
}
),
)
role.attach_policy(
PolicyArn="arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole"
)
print(f"Created role {role_name}")
except ClientError as e:
logger.error(f"Couldn't create role {role_name}. Here's why: {e}")
raise
print("Waiting for the execution role to be fully propagated...")
wait(10)
return role
def _allow_agent_to_invoke_function(self):
policy = self.iam_resource.RolePolicy(
self.agent_role.role_name, ROLE_POLICY_NAME
)
doc = policy.policy_document
doc["Statement"].append(
{
"Effect": "Allow",
"Action": "lambda:InvokeFunction",
"Resource": self.lambda_function["FunctionArn"],
}
)
self.agent_role.Policy(ROLE_POLICY_NAME).put(PolicyDocument=json.dumps(doc))
def _let_function_accept_invocations_from_agent(self):
try:
self.lambda_client.add_permission(
FunctionName=self.lambda_function["FunctionName"],
SourceArn=self.agent["agentArn"],
StatementId="BedrockAccess",
Action="lambda:InvokeFunction",
Principal="bedrock.amazonaws.com",
)
except ClientError as e:
logger.error(
f"Couldn't grant Bedrock permission to invoke the Lambda function. Here's why: {e}"
)
raise
def _create_agent_action_group(self):
print("Creating an action group for the agent...")
try:
with open("./scenario_resources/api_schema.yaml") as file:
self.bedrock_wrapper.create_agent_action_group(
name="current_date_and_time",
description="Gets the current date and time.",
agent_id=self.agent["agentId"],
agent_version=self.prepared_agent_details["agentVersion"],
function_arn=self.lambda_function["FunctionArn"],
api_schema=json.dumps(yaml.safe_load(file)),
)
except ClientError as e:
logger.error(f"Couldn't create agent action group. Here's why: {e}")
raise
def _get_agent(self):
return self.bedrock_wrapper.get_agent(self.agent["agentId"])
def _get_agent_action_groups(self):
return self.bedrock_wrapper.list_agent_action_groups(
self.agent["agentId"], self.prepared_agent_details["agentVersion"]
)
def _get_agent_knowledge_bases(self):
return self.bedrock_wrapper.list_agent_knowledge_bases(
self.agent["agentId"], self.prepared_agent_details["agentVersion"]
)
def _create_agent_alias(self):
print("Creating an agent alias...")
agent_alias_name = "test_agent_alias"
agent_alias = self.bedrock_wrapper.create_agent_alias(
agent_alias_name, self.agent["agentId"]
)
self._wait_for_agent_status(self.agent["agentId"], "PREPARED")
return agent_alias
def _wait_for_agent_status(self, agent_id, status):
while self.bedrock_wrapper.get_agent(agent_id)["agentStatus"] != status:
wait(2)
def _chat_with_agent(self, agent_alias):
print("-" * 88)
print("The agent is ready to chat.")
print("Try asking for the date or time. Type 'exit' to quit.")
# Create a unique session ID for the conversation
session_id = uuid.uuid4().hex
while True:
prompt = q.ask("Prompt: ", q.non_empty)
if prompt == "exit":
break
response = asyncio.run(self._invoke_agent(agent_alias, prompt, session_id))
print(f"Agent: {response}")
async def _invoke_agent(self, agent_alias, prompt, session_id):
response = self.bedrock_agent_runtime_client.invoke_agent(
agentId=self.agent["agentId"],
agentAliasId=agent_alias["agentAliasId"],
sessionId=session_id,
inputText=prompt,
)
completion = ""
for event in response.get("completion"):
chunk = event["chunk"]
completion += chunk["bytes"].decode()
return completion
def _delete_resources(self):
if self.agent:
agent_id = self.agent["agentId"]
if self.agent_alias:
agent_alias_id = self.agent_alias["agentAliasId"]
print("Deleting agent alias...")
self.bedrock_wrapper.delete_agent_alias(agent_id, agent_alias_id)
print("Deleting agent...")
agent_status = self.bedrock_wrapper.delete_agent(agent_id)["agentStatus"]
while agent_status == "DELETING":
wait(5)
try:
agent_status = self.bedrock_wrapper.get_agent(
agent_id, log_error=False
)["agentStatus"]
except ClientError as err:
if err.response["Error"]["Code"] == "ResourceNotFoundException":
agent_status = "DELETED"
if self.lambda_function:
name = self.lambda_function["FunctionName"]
print(f"Deleting function '{name}'...")
self.lambda_client.delete_function(FunctionName=name)
if self.agent_role:
print(f"Deleting role '{self.agent_role.role_name}'...")
self.agent_role.Policy(ROLE_POLICY_NAME).delete()
self.agent_role.delete()
if self.lambda_role:
print(f"Deleting role '{self.lambda_role.role_name}'...")
for policy in self.lambda_role.attached_policies.all():
policy.detach_role(RoleName=self.lambda_role.role_name)
self.lambda_role.delete()
def _list_resources(self):
print("-" * 40)
print(f"Here is the list of created resources in '{REGION}'.")
print("Make sure you delete them once you're done to avoid unnecessary costs.")
if self.agent:
print(f"Bedrock Agent: {self.agent['agentName']}")
if self.lambda_function:
print(f"Lambda function: {self.lambda_function['FunctionName']}")
if self.agent_role:
print(f"IAM role: {self.agent_role.role_name}")
if self.lambda_role:
print(f"IAM role: {self.lambda_role.role_name}")
@staticmethod
def is_valid_agent_name(answer):
valid_regex = r"^[a-zA-Z0-9_-]{1,100}$"
return (
answer
if answer and len(answer) <= 100 and re.match(valid_regex, answer)
else None,
"I need a name for the agent, please. Valid characters are a-z, A-Z, 0-9, _ (underscore) and - (hyphen).",
)
@staticmethod
def _create_deployment_package(function_name):
buffer = io.BytesIO()
with zipfile.ZipFile(buffer, "w") as zipped:
zipped.write(
"./scenario_resources/lambda_function.py", f"{function_name}.py"
)
buffer.seek(0)
return buffer.read()
if __name__ == "__main__":
logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
postfix = "".join(
random.choice(string.ascii_lowercase + "0123456789") for _ in range(8)
)
scenario = BedrockAgentScenarioWrapper(
bedrock_agent_client=boto3.client(
service_name="bedrock-agent", region_name=REGION
),
runtime_client=boto3.client(
service_name="bedrock-agent-runtime", region_name=REGION
),
lambda_client=boto3.client(service_name="lambda", region_name=REGION),
iam_resource=boto3.resource("iam"),
postfix=postfix,
)
try:
scenario.run_scenario()
except Exception as e:
logging.exception(f"Something went wrong with the demo. Here's what: {e}")
```
+ Para obter detalhes da API, consulte os tópicos a seguir na *Referência de API do AWS SDK para Python (Boto3)*.
+ [CreateAgent](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/CreateAgent)
+ [CreateAgentActionGroup](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/CreateAgentActionGroup)
+ [CreateAgentAlias](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/CreateAgentAlias)
+ [DeleteAgent](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/DeleteAgent)
+ [DeleteAgentAlias](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/DeleteAgentAlias)
+ [GetAgent](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/GetAgent)
+ [ListAgentActionGroups](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/ListAgentActionGroups)
+ [ListAgentKnowledgeBases](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/ListAgentKnowledgeBases)
+ [ListAgents](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/ListAgents)
+ [PrepareAgent](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/PrepareAgent)
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Construir e orquestrar aplicações de IA generativa com o Amazon Bedrock e o Step Functions
O exemplo de código a seguir mostra como criar e orquestrar aplicações de IA generativa com o Amazon Bedrock e o Step Functions.
------
#### [ Python ]
**SDK para Python (Boto3)**
O cenário de encadeamento de prompts do Amazon Bedrock Sem Servidor demonstra como o [AWS Step Functions](https://docs.aws.amazon.com/step-functions/latest/dg/welcome.html), o [Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html) e a documentação [https://docs.aws.amazon.com/bedrock/latest/userguide/agents.html](https://docs.aws.amazon.com/bedrock/latest/userguide/agents.html) podem ser usados para criar e orquestrar aplicações de IA generativa complexas, sem servidor e altamente escaláveis. Ele contém os seguintes exemplos de trabalho:
+ Escrever uma análise de um determinado romance para um blog de literatura. Este exemplo ilustra uma cadeia de prompts simples e sequencial.
+ Gerar uma história curta sobre um determinado tópico. Este exemplo ilustra como a IA pode processar uma lista de itens gerada anteriormente de forma iterativa.
+ Criar um itinerário para férias de fim de semana em um determinado destino. Este exemplo ilustra como paralelizar vários prompts distintos.
+ Lançar ideias de filmes para um usuário humano que atua como produtor de filmes. Este exemplo ilustra como paralelizar o mesmo prompt com diferentes parâmetros de inferência, como voltar a uma etapa anterior na cadeia e como incluir a entrada humana como parte do fluxo de trabalho.
+ Planejar uma refeição com base nos ingredientes que o usuário tem em mãos. Este exemplo ilustra como as cadeias de prompts podem incorporar duas conversas distintas de IA, com duas personas de IA participando de um debate entre si para melhorar o resultado final.
+ Encontre e resuma o repositório mais popular GitHub da atualidade. Este exemplo ilustra o encadeamento de vários agentes de IA que interagem com agentes externos. APIs
Para obter o código-fonte completo e as instruções de configuração e execução, consulte o projeto completo em [GitHub](https://github.com/aws-samples/amazon-bedrock-serverless-prompt-chaining).
**Serviços usados neste exemplo**
+ Amazon Bedrock
+ Amazon Bedrock Runtime
+ Amazon Bedrock Agents
+ Amazon Bedrock Agents Runtime
+ Step Functions
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Exemplos de código para Amazon Bedrock Agents Runtime usando AWS SDKs
Os exemplos de código a seguir mostram como usar o Amazon Bedrock Agents Runtime com um kit de desenvolvimento de AWS software (SDK).
As *noções básicas* são exemplos de código que mostram como realizar as operações essenciais em um serviço.
*Ações* são trechos de código de programas maiores e devem ser executadas em contexto. Embora as ações mostrem como chamar perfis de serviço individuais, você pode ver as ações no contexto em seus cenários relacionados.
*Cenários* são exemplos de código que mostram como realizar tarefas específicas chamando várias funções dentro de um serviço ou combinadas com outros Serviços da AWS.
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
**Contents**
+ [Conceitos básicos](service_code_examples_bedrock-agent-runtime_basics.md)
+ [Conheça os conceitos básicos](bedrock-agent-runtime_example_bedrock-agent-runtime_Scenario_ConverseWithFlow_section.md)
+ [Ações](service_code_examples_bedrock-agent-runtime_actions.md)
+ [`InvokeAgent`](bedrock-agent-runtime_example_bedrock-agent-runtime_InvokeAgent_section.md)
+ [`InvokeFlow`](bedrock-agent-runtime_example_bedrock-agent-runtime_InvokeFlow_section.md)
+ [Cenários](service_code_examples_bedrock-agent-runtime_scenarios.md)
+ [Criar e invocar um fluxo](bedrock-agent-runtime_example_bedrock-agent_GettingStartedWithBedrockFlows_section.md)
+ [Orquestrar aplicações de IA generativa com o Step Functions](bedrock-agent-runtime_example_cross_ServerlessPromptChaining_section.md)
# Exemplos básicos do Amazon Bedrock Agents Runtime usando AWS SDKs
Os exemplos de código a seguir mostram como usar os conceitos básicos do Amazon Bedrock Agents Runtime com. AWS SDKs
**Contents**
+ [Conheça os conceitos básicos](bedrock-agent-runtime_example_bedrock-agent-runtime_Scenario_ConverseWithFlow_section.md)
+ [Ações](service_code_examples_bedrock-agent-runtime_actions.md)
+ [`InvokeAgent`](bedrock-agent-runtime_example_bedrock-agent-runtime_InvokeAgent_section.md)
+ [`InvokeFlow`](bedrock-agent-runtime_example_bedrock-agent-runtime_InvokeFlow_section.md)
# Conversar com um fluxo do Amazon Bedrock
O exemplo de código a seguir mostra como usar InvokeFlow para conversar com um fluxo do Amazon Bedrock que inclui um nó de agente.
Para ter mais informações, consulte [Conversar com um fluxo do Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/flows-multi-turn-invocation.html).
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent-runtime#code-examples).
```
"""
Shows how to run an Amazon Bedrock flow with InvokeFlow and handle muli-turn interaction
for a single conversation.
For more information, see https://docs.aws.amazon.com/bedrock/latest/userguide/flows-multi-turn-invocation.html.
"""
import logging
import boto3
import botocore
import botocore.exceptions
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
def invoke_flow(client, flow_id, flow_alias_id, input_data, execution_id):
"""
Invoke an Amazon Bedrock flow and handle the response stream.
Args:
client: Boto3 client for Amazon Bedrock agent runtime.
flow_id: The ID of the flow to invoke.
flow_alias_id: The alias ID of the flow.
input_data: Input data for the flow.
execution_id: Execution ID for continuing a flow. Use the value None on first run.
Returns:
Dict containing flow_complete status, input_required info, and execution_id
"""
response = None
request_params = None
if execution_id is None:
# Don't pass execution ID for first run.
request_params = {
"flowIdentifier": flow_id,
"flowAliasIdentifier": flow_alias_id,
"inputs": [input_data],
"enableTrace": True
}
else:
request_params = {
"flowIdentifier": flow_id,
"flowAliasIdentifier": flow_alias_id,
"executionId": execution_id,
"inputs": [input_data],
"enableTrace": True
}
response = client.invoke_flow(**request_params)
if "executionId" not in request_params:
execution_id = response['executionId']
input_required = None
flow_status = ""
# Process the streaming response
for event in response['responseStream']:
# Check if flow is complete.
if 'flowCompletionEvent' in event:
flow_status = event['flowCompletionEvent']['completionReason']
# Check if more input us needed from user.
elif 'flowMultiTurnInputRequestEvent' in event:
input_required = event
# Print the model output.
elif 'flowOutputEvent' in event:
print(event['flowOutputEvent']['content']['document'])
# Log trace events.
elif 'flowTraceEvent' in event:
logger.info("Flow trace: %s", event['flowTraceEvent'])
return {
"flow_status": flow_status,
"input_required": input_required,
"execution_id": execution_id
}
def converse_with_flow(bedrock_agent_client, flow_id, flow_alias_id):
"""
Run a conversation with the supplied flow.
Args:
bedrock_agent_client: Boto3 client for Amazon Bedrock agent runtime.
flow_id: The ID of the flow to run.
flow_alias_id: The alias ID of the flow.
"""
flow_execution_id = None
finished = False
# Get the intial prompt from the user.
user_input = input("Enter input: ")
# Use prompt to create input data.
flow_input_data = {
"content": {
"document": user_input
},
"nodeName": "FlowInputNode",
"nodeOutputName": "document"
}
try:
while not finished:
# Invoke the flow until successfully finished.
result = invoke_flow(
bedrock_agent_client, flow_id, flow_alias_id, flow_input_data, flow_execution_id)
status = result['flow_status']
flow_execution_id = result['execution_id']
more_input = result['input_required']
if status == "INPUT_REQUIRED":
# The flow needs more information from the user.
logger.info("The flow %s requires more input", flow_id)
user_input = input(
more_input['flowMultiTurnInputRequestEvent']['content']['document'] + ": ")
flow_input_data = {
"content": {
"document": user_input
},
"nodeName": more_input['flowMultiTurnInputRequestEvent']['nodeName'],
"nodeInputName": "agentInputText"
}
elif status == "SUCCESS":
# The flow completed successfully.
finished = True
logger.info("The flow %s successfully completed.", flow_id)
except botocore.exceptions.ClientError as e:
print(f"Client error: {str(e)}")
logger.error("Client error: %s", {str(e)})
except Exception as e:
print(f"An error occurred: {str(e)}")
logger.error("An error occurred: %s", {str(e)})
logger.error("Error type: %s", {type(e)})
def main():
"""
Main entry point for the script.
"""
# Replace these with your actual flow ID and flow alias ID.
FLOW_ID = 'YOUR_FLOW_ID'
FLOW_ALIAS_ID = 'YOUR_FLOW_ALIAS_ID'
logger.info("Starting conversation with FLOW: %s ID: %s",
FLOW_ID, FLOW_ALIAS_ID)
# Get the Bedrock agent runtime client.
session = boto3.Session(profile_name='default')
bedrock_agent_client = session.client('bedrock-agent-runtime')
# Start the conversation.
converse_with_flow(bedrock_agent_client, FLOW_ID, FLOW_ALIAS_ID)
logger.info("Conversation with FLOW: %s ID: %s finished",
FLOW_ID, FLOW_ALIAS_ID)
if __name__ == "__main__":
main()
```
+ Para obter detalhes da API, consulte a [InvokeFlow](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-runtime-2023-12-12/InvokeFlow)Referência da API *AWS SDK for Python (Boto3*).
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Ações para o Amazon Bedrock Agents Runtime usando AWS SDKs
Os exemplos de código a seguir demonstram como realizar ações individuais do Amazon Bedrock Agents Runtime com AWS SDKs. Cada exemplo inclui um link para GitHub, onde você pode encontrar instruções para configurar e executar o código.
Esses trechos chamam a API do Amazon Bedrock Agents Runtime e são trechos de programas maiores que devem ser executados em contexto. É possível ver as ações em contexto em [Cenários para o Amazon Bedrock Agents Runtime usando AWS SDKs](service_code_examples_bedrock-agent-runtime_scenarios.md).
Os exemplos a seguir incluem apenas as ações mais utilizadas. Para obter uma lista completa, consulte a [Amazon Bedrock Agents Runtime API Reference](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_Operations_Agents_for_Amazon_Bedrock_Runtime.html).
**Topics**
+ [`InvokeAgent`](bedrock-agent-runtime_example_bedrock-agent-runtime_InvokeAgent_section.md)
+ [`InvokeFlow`](bedrock-agent-runtime_example_bedrock-agent-runtime_InvokeFlow_section.md)
# Use `InvokeAgent` com um AWS SDK
Os exemplos de código a seguir mostram como usar o `InvokeAgent`.
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-agent-runtime#code-examples).
```
import {
BedrockAgentRuntimeClient,
InvokeAgentCommand,
} from "@aws-sdk/client-bedrock-agent-runtime";
/**
* @typedef {Object} ResponseBody
* @property {string} completion
*/
/**
* Invokes a Bedrock agent to run an inference using the input
* provided in the request body.
*
* @param {string} prompt - The prompt that you want the Agent to complete.
* @param {string} sessionId - An arbitrary identifier for the session.
*/
export const invokeBedrockAgent = async (prompt, sessionId) => {
const client = new BedrockAgentRuntimeClient({ region: "us-east-1" });
// const client = new BedrockAgentRuntimeClient({
// region: "us-east-1",
// credentials: {
// accessKeyId: "accessKeyId", // permission to invoke agent
// secretAccessKey: "accessKeySecret",
// },
// });
const agentId = "AJBHXXILZN";
const agentAliasId = "AVKP1ITZAA";
const command = new InvokeAgentCommand({
agentId,
agentAliasId,
sessionId,
inputText: prompt,
});
try {
let completion = "";
const response = await client.send(command);
if (response.completion === undefined) {
throw new Error("Completion is undefined");
}
for await (const chunkEvent of response.completion) {
const chunk = chunkEvent.chunk;
console.log(chunk);
const decodedResponse = new TextDecoder("utf-8").decode(chunk.bytes);
completion += decodedResponse;
}
return { sessionId: sessionId, completion };
} catch (err) {
console.error(err);
}
};
// Call function if run directly
import { fileURLToPath } from "node:url";
if (process.argv[1] === fileURLToPath(import.meta.url)) {
const result = await invokeBedrockAgent("I need help.", "123");
console.log(result);
}
```
+ Para obter detalhes da API, consulte [InvokeAgent](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-agent-runtime/command/InvokeAgentCommand)a *Referência AWS SDK para JavaScript da API*.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent-runtime#code-examples).
Invoque um agente.
```
def invoke_agent(self, agent_id, agent_alias_id, session_id, prompt):
"""
Sends a prompt for the agent to process and respond to.
:param agent_id: The unique identifier of the agent to use.
:param agent_alias_id: The alias of the agent to use.
:param session_id: The unique identifier of the session. Use the same value across requests
to continue the same conversation.
:param prompt: The prompt that you want Claude to complete.
:return: Inference response from the model.
"""
try:
# Note: The execution time depends on the foundation model, complexity of the agent,
# and the length of the prompt. In some cases, it can take up to a minute or more to
# generate a response.
response = self.agents_runtime_client.invoke_agent(
agentId=agent_id,
agentAliasId=agent_alias_id,
sessionId=session_id,
inputText=prompt,
)
completion = ""
for event in response.get("completion"):
chunk = event["chunk"]
completion = completion + chunk["bytes"].decode()
except ClientError as e:
logger.error(f"Couldn't invoke agent. {e}")
raise
return completion
```
+ Para obter detalhes da API, consulte a [InvokeAgent](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-runtime-2023-12-12/InvokeAgent)Referência da API *AWS SDK for Python (Boto3*).
------
#### [ Rust ]
**SDK para Rust**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/bedrock-agent-runtime#code-examples).
```
use aws_config::{BehaviorVersion, SdkConfig};
use aws_sdk_bedrockagentruntime::{
self as bedrockagentruntime,
types::{error::ResponseStreamError, ResponseStream},
};
#[allow(unused_imports)]
use mockall::automock;
const BEDROCK_AGENT_ID: &str = "AJBHXXILZN";
const BEDROCK_AGENT_ALIAS_ID: &str = "AVKP1ITZAA";
const BEDROCK_AGENT_REGION: &str = "us-east-1";
#[cfg(not(test))]
pub use EventReceiverImpl as EventReceiver;
#[cfg(test)]
pub use MockEventReceiverImpl as EventReceiver;
pub struct EventReceiverImpl {
inner: aws_sdk_bedrockagentruntime::primitives::event_stream::EventReceiver<
ResponseStream,
ResponseStreamError,
>,
}
#[cfg_attr(test, automock)]
impl EventReceiverImpl {
#[allow(dead_code)]
pub fn new(
inner: aws_sdk_bedrockagentruntime::primitives::event_stream::EventReceiver<
ResponseStream,
ResponseStreamError,
>,
) -> Self {
Self { inner }
}
pub async fn recv(
&mut self,
) -> Result<
Option,
aws_sdk_bedrockagentruntime::error::SdkError<
ResponseStreamError,
aws_smithy_types::event_stream::RawMessage,
>,
> {
self.inner.recv().await
}
}
#[tokio::main]
async fn main() -> Result<(), Box> {
let result = invoke_bedrock_agent("I need help.".to_string(), "123".to_string()).await?;
println!("{}", result);
Ok(())
}
async fn invoke_bedrock_agent(
prompt: String,
session_id: String,
) -> Result {
let sdk_config: SdkConfig = aws_config::defaults(BehaviorVersion::latest())
.region(BEDROCK_AGENT_REGION)
.load()
.await;
let bedrock_client = bedrockagentruntime::Client::new(&sdk_config);
let command_builder = bedrock_client
.invoke_agent()
.agent_id(BEDROCK_AGENT_ID)
.agent_alias_id(BEDROCK_AGENT_ALIAS_ID)
.session_id(session_id)
.input_text(prompt);
let response = command_builder.send().await?;
let response_stream = response.completion;
let event_receiver = EventReceiver::new(response_stream);
process_agent_response_stream(event_receiver).await
}
async fn process_agent_response_stream(
mut event_receiver: EventReceiver,
) -> Result {
let mut full_agent_text_response = String::new();
while let Some(event_result) = event_receiver.recv().await? {
match event_result {
ResponseStream::Chunk(chunk) => {
if let Some(bytes) = chunk.bytes {
match String::from_utf8(bytes.into_inner()) {
Ok(text_chunk) => {
full_agent_text_response.push_str(&text_chunk);
}
Err(e) => {
eprintln!("UTF-8 decoding error for chunk: {}", e);
}
}
}
}
_ => {
panic!("received an unhandled event type from Bedrock stream",);
}
}
}
Ok(full_agent_text_response)
}
#[cfg(test)]
mod test {
use super::*;
#[tokio::test]
async fn test_process_agent_response_stream() {
let mut mock = MockEventReceiverImpl::default();
mock.expect_recv().times(1).returning(|| {
Ok(Some(
aws_sdk_bedrockagentruntime::types::ResponseStream::Chunk(
aws_sdk_bedrockagentruntime::types::PayloadPart::builder()
.set_bytes(Some(aws_smithy_types::Blob::new(vec![
116, 101, 115, 116, 32, 99, 111, 109, 112, 108, 101, 116, 105, 111, 110,
])))
.build(),
),
))
});
// end the stream
mock.expect_recv().times(1).returning(|| Ok(None));
let response = process_agent_response_stream(mock).await.unwrap();
assert_eq!("test completion", response);
}
#[tokio::test]
#[should_panic(expected = "received an unhandled event type from Bedrock stream")]
async fn test_process_agent_response_stream_error() {
let mut mock = MockEventReceiverImpl::default();
mock.expect_recv().times(1).returning(|| {
Ok(Some(
aws_sdk_bedrockagentruntime::types::ResponseStream::Trace(
aws_sdk_bedrockagentruntime::types::TracePart::builder().build(),
),
))
});
let _ = process_agent_response_stream(mock).await.unwrap();
}
}
```
+ Para obter detalhes da API, consulte a [InvokeAgent](https://docs.rs/aws-sdk-bedrockagentruntime/latest/aws_sdk_bedrockagentruntime/client/struct.Client.html#method.invoke_agent)referência da *API AWS SDK for Rust*.
------
#### [ SAP ABAP ]
**SDK para SAP ABAP**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/bdz#code-examples).
```
DATA(lo_result) = lo_bdz->invokeagent(
iv_agentid = iv_agentid
iv_agentaliasid = iv_agentaliasid
iv_enabletrace = abap_true
iv_sessionid = CONV #( cl_system_uuid=>create_uuid_c26_static( ) )
iv_inputtext = |Let's play "rock, paper, scissors". I choose rock.| ).
DATA(lo_stream) = lo_result->get_completion( ).
TRY.
" loop while there are still events in the stream
WHILE lo_stream->/aws1/if_rt_stream_reader~data_available( ) = abap_true.
DATA(lo_evt) = lo_stream->read( ).
" each /AWS1/CL_BDZRESPONSESTREAM_EV event contains exactly one member
" all others are INITIAL. For each event, process the non-initial
" member if desired
IF lo_evt->get_chunk( ) IS NOT INITIAL.
" Process a Chunk event
DATA(lv_xstr) = lo_evt->get_chunk( )->get_bytes( ).
DATA(lv_answer) = /aws1/cl_rt_util=>xstring_to_string( lv_xstr ).
" the answer says something like "I chose paper, so you lost"
ELSEIF lo_evt->get_files( ) IS NOT INITIAL.
" process a Files event if desired
ELSEIF lo_evt->get_returncontrol( ) IS NOT INITIAL.
" process a ReturnControl event if desired
ELSEIF lo_evt->get_trace( ) IS NOT INITIAL.
" process a Trace event if desired
ENDIF.
ENDWHILE.
" the stream of events can possibly contain an exception
" which will be raised to break the loop
" catch /AWS1/CX_BDZACCESSDENIEDEX.
" catch /AWS1/CX_BDZINTERNALSERVEREX.
" catch /AWS1/CX_BDZMODELNOTREADYEX.
" catch /AWS1/CX_BDZVALIDATIONEX.
" catch /AWS1/CX_BDZTHROTTLINGEX.
" catch /AWS1/CX_BDZDEPENDENCYFAILEDEX.
" catch /AWS1/CX_BDZBADGATEWAYEX.
" catch /AWS1/CX_BDZRESOURCENOTFOUNDEX.
" catch /AWS1/CX_BDZSERVICEQUOTAEXCDEX.
" catch /AWS1/CX_BDZCONFLICTEXCEPTION.
ENDTRY.
```
+ Para obter detalhes da API, consulte a [InvokeAgent](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)referência da *API AWS SDK for SAP ABAP*.
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Use `InvokeFlow` com um AWS SDK
Os exemplos de código a seguir mostram como usar o `InvokeFlow`.
Exemplos de ações são trechos de código de programas maiores e devem ser executados em contexto. É possível ver essa ação em contexto nos seguintes exemplos de código:
+ [Conheça os conceitos básicos](bedrock-agent-runtime_example_bedrock-agent-runtime_Scenario_ConverseWithFlow_section.md)
+ [Criar e invocar um fluxo](bedrock-agent-runtime_example_bedrock-agent_GettingStartedWithBedrockFlows_section.md)
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-agent-runtime#code-examples).
```
import { fileURLToPath } from "node:url";
import {
BedrockAgentRuntimeClient,
InvokeFlowCommand,
} from "@aws-sdk/client-bedrock-agent-runtime";
/**
* Invokes an alias of a flow to run the inputs that you specify and return
* the output of each node as a stream.
*
* @param {{
* flowIdentifier: string,
* flowAliasIdentifier: string,
* prompt?: string,
* region?: string
* }} options
* @returns {Promise} An object containing information about the output from flow invocation.
*/
export const invokeBedrockFlow = async ({
flowIdentifier,
flowAliasIdentifier,
prompt = "Hi, how are you?",
region = "us-east-1",
}) => {
const client = new BedrockAgentRuntimeClient({ region });
const command = new InvokeFlowCommand({
flowIdentifier,
flowAliasIdentifier,
inputs: [
{
content: {
document: prompt,
},
nodeName: "FlowInputNode",
nodeOutputName: "document",
},
],
});
let flowResponse = {};
const response = await client.send(command);
for await (const chunkEvent of response.responseStream) {
const { flowOutputEvent, flowCompletionEvent } = chunkEvent;
if (flowOutputEvent) {
flowResponse = { ...flowResponse, ...flowOutputEvent };
console.log("Flow output event:", flowOutputEvent);
} else if (flowCompletionEvent) {
flowResponse = { ...flowResponse, ...flowCompletionEvent };
console.log("Flow completion event:", flowCompletionEvent);
}
}
return flowResponse;
};
// Call function if run directly
import { parseArgs } from "node:util";
import {
isMain,
validateArgs,
} from "@aws-doc-sdk-examples/lib/utils/util-node.js";
const loadArgs = () => {
const options = {
flowIdentifier: {
type: "string",
required: true,
},
flowAliasIdentifier: {
type: "string",
required: true,
},
prompt: {
type: "string",
},
region: {
type: "string",
},
};
const results = parseArgs({ options });
const { errors } = validateArgs({ options }, results);
return { errors, results };
};
if (isMain(import.meta.url)) {
const { errors, results } = loadArgs();
if (!errors) {
invokeBedrockFlow(results.values);
} else {
console.error(errors.join("\n"));
}
}
```
+ Para obter detalhes da API, consulte [InvokeFlow](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-agent-runtime/command/InvokeFlowCommand)a *Referência AWS SDK para JavaScript da API*.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent-runtime#code-examples).
Invoque um fluxo.
```
def invoke_flow(self, flow_id, flow_alias_id, input_data, execution_id):
"""
Invoke an Amazon Bedrock flow and handle the response stream.
Args:
param flow_id: The ID of the flow to invoke.
param flow_alias_id: The alias ID of the flow.
param input_data: Input data for the flow.
param execution_id: Execution ID for continuing a flow. Use the value None on first run.
Return: Response from the flow.
"""
try:
request_params = None
if execution_id is None:
# Don't pass execution ID for first run.
request_params = {
"flowIdentifier": flow_id,
"flowAliasIdentifier": flow_alias_id,
"inputs": input_data,
"enableTrace": True
}
else:
request_params = {
"flowIdentifier": flow_id,
"flowAliasIdentifier": flow_alias_id,
"executionId": execution_id,
"inputs": input_data,
"enableTrace": True
}
response = self.agents_runtime_client.invoke_flow(**request_params)
if "executionId" not in request_params:
execution_id = response['executionId']
result = ""
# Get the streaming response
for event in response['responseStream']:
result = result + str(event) + '\n'
print(result)
except ClientError as e:
logger.error("Couldn't invoke flow %s.", {e})
raise
return result
```
+ Para obter detalhes da API, consulte a [InvokeFlow](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-runtime-2023-12-12/InvokeFlow)Referência da API *AWS SDK for Python (Boto3*).
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Cenários para o Amazon Bedrock Agents Runtime usando AWS SDKs
Os exemplos de código a seguir mostram como implementar cenários comuns no Amazon Bedrock Agents Runtime com AWS SDKs. Esses cenários mostram como executar tarefas específicas chamando vários perfis no Amazon Bedrock Agents Runtime ou em conjunto com outros Serviços da AWS. Cada cenário inclui um link para o código-fonte completo, onde podem ser encontradas instruções sobre como configurar e executar o código.
Os cenários têm como alvo um nível intermediário de experiência para ajudar você a compreender ações de serviço em contexto.
**Topics**
+ [Criar e invocar um fluxo](bedrock-agent-runtime_example_bedrock-agent_GettingStartedWithBedrockFlows_section.md)
+ [Orquestrar aplicações de IA generativa com o Step Functions](bedrock-agent-runtime_example_cross_ServerlessPromptChaining_section.md)
# Um end-to-end exemplo mostrando como criar e invocar um fluxo do Amazon Bedrock usando um SDK AWS
O exemplo de código a seguir mostra como:
+ Criar um perfil de execução para o fluxo.
+ Criar o fluxo.
+ Implantar o fluxo totalmente configurado.
+ Invocar o fluxo com prompts fornecidos pelo usuário.
+ Excluir todos os recursos criados.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples).
Gera uma playlist de música com base no gênero e no número de músicas especificados pelo usuário.
```
from datetime import datetime
import logging
import boto3
from botocore.exceptions import ClientError
from roles import create_flow_role, delete_flow_role, update_role_policy
from flow import create_flow, prepare_flow, delete_flow
from run_flow import run_playlist_flow
from flow_version import create_flow_version, delete_flow_version
from flow_alias import create_flow_alias, delete_flow_alias
logging.basicConfig(
level=logging.INFO
)
logger = logging.getLogger(__name__)
def create_input_node(name):
"""
Creates an input node configuration for an Amazon Bedrock flow.
The input node serves as the entry point for the flow and defines
the initial document structure that will be passed to subsequent nodes.
Args:
name (str): The name of the input node.
Returns:
dict: The input node configuration.
"""
return {
"type": "Input",
"name": name,
"outputs": [
{
"name": "document",
"type": "Object"
}
]
}
def create_prompt_node(name, model_id):
"""
Creates a prompt node configuration for a Bedrock flow that generates music playlists.
The prompt node defines an inline prompt template that creates a music playlist based on
a specified genre and number of songs. The prompt uses two variables that are mapped from
the input JSON object:
- {{genre}}: The genre of music to create a playlist for
- {{number}}: The number of songs to include in the playlist
Args:
name (str): The name of the prompt node.
model_id (str): The identifier of the foundation model to use for the prompt.
Returns:
dict: The prompt node.
"""
return {
"type": "Prompt",
"name": name,
"configuration": {
"prompt": {
"sourceConfiguration": {
"inline": {
"modelId": model_id,
"templateType": "TEXT",
"inferenceConfiguration": {
"text": {
"temperature": 0.8
}
},
"templateConfiguration": {
"text": {
"text": "Make me a {{genre}} playlist consisting of the following number of songs: {{number}}."
}
}
}
}
}
},
"inputs": [
{
"name": "genre",
"type": "String",
"expression": "$.data.genre"
},
{
"name": "number",
"type": "Number",
"expression": "$.data.number"
}
],
"outputs": [
{
"name": "modelCompletion",
"type": "String"
}
]
}
def create_output_node(name):
"""
Creates an output node configuration for a Bedrock flow.
The output node validates that the output from the last node is a string
and returns it unmodified. The input name must be "document".
Args:
name (str): The name of the output node.
Returns:
dict: The output node configuration containing the output node:
"""
return {
"type": "Output",
"name": name,
"inputs": [
{
"name": "document",
"type": "String",
"expression": "$.data"
}
]
}
def create_playlist_flow(client, flow_name, flow_description, role_arn, prompt_model_id):
"""
Creates the playlist generator flow.
Args:
client: bedrock agent boto3 client.
role_arn (str): Name for the new IAM role.
prompt_model_id (str): The id of the model to use in the prompt node.
Returns:
dict: The response from the create_flow operation.
"""
input_node = create_input_node("FlowInput")
prompt_node = create_prompt_node("MakePlaylist", prompt_model_id)
output_node = create_output_node("FlowOutput")
# Create connections between the nodes
connections = []
# First, create connections between the output of the flow
# input node and each input of the prompt node.
for prompt_node_input in prompt_node["inputs"]:
connections.append(
{
"name": "_".join([input_node["name"], prompt_node["name"],
prompt_node_input["name"]]),
"source": input_node["name"],
"target": prompt_node["name"],
"type": "Data",
"configuration": {
"data": {
"sourceOutput": input_node["outputs"][0]["name"],
"targetInput": prompt_node_input["name"]
}
}
}
)
# Then, create a connection between the output of the prompt node and the input of the flow output node
connections.append(
{
"name": "_".join([prompt_node["name"], output_node["name"]]),
"source": prompt_node["name"],
"target": output_node["name"],
"type": "Data",
"configuration": {
"data": {
"sourceOutput": prompt_node["outputs"][0]["name"],
"targetInput": output_node["inputs"][0]["name"]
}
}
}
)
flow_def = {
"nodes": [input_node, prompt_node, output_node],
"connections": connections
}
# Create the flow.
response = create_flow(
client, flow_name, flow_description, role_arn, flow_def)
return response
def get_model_arn(client, model_id):
"""
Gets the Amazon Resource Name (ARN) for a model.
Args:
client (str): Amazon Bedrock boto3 client.
model_id (str): The id of the model.
Returns:
str: The ARN of the model.
"""
try:
# Call GetFoundationModelDetails operation
response = client.get_foundation_model(modelIdentifier=model_id)
# Extract model ARN from the response
model_arn = response['modelDetails']['modelArn']
return model_arn
except ClientError as e:
logger.exception("Client error getting model ARN: %s", {str(e)})
raise
except Exception as e:
logger.exception("Unexpected error getting model ARN: %s", {str(e)})
raise
def prepare_flow_version_and_alias(bedrock_agent_client,
flow_id):
"""
Prepares the flow and then creates a flow version and flow alias.
Args:
bedrock_agent_client: Amazon Bedrock Agent boto3 client.
flowd_id (str): The ID of the flow that you want to prepare.
Returns: The flow_version and flow_alias.
"""
status = prepare_flow(bedrock_agent_client, flow_id)
flow_version = None
flow_alias = None
if status == 'Prepared':
# Create the flow version and alias.
flow_version = create_flow_version(bedrock_agent_client,
flow_id,
f"flow version for flow {flow_id}.")
flow_alias = create_flow_alias(bedrock_agent_client,
flow_id,
flow_version,
"latest",
f"Alias for flow {flow_id}, version {flow_version}")
return flow_version, flow_alias
def delete_role_resources(bedrock_agent_client,
iam_client,
role_name,
flow_id,
flow_version,
flow_alias):
"""
Deletes the flow, flow alias, flow version, and IAM roles.
Args:
bedrock_agent_client: Amazon Bedrock Agent boto3 client.
iam_client: Amazon IAM boto3 client.
role_name (str): The name of the IAM role.
flow_id (str): The id of the flow.
flow_version (str): The version of the flow.
flow_alias (str): The alias of the flow.
"""
if flow_id is not None:
if flow_alias is not None:
delete_flow_alias(bedrock_agent_client, flow_id, flow_alias)
if flow_version is not None:
delete_flow_version(bedrock_agent_client,
flow_id, flow_version)
delete_flow(bedrock_agent_client, flow_id)
if role_name is not None:
delete_flow_role(iam_client, role_name)
def main():
"""
Creates, runs, and optionally deletes a Bedrock flow for generating music playlists.
Note:
Requires valid AWS credentials in the default profile
"""
delete_choice = "y"
try:
# Get various boto3 clients.
session = boto3.Session(profile_name='default')
bedrock_agent_runtime_client = session.client('bedrock-agent-runtime')
bedrock_agent_client = session.client('bedrock-agent')
bedrock_client = session.client('bedrock')
iam_client = session.client('iam')
role_name = None
flow_id = None
flow_version = None
flow_alias = None
#Change the model as needed.
prompt_model_id = "amazon.nova-pro-v1:0"
# Base the flow name on the current date and time
current_time = datetime.now()
timestamp = current_time.strftime("%Y-%m-%d-%H-%M-%S")
flow_name = f"FlowPlayList_{timestamp}"
flow_description = "A flow to generate a music playlist."
# Create a role for the flow.
role_name = f"BedrockFlowRole-{flow_name}"
role = create_flow_role(iam_client, role_name)
role_arn = role['Arn']
# Create the flow.
response = create_playlist_flow(
bedrock_agent_client, flow_name, flow_description, role_arn, prompt_model_id)
flow_id = response.get('id')
if flow_id:
# Update accessible resources in the role.
model_arn = get_model_arn(bedrock_client, prompt_model_id)
update_role_policy(iam_client, role_name, [
response.get('arn'), model_arn])
# Prepare the flow and flow version.
flow_version, flow_alias = prepare_flow_version_and_alias(
bedrock_agent_client, flow_id)
# Run the flow.
if flow_version and flow_alias:
run_playlist_flow(bedrock_agent_runtime_client,
flow_id, flow_alias)
delete_choice = input("Delete flow? y or n : ").lower()
else:
print("Couldn't run. Deleting flow and role.")
delete_flow(bedrock_agent_client, flow_id)
delete_flow_role(iam_client, role_name)
else:
print("Couldn't create flow.")
except Exception as e:
print(f"Fatal error: {str(e)}")
finally:
if delete_choice == 'y':
delete_role_resources(bedrock_agent_client,
iam_client,
role_name,
flow_id,
flow_version,
flow_alias)
else:
print("Flow not deleted. ")
print(f"\tFlow ID: {flow_id}")
print(f"\tFlow version: {flow_version}")
print(f"\tFlow alias: {flow_alias}")
print(f"\tRole ARN: {role_arn}")
print("Done!")
if __name__ == "__main__":
main()
def invoke_flow(client, flow_id, flow_alias_id, input_data):
"""
Invoke an Amazon Bedrock flow and handle the response stream.
Args:
client: Boto3 client for Amazon Bedrock agent runtime.
flow_id: The ID of the flow to invoke.
flow_alias_id: The alias ID of the flow.
input_data: Input data for the flow.
Returns:
Dict containing flow status and flow output.
"""
response = None
request_params = None
request_params = {
"flowIdentifier": flow_id,
"flowAliasIdentifier": flow_alias_id,
"inputs": [input_data],
"enableTrace": True
}
response = client.invoke_flow(**request_params)
flow_status = ""
output= ""
# Process the streaming response
for event in response['responseStream']:
# Check if flow is complete.
if 'flowCompletionEvent' in event:
flow_status = event['flowCompletionEvent']['completionReason']
# Save the model output.
elif 'flowOutputEvent' in event:
output = event['flowOutputEvent']['content']['document']
logger.info("Output : %s", output)
# Log trace events.
elif 'flowTraceEvent' in event:
logger.info("Flow trace: %s", event['flowTraceEvent'])
return {
"flow_status": flow_status,
"output": output
}
def run_playlist_flow(bedrock_agent_client, flow_id, flow_alias_id):
"""
Runs the playlist generator flow.
Args:
bedrock_agent_client: Boto3 client for Amazon Bedrock agent runtime.
flow_id: The ID of the flow to run.
flow_alias_id: The alias ID of the flow.
"""
print ("Welcome to the playlist generator flow.")
# Get the initial prompt from the user.
genre = input("Enter genre: ")
number_of_songs = int(input("Enter number of songs: "))
# Use prompt to create input data for the input node.
flow_input_data = {
"content": {
"document": {
"genre" : genre,
"number" : number_of_songs
}
},
"nodeName": "FlowInput",
"nodeOutputName": "document"
}
try:
result = invoke_flow(
bedrock_agent_client, flow_id, flow_alias_id, flow_input_data)
status = result['flow_status']
if status == "SUCCESS":
# The flow completed successfully.
logger.info("The flow %s successfully completed.", flow_id)
print(result['output'])
else:
logger.warning("Flow status: %s",status)
except ClientError as e:
print(f"Client error: {str(e)}")
logger.error("Client error: %s", {str(e)})
raise
except Exception as e:
logger.error("An error occurred: %s", {str(e)})
logger.error("Error type: %s", {type(e)})
raise
def create_flow_role(client, role_name):
"""
Creates an IAM role for Amazon Bedrock with permissions to run a flow.
Args:
role_name (str): Name for the new IAM role.
Returns:
str: The role Amazon Resource Name.
"""
# Trust relationship policy - allows Amazon Bedrock service to assume this role.
trust_policy = {
"Version":"2012-10-17",
"Statement": [{
"Effect": "Allow",
"Principal": {
"Service": "bedrock.amazonaws.com"
},
"Action": "sts:AssumeRole"
}]
}
# Basic inline policy for for running a flow.
resources = "*"
bedrock_policy = {
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"bedrock:InvokeModel",
"bedrock:Retrieve",
"bedrock:RetrieveAndGenerate"
],
# Using * as placeholder - Later you update with specific ARNs.
"Resource": resources
}
]
}
try:
# Create the IAM role with trust policy
logging.info("Creating role: %s",role_name)
role = client.create_role(
RoleName=role_name,
AssumeRolePolicyDocument=json.dumps(trust_policy),
Description="Role for Amazon Bedrock operations"
)
# Attach inline policy to the role
print("Attaching inline policy")
client.put_role_policy(
RoleName=role_name,
PolicyName=f"{role_name}-policy",
PolicyDocument=json.dumps(bedrock_policy)
)
logging.info("Create Role ARN: %s", role['Role']['Arn'])
return role['Role']
except ClientError as e:
logging.warning("Error creating role: %s", str(e))
raise
except Exception as e:
logging.warning("Unexpected error: %s", str(e))
raise
def update_role_policy(client, role_name, resource_arns):
"""
Updates an IAM role's inline policy with specific resource ARNs.
Args:
role_name (str): Name of the existing role.
resource_arns (list): List of resource ARNs to allow access to.
"""
updated_policy = {
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"bedrock:GetFlow",
"bedrock:InvokeModel",
"bedrock:Retrieve",
"bedrock:RetrieveAndGenerate"
],
"Resource": resource_arns
}
]
}
try:
client.put_role_policy(
RoleName=role_name,
PolicyName=f"{role_name}-policy",
PolicyDocument=json.dumps(updated_policy)
)
logging.info("Updated policy for role: %s",role_name)
except ClientError as e:
logging.warning("Error updating role policy: %s", str(e))
raise
def delete_flow_role(client, role_name):
"""
Deletes an IAM role.
Args:
role_name (str): Name of the role to delete.
"""
try:
# Detach and delete inline policies
policies = client.list_role_policies(RoleName=role_name)['PolicyNames']
for policy_name in policies:
client.delete_role_policy(RoleName=role_name, PolicyName=policy_name)
# Delete the role
client.delete_role(RoleName=role_name)
logging.info("Deleted role: %s", role_name)
except ClientError as e:
logging.info("Error Deleting role: %s", str(e))
raise
```
+ Para ver detalhes da API, consulte os tópicos a seguir na *Referência da API do SDK da AWS para Python (Boto3)*.
+ [CreateFlow](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/CreateFlow)
+ [CreateFlowAlias](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/CreateFlowAlias)
+ [CreateFlowVersion](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/CreateFlowVersion)
+ [DeleteFlow](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/DeleteFlow)
+ [DeleteFlowAlias](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/DeleteFlowAlias)
+ [DeleteFlowVersion](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/DeleteFlowVersion)
+ [GetFlow](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/GetFlow)
+ [GetFlowAlias](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/GetFlowAlias)
+ [GetFlowVersion](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/GetFlowVersion)
+ [InvokeFlow](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-runtime-2023-12-12/InvokeFlow)
+ [PrepareFlow](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/PrepareFlow)
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Construir e orquestrar aplicações de IA generativa com o Amazon Bedrock e o Step Functions
O exemplo de código a seguir mostra como criar e orquestrar aplicações de IA generativa com o Amazon Bedrock e o Step Functions.
------
#### [ Python ]
**SDK para Python (Boto3)**
O cenário de encadeamento de prompts do Amazon Bedrock Sem Servidor demonstra como o [AWS Step Functions](https://docs.aws.amazon.com/step-functions/latest/dg/welcome.html), o [Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html) e a documentação [https://docs.aws.amazon.com/bedrock/latest/userguide/agents.html](https://docs.aws.amazon.com/bedrock/latest/userguide/agents.html) podem ser usados para criar e orquestrar aplicações de IA generativa complexas, sem servidor e altamente escaláveis. Ele contém os seguintes exemplos de trabalho:
+ Escrever uma análise de um determinado romance para um blog de literatura. Este exemplo ilustra uma cadeia de prompts simples e sequencial.
+ Gerar uma história curta sobre um determinado tópico. Este exemplo ilustra como a IA pode processar uma lista de itens gerada anteriormente de forma iterativa.
+ Criar um itinerário para férias de fim de semana em um determinado destino. Este exemplo ilustra como paralelizar vários prompts distintos.
+ Lançar ideias de filmes para um usuário humano que atua como produtor de filmes. Este exemplo ilustra como paralelizar o mesmo prompt com diferentes parâmetros de inferência, como voltar a uma etapa anterior na cadeia e como incluir a entrada humana como parte do fluxo de trabalho.
+ Planejar uma refeição com base nos ingredientes que o usuário tem em mãos. Este exemplo ilustra como as cadeias de prompts podem incorporar duas conversas distintas de IA, com duas personas de IA participando de um debate entre si para melhorar o resultado final.
+ Encontre e resuma o repositório mais popular GitHub da atualidade. Este exemplo ilustra o encadeamento de vários agentes de IA que interagem com agentes externos. APIs
Para obter o código-fonte completo e as instruções de configuração e execução, consulte o projeto completo em [GitHub](https://github.com/aws-samples/amazon-bedrock-serverless-prompt-chaining).
**Serviços usados neste exemplo**
+ Amazon Bedrock
+ Amazon Bedrock Runtime
+ Amazon Bedrock Agents
+ Amazon Bedrock Agents Runtime
+ Step Functions
------
Para obter uma lista completa dos guias do desenvolvedor do AWS SDK e exemplos de código, consulte[Usando o Amazon Bedrock com um AWS SDK](sdk-general-information-section.md). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.