Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Codebeispiele für Amazon Bedrock mit AWS SDKs
Die folgenden Codebeispiele zeigen, wie Amazon Bedrock mit einem AWS Software Development Kit (SDK) verwendet wird.
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter[Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md). Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
**Contents**
+ [Amazon Bedrock](service_code_examples_bedrock.md)
+ [Grundlagen](service_code_examples_bedrock_basics.md)
+ [Hallo Amazon Bedrock](bedrock_example_bedrock_Hello_section.md)
+ [Aktionen](service_code_examples_bedrock_actions.md)
+ [`GetFoundationModel`](bedrock_example_bedrock_GetFoundationModel_section.md)
+ [`ListFoundationModels`](bedrock_example_bedrock_ListFoundationModels_section.md)
+ [Szenarien](service_code_examples_bedrock_scenarios.md)
+ [Orchestrieren von Anwendungen mit generativer KI mit Step Functions](bedrock_example_cross_ServerlessPromptChaining_section.md)
+ [Amazon Bedrock Runtime](service_code_examples_bedrock-runtime.md)
+ [Grundlagen](service_code_examples_bedrock-runtime_basics.md)
+ [Hallo Amazon Bedrock](bedrock-runtime_example_bedrock-runtime_Hello_section.md)
+ [Szenarien](service_code_examples_bedrock-runtime_scenarios.md)
+ [Erstellen einer Playground-Anwendung zur Interaktion mit Amazon-Bedrock-Basismodellen](bedrock-runtime_example_cross_FMPlayground_section.md)
+ [Erstellen und Aufrufen eines verwalteten Prompts](bedrock-runtime_example_bedrock-agent_GettingStartedWithBedrockPrompts_section.md)
+ [Generieren von Videos aus Text-Prompts mit Amazon Bedrock](bedrock-runtime_example_bedrock-runtime_Scenario_GenerateVideos_NovaReel_section.md)
+ [Aufrufen mehrerer Basismodelle in Amazon Bedrock](bedrock-runtime_example_bedrock-runtime_Scenario_InvokeModels_section.md)
+ [Orchestrieren von Anwendungen mit generativer KI mit Step Functions](bedrock-runtime_example_cross_ServerlessPromptChaining_section.md)
+ [Verwendung des Tools mit der Converse-API](bedrock-runtime_example_bedrock-runtime_Scenario_ToolUse_section.md)
+ [Amazon Nova](service_code_examples_bedrock-runtime_amazon_nova.md)
+ [Converse](bedrock-runtime_example_bedrock-runtime_Converse_AmazonNovaText_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_AmazonNovaText_section.md)
+ [Verstehen von Dokumenten](bedrock-runtime_example_bedrock-runtime_DocumentUnderstanding_AmazonNova_section.md)
+ [Szenario: Verwenden des Tools mit der Converse-API](bedrock-runtime_example_bedrock-runtime_Scenario_ToolUseDemo_AmazonNova_section.md)
+ [Amazon Nova Canvas](service_code_examples_bedrock-runtime_amazon_nova_canvas.md)
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_AmazonNovaImageGeneration_section.md)
+ [Amazon Nova Reel](service_code_examples_bedrock-runtime_amazon_nova_reel.md)
+ [T ext-to-video](bedrock-runtime_example_bedrock-runtime_Scenario_AmazonNova_TextToVideo_section.md)
+ [Amazon Titan Image Generator](service_code_examples_bedrock-runtime_amazon_titan_image_generator.md)
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_TitanImageGenerator_section.md)
+ [Amazon Titan Text](service_code_examples_bedrock-runtime_amazon_titan_text.md)
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_TitanText_section.md)
+ [Amazon Titan Text Embeddings](service_code_examples_bedrock-runtime_amazon_titan_text_embeddings.md)
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModelWithResponseStream_TitanTextEmbeddings_section.md)
+ [Anthropic Claude](service_code_examples_bedrock-runtime_anthropic_claude.md)
+ [Converse](bedrock-runtime_example_bedrock-runtime_Converse_AnthropicClaude_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_AnthropicClaude_section.md)
+ [Verstehen von Dokumenten](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)
+ [Argumentation mit einer Streamingantwort](bedrock-runtime_example_bedrock-runtime_ConverseStream_AnthropicClaudeReasoning_section.md)
+ [Szenario: Verwenden des Tools mit der Converse-API](bedrock-runtime_example_bedrock-runtime_Scenario_ToolUseDemo_AnthropicClaude_section.md)
+ [Cohere Command](service_code_examples_bedrock-runtime_cohere_command.md)
+ [Converse](bedrock-runtime_example_bedrock-runtime_Converse_CohereCommand_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_CohereCommand_section.md)
+ [Verstehen von Dokumenten](bedrock-runtime_example_bedrock-runtime_DocumentUnderstanding_CohereCommand_section.md)
+ [InvokeModel: Befehl R und R\$1](bedrock-runtime_example_bedrock-runtime_InvokeModel_CohereCommandR_section.md)
+ [InvokeModelWithResponseStream: Befehl R und R\$1](bedrock-runtime_example_bedrock-runtime_InvokeModelWithResponseStream_CohereCommandR_section.md)
+ [Szenario: Verwenden des Tools mit der Converse-API](bedrock-runtime_example_bedrock-runtime_Scenario_ToolUseDemo_CohereCommand_section.md)
+ [DeepSeek](service_code_examples_bedrock-runtime_deepseek.md)
+ [Verstehen von Dokumenten](bedrock-runtime_example_bedrock-runtime_DocumentUnderstanding_DeepSeek_section.md)
+ [Meta Llama](service_code_examples_bedrock-runtime_meta_llama.md)
+ [Converse](bedrock-runtime_example_bedrock-runtime_Converse_MetaLlama_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_MetaLlama_section.md)
+ [Verstehen von Dokumenten](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)
+ [Verstehen von Dokumenten](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)
+ [Stabile Diffusion](service_code_examples_bedrock-runtime_stable_diffusion.md)
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_StableDiffusion_section.md)
+ [Agenten für Amazon Bedrock](service_code_examples_bedrock-agent.md)
+ [Grundlagen](service_code_examples_bedrock-agent_basics.md)
+ [Hallo Agenten für Amazon Bedrock](bedrock-agent_example_bedrock-agent_Hello_section.md)
+ [Aktionen](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)
+ [Szenarien](service_code_examples_bedrock-agent_scenarios.md)
+ [Erstellen und Aufrufen eines Flows](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockFlows_section.md)
+ [Erstellen und Aufrufen eines verwalteten Prompts](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockPrompts_section.md)
+ [Erstellen und Aufrufen eines Agenten](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockAgents_section.md)
+ [Orchestrieren von Anwendungen mit generativer KI mit Step Functions](bedrock-agent_example_cross_ServerlessPromptChaining_section.md)
+ [Runtime der Agenten für Amazon Bedrock](service_code_examples_bedrock-agent-runtime.md)
+ [Grundlagen](service_code_examples_bedrock-agent-runtime_basics.md)
+ [Kennenlernen der Grundlagen](bedrock-agent-runtime_example_bedrock-agent-runtime_Scenario_ConverseWithFlow_section.md)
+ [Aktionen](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)
+ [Szenarien](service_code_examples_bedrock-agent-runtime_scenarios.md)
+ [Erstellen und Aufrufen eines Flows](bedrock-agent-runtime_example_bedrock-agent_GettingStartedWithBedrockFlows_section.md)
+ [Orchestrieren von Anwendungen mit generativer KI mit Step Functions](bedrock-agent-runtime_example_cross_ServerlessPromptChaining_section.md)
# Codebeispiele für Amazon Bedrock mit AWS SDKs
Die folgenden Codebeispiele zeigen, wie Amazon Bedrock mit einem AWS Software Development Kit (SDK) verwendet wird.
*Aktionen* sind Codeauszüge aus größeren Programmen und müssen im Kontext ausgeführt werden. Während Aktionen Ihnen zeigen, wie Sie einzelne Service-Funktionen aufrufen, können Sie Aktionen im Kontext der zugehörigen Szenarien anzeigen.
*Szenarien* sind Codebeispiele, die Ihnen zeigen, wie Sie bestimmte Aufgaben ausführen, indem Sie mehrere Funktionen innerhalb eines Service aufrufen oder mit anderen AWS-Services kombinieren.
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter[Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md). Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
**Contents**
+ [Grundlagen](service_code_examples_bedrock_basics.md)
+ [Hallo Amazon Bedrock](bedrock_example_bedrock_Hello_section.md)
+ [Aktionen](service_code_examples_bedrock_actions.md)
+ [`GetFoundationModel`](bedrock_example_bedrock_GetFoundationModel_section.md)
+ [`ListFoundationModels`](bedrock_example_bedrock_ListFoundationModels_section.md)
+ [Szenarien](service_code_examples_bedrock_scenarios.md)
+ [Orchestrieren von Anwendungen mit generativer KI mit Step Functions](bedrock_example_cross_ServerlessPromptChaining_section.md)
# Grundlegende Beispiele für die Verwendung von Amazon Bedrock AWS SDKs
Die folgenden Codebeispiele zeigen, wie Sie die Grundlagen von Amazon Bedrock mit AWS SDKs verwenden können.
**Contents**
+ [Hallo Amazon Bedrock](bedrock_example_bedrock_Hello_section.md)
+ [Aktionen](service_code_examples_bedrock_actions.md)
+ [`GetFoundationModel`](bedrock_example_bedrock_GetFoundationModel_section.md)
+ [`ListFoundationModels`](bedrock_example_bedrock_ListFoundationModels_section.md)
# Hallo Amazon Bedrock
Die folgenden Codebeispiele veranschaulichen die ersten Schritte mit Amazon Bedrock.
------
#### [ .NET ]
**SDK für .NET (v4)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Bedrock#code-examples) einrichten und ausführen.
```
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)}");
}
}
```
+ Einzelheiten zur API finden Sie [ListFoundationModels](https://docs.aws.amazon.com/goto/DotNetSDKV4/bedrock-2023-04-20/ListFoundationModels)in der *AWS SDK für .NET API-Referenz*.
------
#### [ Go ]
**SDK für Go V2**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/bedrock#code-examples) einrichten und ausführen.
```
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)
}
}
```
+ Einzelheiten zur API finden Sie [ListFoundationModels](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/bedrock#Client.ListFoundationModels)in der *AWS SDK für Go API-Referenz*.
------
#### [ JavaScript ]
**SDK für JavaScript (v3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock#code-examples) einrichten und ausführen.
```
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();
}
```
+ Einzelheiten zur API finden Sie [ListFoundationModels](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock/command/ListFoundationModelsCommand)in der *AWS SDK für JavaScript API-Referenz*.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock#code-examples) einrichten und ausführen.
```
"""
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()
```
+ Einzelheiten zur API finden Sie [ListFoundationModels](https://docs.aws.amazon.com/goto/boto3/bedrock-2023-04-20/ListFoundationModels)in *AWS SDK for Python (Boto3) API* Reference.
------
#### [ Swift ]
**SDK für Swift**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/bedrock#code-examples) einrichten und ausführen.
```
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)
}
}
}
```
+ Einzelheiten zur API finden Sie [ListFoundationModels](https://sdk.amazonaws.com/swift/api/awsbedrock/latest/documentation/awsbedrock/bedrockclient/listfoundationmodels(input:))in der *API-Referenz zum AWS SDK für Swift*.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter[Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md). Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Aktionen für die Verwendung von Amazon Bedrock AWS SDKs
Die folgenden Codebeispiele zeigen, wie Sie einzelne Amazon Bedrock-Aktionen mit AWS SDKs ausführen. Jedes Beispiel enthält einen Link zu GitHub, wo Sie Anweisungen zum Einrichten und Ausführen des Codes finden.
Diese Auszüge rufen die Amazon-Bedrock-API auf und sind Codeauszüge aus größeren Programmen, die im Kontext ausgeführt werden müssen. Sie können Aktionen im Kontext unter [Szenarien für die Verwendung von Amazon Bedrock AWS SDKs](service_code_examples_bedrock_scenarios.md) anzeigen.
Die folgenden Beispiele enthalten nur die am häufigsten verwendeten Aktionen. Eine vollständige Liste finden Sie in der [API-Referenz für Amazon Bedrock](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)
# Verwendung `GetFoundationModel` mit einem AWS SDK
Die folgenden Code-Beispiele zeigen, wie `GetFoundationModel` verwendet wird.
------
#### [ Java ]
**SDK für Java 2.x**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock#code-examples) einrichten und ausführen.
Erfahren Sie mehr über ein Basismodell mithilfe des synchronen Amazon-Bedrock-Clients.
```
/**
* 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);
}
}
```
Erfahren Sie mehr über ein Basismodell mithilfe des asynchronen Amazon-Bedrock-Clients.
```
/**
* 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);
}
}
```
+ Einzelheiten zur API finden Sie [GetFoundationModel](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-2023-04-20/GetFoundationModel)in der *AWS SDK for Java 2.x API-Referenz*.
------
#### [ JavaScript ]
**SDK für JavaScript (v3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock#code-examples) einrichten und ausführen.
Rufen Sie Details über ein Basismodell ab.
```
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);
}
```
+ Einzelheiten zur API finden Sie [GetFoundationModel](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock/command/GetFoundationModelCommand)in der *AWS SDK für JavaScript API-Referenz*.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock#code-examples) einrichten und ausführen.
Rufen Sie Details über ein Basismodell ab.
```
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
```
+ Einzelheiten zur API finden Sie [GetFoundationModel](https://docs.aws.amazon.com/goto/boto3/bedrock-2023-04-20/GetFoundationModel)in *AWS SDK for Python (Boto3) API* Reference.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter. [Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md) Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Verwendung `ListFoundationModels` mit einem AWS SDK
Die folgenden Code-Beispiele zeigen, wie `ListFoundationModels` verwendet wird.
------
#### [ .NET ]
**SDK für .NET (v4)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Bedrock#code-examples) einrichten und ausführen.
Auflisten der verfügbaren Bedrock-Basismodelle.
```
///
/// 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);
}
}
```
+ Einzelheiten zur API finden Sie [ListFoundationModels](https://docs.aws.amazon.com/goto/DotNetSDKV4/bedrock-2023-04-20/ListFoundationModels)in der *AWS SDK für .NET API-Referenz*.
------
#### [ Go ]
**SDK für Go V2**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/bedrock#code-examples) einrichten und ausführen.
Auflisten der verfügbaren Bedrock-Basismodelle.
```
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
}
```
+ Einzelheiten zur API finden Sie [ListFoundationModels](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/bedrock#Client.ListFoundationModels)in der *AWS SDK für Go API-Referenz*.
------
#### [ Java ]
**SDK für Java 2.x**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock#code-examples) einrichten und ausführen.
Listen Sie die verfügbaren Amazon-Bedrock-Basismodelle mithilfe des synchronen Amazon-Bedrock-Clients auf.
```
/**
* 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);
}
}
```
Listen Sie die verfügbaren Amazon-Bedrock-Basismodelle mithilfe des Amazon-Bedrock-Clients auf.
```
/**
* 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);
}
}
```
+ Einzelheiten zur API finden Sie [ListFoundationModels](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-2023-04-20/ListFoundationModels)in der *AWS SDK for Java 2.x API-Referenz*.
------
#### [ JavaScript ]
**SDK für JavaScript (v3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock#code-examples) einrichten und ausführen.
Listen Sie die verfügbaren Basismodelle auf.
```
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);
}
```
+ Einzelheiten zur API finden Sie [ListFoundationModels](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock/command/ListFoundationModelsCommand)in der *AWS SDK für JavaScript API-Referenz*.
------
#### [ Kotlin ]
**SDK für Kotlin**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/bedrock#code-examples) einrichten und ausführen.
Auflisten der verfügbaren Amazon-Bedrock-Basismodelle.
```
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
}
}
```
+ Einzelheiten zur API finden Sie [ListFoundationModels](https://sdk.amazonaws.com/kotlin/api/latest/index.html)in der *API-Referenz zum AWS SDK für Kotlin*.
------
#### [ PHP ]
**SDK für PHP**
Es gibt noch mehr dazu. GitHub Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/bedrock#code-examples) einrichten und ausführen.
Auflisten der verfügbaren Amazon-Bedrock-Basismodelle.
```
public function listFoundationModels()
{
$bedrockClient = new BedrockClient([
'region' => 'us-west-2',
'profile' => 'default'
]);
$response = $bedrockClient->listFoundationModels();
return $response['modelSummaries'];
}
```
+ Einzelheiten zur API finden Sie [ListFoundationModels](https://docs.aws.amazon.com/goto/SdkForPHPV3/bedrock-2023-04-20/ListFoundationModels)in der *AWS SDK für PHP API-Referenz*.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock#code-examples) einrichten und ausführen.
Auflisten der verfügbaren Amazon-Bedrock-Basismodelle.
```
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
```
+ Einzelheiten zur API finden Sie [ListFoundationModels](https://docs.aws.amazon.com/goto/boto3/bedrock-2023-04-20/ListFoundationModels)in *AWS SDK for Python (Boto3) API* Reference.
------
#### [ Swift ]
**SDK für Swift**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/bedrock#code-examples) einrichten und ausführen.
```
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")
}
```
+ Einzelheiten zur API finden Sie [ListFoundationModels](https://sdk.amazonaws.com/swift/api/awsbedrock/latest/documentation/awsbedrock/bedrockclient/listfoundationmodels(input:))in der *API-Referenz zum AWS SDK für Swift*.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter[Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md). Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Szenarien für die Verwendung von Amazon Bedrock AWS SDKs
Die folgenden Codebeispiele zeigen Ihnen, wie Sie gängige Szenarien in Amazon Bedrock mit AWS SDKs implementieren. Diese Szenarien zeigen Ihnen, wie Sie bestimmte Aufgaben durch den Aufruf mehrerer Funktionen innerhalb von Amazon Bedrock oder in Kombination mit anderen AWS-Services ausführen können. Jedes Szenario enthält einen Link zum vollständigen Quell-Code, wo Sie Anleitungen zum Einrichten und Ausführen des Codes finden.
Szenarien zielen auf eine mittlere Erfahrungsebene ab, um Ihnen zu helfen, Service-Aktionen im Kontext zu verstehen.
**Topics**
+ [Orchestrieren von Anwendungen mit generativer KI mit Step Functions](bedrock_example_cross_ServerlessPromptChaining_section.md)
# Erstellen und Orchestrieren von Anwendungen mit generativer KI mit Amazon Bedrock und Step Functions
Im folgenden Codebeispiel wird gezeigt, wie Anwendungen mit generativer KI mit Amazon Bedrock und Step Functions erstellt und orchestriert werden.
------
#### [ Python ]
**SDK für Python (Boto3)**
Das Szenario „Amazon Bedrock Serverless Prompt Chaining” zeigt, wie [AWS Step Functions](https://docs.aws.amazon.com/step-functions/latest/dg/welcome.html), [Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html) und [https://docs.aws.amazon.com/bedrock/latest/userguide/agents.html](https://docs.aws.amazon.com/bedrock/latest/userguide/agents.html) zum Erstellen und Orchestrieren komplexer und hoch skalierbarer Serverless-Anwendungen mit generativer KI verwendet werden können. Es enthält die folgenden praktischen Beispiele:
+ Verfassen einer Analyse eines bestimmten Romans für einen Literaturblog. Dieses Beispiel veranschaulicht eine einfache, sequentielle Kette von Prompts.
+ Generieren einer Kurzgeschichte zu einem bestimmten Thema. Dieses Beispiel veranschaulicht, wie die KI eine Liste von zuvor generierten Elementen iterativ verarbeiten kann.
+ Erstellen eines Reiseplans für einen Wochenendurlaub an einem bestimmten Zielort. Dieses Beispiel veranschaulicht, wie mehrere unterschiedliche Prompts parallelisiert werden können.
+ Präsentieren von Filmideen für einen menschlichen Benutzer, der als Filmproduzent fungiert. Dieses Beispiel zeigt, wie derselbe Prompt mit unterschiedlichen Inferenzparametern parallelisiert wird, wie man zu einem vorherigen Schritt in der Kette zurückkehrt und wie menschliche Eingaben in den Workflow einbezogen werden können.
+ Planen einer Mahlzeit auf Grundlage der Zutaten, die der Benutzer zur Hand hat. Dieses Beispiel zeigt, wie Prompt-Chains zwei unterschiedliche KI-Konversationen beinhalten können, bei denen zwei KI-Personas miteinander debattieren, um das Endergebnis zu verbessern.
+ Finden Sie das Repository mit den meisten Trends GitHub von heute und fassen Sie es zusammen. Dieses Beispiel veranschaulicht die Verkettung mehrerer KI-Agenten, die mit externen Agenten interagieren. APIs
Den vollständigen Quellcode und Anweisungen zur Einrichtung und Ausführung finden Sie im vollständigen Projekt unter [GitHub](https://github.com/aws-samples/amazon-bedrock-serverless-prompt-chaining).
**In diesem Beispiel verwendete Dienste**
+ Amazon Bedrock
+ Amazon Bedrock Runtime
+ Agenten für Amazon Bedrock
+ Runtime der Agenten für Amazon Bedrock
+ Step Functions
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter[Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md). Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Codebeispiele für Amazon Bedrock Runtime mit AWS SDKs
Die folgenden Codebeispiele zeigen, wie Amazon Bedrock Runtime mit einem AWS Software Development Kit (SDK) verwendet wird.
*Szenarien* sind Codebeispiele, die Ihnen zeigen, wie Sie bestimmte Aufgaben ausführen, indem Sie mehrere Funktionen innerhalb eines Service aufrufen oder mit anderen AWS-Services kombinieren.
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter[Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md). Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
**Contents**
+ [Grundlagen](service_code_examples_bedrock-runtime_basics.md)
+ [Hallo Amazon Bedrock](bedrock-runtime_example_bedrock-runtime_Hello_section.md)
+ [Szenarien](service_code_examples_bedrock-runtime_scenarios.md)
+ [Erstellen einer Playground-Anwendung zur Interaktion mit Amazon-Bedrock-Basismodellen](bedrock-runtime_example_cross_FMPlayground_section.md)
+ [Erstellen und Aufrufen eines verwalteten Prompts](bedrock-runtime_example_bedrock-agent_GettingStartedWithBedrockPrompts_section.md)
+ [Generieren von Videos aus Text-Prompts mit Amazon Bedrock](bedrock-runtime_example_bedrock-runtime_Scenario_GenerateVideos_NovaReel_section.md)
+ [Aufrufen mehrerer Basismodelle in Amazon Bedrock](bedrock-runtime_example_bedrock-runtime_Scenario_InvokeModels_section.md)
+ [Orchestrieren von Anwendungen mit generativer KI mit Step Functions](bedrock-runtime_example_cross_ServerlessPromptChaining_section.md)
+ [Verwendung des Tools mit der Converse-API](bedrock-runtime_example_bedrock-runtime_Scenario_ToolUse_section.md)
+ [Amazon Nova](service_code_examples_bedrock-runtime_amazon_nova.md)
+ [Converse](bedrock-runtime_example_bedrock-runtime_Converse_AmazonNovaText_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_AmazonNovaText_section.md)
+ [Verstehen von Dokumenten](bedrock-runtime_example_bedrock-runtime_DocumentUnderstanding_AmazonNova_section.md)
+ [Szenario: Verwenden des Tools mit der Converse-API](bedrock-runtime_example_bedrock-runtime_Scenario_ToolUseDemo_AmazonNova_section.md)
+ [Amazon Nova Canvas](service_code_examples_bedrock-runtime_amazon_nova_canvas.md)
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_AmazonNovaImageGeneration_section.md)
+ [Amazon Nova Reel](service_code_examples_bedrock-runtime_amazon_nova_reel.md)
+ [T ext-to-video](bedrock-runtime_example_bedrock-runtime_Scenario_AmazonNova_TextToVideo_section.md)
+ [Amazon Titan Image Generator](service_code_examples_bedrock-runtime_amazon_titan_image_generator.md)
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_TitanImageGenerator_section.md)
+ [Amazon Titan Text](service_code_examples_bedrock-runtime_amazon_titan_text.md)
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_TitanText_section.md)
+ [Amazon Titan Text Embeddings](service_code_examples_bedrock-runtime_amazon_titan_text_embeddings.md)
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModelWithResponseStream_TitanTextEmbeddings_section.md)
+ [Anthropic Claude](service_code_examples_bedrock-runtime_anthropic_claude.md)
+ [Converse](bedrock-runtime_example_bedrock-runtime_Converse_AnthropicClaude_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_AnthropicClaude_section.md)
+ [Verstehen von Dokumenten](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)
+ [Argumentation mit einer Streamingantwort](bedrock-runtime_example_bedrock-runtime_ConverseStream_AnthropicClaudeReasoning_section.md)
+ [Szenario: Verwenden des Tools mit der Converse-API](bedrock-runtime_example_bedrock-runtime_Scenario_ToolUseDemo_AnthropicClaude_section.md)
+ [Cohere Command](service_code_examples_bedrock-runtime_cohere_command.md)
+ [Converse](bedrock-runtime_example_bedrock-runtime_Converse_CohereCommand_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_CohereCommand_section.md)
+ [Verstehen von Dokumenten](bedrock-runtime_example_bedrock-runtime_DocumentUnderstanding_CohereCommand_section.md)
+ [InvokeModel: Befehl R und R\$1](bedrock-runtime_example_bedrock-runtime_InvokeModel_CohereCommandR_section.md)
+ [InvokeModelWithResponseStream: Befehl R und R\$1](bedrock-runtime_example_bedrock-runtime_InvokeModelWithResponseStream_CohereCommandR_section.md)
+ [Szenario: Verwenden des Tools mit der Converse-API](bedrock-runtime_example_bedrock-runtime_Scenario_ToolUseDemo_CohereCommand_section.md)
+ [DeepSeek](service_code_examples_bedrock-runtime_deepseek.md)
+ [Verstehen von Dokumenten](bedrock-runtime_example_bedrock-runtime_DocumentUnderstanding_DeepSeek_section.md)
+ [Meta Llama](service_code_examples_bedrock-runtime_meta_llama.md)
+ [Converse](bedrock-runtime_example_bedrock-runtime_Converse_MetaLlama_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_MetaLlama_section.md)
+ [Verstehen von Dokumenten](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)
+ [Verstehen von Dokumenten](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)
+ [Stabile Diffusion](service_code_examples_bedrock-runtime_stable_diffusion.md)
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_StableDiffusion_section.md)
# Grundlegende Beispiele für die Verwendung von Amazon Bedrock Runtime AWS SDKs
Die folgenden Codebeispiele zeigen, wie Sie die Grundlagen von Amazon Bedrock Runtime mit AWS SDKs verwenden können.
**Contents**
+ [Hallo Amazon Bedrock](bedrock-runtime_example_bedrock-runtime_Hello_section.md)
# Hallo Amazon Bedrock
Die folgenden Codebeispiele veranschaulichen die ersten Schritte mit Amazon Bedrock.
------
#### [ Go ]
**SDK für Go V2**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/bedrock-runtime#code-examples) einrichten und ausführen.
```
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)
}
```
+ Einzelheiten zur API finden Sie [InvokeModel](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/bedrockruntime#Client.InvokeModel)in der *AWS SDK für Go API-Referenz*.
------
#### [ JavaScript ]
**SDK für JavaScript (v3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
```
/**
* @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();
}
```
+ Einzelheiten zur API finden Sie [InvokeModel](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/InvokeModelCommand)in der *AWS SDK für JavaScript API-Referenz*.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter[Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md). Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Szenarien für die Verwendung von Amazon Bedrock Runtime AWS SDKs
Die folgenden Codebeispiele zeigen Ihnen, wie Sie allgemeine Szenarien in Amazon Bedrock Runtime mit AWS SDKs implementieren. Diese Szenarien zeigen Ihnen, wie Sie bestimmte Aufgaben durch den Aufruf mehrerer Funktionen innerhalb von Amazon Bedrock Runtime oder in Kombination mit anderen AWS-Services ausführen können. Jedes Szenario enthält einen Link zum vollständigen Quell-Code, wo Sie Anleitungen zum Einrichten und Ausführen des Codes finden.
Szenarien zielen auf eine mittlere Erfahrungsebene ab, um Ihnen zu helfen, Service-Aktionen im Kontext zu verstehen.
**Topics**
+ [Erstellen einer Playground-Anwendung zur Interaktion mit Amazon-Bedrock-Basismodellen](bedrock-runtime_example_cross_FMPlayground_section.md)
+ [Erstellen und Aufrufen eines verwalteten Prompts](bedrock-runtime_example_bedrock-agent_GettingStartedWithBedrockPrompts_section.md)
+ [Generieren von Videos aus Text-Prompts mit Amazon Bedrock](bedrock-runtime_example_bedrock-runtime_Scenario_GenerateVideos_NovaReel_section.md)
+ [Aufrufen mehrerer Basismodelle in Amazon Bedrock](bedrock-runtime_example_bedrock-runtime_Scenario_InvokeModels_section.md)
+ [Orchestrieren von Anwendungen mit generativer KI mit Step Functions](bedrock-runtime_example_cross_ServerlessPromptChaining_section.md)
+ [Verwendung des Tools mit der Converse-API](bedrock-runtime_example_bedrock-runtime_Scenario_ToolUse_section.md)
# Erstellen Sie eine Beispielanwendung, die Spielplätze für die Interaktion mit Amazon Bedrock Foundation-Modellen mithilfe eines SDK bietet AWS
Die folgenden Codebeispiele zeigen, wie Sie Playgrounds erstellen können, um über verschiedene Modalitäten mit Amazon-Bedrock-Basismodellen zu interagieren.
------
#### [ .NET ]
**SDK für .NET**
.NET Basismodell (FM) Playground ist eine .NET MAUI Blazor-Beispielanwendung, die zeigt, wie Amazon Bedrock aus C\$1-Code verwendet werden kann. Dieses Beispiel veranschaulicht, wie .NET- und C\$1-Entwickler Amazon Bedrock zur Erstellung von Anwendungen mit generativer KI nutzen können. Sie können die Amazon-Bedrock-Basismodelle mithilfe der folgenden vier Playgrounds testen und mit ihnen interagieren:
+ Ein Text-Playground.
+ Ein Chat-Playground.
+ Ein Voice-Chat-Playground.
+ Ein Image-Playground.
In diesem Beispiel werden zudem die Basismodelle, auf die Sie Zugriff haben, sowie deren Eigenschaften aufgelistet und angezeigt. Den Quellcode und Anweisungen zur Bereitstellung finden Sie im Projekt unter [GitHub](https://github.com/build-on-aws/dotnet-fm-playground).
**In diesem Beispiel verwendete Dienste**
+ Amazon Bedrock Runtime
------
#### [ Java ]
**SDK für Java 2.x**
Der Java Foundation Model (FM) Playground ist eine Spring-Boot-Beispielanwendung, die zeigt, wie Amazon Bedrock mit Java verwendet wird. Dieses Beispiel zeigt, wie Java-Entwickler Amazon Bedrock verwenden können, um durch generative KI gestützte Anwendungen zu erstellen. Sie können die Amazon-Bedrock-Basismodelle in den folgenden drei Playgrounds testen und mit ihnen interagieren:
+ Ein Text-Playground.
+ Ein Chat-Playground.
+ Ein Image-Playground.
In diesem Beispiel werden zudem die Basismodelle, auf die Sie Zugriff haben, sowie deren Eigenschaften aufgelistet und angezeigt. Den Quellcode und Anweisungen zur Bereitstellung finden Sie im Projekt unter [GitHub](https://github.com/build-on-aws/java-fm-playground).
**In diesem Beispiel verwendete Dienste**
+ Amazon Bedrock Runtime
------
#### [ Python ]
**SDK für Python (Boto3)**
Der Python Foundation Model (FM) Playground ist eine Python/FastAPI Beispielanwendung, die zeigt, wie Amazon Bedrock mit Python verwendet wird. Dieses Beispiel zeigt, wie Python-Entwickler Amazon Bedrock verwenden können, um durch generative KI gestützte Anwendungen zu erstellen. Sie können die Amazon-Bedrock-Basismodelle in den folgenden drei Playgrounds testen und mit ihnen interagieren:
+ Ein Text-Playground.
+ Ein Chat-Playground.
+ Ein Image-Playground.
In diesem Beispiel werden zudem die Basismodelle, auf die Sie Zugriff haben, sowie deren Eigenschaften aufgelistet und angezeigt. Quellcode und Anweisungen zur Bereitstellung finden Sie im Projekt unter. [GitHub](https://github.com/build-on-aws/python-fm-playground)
**In diesem Beispiel verwendete Dienste**
+ Amazon Bedrock Runtime
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter[Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md). Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Ein end-to-end Beispiel, das zeigt, wie verwaltete Amazon Bedrock-Eingabeaufforderungen mithilfe eines SDK erstellt und aufgerufen werden AWS
Wie das aussehen kann, sehen Sie am nachfolgenden Beispielcode:
+ Erstellen eines verwalteten Prompts.
+ Erstellen einer Version des Prompts.
+ Aufrufen des Prompts mithilfe der Version.
+ Bereinigen der Ressourcen (optional).
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples) einrichten und ausführen.
Erstellen und Aufrufen eines verwalteten Prompts.
```
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()
```
+ Weitere API-Informationen finden Sie in den folgenden Themen der *API-Referenz zum AWS SDK für 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)
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter[Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md). Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Generieren von Videos aus Text-Prompts mit Amazon Bedrock und Nova-Reel
Das folgende Codebeispiel veranschaulicht, wie eine Spring-Boot-Anwendung Videos aus Text-Prompts unter Verwendung von Amazon Bedrock und dem Nova-Reel-Modell generiert.
------
#### [ Java ]
**SDK für Java 2.x**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Generieren Sie Videos aus Text-Prompts mit Amazon Bedrock und 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;
}
}
```
+ Weitere API-Informationen finden Sie in den folgenden Themen der *AWS SDK for Java 2.x -API-Referenz*.
+ [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)
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter[Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md). Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Aufrufen mehrerer Basismodelle in Amazon Bedrock
Die folgenden Codebeispiele zeigen, wie Sie eine Aufforderung vorbereiten und an eine Vielzahl von großsprachigen Modellen (LLMs) auf Amazon Bedrock senden.
------
#### [ Go ]
**SDK für Go V2**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/bedrock-runtime#code-examples) einrichten und ausführen.
Rufen Sie mehrere Basismodelle in Amazon Bedrock auf.
```
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)
}
```
+ Weitere API-Informationen finden Sie in den folgenden Themen der *AWS SDK für Go -API-Referenz*.
+ [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 für JavaScript (v3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
```
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();
}
```
+ Weitere API-Informationen finden Sie in den folgenden Themen der *AWS SDK für JavaScript -API-Referenz*.
+ [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 für PHP**
Es gibt noch mehr GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/bedrock-runtime/#code-examples) einrichten und ausführen.
Rufen Sie mehrere LLMs auf Amazon Bedrock auf.
```
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;
}
}
```
+ Weitere API-Informationen finden Sie in den folgenden Themen der *AWS SDK für PHP -API-Referenz*.
+ [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)
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter. [Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md) Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Erstellen und Orchestrieren von Anwendungen mit generativer KI mit Amazon Bedrock und Step Functions
Im folgenden Codebeispiel wird gezeigt, wie Anwendungen mit generativer KI mit Amazon Bedrock und Step Functions erstellt und orchestriert werden.
------
#### [ Python ]
**SDK für Python (Boto3)**
Das Szenario „Amazon Bedrock Serverless Prompt Chaining” zeigt, wie [AWS Step Functions](https://docs.aws.amazon.com/step-functions/latest/dg/welcome.html), [Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html) und [https://docs.aws.amazon.com/bedrock/latest/userguide/agents.html](https://docs.aws.amazon.com/bedrock/latest/userguide/agents.html) zum Erstellen und Orchestrieren komplexer und hoch skalierbarer Serverless-Anwendungen mit generativer KI verwendet werden können. Es enthält die folgenden praktischen Beispiele:
+ Verfassen einer Analyse eines bestimmten Romans für einen Literaturblog. Dieses Beispiel veranschaulicht eine einfache, sequentielle Kette von Prompts.
+ Generieren einer Kurzgeschichte zu einem bestimmten Thema. Dieses Beispiel veranschaulicht, wie die KI eine Liste von zuvor generierten Elementen iterativ verarbeiten kann.
+ Erstellen eines Reiseplans für einen Wochenendurlaub an einem bestimmten Zielort. Dieses Beispiel veranschaulicht, wie mehrere unterschiedliche Prompts parallelisiert werden können.
+ Präsentieren von Filmideen für einen menschlichen Benutzer, der als Filmproduzent fungiert. Dieses Beispiel zeigt, wie derselbe Prompt mit unterschiedlichen Inferenzparametern parallelisiert wird, wie man zu einem vorherigen Schritt in der Kette zurückkehrt und wie menschliche Eingaben in den Workflow einbezogen werden können.
+ Planen einer Mahlzeit auf Grundlage der Zutaten, die der Benutzer zur Hand hat. Dieses Beispiel zeigt, wie Prompt-Chains zwei unterschiedliche KI-Konversationen beinhalten können, bei denen zwei KI-Personas miteinander debattieren, um das Endergebnis zu verbessern.
+ Finden Sie das Repository mit den meisten Trends GitHub von heute und fassen Sie es zusammen. Dieses Beispiel veranschaulicht die Verkettung mehrerer KI-Agenten, die mit externen Agenten interagieren. APIs
Den vollständigen Quellcode und Anweisungen zur Einrichtung und Ausführung finden Sie im vollständigen Projekt unter [GitHub](https://github.com/aws-samples/amazon-bedrock-serverless-prompt-chaining).
**In diesem Beispiel verwendete Dienste**
+ Amazon Bedrock
+ Amazon Bedrock Runtime
+ Agenten für Amazon Bedrock
+ Runtime der Agenten für Amazon Bedrock
+ Step Functions
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter[Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md). Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Ein Anwendungsbeispiel, das veranschaulicht, wie KI-Modelle in Amazon Bedrock mit einem benutzerdefinierten Tool oder einer API verbunden werden können
Die folgenden Codebeispiele zeigen, wie eine typische Interaktion zwischen einer Anwendung, einem generativen KI-Modell und verbundenen Tools aufgebaut oder APIs Interaktionen zwischen der KI und der Außenwelt vermittelt werden. Es wird das Beispiel der Verbindung einer externen Wetter-API mit dem KI-Modell verwendet, damit dieses auf Grundlage der Eingaben des Benutzenden Wetterinformationen in Echtzeit bereitstellen kann.
------
#### [ .NET ]
**SDK für .NET**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime/Scenarios/ConverseToolScenario#code-examples) einrichten und ausführen.
Die primäre Ausführung des Szenarioablaufs. Dieses Szenario orchestriert die Kommunikation zwischen dem Benutzer, der Converse-API von Amazon Bedrock und einem Wettertool.
```
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();
}
}
```
Das in der Demo verwendete Wettertool. Diese Datei definiert die Tool-Spezifikation und implementiert die Logik zum Abrufen von Wetterdaten über die Open-Meteo-API.
```
using Amazon.BedrockRuntime.Model;
using Amazon.Runtime.Documents;
using Microsoft.Extensions.Logging;
namespace ConverseToolScenario;
///
/// Weather tool that will be invoked when requested by the Bedrock response.
///
public class WeatherTool
{
private readonly ILogger _logger;
private readonly IHttpClientFactory _httpClientFactory;
public WeatherTool(ILogger logger, IHttpClientFactory httpClientFactory)
{
_logger = logger;
_httpClientFactory = httpClientFactory;
}
///
/// Returns the JSON Schema specification for the Weather tool. The tool specification
/// defines the input schema and describes the tool's functionality.
/// For more information, see https://json-schema.org/understanding-json-schema/reference.
///
/// The tool specification for the Weather tool.
public ToolSpecification GetToolSpec()
{
ToolSpecification toolSpecification = new ToolSpecification();
toolSpecification.Name = "Weather_Tool";
toolSpecification.Description = "Get the current weather for a given location, based on its WGS84 coordinates.";
Document toolSpecDocument = Document.FromObject(
new
{
type = "object",
properties = new
{
latitude = new
{
type = "string",
description = "Geographical WGS84 latitude of the location."
},
longitude = new
{
type = "string",
description = "Geographical WGS84 longitude of the location."
}
},
required = new[] { "latitude", "longitude" }
});
toolSpecification.InputSchema = new ToolInputSchema() { Json = toolSpecDocument };
return toolSpecification;
}
///
/// Fetches weather data for the given latitude and longitude using the Open-Meteo API.
/// Returns the weather data or an error message if the request fails.
///
/// The latitude of the location.
/// The longitude of the location.
/// The weather data or an error message.
public async Task FetchWeatherDataAsync(string latitude, string longitude)
{
string endpoint = "https://api.open-meteo.com/v1/forecast";
try
{
var httpClient = _httpClientFactory.CreateClient();
var response = await httpClient.GetAsync($"{endpoint}?latitude={latitude}&longitude={longitude}¤t_weather=True");
response.EnsureSuccessStatusCode();
var weatherData = await response.Content.ReadAsStringAsync();
Document weatherDocument = Document.FromObject(
new { weather_data = weatherData });
return weatherDocument;
}
catch (HttpRequestException e)
{
_logger.LogError(e, "Error fetching weather data: {Message}", e.Message);
throw;
}
catch (Exception e)
{
_logger.LogError(e, "Unexpected error fetching weather data: {Message}", e.Message);
throw;
}
}
}
```
Die Converse-API-Aktion mit einer Toolkonfiguration.
```
///
/// 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;
}
}
}
```
+ Details zur API finden Sie unter [Converse](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/Converse) in der *AWS SDK für .NET -API-Referenz*.
------
#### [ Java ]
**SDK für Java 2.x**
Es gibt noch mehr GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Die primäre Ausführung des Szenarioablaufs. Dieses Szenario orchestriert die Kommunikation zwischen dem Benutzer, der Converse-API von Amazon Bedrock und einem Wettertool.
```
/*
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
=================================================
""");
}
}
```
Das in der Demo verwendete Wettertool. Diese Datei definiert die Tool-Spezifikation und implementiert die Logik zum Abrufen von Wetterdaten über die Open-Meteo-API.
```
public class WeatherTool {
private static final Logger logger = LoggerFactory.getLogger(WeatherTool.class);
private static java.net.http.HttpClient httpClient = null;
/**
* Returns the JSON Schema specification for the Weather tool. The tool specification
* defines the input schema and describes the tool's functionality.
* For more information, see https://json-schema.org/understanding-json-schema/reference.
*
* @return The tool specification for the Weather tool.
*/
public ToolSpecification getToolSpec() {
Map latitudeMap = new HashMap<>();
latitudeMap.put("type", Document.fromString("string"));
latitudeMap.put("description", Document.fromString("Geographical WGS84 latitude of the location."));
// Create the nested "longitude" object
Map longitudeMap = new HashMap<>();
longitudeMap.put("type", Document.fromString("string"));
longitudeMap.put("description", Document.fromString("Geographical WGS84 longitude of the location."));
// Create the "properties" object
Map propertiesMap = new HashMap<>();
propertiesMap.put("latitude", Document.fromMap(latitudeMap));
propertiesMap.put("longitude", Document.fromMap(longitudeMap));
// Create the "required" array
List requiredList = new ArrayList<>();
requiredList.add(Document.fromString("latitude"));
requiredList.add(Document.fromString("longitude"));
// Create the root object
Map rootMap = new HashMap<>();
rootMap.put("type", Document.fromString("object"));
rootMap.put("properties", Document.fromMap(propertiesMap));
rootMap.put("required", Document.fromList(requiredList));
// Now create the Document representing the JSON schema
Document document = Document.fromMap(rootMap);
ToolSpecification specification = ToolSpecification.builder()
.name("Weather_Tool")
.description("Get the current weather for a given location, based on its WGS84 coordinates.")
.inputSchema(ToolInputSchema.builder()
.json(document)
.build())
.build();
return specification;
}
/**
* Fetches weather data for the given latitude and longitude.
*
* @param latitude the latitude coordinate
* @param longitude the longitude coordinate
* @return a {@link CompletableFuture} containing the weather data as a JSON string
*/
public Document fetchWeatherData(String latitude, String longitude) {
HttpClient httpClient = HttpClient.newHttpClient();
// Ensure no extra double quotes
latitude = latitude.replace("\"", "");
longitude = longitude.replace("\"", "");
String endpoint = "https://api.open-meteo.com/v1/forecast";
String url = String.format("%s?latitude=%s&longitude=%s¤t_weather=True", endpoint, latitude, longitude);
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(url))
.build();
try {
HttpResponse response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());
if (response.statusCode() == 200) {
String weatherJson = response.body();
System.out.println(weatherJson);
ObjectMapper objectMapper = new ObjectMapper();
Map rawMap = objectMapper.readValue(weatherJson, new TypeReference>() {});
Map documentMap = convertToDocumentMap(rawMap);
Document weatherDocument = Document.fromMap(documentMap);
System.out.println(weatherDocument);
return weatherDocument;
} else {
throw new RuntimeException("Error fetching weather data: " + response.statusCode());
}
} catch (Exception e) {
System.out.println("Error fetching weather data: " + e.getMessage());
throw new RuntimeException("Error fetching weather data", e);
}
}
private static Map convertToDocumentMap(Map inputMap) {
Map result = new HashMap<>();
for (Map.Entry entry : inputMap.entrySet()) {
result.put(entry.getKey(), convertToDocument(entry.getValue()));
}
return result;
}
// Convert different types of Objects to Document
private static Document convertToDocument(Object value) {
if (value instanceof Map) {
return Document.fromMap(convertToDocumentMap((Map) value));
} else if (value instanceof Integer) {
return Document.fromNumber(SdkNumber.fromInteger((Integer) value));
} else if (value instanceof Double) { //
return Document.fromNumber(SdkNumber.fromDouble((Double) value));
} else if (value instanceof Boolean) {
return Document.fromBoolean((Boolean) value);
} else if (value instanceof String) {
return Document.fromString((String) value);
}
return Document.fromNull(); // Handle null values safely
}
}
```
Die Converse-API-Aktion mit einer Toolkonfiguration.
```
/**
* 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);
}
}
```
+ Weitere API-Informationen finden Sie unter [Converse](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/Converse) in der *AWS SDK for Java 2.x -API-Referenz*.
------
#### [ JavaScript ]
**SDK für JavaScript (v3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime/scenarios/converse_tool_scenario#code-examples) einrichten und ausführen.
Die primäre Ausführung des Szenarioablaufs. Dieses Szenario orchestriert die Kommunikation zwischen dem Benutzer, der Converse-API von Amazon Bedrock und einem Wettertool.
```
/* 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 });
}
```
+ Details zur API finden Sie unter [Converse](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseCommand) in der *AWS SDK für JavaScript -API-Referenz*.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Das primäre Ausführungsskript der Demo. Dieses Skript orchestriert die Kommunikation zwischen dem Benutzer, der Converse-API von Amazon Bedrock und einem Wettertool.
```
"""
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()
```
Das in der Demo verwendete Wettertool. Dieses Skript definiert die Tool-Spezifikation und implementiert die Logik zum Abrufen von Wetterdaten über die Open-Meteo-API.
```
import requests
from requests.exceptions import RequestException
def get_tool_spec():
"""
Returns the JSON Schema specification for the Weather tool. The tool specification
defines the input schema and describes the tool's functionality.
For more information, see https://json-schema.org/understanding-json-schema/reference.
:return: The tool specification for the Weather tool.
"""
return {
"toolSpec": {
"name": "Weather_Tool",
"description": "Get the current weather for a given location, based on its WGS84 coordinates.",
"inputSchema": {
"json": {
"type": "object",
"properties": {
"latitude": {
"type": "string",
"description": "Geographical WGS84 latitude of the location.",
},
"longitude": {
"type": "string",
"description": "Geographical WGS84 longitude of the location.",
},
},
"required": ["latitude", "longitude"],
}
},
}
}
def fetch_weather_data(input_data):
"""
Fetches weather data for the given latitude and longitude using the Open-Meteo API.
Returns the weather data or an error message if the request fails.
:param input_data: The input data containing the latitude and longitude.
:return: The weather data or an error message.
"""
endpoint = "https://api.open-meteo.com/v1/forecast"
latitude = input_data.get("latitude")
longitude = input_data.get("longitude", "")
params = {"latitude": latitude, "longitude": longitude, "current_weather": True}
try:
response = requests.get(endpoint, params=params)
weather_data = {"weather_data": response.json()}
response.raise_for_status()
return weather_data
except RequestException as e:
return e.response.json()
except Exception as e:
return {"error": type(e), "message": str(e)}
```
+ Details zur API finden Sie unter [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) in der *API-Referenz zum AWS SDK für Python (Boto3)*.
------
#### [ Rust ]
**SDK für Rust**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/bedrock-runtime#code-examples) einrichten und ausführen.
Das primäre Szenario und die Logik für die Demo. Dies orchestriert die Kommunikation zwischen dem Benutzer, der Converse-API von Amazon Bedrock und einem Wettertool.
```
#[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();
}
```
Das in der Demo verwendete Wettertool. Dieses Skript definiert die Tool-Spezifikation und implementiert die Logik zum Abrufen von Wetterdaten über die Open-Meteo-API.
```
const ENDPOINT: &str = "https://api.open-meteo.com/v1/forecast";
async fn fetch_weather_data(
tool_use: &ToolUseBlock,
) -> Result {
let input = tool_use.input();
let latitude = input
.as_object()
.unwrap()
.get("latitude")
.unwrap()
.as_string()
.unwrap();
let longitude = input
.as_object()
.unwrap()
.get("longitude")
.unwrap()
.as_string()
.unwrap();
let params = [
("latitude", latitude),
("longitude", longitude),
("current_weather", "true"),
];
debug!("Calling {ENDPOINT} with {params:?}");
let response = reqwest::Client::new()
.get(ENDPOINT)
.query(¶ms)
.send()
.await
.map_err(|e| ToolUseScenarioError(format!("Error requesting weather: {e:?}")))?
.error_for_status()
.map_err(|e| ToolUseScenarioError(format!("Failed to request weather: {e:?}")))?;
debug!("Response: {response:?}");
let bytes = response
.bytes()
.await
.map_err(|e| ToolUseScenarioError(format!("Error reading response: {e:?}")))?;
let result = String::from_utf8(bytes.to_vec())
.map_err(|_| ToolUseScenarioError("Response was not utf8".into()))?;
Ok(ToolResultBlock::builder()
.tool_use_id(tool_use.tool_use_id())
.content(ToolResultContentBlock::Text(result))
.build()?)
}
```
Dienstprogramme zum Drucken der Nachrichteninhaltsblöcke.
```
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:?})"
)))
}
}
```
Verwenden von Anweisungen, des Fehlerdienstprogramms und von Konstanten.
```
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(),
})
}
}
```
+ Details zu API finden Sie unter [Converse](https://docs.rs/aws-sdk-bedrockruntime/latest/aws_sdk_bedrockruntime/client/struct.Client.html#method.converse) in der *API-Referenz zum AWS SDK für Rust*.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter[Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md). Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Amazon Nova für Amazon Bedrock Runtime
Die folgenden Codebeispiele zeigen, wie Sie Amazon Bedrock Runtime mit AWS SDKs verwenden.
**Topics**
+ [Converse](bedrock-runtime_example_bedrock-runtime_Converse_AmazonNovaText_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_AmazonNovaText_section.md)
+ [Verstehen von Dokumenten](bedrock-runtime_example_bedrock-runtime_DocumentUnderstanding_AmazonNova_section.md)
+ [Szenario: Verwenden des Tools mit der Converse-API](bedrock-runtime_example_bedrock-runtime_Scenario_ToolUseDemo_AmazonNova_section.md)
# Aufrufen von Amazon Nova in Amazon Bedrock mithilfe der Converse-API von Bedrock
Die folgenden Codebeispiele zeigen, wie eine Textnachricht mithilfe der Converse-API von Bedrock an Amazon Nova gesendet wird.
------
#### [ .NET ]
**SDK für .NET**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime#code-examples) einrichten und ausführen.
Senden Sie mithilfe der Converse-API von Bedrock eine Textnachricht an Amazon Nova.
```
// 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;
}
```
Senden Sie mithilfe der Converse-API von Bedrock und einer Tool-Konfiguration eine Konversation mit Nachrichten an Amazon Nova.
```
///
/// 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;
}
}
}
```
+ Details zur API finden Sie unter [Converse](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/Converse) in der *AWS SDK für .NET -API-Referenz*.
------
#### [ Java ]
**SDK für Java 2.x**
Es gibt noch mehr GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Senden Sie mithilfe der Converse-API von Bedrock und dem asynchronen Java-Client eine Textnachricht an Amazon Nova.
```
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);
}
}
```
Senden Sie mithilfe der Converse-API von Bedrock eine Textnachricht an Amazon Nova.
```
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);
}
}
```
+ Details zur API finden Sie unter [Converse](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/Converse) in der *AWS SDK for Java 2.x -API-Referenz*.
------
#### [ JavaScript ]
**SDK für JavaScript (v3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Senden Sie mithilfe der Converse-API von Bedrock eine Textnachricht an Amazon Nova.
```
// 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;
}
```
Senden Sie mithilfe der Converse-API von Bedrock und einer Tool-Konfiguration eine Konversation mit Nachrichten an Amazon Nova.
```
// 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);
```
+ Details zur API finden Sie unter [Converse](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseCommand) in der *AWS SDK für JavaScript -API-Referenz*.
------
#### [ Kotlin ]
**SDK für Kotlin**
Es gibt noch mehr GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/bedrock-runtime#code-examples) einrichten und ausführen.
Senden Sie mithilfe der Converse-API von Bedrock eine Textnachricht an Amazon Nova.
```
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)
}
}
}
```
+ Details zur API finden Sie unter [Converse](https://sdk.amazonaws.com/kotlin/api/latest/index.html) in der *API-Referenz zum AWS SDK für Kotlin*.
------
#### [ PHP ]
**SDK für PHP**
Es gibt noch mehr GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Senden Sie mithilfe der Converse-API von Bedrock eine Textnachricht an Amazon Nova.
```
// 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();
```
+ Details zur API finden Sie unter [Converse](https://docs.aws.amazon.com/goto/SdkForPHPV3/bedrock-runtime-2023-09-30/Converse) in der *AWS SDK für PHP -API-Referenz*.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Senden Sie mithilfe der Converse-API von Bedrock eine Textnachricht an Amazon Nova.
```
# 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)
```
+ Details zur API finden Sie unter [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) in der *API-Referenz zum AWS SDK für Python (Boto3)*.
------
#### [ Swift ]
**SDK für Swift**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Senden Sie mithilfe der Converse-API von Bedrock eine Textnachricht an Amazon Nova.
```
// 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"
}
}
```
+ Weitere API-Informationen finden Sie unter [Converse](https://sdk.amazonaws.com/swift/api/awsbedrockruntime/latest/documentation/awsbedrockruntime/bedrockruntimeclient/converse(input:)) in der *API-Referenz zum AWS -SDK für Swift*.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter[Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md). Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Aufrufen von Amazon Nova in Amazon Bedrock mithilfe der Converse-API von Bedrock mit Antwortstream
Die folgenden Codebeispiele zeigen, wie Sie mithilfe der Converse-API von Bedrock eine Textnachricht an Amazon Nova senden und den Antwortstream in Echtzeit verarbeiten.
------
#### [ .NET ]
**SDK für .NET**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime#code-examples) einrichten und ausführen.
Senden Sie mithilfe der Converse-API von Bedrock eine Textnachricht an Amazon Nova und verarbeiten Sie den Antwortstream in Echtzeit.
```
// 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;
}
```
+ Einzelheiten zur API finden Sie [ConverseStream](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/ConverseStream)in der *AWS SDK für .NET API-Referenz*.
------
#### [ Java ]
**SDK für Java 2.x**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Senden Sie mithilfe der Converse-API von Bedrock eine Textnachricht an Amazon Nova und verarbeiten Sie den Antwortstream in Echtzeit.
```
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();
}
}
```
+ Einzelheiten zur API finden Sie [ConverseStream](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/ConverseStream)in der *AWS SDK for Java 2.x API-Referenz*.
------
#### [ JavaScript ]
**SDK für JavaScript (v3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Senden Sie mithilfe der Converse-API von Bedrock eine Textnachricht an Amazon Nova und verarbeiten Sie den Antwortstream in Echtzeit.
```
// 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;
}
```
+ Einzelheiten zur API finden Sie [ConverseStream](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseStreamCommand)in der *AWS SDK für JavaScript API-Referenz*.
------
#### [ Kotlin ]
**SDK für Kotlin**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/bedrock-runtime#code-examples) einrichten und ausführen.
Senden Sie mithilfe der Converse-API von Bedrock eine Textnachricht an Amazon Nova und verarbeiten Sie den Antwortstream in Echtzeit.
```
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()
}
```
+ Einzelheiten zur API finden Sie [ConverseStream](https://sdk.amazonaws.com/kotlin/api/latest/index.html)in der *API-Referenz zum AWS SDK für Kotlin*.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu. GitHub Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Senden Sie mithilfe der Converse-API von Bedrock eine Textnachricht an Amazon Nova und verarbeiten Sie den Antwortstream in Echtzeit.
```
# 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)
```
+ Einzelheiten zur API finden Sie [ConverseStream](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/ConverseStream)in *AWS SDK for Python (Boto3) API* Reference.
------
#### [ Swift ]
**SDK für Swift**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Senden Sie mithilfe der Converse-API von Bedrock eine Textnachricht an Amazon Nova und verarbeiten Sie den Antwortstream in Echtzeit.
```
// 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
}
}
}
```
+ Einzelheiten zur API finden Sie [ConverseStream](https://sdk.amazonaws.com/swift/api/awsbedrockruntime/latest/documentation/awsbedrockruntime/bedrockruntimeclient/conversestream(input:))in der *API-Referenz zum AWS SDK für Swift*.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter[Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md). Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Senden und Verarbeiten eines Dokuments mit Amazon Nova in Amazon Bedrock
In dem folgenden Codebeispiel wird gezeigt, wie ein Dokument mit Amazon Nova in Amazon Bedrock gesendet und verarbeitet wird.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Senden und verarbeiten Sie ein Dokument mit Amazon Nova in 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)
```
+ Weitere API-Informationen finden Sie unter [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) in der *API-Referenz zum AWS -SDK für Python (Boto3)*.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter[Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md). Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Eine Demo für die Verwendung des Tools, die veranschaulicht, wie KI-Modelle in Amazon Bedrock mit einem benutzerdefinierten Tool oder einer API verbunden werden
Die folgenden Codebeispiele zeigen, wie eine typische Interaktion zwischen einer Anwendung, einem generativen KI-Modell und verbundenen Tools aufgebaut oder APIs Interaktionen zwischen der KI und der Außenwelt vermittelt werden. Es wird das Beispiel der Verbindung einer externen Wetter-API mit dem KI-Modell verwendet, damit dieses auf Grundlage der Eingaben des Benutzenden Wetterinformationen in Echtzeit bereitstellen kann.
------
#### [ .NET ]
**SDK für .NET**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime/Scenarios/ConverseToolScenario#code-examples) einrichten und ausführen.
Die primäre Ausführung des Szenarioablaufs. Dieses Szenario orchestriert die Kommunikation zwischen dem Benutzer, der Converse-API von Amazon Bedrock und einem Wettertool.
```
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();
}
}
```
Das in der Demo verwendete Wettertool. Diese Datei definiert die Tool-Spezifikation und implementiert die Logik zum Abrufen von Wetterdaten über die Open-Meteo-API.
```
using Amazon.BedrockRuntime.Model;
using Amazon.Runtime.Documents;
using Microsoft.Extensions.Logging;
namespace ConverseToolScenario;
///
/// Weather tool that will be invoked when requested by the Bedrock response.
///
public class WeatherTool
{
private readonly ILogger _logger;
private readonly IHttpClientFactory _httpClientFactory;
public WeatherTool(ILogger logger, IHttpClientFactory httpClientFactory)
{
_logger = logger;
_httpClientFactory = httpClientFactory;
}
///
/// Returns the JSON Schema specification for the Weather tool. The tool specification
/// defines the input schema and describes the tool's functionality.
/// For more information, see https://json-schema.org/understanding-json-schema/reference.
///
/// The tool specification for the Weather tool.
public ToolSpecification GetToolSpec()
{
ToolSpecification toolSpecification = new ToolSpecification();
toolSpecification.Name = "Weather_Tool";
toolSpecification.Description = "Get the current weather for a given location, based on its WGS84 coordinates.";
Document toolSpecDocument = Document.FromObject(
new
{
type = "object",
properties = new
{
latitude = new
{
type = "string",
description = "Geographical WGS84 latitude of the location."
},
longitude = new
{
type = "string",
description = "Geographical WGS84 longitude of the location."
}
},
required = new[] { "latitude", "longitude" }
});
toolSpecification.InputSchema = new ToolInputSchema() { Json = toolSpecDocument };
return toolSpecification;
}
///
/// Fetches weather data for the given latitude and longitude using the Open-Meteo API.
/// Returns the weather data or an error message if the request fails.
///
/// The latitude of the location.
/// The longitude of the location.
/// The weather data or an error message.
public async Task FetchWeatherDataAsync(string latitude, string longitude)
{
string endpoint = "https://api.open-meteo.com/v1/forecast";
try
{
var httpClient = _httpClientFactory.CreateClient();
var response = await httpClient.GetAsync($"{endpoint}?latitude={latitude}&longitude={longitude}¤t_weather=True");
response.EnsureSuccessStatusCode();
var weatherData = await response.Content.ReadAsStringAsync();
Document weatherDocument = Document.FromObject(
new { weather_data = weatherData });
return weatherDocument;
}
catch (HttpRequestException e)
{
_logger.LogError(e, "Error fetching weather data: {Message}", e.Message);
throw;
}
catch (Exception e)
{
_logger.LogError(e, "Unexpected error fetching weather data: {Message}", e.Message);
throw;
}
}
}
```
Die Converse-API-Aktion mit einer Toolkonfiguration.
```
///
/// 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;
}
}
}
```
+ Details zur API finden Sie unter [Converse](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/Converse) in der *AWS SDK für .NET -API-Referenz*.
------
#### [ Java ]
**SDK für Java 2.x**
Es gibt noch mehr GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Die primäre Ausführung des Szenarioablaufs. Dieses Szenario orchestriert die Kommunikation zwischen dem Benutzer, der Converse-API von Amazon Bedrock und einem Wettertool.
```
/*
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
=================================================
""");
}
}
```
Das in der Demo verwendete Wettertool. Diese Datei definiert die Tool-Spezifikation und implementiert die Logik zum Abrufen von Wetterdaten über die Open-Meteo-API.
```
public class WeatherTool {
private static final Logger logger = LoggerFactory.getLogger(WeatherTool.class);
private static java.net.http.HttpClient httpClient = null;
/**
* Returns the JSON Schema specification for the Weather tool. The tool specification
* defines the input schema and describes the tool's functionality.
* For more information, see https://json-schema.org/understanding-json-schema/reference.
*
* @return The tool specification for the Weather tool.
*/
public ToolSpecification getToolSpec() {
Map latitudeMap = new HashMap<>();
latitudeMap.put("type", Document.fromString("string"));
latitudeMap.put("description", Document.fromString("Geographical WGS84 latitude of the location."));
// Create the nested "longitude" object
Map longitudeMap = new HashMap<>();
longitudeMap.put("type", Document.fromString("string"));
longitudeMap.put("description", Document.fromString("Geographical WGS84 longitude of the location."));
// Create the "properties" object
Map propertiesMap = new HashMap<>();
propertiesMap.put("latitude", Document.fromMap(latitudeMap));
propertiesMap.put("longitude", Document.fromMap(longitudeMap));
// Create the "required" array
List requiredList = new ArrayList<>();
requiredList.add(Document.fromString("latitude"));
requiredList.add(Document.fromString("longitude"));
// Create the root object
Map rootMap = new HashMap<>();
rootMap.put("type", Document.fromString("object"));
rootMap.put("properties", Document.fromMap(propertiesMap));
rootMap.put("required", Document.fromList(requiredList));
// Now create the Document representing the JSON schema
Document document = Document.fromMap(rootMap);
ToolSpecification specification = ToolSpecification.builder()
.name("Weather_Tool")
.description("Get the current weather for a given location, based on its WGS84 coordinates.")
.inputSchema(ToolInputSchema.builder()
.json(document)
.build())
.build();
return specification;
}
/**
* Fetches weather data for the given latitude and longitude.
*
* @param latitude the latitude coordinate
* @param longitude the longitude coordinate
* @return a {@link CompletableFuture} containing the weather data as a JSON string
*/
public Document fetchWeatherData(String latitude, String longitude) {
HttpClient httpClient = HttpClient.newHttpClient();
// Ensure no extra double quotes
latitude = latitude.replace("\"", "");
longitude = longitude.replace("\"", "");
String endpoint = "https://api.open-meteo.com/v1/forecast";
String url = String.format("%s?latitude=%s&longitude=%s¤t_weather=True", endpoint, latitude, longitude);
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(url))
.build();
try {
HttpResponse response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());
if (response.statusCode() == 200) {
String weatherJson = response.body();
System.out.println(weatherJson);
ObjectMapper objectMapper = new ObjectMapper();
Map rawMap = objectMapper.readValue(weatherJson, new TypeReference>() {});
Map documentMap = convertToDocumentMap(rawMap);
Document weatherDocument = Document.fromMap(documentMap);
System.out.println(weatherDocument);
return weatherDocument;
} else {
throw new RuntimeException("Error fetching weather data: " + response.statusCode());
}
} catch (Exception e) {
System.out.println("Error fetching weather data: " + e.getMessage());
throw new RuntimeException("Error fetching weather data", e);
}
}
private static Map convertToDocumentMap(Map inputMap) {
Map result = new HashMap<>();
for (Map.Entry entry : inputMap.entrySet()) {
result.put(entry.getKey(), convertToDocument(entry.getValue()));
}
return result;
}
// Convert different types of Objects to Document
private static Document convertToDocument(Object value) {
if (value instanceof Map) {
return Document.fromMap(convertToDocumentMap((Map) value));
} else if (value instanceof Integer) {
return Document.fromNumber(SdkNumber.fromInteger((Integer) value));
} else if (value instanceof Double) { //
return Document.fromNumber(SdkNumber.fromDouble((Double) value));
} else if (value instanceof Boolean) {
return Document.fromBoolean((Boolean) value);
} else if (value instanceof String) {
return Document.fromString((String) value);
}
return Document.fromNull(); // Handle null values safely
}
}
```
Die Converse-API-Aktion mit einer Toolkonfiguration.
```
/**
* 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);
}
}
```
+ Weitere API-Informationen finden Sie unter [Converse](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/Converse) in der *AWS SDK for Java 2.x -API-Referenz*.
------
#### [ JavaScript ]
**SDK für JavaScript (v3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime/scenarios/converse_tool_scenario#code-examples) einrichten und ausführen.
Die primäre Ausführung des Szenarioablaufs. Dieses Szenario orchestriert die Kommunikation zwischen dem Benutzer, der Converse-API von Amazon Bedrock und einem Wettertool.
```
/* 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 });
}
```
+ Details zur API finden Sie unter [Converse](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseCommand) in der *AWS SDK für JavaScript -API-Referenz*.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter[Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md). Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Amazon Nova Canvas für Amazon Bedrock Runtime
Die folgenden Codebeispiele zeigen, wie Sie Amazon Bedrock Runtime mit AWS SDKs verwenden.
**Topics**
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_AmazonNovaImageGeneration_section.md)
# Aufrufen von Amazon Nova Canvas in Amazon Bedrock, um ein Bild zu generieren
Die folgenden Codebeispiele zeigen, wie Sie Amazon Nova Canvas in Amazon Bedrock aufrufen, um ein Bild zu generieren.
------
#### [ .NET ]
**SDK für .NET**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime#code-examples) einrichten und ausführen.
Erstellen Sie ein Bild mit 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;
}
```
+ Einzelheiten zur API finden Sie [InvokeModel](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/InvokeModel)in der *AWS SDK für .NET API-Referenz*.
------
#### [ Java ]
**SDK für Java 2.x**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Erstellen Sie ein Bild mit 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);
}
}
```
+ Einzelheiten zur API finden Sie [InvokeModel](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModel)in der *AWS SDK for Java 2.x API-Referenz*.
------
#### [ JavaScript ]
**SDK für JavaScript (v3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Erstellen Sie ein Bild mit 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;
});
}
```
+ Einzelheiten zur API finden Sie [InvokeModel](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/InvokeModelCommand)in der *AWS SDK für JavaScript API-Referenz*.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Erstellen Sie ein Bild mit 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}")
```
+ Einzelheiten zur API finden Sie [InvokeModel](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModel)in *AWS SDK for Python (Boto3) API* Reference.
------
#### [ Swift ]
**SDK für Swift**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Erstellen Sie ein Bild mit 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)")
}
```
+ Einzelheiten zur API finden Sie [InvokeModel](https://sdk.amazonaws.com/swift/api/awsbedrockruntime/latest/documentation/awsbedrockruntime/bedrockruntimeclient/invokemodel(input:))in der *API-Referenz zum AWS SDK für Swift*.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter[Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md). Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Amazon Nova Reel für Amazon Bedrock Runtime
Die folgenden Codebeispiele zeigen, wie Sie Amazon Bedrock Runtime mit AWS SDKs verwenden.
**Topics**
+ [T ext-to-video](bedrock-runtime_example_bedrock-runtime_Scenario_AmazonNova_TextToVideo_section.md)
# Verwenden von Amazon Nova Reel, um ein Video aus einem Text-Prompt zu generieren
Die folgenden Codebeispiele zeigen, wie Amazon Nova Reel zur Generierung eines Videos anhand eines Text-Prompts verwendet wird.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Verwenden Sie Amazon Nova Reel, um ein Video aus einem Text-Prompt zu generieren.
```
"""
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()
```
+ Weitere API-Informationen finden Sie in den folgenden Themen der *API-Referenz zum AWS SDK für 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 für Swift**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Verwenden Sie Amazon Nova Reel, um ein Video aus einem Text-Prompt zu generieren.
```
// 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)")
}
```
+ Weitere API-Informationen finden Sie in den folgenden Themen der *API-Referenz zum AWS SDK für 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:))
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter[Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md). Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Amazon Titan Image Generator für Amazon Bedrock Runtime
Die folgenden Codebeispiele zeigen, wie Sie Amazon Bedrock Runtime mit AWS SDKs verwenden.
**Topics**
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_TitanImageGenerator_section.md)
# Aufrufen von Amazon Titan Image in Amazon Bedrock, um ein Bild zu generieren
Die folgenden Codebeispiele zeigen, wie Sie Amazon Titan Image in Amazon Bedrock aufrufen, um ein Bild zu generieren.
------
#### [ Go ]
**SDK für Go V2**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/bedrock-runtime#code-examples) einrichten und ausführen.
Erstellen Sie ein Bild mit dem Amazon Titan Image Generator.
```
import (
"context"
"encoding/json"
"log"
"strings"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/bedrockruntime"
)
// InvokeModelWrapper encapsulates Amazon Bedrock actions used in the examples.
// It contains a Bedrock Runtime client that is used to invoke foundation models.
type InvokeModelWrapper struct {
BedrockRuntimeClient *bedrockruntime.Client
}
type TitanImageRequest struct {
TaskType string `json:"taskType"`
TextToImageParams TextToImageParams `json:"textToImageParams"`
ImageGenerationConfig ImageGenerationConfig `json:"imageGenerationConfig"`
}
type TextToImageParams struct {
Text string `json:"text"`
}
type ImageGenerationConfig struct {
NumberOfImages int `json:"numberOfImages"`
Quality string `json:"quality"`
CfgScale float64 `json:"cfgScale"`
Height int `json:"height"`
Width int `json:"width"`
Seed int64 `json:"seed"`
}
type TitanImageResponse struct {
Images []string `json:"images"`
}
// Invokes the Titan Image model to create an image using the input provided
// in the request body.
func (wrapper InvokeModelWrapper) InvokeTitanImage(ctx context.Context, prompt string, seed int64) (string, error) {
modelId := "amazon.titan-image-generator-v2:0"
body, err := json.Marshal(TitanImageRequest{
TaskType: "TEXT_IMAGE",
TextToImageParams: TextToImageParams{
Text: prompt,
},
ImageGenerationConfig: ImageGenerationConfig{
NumberOfImages: 1,
Quality: "standard",
CfgScale: 8.0,
Height: 512,
Width: 512,
Seed: seed,
},
})
if err != nil {
log.Fatal("failed to marshal", err)
}
output, err := wrapper.BedrockRuntimeClient.InvokeModel(ctx, &bedrockruntime.InvokeModelInput{
ModelId: aws.String(modelId),
ContentType: aws.String("application/json"),
Body: body,
})
if err != nil {
ProcessError(err, modelId)
}
var response TitanImageResponse
if err := json.Unmarshal(output.Body, &response); err != nil {
log.Fatal("failed to unmarshal", err)
}
base64ImageData := response.Images[0]
return base64ImageData, nil
}
```
+ Einzelheiten zur API finden Sie [InvokeModel](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/bedrockruntime#Client.InvokeModel)in der *AWS SDK für Go API-Referenz*.
------
#### [ Java ]
**SDK für Java 2.x**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Erstellen Sie ein Bild mit dem Amazon Titan Image Generator.
```
// Create an image with the Amazon Titan Image Generator.
import org.json.JSONObject;
import org.json.JSONPointer;
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.core.SdkBytes;
import software.amazon.awssdk.core.exception.SdkClientException;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.bedrockruntime.BedrockRuntimeClient;
import java.math.BigInteger;
import java.security.SecureRandom;
import static com.example.bedrockruntime.libs.ImageTools.displayImage;
public class InvokeModel {
public static String invokeModel() {
// Create a Bedrock Runtime client in the AWS Region you want to use.
// Replace the DefaultCredentialsProvider with your preferred credentials provider.
var client = BedrockRuntimeClient.builder()
.credentialsProvider(DefaultCredentialsProvider.create())
.region(Region.US_EAST_1)
.build();
// Set the model ID, e.g., Titan Image G2.
var modelId = "amazon.titan-image-generator-v2:0";
// The InvokeModel API uses the model's native payload.
// Learn more about the available inference parameters and response fields at:
// https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-titan-image.html
var nativeRequestTemplate = """
{
"taskType": "TEXT_IMAGE",
"textToImageParams": { "text": "{{prompt}}" },
"imageGenerationConfig": { "seed": {{seed}} }
}""";
// Define the prompt for the image generation.
var prompt = "A stylized picture of a cute old steampunk robot";
// Get a random 31-bit seed for the image generation (max. 2,147,483,647).
var seed = new BigInteger(31, new SecureRandom());
// Embed the prompt and seed in the model's native request payload.
var nativeRequest = nativeRequestTemplate
.replace("{{prompt}}", prompt)
.replace("{{seed}}", seed.toString());
try {
// Encode and send the request to the Bedrock Runtime.
var response = client.invokeModel(request -> request
.body(SdkBytes.fromUtf8String(nativeRequest))
.modelId(modelId)
);
// Decode the response body.
var responseBody = new JSONObject(response.body().asUtf8String());
// Retrieve the generated image data from the model's response.
var base64ImageData = new JSONPointer("/images/0").queryFrom(responseBody).toString();
return base64ImageData;
} catch (SdkClientException e) {
System.err.printf("ERROR: Can't invoke '%s'. Reason: %s", modelId, e.getMessage());
throw new RuntimeException(e);
}
}
public static void main(String[] args) {
System.out.println("Generating image. This may take a few seconds...");
String base64ImageData = invokeModel();
displayImage(base64ImageData);
}
}
```
+ Einzelheiten zur API finden Sie [InvokeModel](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModel)in der *AWS SDK for Java 2.x API-Referenz*.
------
#### [ PHP ]
**SDK für PHP**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Erstellen Sie ein Bild mit dem Amazon Titan Image Generator.
```
public function invokeTitanImage(string $prompt, int $seed)
{
// The different model providers have individual request and response formats.
// For the format, ranges, and default values for Titan Image models refer to:
// https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-titan-image.html
$base64_image_data = "";
try {
$modelId = 'amazon.titan-image-generator-v2:0';
$request = json_encode([
'taskType' => 'TEXT_IMAGE',
'textToImageParams' => [
'text' => $prompt
],
'imageGenerationConfig' => [
'numberOfImages' => 1,
'quality' => 'standard',
'cfgScale' => 8.0,
'height' => 512,
'width' => 512,
'seed' => $seed
]
]);
$result = $this->bedrockRuntimeClient->invokeModel([
'contentType' => 'application/json',
'body' => $request,
'modelId' => $modelId,
]);
$response_body = json_decode($result['body']);
$base64_image_data = $response_body->images[0];
} catch (Exception $e) {
echo "Error: ({$e->getCode()}) - {$e->getMessage()}\n";
}
return $base64_image_data;
}
```
+ Einzelheiten zur API finden Sie [InvokeModel](https://docs.aws.amazon.com/goto/SdkForPHPV3/bedrock-runtime-2023-09-30/InvokeModel)in der *AWS SDK für PHP API-Referenz*.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Erstellen Sie ein Bild mit dem Amazon Titan Image Generator.
```
# Use the native inference API to create an image with Amazon Titan Image Generator
import base64
import boto3
import json
import os
import random
# Create a Bedrock Runtime client in the AWS Region of your choice.
client = boto3.client("bedrock-runtime", region_name="us-east-1")
# Set the model ID, e.g., Titan Image Generator G1.
model_id = "amazon.titan-image-generator-v2:0"
# Define the image generation prompt for the model.
prompt = "A stylized picture of a cute old steampunk robot."
# Generate a random seed.
seed = random.randint(0, 2147483647)
# Format the request payload using the model's native structure.
native_request = {
"taskType": "TEXT_IMAGE",
"textToImageParams": {"text": prompt},
"imageGenerationConfig": {
"numberOfImages": 1,
"quality": "standard",
"cfgScale": 8.0,
"height": 512,
"width": 512,
"seed": seed,
},
}
# Convert the native request to JSON.
request = json.dumps(native_request)
# Invoke the model with the request.
response = client.invoke_model(modelId=model_id, body=request)
# Decode the response body.
model_response = json.loads(response["body"].read())
# Extract the image data.
base64_image_data = model_response["images"][0]
# Save the generated image to a local folder.
i, output_dir = 1, "output"
if not os.path.exists(output_dir):
os.makedirs(output_dir)
while os.path.exists(os.path.join(output_dir, f"titan_{i}.png")):
i += 1
image_data = base64.b64decode(base64_image_data)
image_path = os.path.join(output_dir, f"titan_{i}.png")
with open(image_path, "wb") as file:
file.write(image_data)
print(f"The generated image has been saved to {image_path}")
```
+ Einzelheiten zur API finden Sie [InvokeModel](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModel)in *AWS SDK for Python (Boto3) API* Reference.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter. [Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md) Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Amazon Titan Text für Amazon Bedrock Runtime
Die folgenden Codebeispiele zeigen, wie Sie Amazon Bedrock Runtime mit AWS SDKs verwenden.
**Topics**
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_TitanText_section.md)
# Aufrufen von Modellen von Amazon Titan Text in Amazon Bedrock mithilfe der Invoke-Model-API
Das folgende Codebeispiel zeigt, wie mit der Invoke-Model-API eine Textnachricht an Amazon Titan Text gesendet wird.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Verwenden der API zum Aufrufen eines Modells zum Senden einer Textnachricht.
```
# 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)
```
+ Einzelheiten zur API finden Sie [InvokeModel](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModel)in *AWS SDK for Python (Boto3) API* Reference.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter. [Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md) Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Amazon Titan Text Embeddings für Amazon Bedrock Runtime
Die folgenden Codebeispiele zeigen, wie Sie Amazon Bedrock Runtime mit AWS SDKs verwenden.
**Topics**
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModelWithResponseStream_TitanTextEmbeddings_section.md)
# Aufrufen von Amazon Titan Text Embeddings in Amazon Bedrock
Die folgenden Code-Beispiele veranschaulichen Folgendes:
+ Beginnen Sie mit der Erstellung Ihrer ersten Einbettung.
+ Erstellen Sie Einbettungen, indem Sie die Anzahl der Dimensionen und die Normalisierung konfigurieren (nur V2).
------
#### [ Java ]
**SDK für Java 2.x**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Erstellen Sie Ihre erste Einbettung mit Titan Text Embeddings V2.
```
// Generate and print an embedding with Amazon Titan Text Embeddings.
import org.json.JSONObject;
import org.json.JSONPointer;
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.core.SdkBytes;
import software.amazon.awssdk.core.exception.SdkClientException;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.bedrockruntime.BedrockRuntimeClient;
public class InvokeModel {
public static String invokeModel() {
// Create a Bedrock Runtime client in the AWS Region you want to use.
// Replace the DefaultCredentialsProvider with your preferred credentials provider.
var client = BedrockRuntimeClient.builder()
.credentialsProvider(DefaultCredentialsProvider.create())
.region(Region.US_EAST_1)
.build();
// Set the model ID, e.g., Titan Text Embeddings V2.
var modelId = "amazon.titan-embed-text-v2:0";
// The InvokeModel API uses the model's native payload.
// Learn more about the available inference parameters and response fields at:
// https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-titan-embed-text.html
var nativeRequestTemplate = "{ \"inputText\": \"{{inputText}}\" }";
// The text to convert into an embedding.
var inputText = "Please recommend books with a theme similar to the movie 'Inception'.";
// Embed the prompt in the model's native request payload.
String nativeRequest = nativeRequestTemplate.replace("{{inputText}}", inputText);
try {
// Encode and send the request to the Bedrock Runtime.
var response = client.invokeModel(request -> request
.body(SdkBytes.fromUtf8String(nativeRequest))
.modelId(modelId)
);
// Decode the response body.
var responseBody = new JSONObject(response.body().asUtf8String());
// Retrieve the generated text from the model's response.
var text = new JSONPointer("/embedding").queryFrom(responseBody).toString();
System.out.println(text);
return text;
} catch (SdkClientException e) {
System.err.printf("ERROR: Can't invoke '%s'. Reason: %s", modelId, e.getMessage());
throw new RuntimeException(e);
}
}
public static void main(String[] args) {
invokeModel();
}
}
```
Rufen Sie Titan Text Embeddings V2 auf, indem Sie die Anzahl der Dimensionen und die Normalisierung konfigurieren.
```
/**
* 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;
}
```
+ Einzelheiten zur API finden Sie [InvokeModel](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModel)in der *AWS SDK for Java 2.x API-Referenz*.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Erstellen Sie Ihre erste Einbettung mit Amazon Titan Text Embeddings.
```
# Generate and print an embedding with Amazon Titan Text Embeddings V2.
import boto3
import json
# Create a Bedrock Runtime client in the AWS Region of your choice.
client = boto3.client("bedrock-runtime", region_name="us-east-1")
# Set the model ID, e.g., Titan Text Embeddings V2.
model_id = "amazon.titan-embed-text-v2:0"
# The text to convert to an embedding.
input_text = "Please recommend books with a theme similar to the movie 'Inception'."
# Create the request for the model.
native_request = {"inputText": input_text}
# Convert the native request to JSON.
request = json.dumps(native_request)
# Invoke the model with the request.
response = client.invoke_model(modelId=model_id, body=request)
# Decode the model's native response body.
model_response = json.loads(response["body"].read())
# Extract and print the generated embedding and the input text token count.
embedding = model_response["embedding"]
input_token_count = model_response["inputTextTokenCount"]
print("\nYour input:")
print(input_text)
print(f"Number of input tokens: {input_token_count}")
print(f"Size of the generated embedding: {len(embedding)}")
print("Embedding:")
print(embedding)
```
+ Einzelheiten zur API finden Sie [InvokeModel](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModel)in *AWS SDK for Python (Boto3) API* Reference.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter. [Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md) Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Anthropic Claude für Amazon Bedrock Runtime
Die folgenden Codebeispiele zeigen, wie Sie Amazon Bedrock Runtime mit AWS SDKs verwenden.
**Topics**
+ [Converse](bedrock-runtime_example_bedrock-runtime_Converse_AnthropicClaude_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_AnthropicClaude_section.md)
+ [Verstehen von Dokumenten](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)
+ [Argumentation mit einer Streamingantwort](bedrock-runtime_example_bedrock-runtime_ConverseStream_AnthropicClaudeReasoning_section.md)
+ [Szenario: Verwenden des Tools mit der Converse-API](bedrock-runtime_example_bedrock-runtime_Scenario_ToolUseDemo_AnthropicClaude_section.md)
# Aufrufen von Anthropic Claude in Amazon Bedrock mithilfe der Converse-API von Bedrock
Die folgenden Codebeispiele zeigen, wie Sie mithilfe der Converse-API von Bedrock eine Textnachricht an Anthropic Claude senden können.
------
#### [ .NET ]
**SDK für .NET (v4)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Bedrock-runtime#code-examples) einrichten und ausführen.
Senden Sie eine Textnachricht an Anthropic Claude mithilfe der Converse-API von 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;
}
```
+ Details zur API finden Sie unter [Converse](https://docs.aws.amazon.com/goto/DotNetSDKV4/bedrock-runtime-2023-09-30/Converse) in der *AWS SDK für .NET -API-Referenz*.
------
#### [ Go ]
**SDK für Go V2**
Es gibt noch mehr GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/bedrock-runtime#code-examples) einrichten und ausführen.
Senden Sie eine Textnachricht an Anthropic Claude mithilfe der Converse-API von 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
}
```
+ Details zur API finden Sie unter [Converse](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/bedrockruntime#Client.Converse) in der *AWS SDK für Go -API-Referenz*.
------
#### [ Java ]
**SDK für Java 2.x**
Es gibt noch mehr GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Senden Sie eine Textnachricht an Anthropic Claude mithilfe der Converse-API von 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();
}
}
```
Senden Sie eine Textnachricht an Anthropic Claude mithilfe der Converse-API von Bedrock mit dem asynchronen Java-Client.
```
// Use the Converse API to send a text message to Anthropic Claude
// with the async Java client.
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.bedrockruntime.BedrockRuntimeAsyncClient;
import software.amazon.awssdk.services.bedrockruntime.model.ContentBlock;
import software.amazon.awssdk.services.bedrockruntime.model.ConversationRole;
import software.amazon.awssdk.services.bedrockruntime.model.Message;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
public class ConverseAsync {
public static String converseAsync() {
// Create a Bedrock Runtime client in the AWS Region you want to use.
// Replace the DefaultCredentialsProvider with your preferred credentials provider.
var client = BedrockRuntimeAsyncClient.builder()
.credentialsProvider(DefaultCredentialsProvider.create())
.region(Region.US_EAST_1)
.build();
// Set the model ID, e.g., Claude 3 Haiku.
var modelId = "anthropic.claude-3-haiku-20240307-v1:0";
// Create the input text and embed it in a message object with the user role.
var inputText = "Describe the purpose of a 'hello world' program in one line.";
var message = Message.builder()
.content(ContentBlock.fromText(inputText))
.role(ConversationRole.USER)
.build();
// Send the message with a basic inference configuration.
var request = client.converse(params -> params
.modelId(modelId)
.messages(message)
.inferenceConfig(config -> config
.maxTokens(512)
.temperature(0.5F)
.topP(0.9F))
);
// Prepare a future object to handle the asynchronous response.
CompletableFuture future = new CompletableFuture<>();
// Handle the response or error using the future object.
request.whenComplete((response, error) -> {
if (error == null) {
// Extract the generated text from Bedrock's response object.
String responseText = response.output().message().content().getFirst().text();
future.complete(responseText);
} else {
future.completeExceptionally(error);
}
});
try {
// Wait for the future object to complete and retrieve the generated text.
String responseText = future.get();
System.out.println(responseText);
return responseText;
} catch (ExecutionException | InterruptedException e) {
System.err.printf("Can't invoke '%s': %s", modelId, e.getMessage());
throw new RuntimeException(e);
}
}
public static void main(String[] args) {
converseAsync();
}
}
```
+ Details zur API finden Sie unter [Converse](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/Converse) in der *AWS SDK for Java 2.x -API-Referenz*.
------
#### [ JavaScript ]
**SDK für JavaScript (v3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Senden Sie eine Textnachricht an Anthropic Claude mithilfe der Converse-API von 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);
}
```
+ Details zur API finden Sie unter [Converse](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseCommand) in der *AWS SDK für JavaScript -API-Referenz*.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Senden Sie eine Textnachricht an Anthropic Claude mithilfe der Converse-API von 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)
```
+ Details zur API finden Sie unter [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) in der *API-Referenz zum AWS SDK für Python (Boto3)*.
------
#### [ Rust ]
**SDK für Rust**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/bedrock-runtime#code-examples) einrichten und ausführen.
Senden Sie eine Textnachricht an Anthropic Claude mithilfe der Converse-API von 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)
}
```
Verwenden von Anweisungen, des Fehlerdienstprogramms und von Konstanten.
```
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",
})
}
}
```
+ Details zu API finden Sie unter [Converse](https://docs.rs/aws-sdk-bedrockruntime/latest/aws_sdk_bedrockruntime/client/struct.Client.html#method.converse) in der *API-Referenz zum AWS SDK für Rust*.
------
#### [ Swift ]
**SDK für Swift**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Senden Sie eine Textnachricht an Anthropic Claude mithilfe der Converse-API von 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"
}
}
```
+ Weitere API-Informationen finden Sie unter [Converse](https://sdk.amazonaws.com/swift/api/awsbedrockruntime/latest/documentation/awsbedrockruntime/bedrockruntimeclient/converse(input:)) in der *API-Referenz zum AWS SDK für Swift*.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter[Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md). Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Aufrufen von Anthropic Claude in Amazon Bedrock mithilfe der Converse-API von Bedrock mit Antwortstream
Die folgenden Codebeispiele zeigen, wie Sie mithilfe der Converse-API von Bedrock eine Textnachricht an Anthropic Claude senden und den Antwortstrom in Echtzeit verarbeiten können.
------
#### [ .NET ]
**SDK für .NET (v4)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Bedrock-runtime#code-examples) einrichten und ausführen.
Senden Sie eine Textnachricht an Anthropic Claude mithilfe der Converse-API von Bedrock und verarbeiten Sie den Antwortstrom in Echtzeit.
```
// 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;
}
```
+ Einzelheiten zur API finden Sie [ConverseStream](https://docs.aws.amazon.com/goto/DotNetSDKV4/bedrock-runtime-2023-09-30/ConverseStream)in der *AWS SDK für .NET API-Referenz*.
------
#### [ Java ]
**SDK für Java 2.x**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Senden Sie eine Textnachricht an Anthropic Claude mithilfe der Converse-API von Bedrock und verarbeiten Sie den Antwortstrom in Echtzeit.
```
// 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());
}
}
}
```
+ Einzelheiten zur API finden Sie [ConverseStream](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/ConverseStream)in der *AWS SDK for Java 2.x API-Referenz*.
------
#### [ JavaScript ]
**SDK für JavaScript (v3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Senden Sie eine Textnachricht an Anthropic Claude mithilfe der Converse-API von Bedrock und verarbeiten Sie den Antwortstrom in Echtzeit.
```
// 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);
}
```
+ Einzelheiten zur API finden Sie [ConverseStream](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseStreamCommand)in der *AWS SDK für JavaScript API-Referenz*.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Senden Sie eine Textnachricht an Anthropic Claude mithilfe der Converse-API von Bedrock und verarbeiten Sie den Antwortstrom in Echtzeit.
```
# 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)
```
+ Einzelheiten zur API finden Sie [ConverseStream](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/ConverseStream)in *AWS SDK for Python (Boto3) API* Reference.
------
#### [ Rust ]
**SDK für Rust**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/bedrock-runtime#code-examples) einrichten und ausführen.
Senden Sie mithilfe der Bedrock-API eine Textnachricht an Anthropic Claude und streamen Sie Antwort-Token. 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(),
})
}
```
Verwenden von Anweisungen, des Fehlerdienstprogramms und von Konstanten.
```
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(),
),
}
}
}
```
+ Einzelheiten zur API finden Sie [ConverseStream](https://docs.rs/aws-sdk-bedrockruntime/latest/aws_sdk_bedrockruntime/client/struct.Client.html#method.converse_stream)in der *API-Referenz zum AWS SDK für Rust*.
------
#### [ Swift ]
**SDK für Swift**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Senden Sie eine Textnachricht an Anthropic Claude mithilfe der Converse-API von Bedrock und verarbeiten Sie den Antwortstrom in Echtzeit.
```
// 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
}
}
}
```
+ Einzelheiten zur API finden Sie [ConverseStream](https://sdk.amazonaws.com/swift/api/awsbedrockruntime/latest/documentation/awsbedrockruntime/bedrockruntimeclient/conversestream(input:))in der *API-Referenz zum AWS SDK für Swift*.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter[Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md). Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Senden und Verarbeiten eines Dokuments mit Anthropic Claude in Amazon Bedrock
Das folgende Codebeispiel zeigt, wie ein Dokument mit Anthropic Claude in Amazon Bedrock gesendet und verarbeitet wird.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Senden und Verarbeiten eines Dokuments mit Anthropic Claude in 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)
```
+ Weitere API-Informationen finden Sie unter [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) in der *API-Referenz zum AWS -SDK für Python (Boto3)*.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter[Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md). Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Aufrufen von Anthropic Claude in Amazon Bedrock mithilfe der Invoke-Model-API
Die folgenden Codebeispiele zeigen, wie Sie mithilfe der Invoke-Model-API eine Textnachricht an Anthropic Claude senden können.
------
#### [ .NET ]
**SDK für .NET (v4)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Bedrock-runtime#code-examples) einrichten und ausführen.
Verwenden der API zum Aufrufen eines Modells zum Senden einer Textnachricht.
```
// 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;
}
```
+ Einzelheiten zur API finden Sie [InvokeModel](https://docs.aws.amazon.com/goto/DotNetSDKV4/bedrock-runtime-2023-09-30/InvokeModel)in der *AWS SDK für .NET API-Referenz*.
------
#### [ Go ]
**SDK für Go V2**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/bedrock-runtime#code-examples) einrichten und ausführen.
Rufen Sie das Basismodell von Anthropic Claude 2 auf, um Text zu generieren.
```
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
}
```
+ Einzelheiten zur API finden Sie [InvokeModel](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/bedrockruntime#Client.InvokeModel)in der *AWS SDK für Go API-Referenz*.
------
#### [ Java ]
**SDK für Java 2.x**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Verwenden der API zum Aufrufen eines Modells zum Senden einer Textnachricht.
```
// 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();
}
}
```
+ Einzelheiten zur API finden Sie [InvokeModel](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModel)in der *AWS SDK for Java 2.x API-Referenz*.
------
#### [ JavaScript ]
**SDK für JavaScript (v3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Verwenden der API zum Aufrufen eines Modells zum Senden einer Textnachricht.
```
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}`);
}
}
```
+ Einzelheiten zur API finden Sie [InvokeModel](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/InvokeModelCommand)in der *AWS SDK für JavaScript API-Referenz*.
------
#### [ PHP ]
**SDK für PHP**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Rufen Sie das Basismodell von Anthropic Claude 2 auf, um Text zu generieren.
```
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;
}
```
+ Einzelheiten zur API finden Sie [InvokeModel](https://docs.aws.amazon.com/goto/SdkForPHPV3/bedrock-runtime-2023-09-30/InvokeModel)in der *AWS SDK für PHP API-Referenz*.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Verwenden der API zum Aufrufen eines Modells zum Senden einer Textnachricht.
```
# 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)
```
+ Einzelheiten zur API finden Sie [InvokeModel](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModel)in *AWS SDK for Python (Boto3) API* Reference.
------
#### [ SAP ABAP ]
**SDK für SAP ABAP**
Es gibt noch mehr dazu. GitHub Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/bdr#code-examples) einrichten und ausführen.
Rufen Sie das Basismodell von Anthropic Claude 2 auf, um Text zu generieren. In diesem Beispiel werden Funktionen von/US2/CL\$1JSON verwendet, die in einigen Versionen möglicherweise nicht verfügbar sind. 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.
```
Rufen Sie das Basismodell von Anthropic Claude 2 auf, um Text mit dem L2-High-Level-Client zu generieren.
```
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.
```
Rufen Sie das Basismodell von Anthropic Claude 3 auf, um Text mit dem L2-High-Level-Client zu generieren.
```
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.
```
+ Einzelheiten zur API finden Sie [InvokeModel](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)in der API-Referenz *zum AWS SDK für SAP ABAP*.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter[Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md). Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Aufrufen von Anthropic-Claude-Modellen in Amazon Bedrock mithilfe der Invoke-Model-API mit Antwortstream
Die folgenden Codebeispiele zeigen, wie Sie mithilfe der Invoke-Model-API eine Textnachricht an Anthropic-Claude-Modelle senden und den Antwortstrom ausdrucken.
------
#### [ .NET ]
**SDK für .NET**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime#code-examples) einrichten und ausführen.
Verwenden Sie die Invoke-Model-API, um eine Textnachricht zu senden und den Antwortstream in Echtzeit zu verarbeiten.
```
// 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;
}
```
+ Einzelheiten zur API finden Sie [InvokeModelWithResponseStream](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/InvokeModelWithResponseStream)in der *AWS SDK für .NET API-Referenz*.
------
#### [ Go ]
**SDK für Go V2**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/bedrock-runtime#code-examples) einrichten und ausführen.
Verwenden Sie die Invoke-Model-API, um eine Textnachricht zu senden und den Antwortstream in Echtzeit zu verarbeiten.
```
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
}
```
+ Einzelheiten zur API finden Sie [InvokeModelWithResponseStream](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/bedrockruntime#Client.InvokeModelWithResponseStream)in der *AWS SDK für Go API-Referenz*.
------
#### [ Java ]
**SDK für Java 2.x**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Verwenden Sie die Invoke-Model-API, um eine Textnachricht zu senden und den Antwortstream in Echtzeit zu verarbeiten.
```
// 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();
}
}
```
+ Einzelheiten zur API finden Sie [InvokeModelWithResponseStream](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModelWithResponseStream)in der *AWS SDK for Java 2.x API-Referenz*.
------
#### [ JavaScript ]
**SDK für JavaScript (v3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Verwenden Sie die Invoke-Model-API, um eine Textnachricht zu senden und den Antwortstream in Echtzeit zu verarbeiten.
```
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}`);
}
}
```
+ Einzelheiten zur API finden Sie [InvokeModelWithResponseStream](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/InvokeModelWithResponseStreamCommand)in der *AWS SDK für JavaScript API-Referenz*.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Verwenden Sie die Invoke-Model-API, um eine Textnachricht zu senden und den Antwortstream in Echtzeit zu verarbeiten.
```
# 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="")
```
+ Einzelheiten zur API finden Sie [InvokeModelWithResponseStream](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModelWithResponseStream)in *AWS SDK for Python (Boto3) API* Reference.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter. [Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md) Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Verwenden der Argumentationsfunktion von Anthropic Claude 3.7 Sonnet in Amazon Bedrock
Das folgende Codebeispiel zeigt, wie Sie die Argumentationsfunktion von Anthropic Claude 3.7 Sonnet in Amazon Bedrock verwenden.
------
#### [ Java ]
**SDK für Java 2.x**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Verwenden Sie die Argumentationsfunktion von Anthropic Claude 3.7 Sonnet mit dem asynchronen Bedrock-Runtime-Client.
```
import com.example.bedrockruntime.models.anthropicClaude.lib.ReasoningResponse;
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.core.document.Document;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.bedrockruntime.BedrockRuntimeAsyncClient;
import software.amazon.awssdk.services.bedrockruntime.model.*;
import java.util.concurrent.CompletableFuture;
/**
* This example demonstrates how to use Anthropic Claude 3.7 Sonnet's reasoning capability
* with an asynchronous Amazon Bedrock runtime client.
* It shows how to:
* - Set up the Amazon Bedrock async runtime client
* - Create a message
* - Configure reasoning parameters
* - Send an asynchronous request with reasoning enabled
* - Process both the reasoning output and final response
*/
public class ReasoningAsync {
public static ReasoningResponse reasoningAsync() {
// Create the Amazon Bedrock runtime client
var client = BedrockRuntimeAsyncClient.builder()
.credentialsProvider(DefaultCredentialsProvider.create())
.region(Region.US_EAST_1)
.build();
// Specify the model ID. For the latest available models, see:
// https://docs.aws.amazon.com/bedrock/latest/userguide/models-supported.html
var modelId = "us.anthropic.claude-3-7-sonnet-20250219-v1:0";
// Create the message with the user's prompt
var prompt = "Describe the purpose of a 'hello world' program in one line.";
var message = Message.builder()
.content(ContentBlock.fromText(prompt))
.role(ConversationRole.USER)
.build();
// Configure reasoning parameters with a 2000 token budget
Document reasoningConfig = Document.mapBuilder()
.putDocument("thinking", Document.mapBuilder()
.putString("type", "enabled")
.putNumber("budget_tokens", 2000)
.build())
.build();
try {
// Send message and reasoning configuration to the model
CompletableFuture asyncResponse = client.converse(request -> request
.additionalModelRequestFields(reasoningConfig)
.messages(message)
.modelId(modelId)
);
// Process the response asynchronously
return asyncResponse.thenApply(response -> {
var content = response.output().message().content();
ReasoningContentBlock reasoning = null;
String text = null;
// Process each content block to find reasoning and response text
for (ContentBlock block : content) {
if (block.reasoningContent() != null) {
reasoning = block.reasoningContent();
} else if (block.text() != null) {
text = block.text();
}
}
return new ReasoningResponse(reasoning, text);
}
).get();
} catch (Exception e) {
System.err.printf("Can't invoke '%s': %s", modelId, e.getMessage());
throw new RuntimeException(e);
}
}
public static void main(String[] args) {
// Execute the example and display reasoning and final response
ReasoningResponse response = reasoningAsync();
System.out.println("\n");
System.out.println(response.reasoning().reasoningText());
System.out.println("\n");
System.out.println(response.text());
}
}
```
Verwenden Sie die Argumentationsfunktion von Anthropic Claude 3.7 Sonnet mit dem synchronen Bedrock-Runtime-Client.
```
import com.example.bedrockruntime.models.anthropicClaude.lib.ReasoningResponse;
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.core.document.Document;
import software.amazon.awssdk.core.exception.SdkClientException;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.bedrockruntime.BedrockRuntimeClient;
import software.amazon.awssdk.services.bedrockruntime.model.*;
/**
* This example demonstrates how to use Anthropic Claude 3.7 Sonnet's reasoning capability
* with the synchronous Amazon Bedrock runtime client.
* It shows how to:
* - Set up the Amazon Bedrock runtime client
* - Create a message
* - Configure reasoning parameters
* - Send a request with reasoning enabled
* - Process both the reasoning output and final response
*/
public class Reasoning {
public static ReasoningResponse reasoning() {
// Create the Amazon Bedrock runtime client
var client = BedrockRuntimeClient.builder()
.credentialsProvider(DefaultCredentialsProvider.create())
.region(Region.US_EAST_1)
.build();
// Specify the model ID. For the latest available models, see:
// https://docs.aws.amazon.com/bedrock/latest/userguide/models-supported.html
var modelId = "us.anthropic.claude-3-7-sonnet-20250219-v1:0";
// Create the message with the user's prompt
var prompt = "Describe the purpose of a 'hello world' program in one line.";
var message = Message.builder()
.content(ContentBlock.fromText(prompt))
.role(ConversationRole.USER)
.build();
// Configure reasoning parameters with a 2000 token budget
Document reasoningConfig = Document.mapBuilder()
.putDocument("thinking", Document.mapBuilder()
.putString("type", "enabled")
.putNumber("budget_tokens", 2000)
.build())
.build();
try {
// Send message and reasoning configuration to the model
ConverseResponse bedrockResponse = client.converse(request -> request
.additionalModelRequestFields(reasoningConfig)
.messages(message)
.modelId(modelId)
);
// Extract both reasoning and final response
var content = bedrockResponse.output().message().content();
ReasoningContentBlock reasoning = null;
String text = null;
// Process each content block to find reasoning and response text
for (ContentBlock block : content) {
if (block.reasoningContent() != null) {
reasoning = block.reasoningContent();
} else if (block.text() != null) {
text = block.text();
}
}
return new ReasoningResponse(reasoning, text);
} catch (SdkClientException e) {
System.err.printf("ERROR: Can't invoke '%s'. Reason: %s", modelId, e.getMessage());
throw new RuntimeException(e);
}
}
public static void main(String[] args) {
// Execute the example and display reasoning and final response
ReasoningResponse response = reasoning();
System.out.println("\n");
System.out.println(response.reasoning().reasoningText());
System.out.println("\n");
System.out.println(response.text());
}
}
```
+ Details zur API finden Sie unter [Converse](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/Converse) in der *AWS SDK for Java 2.x -API-Referenz*.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter[Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md). Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Verwenden der Argumentationsfunktion von Anthropic Claude 3.7 Sonnet in Amazon Bedrock
Das folgende Codebeispiel zeigt, wie Sie die Argumentationsfunktion von Anthropic Claude 3.7 Sonnet in Amazon Bedrock verwenden.
------
#### [ Java ]
**SDK für Java 2.x**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Verwenden Sie die Argumentationsfunktion Fähigkeit von Anthropic Claude 3.7 Sonnet, um Streaming-Textantworten zu generieren.
```
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();
}
}
```
+ Weitere API-Informationen finden Sie unter [Converse](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/Converse) in der *AWS SDK for Java 2.x -API-Referenz*.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter[Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md). Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Eine Demo für die Verwendung des Tools, die veranschaulicht, wie KI-Modelle in Amazon Bedrock mit einem benutzerdefinierten Tool oder einer API verbunden werden
Die folgenden Codebeispiele zeigen, wie eine typische Interaktion zwischen einer Anwendung, einem generativen KI-Modell und verbundenen Tools aufgebaut oder APIs Interaktionen zwischen der KI und der Außenwelt vermittelt werden. Es wird das Beispiel der Verbindung einer externen Wetter-API mit dem KI-Modell verwendet, damit dieses auf Grundlage der Eingaben des Benutzenden Wetterinformationen in Echtzeit bereitstellen kann.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Das primäre Ausführungsskript der Demo. Dieses Skript orchestriert die Kommunikation zwischen dem Benutzer, der Converse-API von Amazon Bedrock und einem Wettertool.
```
"""
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()
```
Das in der Demo verwendete Wettertool. Dieses Skript definiert die Tool-Spezifikation und implementiert die Logik zum Abrufen von Wetterdaten über die Open-Meteo-API.
```
import requests
from requests.exceptions import RequestException
def get_tool_spec():
"""
Returns the JSON Schema specification for the Weather tool. The tool specification
defines the input schema and describes the tool's functionality.
For more information, see https://json-schema.org/understanding-json-schema/reference.
:return: The tool specification for the Weather tool.
"""
return {
"toolSpec": {
"name": "Weather_Tool",
"description": "Get the current weather for a given location, based on its WGS84 coordinates.",
"inputSchema": {
"json": {
"type": "object",
"properties": {
"latitude": {
"type": "string",
"description": "Geographical WGS84 latitude of the location.",
},
"longitude": {
"type": "string",
"description": "Geographical WGS84 longitude of the location.",
},
},
"required": ["latitude", "longitude"],
}
},
}
}
def fetch_weather_data(input_data):
"""
Fetches weather data for the given latitude and longitude using the Open-Meteo API.
Returns the weather data or an error message if the request fails.
:param input_data: The input data containing the latitude and longitude.
:return: The weather data or an error message.
"""
endpoint = "https://api.open-meteo.com/v1/forecast"
latitude = input_data.get("latitude")
longitude = input_data.get("longitude", "")
params = {"latitude": latitude, "longitude": longitude, "current_weather": True}
try:
response = requests.get(endpoint, params=params)
weather_data = {"weather_data": response.json()}
response.raise_for_status()
return weather_data
except RequestException as e:
return e.response.json()
except Exception as e:
return {"error": type(e), "message": str(e)}
```
+ Details zur API finden Sie unter [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) in der *API-Referenz zum AWS SDK für Python (Boto3)*.
------
#### [ Rust ]
**SDK für Rust**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/bedrock-runtime#code-examples) einrichten und ausführen.
Das primäre Szenario und die Logik für die Demo. Dies orchestriert die Kommunikation zwischen dem Benutzer, der Converse-API von Amazon Bedrock und einem Wettertool.
```
#[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();
}
```
Das in der Demo verwendete Wettertool. Dieses Skript definiert die Tool-Spezifikation und implementiert die Logik zum Abrufen von Wetterdaten über die Open-Meteo-API.
```
const ENDPOINT: &str = "https://api.open-meteo.com/v1/forecast";
async fn fetch_weather_data(
tool_use: &ToolUseBlock,
) -> Result {
let input = tool_use.input();
let latitude = input
.as_object()
.unwrap()
.get("latitude")
.unwrap()
.as_string()
.unwrap();
let longitude = input
.as_object()
.unwrap()
.get("longitude")
.unwrap()
.as_string()
.unwrap();
let params = [
("latitude", latitude),
("longitude", longitude),
("current_weather", "true"),
];
debug!("Calling {ENDPOINT} with {params:?}");
let response = reqwest::Client::new()
.get(ENDPOINT)
.query(¶ms)
.send()
.await
.map_err(|e| ToolUseScenarioError(format!("Error requesting weather: {e:?}")))?
.error_for_status()
.map_err(|e| ToolUseScenarioError(format!("Failed to request weather: {e:?}")))?;
debug!("Response: {response:?}");
let bytes = response
.bytes()
.await
.map_err(|e| ToolUseScenarioError(format!("Error reading response: {e:?}")))?;
let result = String::from_utf8(bytes.to_vec())
.map_err(|_| ToolUseScenarioError("Response was not utf8".into()))?;
Ok(ToolResultBlock::builder()
.tool_use_id(tool_use.tool_use_id())
.content(ToolResultContentBlock::Text(result))
.build()?)
}
```
Dienstprogramme zum Drucken der Nachrichteninhaltsblöcke.
```
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:?})"
)))
}
}
```
Verwenden von Anweisungen, des Fehlerdienstprogramms und von Konstanten.
```
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(),
})
}
}
```
+ Details zu API finden Sie unter [Converse](https://docs.rs/aws-sdk-bedrockruntime/latest/aws_sdk_bedrockruntime/client/struct.Client.html#method.converse) in der *API-Referenz zum AWS SDK für Rust*.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter[Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md). Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Cohere Command für Amazon Bedrock Runtime
Die folgenden Codebeispiele zeigen, wie Sie Amazon Bedrock Runtime mit AWS SDKs verwenden.
**Topics**
+ [Converse](bedrock-runtime_example_bedrock-runtime_Converse_CohereCommand_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_CohereCommand_section.md)
+ [Verstehen von Dokumenten](bedrock-runtime_example_bedrock-runtime_DocumentUnderstanding_CohereCommand_section.md)
+ [InvokeModel: Befehl R und R\$1](bedrock-runtime_example_bedrock-runtime_InvokeModel_CohereCommandR_section.md)
+ [InvokeModelWithResponseStream: Befehl R und R\$1](bedrock-runtime_example_bedrock-runtime_InvokeModelWithResponseStream_CohereCommandR_section.md)
+ [Szenario: Verwenden des Tools mit der Converse-API](bedrock-runtime_example_bedrock-runtime_Scenario_ToolUseDemo_CohereCommand_section.md)
# Aufrufen von Cohere Command in Amazon Bedrock mithilfe der Converse-API von Bedrock
Die folgenden Codebeispiele zeigen, wie Sie mithilfe der Converse-API von Bedrock eine Textnachricht an Cohere Command senden können.
------
#### [ .NET ]
**SDK für .NET (v4)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Bedrock-runtime#code-examples) einrichten und ausführen.
Senden Sie mithilfe der Converse-API von Bedrock eine Textnachricht an Cohere Command.
```
// 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;
}
```
+ Details zur API finden Sie unter [Converse](https://docs.aws.amazon.com/goto/DotNetSDKV4/bedrock-runtime-2023-09-30/Converse) in der *AWS SDK für .NET -API-Referenz*.
------
#### [ Java ]
**SDK für Java 2.x**
Es gibt noch mehr GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Senden Sie mithilfe der Converse-API von Bedrock eine Textnachricht an Cohere Command.
```
// 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();
}
}
```
Senden Sie mithilfe der Converse-API von Bedrock mit dem asynchronen Java-Client eine Textnachricht an Cohere Command.
```
// 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();
}
}
```
+ Weitere API-Informationen finden Sie unter [Converse](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/Converse) in der *AWS SDK for Java 2.x -API-Referenz*.
------
#### [ JavaScript ]
**SDK für JavaScript (v3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Senden Sie mithilfe der Converse-API von Bedrock eine Textnachricht an Cohere Command.
```
// 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);
}
```
+ Details zur API finden Sie unter [Converse](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseCommand) in der *AWS SDK für JavaScript -API-Referenz*.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Senden Sie mithilfe der Converse-API von Bedrock eine Textnachricht an Cohere Command.
```
# 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)
```
+ Weitere API-Informationen finden Sie unter [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) in der *API-Referenz zum AWS -SDK für Python (Boto3)*.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter[Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md). Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Aufrufen von Cohere Command in Amazon Bedrock mithilfe der Converse-API von Bedrock mit Antwortstream
Die folgenden Codebeispiele zeigen, wie Sie mithilfe der Converse-API von Bedrock eine Textnachricht an Cohere Command senden und den Antwortstream in Echtzeit verarbeiten.
------
#### [ .NET ]
**SDK für .NET (v4)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Bedrock-runtime#code-examples) einrichten und ausführen.
Senden Sie mithilfe der Converse-API von Bedrock eine Textnachricht an Cohere Command und verarbeiten Sie den Antwortstream in Echtzeit.
```
// 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;
}
```
+ Einzelheiten zur API finden Sie [ConverseStream](https://docs.aws.amazon.com/goto/DotNetSDKV4/bedrock-runtime-2023-09-30/ConverseStream)in der *AWS SDK für .NET API-Referenz*.
------
#### [ Java ]
**SDK für Java 2.x**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Senden Sie mithilfe der Converse-API von Bedrock eine Textnachricht an Cohere Command und verarbeiten Sie den Antwortstream in Echtzeit.
```
// 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());
}
}
}
```
+ Einzelheiten zur API finden Sie [ConverseStream](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/ConverseStream)in der *AWS SDK for Java 2.x API-Referenz*.
------
#### [ JavaScript ]
**SDK für JavaScript (v3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Senden Sie mithilfe der Converse-API von Bedrock eine Textnachricht an Cohere Command und verarbeiten Sie den Antwortstream in Echtzeit.
```
// 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);
}
```
+ Einzelheiten zur API finden Sie [ConverseStream](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseStreamCommand)in der *AWS SDK für JavaScript API-Referenz*.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Senden Sie mithilfe der Converse-API von Bedrock eine Textnachricht an Cohere Command und verarbeiten Sie den Antwortstream in Echtzeit.
```
# 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)
```
+ Einzelheiten zur API finden Sie [ConverseStream](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/ConverseStream)in *AWS SDK for Python (Boto3) API* Reference.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter. [Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md) Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Senden und Verarbeiten eines Dokuments mit Cohere-Command-Modellen in Amazon Bedrock
Das folgende Codebeispiel zeigt, wie man ein Dokument mit Cohere-Command-Modellen in Amazon Bedrock sendet und verarbeitet.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Senden und verarbeiten Sie ein Dokument mit Cohere-Command-Modellen in 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)
```
+ Weitere API-Informationen finden Sie unter [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) in der *API-Referenz zum AWS -SDK für Python (Boto3)*.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter[Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md). Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Aufrufen von Cohere Command R und R\$1 in Amazon Bedrock mithilfe der Invoke-Model-API
Die folgenden Codebeispiele zeigen, wie Sie mithilfe der Invoke-Model-API eine Textnachricht an Cohere Command R und R\$1 senden können.
------
#### [ .NET ]
**SDK für .NET**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime#code-examples) einrichten und ausführen.
Verwenden der API zum Aufrufen eines Modells zum Senden einer Textnachricht.
```
// 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;
}
```
+ Einzelheiten zur API finden Sie [InvokeModel](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/InvokeModel)in der *AWS SDK für .NET API-Referenz*.
------
#### [ Java ]
**SDK für Java 2.x**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Verwenden der API zum Aufrufen eines Modells zum Senden einer Textnachricht.
```
// 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();
}
}
```
+ Einzelheiten zur API finden Sie [InvokeModel](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModel)in der *AWS SDK for Java 2.x API-Referenz*.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Verwenden der API zum Aufrufen eines Modells zum Senden einer Textnachricht.
```
# 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)
```
+ Einzelheiten zur API finden Sie [InvokeModel](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModel)in *AWS SDK for Python (Boto3) API* Reference.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter. [Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md) Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Aufrufen von Cohere Command R und R\$1 in Amazon Bedrock mithilfe der Invoke-Model-API mit Antwortstream
Die folgenden Codebeispiele zeigen, wie Sie mithilfe der Invoke-Model-API mit Antwortstream eine Textnachricht an Cohere Command senden.
------
#### [ .NET ]
**SDK für .NET**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime#code-examples) einrichten und ausführen.
Verwenden Sie die Invoke-Model-API, um eine Textnachricht zu senden und den Antwortstream in Echtzeit zu verarbeiten.
```
// 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;
}
```
+ Einzelheiten zur API finden Sie [InvokeModel](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/InvokeModel)in der *AWS SDK für .NET API-Referenz*.
------
#### [ Java ]
**SDK für Java 2.x**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Verwenden Sie die Invoke-Model-API, um eine Textnachricht zu senden und den Antwortstream in Echtzeit zu verarbeiten.
```
// 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();
}
}
```
+ Einzelheiten zur API finden Sie [InvokeModel](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModel)in der *AWS SDK for Java 2.x API-Referenz*.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Verwenden Sie die Invoke-Model-API, um eine Textnachricht zu senden und den Antwortstream in Echtzeit zu verarbeiten.
```
# 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)
```
+ Einzelheiten zur API finden Sie [InvokeModel](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModel)in *AWS SDK for Python (Boto3) API* Reference.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter. [Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md) Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Eine Demo für die Verwendung des Tools, die veranschaulicht, wie KI-Modelle in Amazon Bedrock mit einem benutzerdefinierten Tool oder einer API verbunden werden
Das folgende Codebeispiel zeigt, wie eine typische Interaktion zwischen einer Anwendung, einem generativen KI-Modell und verbundenen Tools aufgebaut oder APIs Interaktionen zwischen der KI und der Außenwelt vermittelt werden. Es wird das Beispiel der Verbindung einer externen Wetter-API mit dem KI-Modell verwendet, damit dieses auf Grundlage der Eingaben des Benutzenden Wetterinformationen in Echtzeit bereitstellen kann.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Das primäre Ausführungsskript der Demo. Dieses Skript orchestriert die Kommunikation zwischen dem Benutzer, der Converse-API von Amazon Bedrock und einem Wettertool.
```
"""
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()
```
Das in der Demo verwendete Wettertool. Dieses Skript definiert die Tool-Spezifikation und implementiert die Logik zum Abrufen von Wetterdaten über die Open-Meteo-API.
```
import requests
from requests.exceptions import RequestException
def get_tool_spec():
"""
Returns the JSON Schema specification for the Weather tool. The tool specification
defines the input schema and describes the tool's functionality.
For more information, see https://json-schema.org/understanding-json-schema/reference.
:return: The tool specification for the Weather tool.
"""
return {
"toolSpec": {
"name": "Weather_Tool",
"description": "Get the current weather for a given location, based on its WGS84 coordinates.",
"inputSchema": {
"json": {
"type": "object",
"properties": {
"latitude": {
"type": "string",
"description": "Geographical WGS84 latitude of the location.",
},
"longitude": {
"type": "string",
"description": "Geographical WGS84 longitude of the location.",
},
},
"required": ["latitude", "longitude"],
}
},
}
}
def fetch_weather_data(input_data):
"""
Fetches weather data for the given latitude and longitude using the Open-Meteo API.
Returns the weather data or an error message if the request fails.
:param input_data: The input data containing the latitude and longitude.
:return: The weather data or an error message.
"""
endpoint = "https://api.open-meteo.com/v1/forecast"
latitude = input_data.get("latitude")
longitude = input_data.get("longitude", "")
params = {"latitude": latitude, "longitude": longitude, "current_weather": True}
try:
response = requests.get(endpoint, params=params)
weather_data = {"weather_data": response.json()}
response.raise_for_status()
return weather_data
except RequestException as e:
return e.response.json()
except Exception as e:
return {"error": type(e), "message": str(e)}
```
+ Details zur API finden Sie unter [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) in der *API-Referenz zum AWS SDK für Python (Boto3)*.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter[Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md). Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# DeepSeek für Amazon Bedrock Runtime
Die folgenden Codebeispiele zeigen, wie Sie Amazon Bedrock Runtime mit AWS SDKs verwenden.
**Topics**
+ [Verstehen von Dokumenten](bedrock-runtime_example_bedrock-runtime_DocumentUnderstanding_DeepSeek_section.md)
# Senden und Verarbeiten eines Dokuments mit DeepSeek auf Amazon Bedrock
Das folgende Codebeispiel zeigt, wie ein Dokument mit DeepSeek auf Amazon Bedrock gesendet und verarbeitet wird.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Senden und verarbeiten Sie ein Dokument mit DeepSeek auf 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)
```
+ Details zur API finden Sie unter [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) in der *API-Referenz zum AWS SDK für Python (Boto3)*.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter[Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md). Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Meta Llama für Amazon Bedrock Runtime
Die folgenden Codebeispiele zeigen, wie Sie Amazon Bedrock Runtime mit AWS SDKs verwenden.
**Topics**
+ [Converse](bedrock-runtime_example_bedrock-runtime_Converse_MetaLlama_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_MetaLlama_section.md)
+ [Verstehen von Dokumenten](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)
# Aufrufen von Meta Llama in Amazon Bedrock mithilfe der Converse-API von Bedrock
Die folgenden Codebeispiele zeigen, wie Sie mithilfe der Converse-API von Bedrock eine Textnachricht an Meta Llama senden können.
------
#### [ .NET ]
**SDK für .NET (v4)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Bedrock-runtime#code-examples) einrichten und ausführen.
Senden Sie mithilfe der Converse-API von Bedrock eine Textnachricht an Meta Llama.
```
// 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;
}
```
+ Details zur API finden Sie unter [Converse](https://docs.aws.amazon.com/goto/DotNetSDKV4/bedrock-runtime-2023-09-30/Converse) in der *AWS SDK für .NET -API-Referenz*.
------
#### [ Java ]
**SDK für Java 2.x**
Es gibt noch mehr GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Senden Sie mithilfe der Converse-API von Bedrock eine Textnachricht an Meta Llama.
```
// 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();
}
}
```
Senden Sie eine Textnachricht an Meta Llama, indem Sie die Converse-API von Bedrock mit dem asynchronen Java-Client verwenden.
```
// 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();
}
}
```
+ Details zur API finden Sie unter [Converse](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/Converse) in der *AWS SDK for Java 2.x -API-Referenz*.
------
#### [ JavaScript ]
**SDK für JavaScript (v3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Senden Sie mithilfe der Converse-API von Bedrock eine Textnachricht an Meta Llama.
```
// 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);
}
```
+ Details zur API finden Sie unter [Converse](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseCommand) in der *AWS SDK für JavaScript -API-Referenz*.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Senden Sie mithilfe der Converse-API von Bedrock eine Textnachricht an Meta Llama.
```
# 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)
```
+ Details zur API finden Sie unter [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) in der *API-Referenz zum AWS SDK für Python (Boto3)*.
------
#### [ Swift ]
**SDK für Swift**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Senden Sie mithilfe der Converse-API von Bedrock eine Textnachricht an Meta Llama.
```
// 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"
}
}
```
+ Weitere API-Informationen finden Sie unter [Converse](https://sdk.amazonaws.com/swift/api/awsbedrockruntime/latest/documentation/awsbedrockruntime/bedrockruntimeclient/converse(input:)) in der *API-Referenz zum AWS SDK für Swift*.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter[Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md). Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Aufrufen von Meta Llama in Amazon Bedrock mithilfe der Converse-API von Bedrock mit Antwortstream
Die folgenden Codebeispiele zeigen, wie Sie mithilfe der Converse-API von Bedrock eine Textnachricht an Meta Llama senden und den Antwortstrom in Echtzeit verarbeiten.
------
#### [ .NET ]
**SDK für .NET (v4)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Bedrock-runtime#code-examples) einrichten und ausführen.
Senden Sie mithilfe der Converse-API von Bedrock eine Textnachricht an Meta Llama und verarbeiten Sie den Antwortstream in Echtzeit.
```
// 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;
}
```
+ Einzelheiten zur API finden Sie [ConverseStream](https://docs.aws.amazon.com/goto/DotNetSDKV4/bedrock-runtime-2023-09-30/ConverseStream)in der *AWS SDK für .NET API-Referenz*.
------
#### [ Java ]
**SDK für Java 2.x**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Senden Sie mithilfe der Converse-API von Bedrock eine Textnachricht an Meta Llama und verarbeiten Sie den Antwortstream in Echtzeit.
```
// 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());
}
}
}
```
+ Einzelheiten zur API finden Sie [ConverseStream](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/ConverseStream)in der *AWS SDK for Java 2.x API-Referenz*.
------
#### [ JavaScript ]
**SDK für JavaScript (v3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Senden Sie mithilfe der Converse-API von Bedrock eine Textnachricht an Meta Llama und verarbeiten Sie den Antwortstream in Echtzeit.
```
// 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);
}
```
+ Einzelheiten zur API finden Sie [ConverseStream](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseStreamCommand)in der *AWS SDK für JavaScript API-Referenz*.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Senden Sie mithilfe der Converse-API von Bedrock eine Textnachricht an Meta Llama und verarbeiten Sie den Antwortstream in Echtzeit.
```
# 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)
```
+ Einzelheiten zur API finden Sie [ConverseStream](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/ConverseStream)in *AWS SDK for Python (Boto3) API* Reference.
------
#### [ Swift ]
**SDK für Swift**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Senden Sie mithilfe der Converse-API von Bedrock eine Textnachricht an Meta Llama und verarbeiten Sie den Antwortstream in Echtzeit.
```
// 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
}
}
}
```
+ Einzelheiten zur API finden Sie [ConverseStream](https://sdk.amazonaws.com/swift/api/awsbedrockruntime/latest/documentation/awsbedrockruntime/bedrockruntimeclient/conversestream(input:))in der *API-Referenz zum AWS SDK für Swift*.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter[Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md). Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Senden und Verarbeiten eines Dokuments mit Llama in Amazon Bedrock
Das folgende Codebeispiel zeigt, wie ein Dokument mit Llama in Amazon Bedrock gesendet und verarbeitet wird.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Senden und verarbeiten Sie ein Dokument mit Llama in 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)
```
+ Weitere API-Informationen finden Sie unter [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) in der *API-Referenz zum AWS -SDK für Python (Boto3)*.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter[Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md). Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Aufrufen von Meta Llama in Amazon Bedrock mithilfe der Invoke-Model-API
Die folgenden Codebeispiele zeigen, wie eine Textnachricht mit der Invoke-Model-API an Meta Llama gesendet wird.
------
#### [ .NET ]
**SDK für .NET**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime#code-examples) einrichten und ausführen.
Verwenden der API zum Aufrufen eines Modells zum Senden einer Textnachricht.
```
// 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;
}
```
+ Einzelheiten zur API finden Sie [InvokeModel](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/InvokeModel)in der *AWS SDK für .NET API-Referenz*.
------
#### [ Java ]
**SDK für Java 2.x**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Verwenden der API zum Aufrufen eines Modells zum Senden einer Textnachricht.
```
// 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();
}
}
```
+ Einzelheiten zur API finden Sie [InvokeModel](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModel)in der *AWS SDK for Java 2.x API-Referenz*.
------
#### [ JavaScript ]
**SDK für JavaScript (v3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Verwenden der API zum Aufrufen eines Modells zum Senden einer Textnachricht.
```
// 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
```
+ Einzelheiten zur API finden Sie [InvokeModel](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/InvokeModelCommand)in der *AWS SDK für JavaScript API-Referenz*.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Verwenden der API zum Aufrufen eines Modells zum Senden einer Textnachricht.
```
# 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)
```
+ Einzelheiten zur API finden Sie [InvokeModel](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModel)in *AWS SDK for Python (Boto3) API* Reference.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter. [Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md) Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Aufrufen von Meta Llama in Amazon Bedrock mithilfe der Invoke-Model-API mit Antwortstream
Die folgenden Codebeispiele zeigen, wie eine Textnachricht mithilfe der Invoke Model API an Meta Llama gesendet und der Antwortstrom ausgedruckt wird.
------
#### [ .NET ]
**SDK für .NET**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime#code-examples) einrichten und ausführen.
Verwenden Sie die Invoke-Model-API, um eine Textnachricht zu senden und den Antwortstream in Echtzeit zu verarbeiten.
```
// 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;
}
```
+ Einzelheiten zur API finden Sie [InvokeModelWithResponseStream](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/InvokeModelWithResponseStream)in der *AWS SDK für .NET API-Referenz*.
------
#### [ Java ]
**SDK für Java 2.x**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Verwenden Sie die Invoke-Model-API, um eine Textnachricht zu senden und den Antwortstream in Echtzeit zu verarbeiten.
```
// 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();
}
}
```
+ Einzelheiten zur API finden Sie [InvokeModelWithResponseStream](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModelWithResponseStream)in der *AWS SDK for Java 2.x API-Referenz*.
------
#### [ JavaScript ]
**SDK für JavaScript (v3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Verwenden Sie die Invoke-Model-API, um eine Textnachricht zu senden und den Antwortstream in Echtzeit zu verarbeiten.
```
// 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
```
+ Einzelheiten zur API finden Sie [InvokeModelWithResponseStream](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/InvokeModelWithResponseStreamCommand)in der *AWS SDK für JavaScript API-Referenz*.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Verwenden Sie die Invoke-Model-API, um eine Textnachricht zu senden und den Antwortstream in Echtzeit zu verarbeiten.
```
# 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)
```
+ Einzelheiten zur API finden Sie [InvokeModelWithResponseStream](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModelWithResponseStream)in *AWS SDK for Python (Boto3) API* Reference.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter. [Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md) Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Mistral AI für Amazon Bedrock Runtime
Die folgenden Codebeispiele zeigen, wie Sie Amazon Bedrock Runtime mit AWS SDKs verwenden.
**Topics**
+ [Converse](bedrock-runtime_example_bedrock-runtime_Converse_Mistral_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_Mistral_section.md)
+ [Verstehen von Dokumenten](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)
# Aufrufen von Mistral in Amazon Bedrock mithilfe der Converse-API von Bedrock
Die folgenden Codebeispiele zeigen, wie eine Textnachricht mit der Converse-API von Bedrock an Mistral gesendet wird.
------
#### [ .NET ]
**SDK für .NET (v4)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Bedrock-runtime#code-examples) einrichten und ausführen.
Senden Sie mithilfe der Converse-API von Bedrock eine Textnachricht an Mistral.
```
// 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;
}
```
+ Details zur API finden Sie unter [Converse](https://docs.aws.amazon.com/goto/DotNetSDKV4/bedrock-runtime-2023-09-30/Converse) in der *AWS SDK für .NET -API-Referenz*.
------
#### [ Java ]
**SDK für Java 2.x**
Es gibt noch mehr GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Senden Sie mithilfe der Converse-API von Bedrock eine Textnachricht an Mistral.
```
// 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();
}
}
```
Senden Sie mithilfe der Converse-API von Bedrock mit dem asynchronen Java-Client eine Textnachricht an Mistral.
```
// 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();
}
}
```
+ Weitere API-Informationen finden Sie unter [Converse](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/Converse) in der *AWS SDK for Java 2.x -API-Referenz*.
------
#### [ JavaScript ]
**SDK für JavaScript (v3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Senden Sie mithilfe der Converse-API von Bedrock eine Textnachricht an Mistral.
```
// 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);
}
```
+ Details zur API finden Sie unter [Converse](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseCommand) in der *AWS SDK für JavaScript -API-Referenz*.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Senden Sie mithilfe der Converse-API von Bedrock eine Textnachricht an Mistral.
```
# 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)
```
+ Weitere API-Informationen finden Sie unter [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) in der *API-Referenz zum AWS -SDK für Python (Boto3)*.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter[Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md). Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Aufrufen von Mistral in Amazon Bedrock mithilfe der Converse-API von Bedrock mit Antwortstream
Die folgenden Codebeispiele zeigen, wie Sie mithilfe der Converse-API von Bedrock eine Textnachricht an Mistral senden und den Antwortstream in Echtzeit verarbeiten.
------
#### [ .NET ]
**SDK für .NET (v4)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Bedrock-runtime#code-examples) einrichten und ausführen.
Senden Sie mithilfe der Converse-API von Bedrock eine Textnachricht an Mistral und verarbeiten Sie den Antwortstream in Echtzeit.
```
// 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;
}
```
+ Einzelheiten zur API finden Sie [ConverseStream](https://docs.aws.amazon.com/goto/DotNetSDKV4/bedrock-runtime-2023-09-30/ConverseStream)in der *AWS SDK für .NET API-Referenz*.
------
#### [ Java ]
**SDK für Java 2.x**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Senden Sie mithilfe der Converse-API von Bedrock eine Textnachricht an Mistral und verarbeiten Sie den Antwortstream in Echtzeit.
```
// 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());
}
}
}
```
+ Einzelheiten zur API finden Sie [ConverseStream](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/ConverseStream)in der *AWS SDK for Java 2.x API-Referenz*.
------
#### [ JavaScript ]
**SDK für JavaScript (v3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Senden Sie mithilfe der Converse-API von Bedrock eine Textnachricht an Mistral und verarbeiten Sie den Antwortstream in Echtzeit.
```
// 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);
}
```
+ Einzelheiten zur API finden Sie [ConverseStream](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseStreamCommand)in der *AWS SDK für JavaScript API-Referenz*.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Senden Sie mithilfe der Converse-API von Bedrock eine Textnachricht an Mistral und verarbeiten Sie den Antwortstream in Echtzeit.
```
# 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)
```
+ Einzelheiten zur API finden Sie [ConverseStream](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/ConverseStream)in *AWS SDK for Python (Boto3) API* Reference.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter. [Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md) Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Senden und Verarbeiten eines Dokuments mit Mistral-Modellen in Amazon Bedrock
Das folgende Code-Beispiel zeigt, wie Sie ein Dokument mit Mistral-Modellen in Amazon Bedrock senden und verarbeiten.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Senden und verarbeiten Sie ein Dokument mit Mistral-Modellen in 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)
```
+ Weitere API-Informationen finden Sie unter [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) in der *API-Referenz zum AWS -SDK für Python (Boto3)*.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter[Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md). Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Aufrufen von Mistral-AI-Modellen in Amazon Bedrock mithilfe der Invoke-Model-API
Die folgenden Codebeispiele zeigen, wie eine Textnachricht mit der Invoke-Model-API an Mistral-Modelle gesendet wird.
------
#### [ .NET ]
**SDK für .NET**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime#code-examples) einrichten und ausführen.
Verwenden der API zum Aufrufen eines Modells zum Senden einer Textnachricht.
```
// 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;
}
```
+ Einzelheiten zur API finden Sie [InvokeModel](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/InvokeModel)in der *AWS SDK für .NET API-Referenz*.
------
#### [ Java ]
**SDK für Java 2.x**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Verwenden der API zum Aufrufen eines Modells zum Senden einer Textnachricht.
```
// 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();
}
}
```
+ Einzelheiten zur API finden Sie [InvokeModel](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModel)in der *AWS SDK for Java 2.x API-Referenz*.
------
#### [ JavaScript ]
**SDK für JavaScript (v3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Verwenden der API zum Aufrufen eines Modells zum Senden einer Textnachricht.
```
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);
}
}
```
+ Einzelheiten zur API finden Sie [InvokeModel](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/InvokeModelCommand)in der *AWS SDK für JavaScript API-Referenz*.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Verwenden der API zum Aufrufen eines Modells zum Senden einer Textnachricht.
```
# 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)
```
+ Einzelheiten zur API finden Sie [InvokeModel](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModel)in *AWS SDK for Python (Boto3) API* Reference.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter. [Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md) Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Aufrufen von Mistral-AI-Modellen in Amazon Bedrock mithilfe der Invoke-Model-API mit Antwortstream
Die folgenden Codebeispiele zeigen, wie Sie eine Textnachricht mit der Invoke-Model-API an Mistral-AI-Modelle senden und den Antwortstream ausdrucken.
------
#### [ .NET ]
**SDK für .NET**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime#code-examples) einrichten und ausführen.
Verwenden Sie die Invoke-Model-API, um eine Textnachricht zu senden und den Antwortstream in Echtzeit zu verarbeiten.
```
// 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;
}
```
+ Einzelheiten zur API finden Sie [InvokeModelWithResponseStream](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/InvokeModelWithResponseStream)in der *AWS SDK für .NET API-Referenz*.
------
#### [ Java ]
**SDK für Java 2.x**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Verwenden Sie die Invoke-Model-API, um eine Textnachricht zu senden und den Antwortstream in Echtzeit zu verarbeiten.
```
// 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();
}
}
```
+ Einzelheiten zur API finden Sie [InvokeModelWithResponseStream](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModelWithResponseStream)in der *AWS SDK for Java 2.x API-Referenz*.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Verwenden Sie die Invoke-Model-API, um eine Textnachricht zu senden und den Antwortstream in Echtzeit zu verarbeiten.
```
# 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)
```
+ Einzelheiten zur API finden Sie [InvokeModelWithResponseStream](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModelWithResponseStream)in *AWS SDK for Python (Boto3) API* Reference.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter. [Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md) Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Stable Diffusion für Amazon Bedrock Runtime
Die folgenden Codebeispiele zeigen, wie Sie Amazon Bedrock Runtime mit AWS SDKs verwenden.
**Topics**
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_StableDiffusion_section.md)
# Aufrufen von Stability.ai Stable Diffusion XL in Amazon Bedrock, um ein Bild zu generieren
Die folgenden Codebeispiele zeigen, wie Sie Stability.ai Stable Diffusion XL in Amazon Bedrock aufrufen, um ein Bild zu generieren.
------
#### [ Java ]
**SDK für Java 2.x**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Erstellen Sie ein Bild mit 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);
}
}
```
+ Einzelheiten zur API finden Sie [InvokeModel](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModel)in der *AWS SDK for Java 2.x API-Referenz*.
------
#### [ PHP ]
**SDK für PHP**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Erstellen Sie ein Bild mit 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;
}
```
+ Einzelheiten zur API finden Sie [InvokeModel](https://docs.aws.amazon.com/goto/SdkForPHPV3/bedrock-runtime-2023-09-30/InvokeModel)in der *AWS SDK für PHP API-Referenz*.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples) einrichten und ausführen.
Erstellen Sie ein Bild mit 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}")
```
+ Einzelheiten zur API finden Sie [InvokeModel](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModel)in *AWS SDK for Python (Boto3) API* Reference.
------
#### [ SAP ABAP ]
**SDK für SAP ABAP**
Es gibt noch mehr dazu. GitHub Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/bdr#code-examples) einrichten und ausführen.
Erstellen Sie ein Bild mit 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.
```
Rufen Sie das Basismodell von Stability.ai Stable Diffusion XL auf, um Bilder mit dem L2-High-Level-Client zu generieren.
```
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.
```
+ Einzelheiten zur API finden Sie [InvokeModel](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)in der *API-Referenz zum AWS SDK für SAP ABAP*.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter[Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md). Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Codebeispiele für Amazon Bedrock Agents mit AWS SDKs
Die folgenden Codebeispiele zeigen, wie Amazon Bedrock Agents mit einem AWS Software Development Kit (SDK) verwendet werden.
*Aktionen* sind Codeauszüge aus größeren Programmen und müssen im Kontext ausgeführt werden. Während Aktionen Ihnen zeigen, wie Sie einzelne Service-Funktionen aufrufen, können Sie Aktionen im Kontext der zugehörigen Szenarien anzeigen.
*Szenarien* sind Codebeispiele, die Ihnen zeigen, wie Sie bestimmte Aufgaben ausführen, indem Sie mehrere Funktionen innerhalb eines Service aufrufen oder mit anderen AWS-Services kombinieren.
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter[Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md). Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
**Contents**
+ [Grundlagen](service_code_examples_bedrock-agent_basics.md)
+ [Hallo Agenten für Amazon Bedrock](bedrock-agent_example_bedrock-agent_Hello_section.md)
+ [Aktionen](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)
+ [Szenarien](service_code_examples_bedrock-agent_scenarios.md)
+ [Erstellen und Aufrufen eines Flows](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockFlows_section.md)
+ [Erstellen und Aufrufen eines verwalteten Prompts](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockPrompts_section.md)
+ [Erstellen und Aufrufen eines Agenten](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockAgents_section.md)
+ [Orchestrieren von Anwendungen mit generativer KI mit Step Functions](bedrock-agent_example_cross_ServerlessPromptChaining_section.md)
# Grundlegende Beispiele für die Verwendung von Amazon Bedrock Agents AWS SDKs
Die folgenden Codebeispiele zeigen, wie Sie die Grundlagen von Amazon Bedrock Agents mit AWS SDKs verwenden können.
**Contents**
+ [Hallo Agenten für Amazon Bedrock](bedrock-agent_example_bedrock-agent_Hello_section.md)
+ [Aktionen](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)
# Hallo Agenten für Amazon Bedrock
Die folgenden Codebeispiele veranschaulichen die ersten Schritte mit Agenten für Amazon Bedrock.
------
#### [ JavaScript ]
**SDK für JavaScript (v3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-agent#code-examples) einrichten und ausführen.
```
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();
}
```
+ Weitere API-Informationen finden Sie in den folgenden Themen der *AWS SDK für JavaScript -API-Referenz*.
+ [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)
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter[Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md). Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Aktionen für Amazon Bedrock-Agenten, die AWS SDKs
Die folgenden Codebeispiele zeigen, wie einzelne Amazon Bedrock Agents-Aktionen mit AWS SDKs ausgeführt werden. Jedes Beispiel enthält einen Link zu GitHub, wo Sie Anweisungen zum Einrichten und Ausführen des Codes finden.
Diese Auszüge rufen die API der Agenten für Amazon Bedrock auf und sind Codeauszüge aus größeren Programmen, die im Kontext ausgeführt werden müssen. Sie können Aktionen im Kontext unter [Szenarien für die Verwendung von Amazon Bedrock Agents AWS SDKs](service_code_examples_bedrock-agent_scenarios.md) anzeigen.
Die folgenden Beispiele enthalten nur die am häufigsten verwendeten Aktionen. Eine vollständige Liste finden Sie in der [API-Referenz der Agenten für Amazon Bedrock](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)
# Verwendung `CreateAgent` mit einem AWS SDK
Die folgenden Code-Beispiele zeigen, wie `CreateAgent` verwendet wird.
Beispiele für Aktionen sind Codeauszüge aus größeren Programmen und müssen im Kontext ausgeführt werden. Im folgenden Codebeispiel können Sie diese Aktion im Kontext sehen:
+ [Erstellen und Aufrufen eines Agenten](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockAgents_section.md)
------
#### [ JavaScript ]
**SDK für JavaScript (v3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-agent#code-examples) einrichten und ausführen.
Erstellen Sie einen Agenten.
```
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);
}
```
+ Einzelheiten zur API finden Sie [CreateAgent](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-agent/command/CreateAgentCommand)in der *AWS SDK für JavaScript API-Referenz*.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples) einrichten und ausführen.
Erstellen Sie einen Agenten.
```
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"]
```
+ Einzelheiten zur API finden Sie [CreateAgent](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/CreateAgent)in *AWS SDK for Python (Boto3) API* Reference.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter. [Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md) Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Verwendung `CreateAgentActionGroup` mit einem AWS SDK
Das folgende Codebeispiel zeigt, wie es verwendet wird`CreateAgentActionGroup`.
Beispiele für Aktionen sind Codeauszüge aus größeren Programmen und müssen im Kontext ausgeführt werden. Im folgenden Codebeispiel können Sie diese Aktion im Kontext sehen:
+ [Erstellen und Aufrufen eines Agenten](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockAgents_section.md)
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples) einrichten und ausführen.
Erstellen einer Agentenaktionsgruppe.
```
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
```
+ Einzelheiten zur API finden Sie [CreateAgentActionGroup](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/CreateAgentActionGroup)in *AWS SDK for Python (Boto3) API* Reference.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter. [Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md) Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Verwendung `CreateAgentAlias` mit einem AWS SDK
Das folgende Codebeispiel zeigt, wie es verwendet wird`CreateAgentAlias`.
Beispiele für Aktionen sind Codeauszüge aus größeren Programmen und müssen im Kontext ausgeführt werden. Im folgenden Codebeispiel können Sie diese Aktion im Kontext sehen:
+ [Erstellen und Aufrufen eines Agenten](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockAgents_section.md)
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples) einrichten und ausführen.
Erstellen eines Alias für einen Agenten.
```
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
```
+ Einzelheiten zur API finden Sie [CreateAgentAlias](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/CreateAgentAlias)in *AWS SDK for Python (Boto3) API* Reference.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter. [Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md) Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Verwendung `CreateFlow` mit einem AWS SDK
Das folgende Codebeispiel zeigt, wie es verwendet wird`CreateFlow`.
Beispiele für Aktionen sind Codeauszüge aus größeren Programmen und müssen im Kontext ausgeführt werden. Im folgenden Codebeispiel können Sie diese Aktion im Kontext sehen:
+ [Erstellen und Aufrufen eines Flows](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockFlows_section.md)
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples) einrichten und ausführen.
Erstellen eines Amazon-Bedrock-Flow.
```
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
```
+ Einzelheiten zur API finden Sie [CreateFlow](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/CreateFlow)in *AWS SDK for Python (Boto3) API* Reference.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter. [Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md) Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Verwendung `CreateFlowAlias` mit einem AWS SDK
Das folgende Codebeispiel zeigt, wie es verwendet wird`CreateFlowAlias`.
Beispiele für Aktionen sind Codeauszüge aus größeren Programmen und müssen im Kontext ausgeführt werden. Im folgenden Codebeispiel können Sie diese Aktion im Kontext sehen:
+ [Erstellen und Aufrufen eines Flows](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockFlows_section.md)
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples) einrichten und ausführen.
Erstellen eines Alias für einen Amazon-Bedrock-Flow.
```
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
```
+ Einzelheiten zur API finden Sie [CreateFlowAlias](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/CreateFlowAlias)in *AWS SDK for Python (Boto3) API* Reference.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter. [Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md) Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Verwendung `CreateFlowVersion` mit einem AWS SDK
Das folgende Codebeispiel zeigt, wie es verwendet wird`CreateFlowVersion`.
Beispiele für Aktionen sind Codeauszüge aus größeren Programmen und müssen im Kontext ausgeführt werden. Im folgenden Codebeispiel können Sie diese Aktion im Kontext sehen:
+ [Erstellen und Aufrufen eines Flows](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockFlows_section.md)
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples) einrichten und ausführen.
Erstellen einer Version eines Amazon-Bedrock-Flows.
```
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
```
+ Einzelheiten zur API finden Sie [CreateFlowVersion](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/CreateFlowVersion)in *AWS SDK for Python (Boto3) API* Reference.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter. [Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md) Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Verwendung `CreateKnowledgeBase` mit einem AWS SDK
Das folgende Codebeispiel zeigt, wie es verwendet wird`CreateKnowledgeBase`.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples) einrichten und ausführen.
Erstellen einer Amazon-Bedrock-Wissensdatenbank.
```
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
```
+ Einzelheiten zur API finden Sie [CreateKnowledgeBase](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/CreateKnowledgeBase)in *AWS SDK for Python (Boto3) API* Reference.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter. [Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md) Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Verwendung `CreatePrompt` mit einem AWS SDK
Das folgende Codebeispiel zeigt, wie es verwendet wird`CreatePrompt`.
Beispiele für Aktionen sind Codeauszüge aus größeren Programmen und müssen im Kontext ausgeführt werden. Im folgenden Codebeispiel können Sie diese Aktion im Kontext sehen:
+ [Erstellen und Aufrufen eines verwalteten Prompts](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockPrompts_section.md)
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples) einrichten und ausführen.
Erstellen eines von Amazon Bedrock verwalteten Prompts.
```
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
```
+ Einzelheiten zur API finden Sie [CreatePrompt](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/CreatePrompt)in *AWS SDK for Python (Boto3) API* Reference.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter. [Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md) Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Verwendung `CreatePromptVersion` mit einem AWS SDK
Das folgende Codebeispiel zeigt, wie es verwendet wird`CreatePromptVersion`.
Beispiele für Aktionen sind Codeauszüge aus größeren Programmen und müssen im Kontext ausgeführt werden. Im folgenden Codebeispiel können Sie diese Aktion im Kontext sehen:
+ [Erstellen und Aufrufen eines verwalteten Prompts](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockPrompts_section.md)
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples) einrichten und ausführen.
Erstellen einer Version eines von Amazon Bedrock verwalteten Prompts.
```
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
```
+ Einzelheiten zur API finden Sie [CreatePromptVersion](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/CreatePromptVersion)in *AWS SDK for Python (Boto3) API* Reference.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter. [Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md) Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Verwendung `DeleteAgent` mit einem AWS SDK
Die folgenden Code-Beispiele zeigen, wie `DeleteAgent` verwendet wird.
Beispiele für Aktionen sind Codeauszüge aus größeren Programmen und müssen im Kontext ausgeführt werden. Im folgenden Codebeispiel können Sie diese Aktion im Kontext sehen:
+ [Erstellen und Aufrufen eines Agenten](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockAgents_section.md)
------
#### [ JavaScript ]
**SDK für JavaScript (v3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-agent#code-examples) einrichten und ausführen.
Löschen eines Agenten.
```
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);
}
```
+ Einzelheiten zur API finden Sie [DeleteAgent](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-agent/command/DeleteAgentCommand)in der *AWS SDK für JavaScript API-Referenz*.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples) einrichten und ausführen.
Löschen eines Agenten.
```
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
```
+ Einzelheiten zur API finden Sie [DeleteAgent](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/DeleteAgent)in *AWS SDK for Python (Boto3) API* Reference.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter. [Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md) Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Verwendung `DeleteAgentAlias` mit einem AWS SDK
Das folgende Codebeispiel zeigt, wie es verwendet wird`DeleteAgentAlias`.
Beispiele für Aktionen sind Codeauszüge aus größeren Programmen und müssen im Kontext ausgeführt werden. Im folgenden Codebeispiel können Sie diese Aktion im Kontext sehen:
+ [Erstellen und Aufrufen eines Agenten](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockAgents_section.md)
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples) einrichten und ausführen.
Löschen des Alias eines Agenten.
```
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
```
+ Einzelheiten zur API finden Sie [DeleteAgentAlias](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/DeleteAgentAlias)in *AWS SDK for Python (Boto3) API* Reference.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter. [Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md) Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Verwendung `DeleteFlow` mit einem AWS SDK
Das folgende Codebeispiel zeigt, wie es verwendet wird`DeleteFlow`.
Beispiele für Aktionen sind Codeauszüge aus größeren Programmen und müssen im Kontext ausgeführt werden. Im folgenden Codebeispiel können Sie diese Aktion im Kontext sehen:
+ [Erstellen und Aufrufen eines Flows](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockFlows_section.md)
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples) einrichten und ausführen.
Löschen eines Amazon-Bedrock-Flows.
```
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
```
+ Einzelheiten zur API finden Sie [DeleteFlow](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/DeleteFlow)in *AWS SDK for Python (Boto3) API* Reference.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter. [Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md) Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Verwendung `DeleteFlowAlias` mit einem AWS SDK
Das folgende Codebeispiel zeigt, wie es verwendet wird`DeleteFlowAlias`.
Beispiele für Aktionen sind Codeauszüge aus größeren Programmen und müssen im Kontext ausgeführt werden. Im folgenden Codebeispiel können Sie diese Aktion im Kontext sehen:
+ [Erstellen und Aufrufen eines Flows](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockFlows_section.md)
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples) einrichten und ausführen.
Löschen eines Alias für einen Amazon-Bedrock-Flow.
```
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
```
+ Einzelheiten zur API finden Sie [DeleteFlowAlias](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/DeleteFlowAlias)in *AWS SDK for Python (Boto3) API* Reference.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter. [Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md) Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Verwendung `DeleteFlowVersion` mit einem AWS SDK
Das folgende Codebeispiel zeigt, wie es verwendet wird`DeleteFlowVersion`.
Beispiele für Aktionen sind Codeauszüge aus größeren Programmen und müssen im Kontext ausgeführt werden. Im folgenden Codebeispiel können Sie diese Aktion im Kontext sehen:
+ [Erstellen und Aufrufen eines Flows](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockFlows_section.md)
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples) einrichten und ausführen.
Löschen einer Version eines Amazon-Bedrock-Flows.
```
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
```
+ Einzelheiten zur API finden Sie [DeleteFlowVersion](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/DeleteFlowVersion)in *AWS SDK for Python (Boto3) API* Reference.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter. [Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md) Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Verwendung `DeleteKnowledgeBase` mit einem AWS SDK
Das folgende Codebeispiel zeigt, wie es verwendet wird`DeleteKnowledgeBase`.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples) einrichten und ausführen.
Löschen Sie eine Amazon-Bedrock-Wissensdatenbank.
```
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
```
+ Einzelheiten zur API finden Sie [DeleteKnowledgeBase](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/DeleteKnowledgeBase)in *AWS SDK for Python (Boto3) API* Reference.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter. [Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md) Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Verwendung `DeletePrompt` mit einem AWS SDK
Das folgende Codebeispiel zeigt, wie es verwendet wird`DeletePrompt`.
Beispiele für Aktionen sind Codeauszüge aus größeren Programmen und müssen im Kontext ausgeführt werden. Im folgenden Codebeispiel können Sie diese Aktion im Kontext sehen:
+ [Erstellen und Aufrufen eines verwalteten Prompts](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockPrompts_section.md)
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples) einrichten und ausführen.
Löschen eines von Amazon Bedrock verwalteten Prompts.
```
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
```
+ Einzelheiten zur API finden Sie [DeletePrompt](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/DeletePrompt)in *AWS SDK for Python (Boto3) API* Reference.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter. [Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md) Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Verwendung `GetAgent` mit einem AWS SDK
Die folgenden Code-Beispiele zeigen, wie `GetAgent` verwendet wird.
Beispiele für Aktionen sind Codeauszüge aus größeren Programmen und müssen im Kontext ausgeführt werden. Im folgenden Codebeispiel können Sie diese Aktion im Kontext sehen:
+ [Erstellen und Aufrufen eines Agenten](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockAgents_section.md)
------
#### [ JavaScript ]
**SDK für JavaScript (v3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-agent#code-examples) einrichten und ausführen.
Abrufen eines Agenten.
```
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);
}
```
+ Einzelheiten zur API finden Sie [GetAgent](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-agent/command/GetAgentCommand)in der *AWS SDK für JavaScript API-Referenz*.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples) einrichten und ausführen.
Abrufen eines Agenten.
```
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
```
+ Einzelheiten zur API finden Sie [GetAgent](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/GetAgent)in *AWS SDK for Python (Boto3) API* Reference.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter. [Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md) Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Verwendung `GetFlow` mit einem AWS SDK
Das folgende Codebeispiel zeigt, wie es verwendet wird`GetFlow`.
Beispiele für Aktionen sind Codeauszüge aus größeren Programmen und müssen im Kontext ausgeführt werden. Im folgenden Codebeispiel können Sie diese Aktion im Kontext sehen:
+ [Erstellen und Aufrufen eines Flows](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockFlows_section.md)
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples) einrichten und ausführen.
Abrufen eines Amazon-Bedrock-Flows.
```
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
```
+ Einzelheiten zur API finden Sie [GetFlow](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/GetFlow)in *AWS SDK for Python (Boto3) API* Reference.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter. [Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md) Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Verwendung `GetFlowVersion` mit einem AWS SDK
Das folgende Codebeispiel zeigt, wie es verwendet wird`GetFlowVersion`.
Beispiele für Aktionen sind Codeauszüge aus größeren Programmen und müssen im Kontext ausgeführt werden. Im folgenden Codebeispiel können Sie diese Aktion im Kontext sehen:
+ [Erstellen und Aufrufen eines Flows](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockFlows_section.md)
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples) einrichten und ausführen.
Abrufen einer Version eines Amazon-Bedrock-Flows.
```
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
```
+ Einzelheiten zur API finden Sie [GetFlowVersion](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/GetFlowVersion)in *AWS SDK for Python (Boto3) API* Reference.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter. [Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md) Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Verwendung `GetKnowledgeBase` mit einem AWS SDK
Das folgende Codebeispiel zeigt, wie es verwendet wird`GetKnowledgeBase`.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples) einrichten und ausführen.
Rufen Sie eine Amazon-Bedrock-Wissensdatenbank ab.
```
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
```
+ Einzelheiten zur API finden Sie [GetKnowledgeBase](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/GetKnowledgeBase)in *AWS SDK for Python (Boto3) API* Reference.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter. [Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md) Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Verwendung `GetPrompt` mit einem AWS SDK
Das folgende Codebeispiel zeigt, wie es verwendet wird`GetPrompt`.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples) einrichten und ausführen.
Abrufen eines von Amazon Bedrock verwalteten Prompts.
```
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
```
+ Einzelheiten zur API finden Sie [GetPrompt](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/GetPrompt)in *AWS SDK for Python (Boto3) API* Reference.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter. [Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md) Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Verwendung `ListAgentActionGroups` mit einem AWS SDK
Die folgenden Code-Beispiele zeigen, wie `ListAgentActionGroups` verwendet wird.
Beispiele für Aktionen sind Codeauszüge aus größeren Programmen und müssen im Kontext ausgeführt werden. Im folgenden Codebeispiel können Sie diese Aktion im Kontext sehen:
+ [Erstellen und Aufrufen eines Agenten](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockAgents_section.md)
------
#### [ JavaScript ]
**SDK für JavaScript (v3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-agent#code-examples) einrichten und ausführen.
Auflisten der Aktionsgruppen für einen Agenten.
```
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);
}
}
```
+ Einzelheiten zur API finden Sie [ListAgentActionGroups](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-agent/command/ListAgentActionGroupsCommand)in der *AWS SDK für JavaScript API-Referenz*.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples) einrichten und ausführen.
Auflisten der Aktionsgruppen für einen Agenten.
```
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
```
+ Einzelheiten zur API finden Sie [ListAgentActionGroups](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/ListAgentActionGroups)in *AWS SDK for Python (Boto3) API* Reference.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter. [Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md) Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Verwendung `ListAgentKnowledgeBases` mit einem AWS SDK
Das folgende Codebeispiel zeigt, wie es verwendet wird`ListAgentKnowledgeBases`.
Beispiele für Aktionen sind Codeauszüge aus größeren Programmen und müssen im Kontext ausgeführt werden. Im folgenden Codebeispiel können Sie diese Aktion im Kontext sehen:
+ [Erstellen und Aufrufen eines Agenten](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockAgents_section.md)
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples) einrichten und ausführen.
Auflisten der einem Agenten zugeordneten Wissensdatenbanken.
```
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
```
+ Einzelheiten zur API finden Sie [ListAgentKnowledgeBases](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/ListAgentKnowledgeBases)in *AWS SDK for Python (Boto3) API* Reference.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter. [Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md) Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Verwendung `ListAgents` mit einem AWS SDK
Die folgenden Code-Beispiele zeigen, wie `ListAgents` verwendet wird.
Beispiele für Aktionen sind Codeauszüge aus größeren Programmen und müssen im Kontext ausgeführt werden. Im folgenden Codebeispiel können Sie diese Aktion im Kontext sehen:
+ [Erstellen und Aufrufen eines Agenten](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockAgents_section.md)
------
#### [ JavaScript ]
**SDK für JavaScript (v3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-agent#code-examples) einrichten und ausführen.
Auflisten der Agenten, die zu einem Konto gehören.
```
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);
}
}
```
+ Einzelheiten zur API finden Sie [ListAgents](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-agent/command/ListAgentsCommand)in der *AWS SDK für JavaScript API-Referenz*.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples) einrichten und ausführen.
Auflisten der Agenten, die zu einem Konto gehören.
```
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
```
+ Einzelheiten zur API finden Sie [ListAgents](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/ListAgents)in *AWS SDK for Python (Boto3) API* Reference.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter. [Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md) Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Verwendung `ListFlowAliases` mit einem AWS SDK
Das folgende Codebeispiel zeigt, wie es verwendet wird`ListFlowAliases`.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples) einrichten und ausführen.
Auflisten der Aliasse für einen Amazon-Bedrock-Flow.
```
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
```
+ Einzelheiten zur API finden Sie [ListFlowAliases](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/ListFlowAliases)in *AWS SDK for Python (Boto3) API* Reference.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter. [Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md) Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Verwendung `ListFlowVersions` mit einem AWS SDK
Das folgende Codebeispiel zeigt, wie es verwendet wird`ListFlowVersions`.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples) einrichten und ausführen.
Auflisten der Versionen eines Amazon-Bedrock-Flows.
```
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
```
+ Einzelheiten zur API finden Sie [ListFlowVersions](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/ListFlowVersions)in *AWS SDK for Python (Boto3) API* Reference.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter. [Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md) Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Verwendung `ListFlows` mit einem AWS SDK
Das folgende Codebeispiel zeigt, wie es verwendet wird`ListFlows`.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples) einrichten und ausführen.
Auflisten der Amazon-Bedrock-Flows.
```
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
```
+ Einzelheiten zur API finden Sie [ListFlows](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/ListFlows)in *AWS SDK for Python (Boto3) API* Reference.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter. [Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md) Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Verwendung `ListKnowledgeBases` mit einem AWS SDK
Das folgende Codebeispiel zeigt, wie es verwendet wird`ListKnowledgeBases`.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples) einrichten und ausführen.
Listet die Amazon-Bedrock-Wissensdatenbanken auf.
```
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
```
+ Einzelheiten zur API finden Sie [ListKnowledgeBases](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/ListKnowledgeBases)in *AWS SDK for Python (Boto3) API* Reference.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter. [Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md) Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Verwendung `ListPrompts` mit einem AWS SDK
Das folgende Codebeispiel zeigt, wie es verwendet wird`ListPrompts`.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples) einrichten und ausführen.
Auflisten der von Amazon Bedrock verwalteten Prompts.
```
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
```
+ Einzelheiten zur API finden Sie [ListPrompts](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/ListPrompts)in *AWS SDK for Python (Boto3) API* Reference.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter. [Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md) Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Verwendung `PrepareAgent` mit einem AWS SDK
Das folgende Codebeispiel zeigt, wie es verwendet wird`PrepareAgent`.
Beispiele für Aktionen sind Codeauszüge aus größeren Programmen und müssen im Kontext ausgeführt werden. Im folgenden Codebeispiel können Sie diese Aktion im Kontext sehen:
+ [Erstellen und Aufrufen eines Agenten](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockAgents_section.md)
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples) einrichten und ausführen.
Vorbereiten eines Agenten auf interne Tests.
```
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
```
+ Einzelheiten zur API finden Sie [PrepareAgent](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/PrepareAgent)in *AWS SDK for Python (Boto3) API* Reference.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter. [Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md) Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Verwendung `PrepareFlow` mit einem AWS SDK
Das folgende Codebeispiel zeigt, wie es verwendet wird`PrepareFlow`.
Beispiele für Aktionen sind Codeauszüge aus größeren Programmen und müssen im Kontext ausgeführt werden. Im folgenden Codebeispiel können Sie diese Aktion im Kontext sehen:
+ [Erstellen und Aufrufen eines Flows](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockFlows_section.md)
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples) einrichten und ausführen.
Vorbereiten eines Amazon-Bedrock-Flows.
```
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
```
+ Einzelheiten zur API finden Sie [PrepareFlow](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/PrepareFlow)in *AWS SDK for Python (Boto3) API* Reference.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter. [Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md) Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Verwendung `UpdateFlow` mit einem AWS SDK
Das folgende Codebeispiel zeigt, wie es verwendet wird`UpdateFlow`.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples) einrichten und ausführen.
Aktualisieren eines Amazon-Bedrock-Flows.
```
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
```
+ Einzelheiten zur API finden Sie [UpdateFlow](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/UpdateFlow)in *AWS SDK for Python (Boto3) API* Reference.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter. [Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md) Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Verwendung `UpdateFlowAlias` mit einem AWS SDK
Das folgende Codebeispiel zeigt, wie es verwendet wird`UpdateFlowAlias`.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples) einrichten und ausführen.
Aktualisieren des Alias eines Amazon-Bedrock-Flows.
```
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
```
+ Einzelheiten zur API finden Sie [UpdateFlowAlias](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/UpdateFlowAlias)in *AWS SDK for Python (Boto3) API* Reference.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter. [Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md) Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Verwendung `UpdateKnowledgeBase` mit einem AWS SDK
Das folgende Codebeispiel zeigt, wie es verwendet wird`UpdateKnowledgeBase`.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples) einrichten und ausführen.
Aktualisieren einer Amazon-Bedrock-Wissensdatenbank.
```
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
```
+ Einzelheiten zur API finden Sie [UpdateKnowledgeBase](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-2023-12-12/UpdateKnowledgeBase)in *AWS SDK for Python (Boto3) API* Reference.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter. [Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md) Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Szenarien für die Verwendung von Amazon Bedrock Agents AWS SDKs
Die folgenden Codebeispiele zeigen Ihnen, wie Sie allgemeine Szenarien in Amazon Bedrock Agents mit AWS SDKs implementieren. Diese Szenarien zeigen Ihnen, wie Sie bestimmte Aufgaben durch den Aufruf mehrerer Funktionen innerhalb von Agenten für Amazon Bedrock oder in Kombination mit anderen AWS-Services ausführen können. Jedes Szenario enthält einen Link zum vollständigen Quell-Code, wo Sie Anleitungen zum Einrichten und Ausführen des Codes finden.
Szenarien zielen auf eine mittlere Erfahrungsebene ab, um Ihnen zu helfen, Service-Aktionen im Kontext zu verstehen.
**Topics**
+ [Erstellen und Aufrufen eines Flows](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockFlows_section.md)
+ [Erstellen und Aufrufen eines verwalteten Prompts](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockPrompts_section.md)
+ [Erstellen und Aufrufen eines Agenten](bedrock-agent_example_bedrock-agent_GettingStartedWithBedrockAgents_section.md)
+ [Orchestrieren von Anwendungen mit generativer KI mit Step Functions](bedrock-agent_example_cross_ServerlessPromptChaining_section.md)
# Ein end-to-end Beispiel, das zeigt, wie ein Amazon Bedrock-Flow mithilfe eines SDK erstellt und aufgerufen wird AWS
Wie das aussehen kann, sehen Sie am nachfolgenden Beispielcode:
+ Erstellen einer Ausführungsrolle für den Flow.
+ Erstellen Sie den Flow.
+ Stellen Sie den vollständig konfigurierten Flow bereit.
+ Rufen Sie den Flow mit vom Benutzer bereitgestellten Prompts auf.
+ Löschen aller erstellten Ressourcen.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples) einrichten und ausführen.
Erstellt eine Musik-Playlist basierend auf dem vom Benutzenden angegebenen Genre und der Anzahl der Songs.
```
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
```
+ Weitere API-Informationen finden Sie in den folgenden Themen der *API-Referenz zum AWS SDK für 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)
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter[Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md). Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Ein end-to-end Beispiel, das zeigt, wie verwaltete Amazon Bedrock-Eingabeaufforderungen mithilfe eines SDK erstellt und aufgerufen werden AWS
Wie das aussehen kann, sehen Sie am nachfolgenden Beispielcode:
+ Erstellen eines verwalteten Prompts.
+ Erstellen einer Version des Prompts.
+ Aufrufen des Prompts mithilfe der Version.
+ Bereinigen der Ressourcen (optional).
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples) einrichten und ausführen.
Erstellen und Aufrufen eines verwalteten Prompts.
```
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()
```
+ Weitere API-Informationen finden Sie in den folgenden Themen der *API-Referenz zum AWS SDK für 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)
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter[Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md). Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Ein end-to-end Beispiel, das zeigt, wie Amazon Bedrock Agents mithilfe eines SDK erstellt und aufgerufen werden AWS
Wie das aussehen kann, sehen Sie am nachfolgenden Beispielcode:
+ Erstellen einer Ausführungsrolle für den Agenten.
+ Erstellen einer Lambda-Funktion, die die Funktionen des Agenten implementiert.
+ Erstellen einer Lambda-Funktion, die die Funktionen des Agenten implementiert.
+ Erstellen einer Aktionsgruppe, die den Agenten mit der Lambda-Funktion verbindet.
+ Bereitstellen des vollständig konfigurierten Agenten.
+ Aufrufen des Agenten mit vom Benutzer bereitgestellten Prompts.
+ Löschen aller erstellten Ressourcen.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples) einrichten und ausführen.
Erstellen und Aufrufen eines Agenten.
```
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}")
```
+ Weitere API-Informationen finden Sie in den folgenden Themen der *API-Referenz zum AWS SDK für 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)
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter[Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md). Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Erstellen und Orchestrieren von Anwendungen mit generativer KI mit Amazon Bedrock und Step Functions
Im folgenden Codebeispiel wird gezeigt, wie Anwendungen mit generativer KI mit Amazon Bedrock und Step Functions erstellt und orchestriert werden.
------
#### [ Python ]
**SDK für Python (Boto3)**
Das Szenario „Amazon Bedrock Serverless Prompt Chaining” zeigt, wie [AWS Step Functions](https://docs.aws.amazon.com/step-functions/latest/dg/welcome.html), [Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html) und [https://docs.aws.amazon.com/bedrock/latest/userguide/agents.html](https://docs.aws.amazon.com/bedrock/latest/userguide/agents.html) zum Erstellen und Orchestrieren komplexer und hoch skalierbarer Serverless-Anwendungen mit generativer KI verwendet werden können. Es enthält die folgenden praktischen Beispiele:
+ Verfassen einer Analyse eines bestimmten Romans für einen Literaturblog. Dieses Beispiel veranschaulicht eine einfache, sequentielle Kette von Prompts.
+ Generieren einer Kurzgeschichte zu einem bestimmten Thema. Dieses Beispiel veranschaulicht, wie die KI eine Liste von zuvor generierten Elementen iterativ verarbeiten kann.
+ Erstellen eines Reiseplans für einen Wochenendurlaub an einem bestimmten Zielort. Dieses Beispiel veranschaulicht, wie mehrere unterschiedliche Prompts parallelisiert werden können.
+ Präsentieren von Filmideen für einen menschlichen Benutzer, der als Filmproduzent fungiert. Dieses Beispiel zeigt, wie derselbe Prompt mit unterschiedlichen Inferenzparametern parallelisiert wird, wie man zu einem vorherigen Schritt in der Kette zurückkehrt und wie menschliche Eingaben in den Workflow einbezogen werden können.
+ Planen einer Mahlzeit auf Grundlage der Zutaten, die der Benutzer zur Hand hat. Dieses Beispiel zeigt, wie Prompt-Chains zwei unterschiedliche KI-Konversationen beinhalten können, bei denen zwei KI-Personas miteinander debattieren, um das Endergebnis zu verbessern.
+ Finden Sie das Repository mit den meisten Trends GitHub von heute und fassen Sie es zusammen. Dieses Beispiel veranschaulicht die Verkettung mehrerer KI-Agenten, die mit externen Agenten interagieren. APIs
Den vollständigen Quellcode und Anweisungen zur Einrichtung und Ausführung finden Sie im vollständigen Projekt unter [GitHub](https://github.com/aws-samples/amazon-bedrock-serverless-prompt-chaining).
**In diesem Beispiel verwendete Dienste**
+ Amazon Bedrock
+ Amazon Bedrock Runtime
+ Agenten für Amazon Bedrock
+ Runtime der Agenten für Amazon Bedrock
+ Step Functions
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter[Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md). Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Codebeispiele für Amazon Bedrock Agents Runtime mit AWS SDKs
Die folgenden Codebeispiele zeigen, wie Amazon Bedrock Agents Runtime mit einem AWS Software Development Kit (SDK) verwendet wird.
Bei *Grundlagen* handelt es sich um Codebeispiele, die Ihnen zeigen, wie Sie die wesentlichen Vorgänge innerhalb eines Services ausführen.
*Aktionen* sind Codeauszüge aus größeren Programmen und müssen im Kontext ausgeführt werden. Während Aktionen Ihnen zeigen, wie Sie einzelne Service-Funktionen aufrufen, können Sie Aktionen im Kontext der zugehörigen Szenarien anzeigen.
*Szenarien* sind Codebeispiele, die Ihnen zeigen, wie Sie bestimmte Aufgaben ausführen, indem Sie mehrere Funktionen innerhalb eines Service aufrufen oder mit anderen AWS-Services kombinieren.
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter[Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md). Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
**Contents**
+ [Grundlagen](service_code_examples_bedrock-agent-runtime_basics.md)
+ [Kennenlernen der Grundlagen](bedrock-agent-runtime_example_bedrock-agent-runtime_Scenario_ConverseWithFlow_section.md)
+ [Aktionen](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)
+ [Szenarien](service_code_examples_bedrock-agent-runtime_scenarios.md)
+ [Erstellen und Aufrufen eines Flows](bedrock-agent-runtime_example_bedrock-agent_GettingStartedWithBedrockFlows_section.md)
+ [Orchestrieren von Anwendungen mit generativer KI mit Step Functions](bedrock-agent-runtime_example_cross_ServerlessPromptChaining_section.md)
# Grundlegende Beispiele für die Verwendung von Amazon Bedrock Agents Runtime AWS SDKs
Die folgenden Codebeispiele zeigen, wie Sie die Grundlagen von Amazon Bedrock Agents Runtime mit AWS SDKs verwenden können.
**Contents**
+ [Kennenlernen der Grundlagen](bedrock-agent-runtime_example_bedrock-agent-runtime_Scenario_ConverseWithFlow_section.md)
+ [Aktionen](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)
# Konversation mit einem Amazon-Bedrock-Flow
Das folgende Codebeispiel zeigt, wie Sie InvokeFlow mit einem Amazon Bedrock-Flow kommunizieren können, der einen Agentenknoten enthält.
Weitere Informationen finden Sie unter [Konversation mit einem Amazon-Bedrock-Flow](https://docs.aws.amazon.com/bedrock/latest/userguide/flows-multi-turn-invocation.html).
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent-runtime#code-examples) einrichten und ausführen.
```
"""
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()
```
+ Einzelheiten zur API finden Sie [InvokeFlow](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-runtime-2023-12-12/InvokeFlow)in *AWS SDK for Python (Boto3) API* Reference.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter. [Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md) Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Aktionen für Amazon Bedrock Agents Runtime mit AWS SDKs
Die folgenden Codebeispiele zeigen, wie einzelne Amazon Bedrock Agents Runtime-Aktionen mit AWS SDKs ausgeführt werden. Jedes Beispiel enthält einen Link zu GitHub, über den Sie Anweisungen zum Einrichten und Ausführen des Codes finden.
Diese Ausschnitte rufen die API für Runtime der Agenten für Amazon Bedrock auf und stammen aus größeren Programmen, die im entsprechenden Kontext ausgeführt werden müssen. Sie können Aktionen im Kontext unter [Szenarien für die Verwendung von Amazon Bedrock Agents Runtime AWS SDKs](service_code_examples_bedrock-agent-runtime_scenarios.md) anzeigen.
Die folgenden Beispiele enthalten nur die am häufigsten verwendeten Aktionen. Eine vollständige Liste finden Sie in der [API-Referenz zu Runtime der Agenten für Amazon Bedrock](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)
# Verwendung `InvokeAgent` mit einem AWS SDK
Die folgenden Code-Beispiele zeigen, wie `InvokeAgent` verwendet wird.
------
#### [ JavaScript ]
**SDK für JavaScript (v3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-agent-runtime#code-examples) einrichten und ausführen.
```
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);
}
```
+ Einzelheiten zur API finden Sie [InvokeAgent](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-agent-runtime/command/InvokeAgentCommand)in der *AWS SDK für JavaScript API-Referenz*.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent-runtime#code-examples) einrichten und ausführen.
Aufrufen eines Agenten.
```
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
```
+ Einzelheiten zur API finden Sie [InvokeAgent](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-runtime-2023-12-12/InvokeAgent)in *AWS SDK for Python (Boto3) API* Reference.
------
#### [ Rust ]
**SDK für Rust**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/bedrock-agent-runtime#code-examples) einrichten und ausführen.
```
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();
}
}
```
+ Einzelheiten zur API finden Sie [InvokeAgent](https://docs.rs/aws-sdk-bedrockagentruntime/latest/aws_sdk_bedrockagentruntime/client/struct.Client.html#method.invoke_agent)in der *API-Referenz zum AWS SDK für Rust*.
------
#### [ SAP ABAP ]
**SDK für SAP ABAP**
Es gibt noch mehr dazu. GitHub Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/bdz#code-examples) einrichten und ausführen.
```
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.
```
+ Einzelheiten zur API finden Sie [InvokeAgent](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)in der *API-Referenz zum AWS SDK für SAP ABAP*.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter[Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md). Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Verwendung `InvokeFlow` mit einem AWS SDK
Die folgenden Code-Beispiele zeigen, wie `InvokeFlow` verwendet wird.
Aktionsbeispiele sind Codeauszüge aus größeren Programmen und müssen im Kontext ausgeführt werden. Sie können diese Aktion in den folgenden Codebeispielen im Kontext sehen:
+ [Kennenlernen der Grundlagen](bedrock-agent-runtime_example_bedrock-agent-runtime_Scenario_ConverseWithFlow_section.md)
+ [Erstellen und Aufrufen eines Flows](bedrock-agent-runtime_example_bedrock-agent_GettingStartedWithBedrockFlows_section.md)
------
#### [ JavaScript ]
**SDK für JavaScript (v3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-agent-runtime#code-examples) einrichten und ausführen.
```
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"));
}
}
```
+ Einzelheiten zur API finden Sie [InvokeFlow](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-agent-runtime/command/InvokeFlowCommand)in der *AWS SDK für JavaScript API-Referenz*.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent-runtime#code-examples) einrichten und ausführen.
Aufrufen eines Flows.
```
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
```
+ Einzelheiten zur API finden Sie [InvokeFlow](https://docs.aws.amazon.com/goto/boto3/bedrock-agent-runtime-2023-12-12/InvokeFlow)in *AWS SDK for Python (Boto3) API* Reference.
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter. [Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md) Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Szenarien für die Verwendung von Amazon Bedrock Agents Runtime AWS SDKs
Die folgenden Codebeispiele zeigen Ihnen, wie Sie allgemeine Szenarien in Amazon Bedrock Agents Runtime mit AWS SDKs implementieren. Diese Szenarien zeigen Ihnen, wie Sie bestimmte Aufgaben durch den Aufruf mehrerer Funktionen innerhalb von Runtime der Agenten für Amazon Bedrock oder in Kombination mit anderen AWS-Services ausführen können. Jedes Szenario enthält einen Link zum vollständigen Quell-Code, wo Sie Anleitungen zum Einrichten und Ausführen des Codes finden.
Szenarien zielen auf eine mittlere Erfahrungsebene ab, um Ihnen zu helfen, Service-Aktionen im Kontext zu verstehen.
**Topics**
+ [Erstellen und Aufrufen eines Flows](bedrock-agent-runtime_example_bedrock-agent_GettingStartedWithBedrockFlows_section.md)
+ [Orchestrieren von Anwendungen mit generativer KI mit Step Functions](bedrock-agent-runtime_example_cross_ServerlessPromptChaining_section.md)
# Ein end-to-end Beispiel, das zeigt, wie ein Amazon Bedrock-Flow mithilfe eines SDK erstellt und aufgerufen wird AWS
Wie das aussehen kann, sehen Sie am nachfolgenden Beispielcode:
+ Erstellen einer Ausführungsrolle für den Flow.
+ Erstellen Sie den Flow.
+ Stellen Sie den vollständig konfigurierten Flow bereit.
+ Rufen Sie den Flow mit vom Benutzer bereitgestellten Prompts auf.
+ Löschen aller erstellten Ressourcen.
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples) einrichten und ausführen.
Erstellt eine Musik-Playlist basierend auf dem vom Benutzenden angegebenen Genre und der Anzahl der Songs.
```
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
```
+ Weitere API-Informationen finden Sie in den folgenden Themen der *API-Referenz zum AWS SDK für 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)
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter[Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md). Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.
# Erstellen und Orchestrieren von Anwendungen mit generativer KI mit Amazon Bedrock und Step Functions
Im folgenden Codebeispiel wird gezeigt, wie Anwendungen mit generativer KI mit Amazon Bedrock und Step Functions erstellt und orchestriert werden.
------
#### [ Python ]
**SDK für Python (Boto3)**
Das Szenario „Amazon Bedrock Serverless Prompt Chaining” zeigt, wie [AWS Step Functions](https://docs.aws.amazon.com/step-functions/latest/dg/welcome.html), [Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html) und [https://docs.aws.amazon.com/bedrock/latest/userguide/agents.html](https://docs.aws.amazon.com/bedrock/latest/userguide/agents.html) zum Erstellen und Orchestrieren komplexer und hoch skalierbarer Serverless-Anwendungen mit generativer KI verwendet werden können. Es enthält die folgenden praktischen Beispiele:
+ Verfassen einer Analyse eines bestimmten Romans für einen Literaturblog. Dieses Beispiel veranschaulicht eine einfache, sequentielle Kette von Prompts.
+ Generieren einer Kurzgeschichte zu einem bestimmten Thema. Dieses Beispiel veranschaulicht, wie die KI eine Liste von zuvor generierten Elementen iterativ verarbeiten kann.
+ Erstellen eines Reiseplans für einen Wochenendurlaub an einem bestimmten Zielort. Dieses Beispiel veranschaulicht, wie mehrere unterschiedliche Prompts parallelisiert werden können.
+ Präsentieren von Filmideen für einen menschlichen Benutzer, der als Filmproduzent fungiert. Dieses Beispiel zeigt, wie derselbe Prompt mit unterschiedlichen Inferenzparametern parallelisiert wird, wie man zu einem vorherigen Schritt in der Kette zurückkehrt und wie menschliche Eingaben in den Workflow einbezogen werden können.
+ Planen einer Mahlzeit auf Grundlage der Zutaten, die der Benutzer zur Hand hat. Dieses Beispiel zeigt, wie Prompt-Chains zwei unterschiedliche KI-Konversationen beinhalten können, bei denen zwei KI-Personas miteinander debattieren, um das Endergebnis zu verbessern.
+ Finden Sie das Repository mit den meisten Trends GitHub von heute und fassen Sie es zusammen. Dieses Beispiel veranschaulicht die Verkettung mehrerer KI-Agenten, die mit externen Agenten interagieren. APIs
Den vollständigen Quellcode und Anweisungen zur Einrichtung und Ausführung finden Sie im vollständigen Projekt unter [GitHub](https://github.com/aws-samples/amazon-bedrock-serverless-prompt-chaining).
**In diesem Beispiel verwendete Dienste**
+ Amazon Bedrock
+ Amazon Bedrock Runtime
+ Agenten für Amazon Bedrock
+ Runtime der Agenten für Amazon Bedrock
+ Step Functions
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter[Amazon Bedrock mit einem AWS SDK verwenden](sdk-general-information-section.md). Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.