Ada lebih banyak contoh AWS SDK yang tersedia di repo Contoh [SDK AWS Doc](https://github.com/awsdocs/aws-doc-sdk-examples). GitHub
Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Contoh kode untuk Amazon Bedrock Runtime menggunakan AWS SDKs
Contoh kode berikut menunjukkan cara menggunakan Amazon Bedrock Runtime dengan kit pengembangan AWS perangkat lunak (SDK).
*Skenario* adalah contoh kode yang menunjukkan kepada Anda bagaimana menyelesaikan tugas tertentu dengan memanggil beberapa fungsi dalam layanan atau dikombinasikan dengan yang lain Layanan AWS.
**Sumber daya lainnya**
+ **[Panduan Pengguna Amazon Bedrock Runtime](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html)** — Informasi lebih lanjut tentang Amazon Bedrock Runtime.
+ **[Referensi API Amazon Bedrock Runtime](https://docs.aws.amazon.com/bedrock/latest/APIReference/welcome.html)** — Detail tentang semua tindakan Amazon Bedrock Runtime yang tersedia.
+ **[AWS Pusat Pengembang](https://aws.amazon.com/developer/code-examples/?awsf.sdk-code-examples-product=product%23bedrock)** - Contoh kode yang dapat Anda filter berdasarkan kategori atau pencarian teks lengkap.
+ **[AWS Contoh SDK](https://github.com/awsdocs/aws-doc-sdk-examples)** — GitHub repo dengan kode lengkap dalam bahasa pilihan. Termasuk instruksi untuk mengatur dan menjalankan kode.
**Contents**
+ [Hal-hal mendasar](bedrock-runtime_code_examples_basics.md)
+ [Halo Amazon Bedrock](bedrock-runtime_example_bedrock-runtime_Hello_section.md)
+ [Skenario](bedrock-runtime_code_examples_scenarios.md)
+ [Buat aplikasi taman bermain untuk berinteraksi dengan model yayasan Amazon Bedrock](bedrock-runtime_example_cross_FMPlayground_section.md)
+ [Membuat dan memanggil prompt terkelola](bedrock-runtime_example_bedrock-agent_GettingStartedWithBedrockPrompts_section.md)
+ [Hasilkan video dari petunjuk teks menggunakan Amazon Bedrock](bedrock-runtime_example_bedrock-runtime_Scenario_GenerateVideos_NovaReel_section.md)
+ [Gunakan beberapa model fondasi di Amazon Bedrock](bedrock-runtime_example_bedrock-runtime_Scenario_InvokeModels_section.md)
+ [Mengatur aplikasi AI generatif dengan Step Functions](bedrock-runtime_example_cross_ServerlessPromptChaining_section.md)
+ [Penggunaan alat dengan API Converse](bedrock-runtime_example_bedrock-runtime_Scenario_ToolUse_section.md)
+ [Amazon Nova](bedrock-runtime_code_examples_amazon_nova.md)
+ [Bercakap-cakap](bedrock-runtime_example_bedrock-runtime_Converse_AmazonNovaText_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_AmazonNovaText_section.md)
+ [Pemahaman dokumen](bedrock-runtime_example_bedrock-runtime_DocumentUnderstanding_AmazonNova_section.md)
+ [Skenario: Penggunaan alat dengan API Converse](bedrock-runtime_example_bedrock-runtime_Scenario_ToolUseDemo_AmazonNova_section.md)
+ [Kanvas Amazon Nova](bedrock-runtime_code_examples_amazon_nova_canvas.md)
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_AmazonNovaImageGeneration_section.md)
+ [Amazon Nova Reel](bedrock-runtime_code_examples_amazon_nova_reel.md)
+ [T ext-to-video](bedrock-runtime_example_bedrock-runtime_Scenario_AmazonNova_TextToVideo_section.md)
+ [Generator Gambar Amazon Titan](bedrock-runtime_code_examples_amazon_titan_image_generator.md)
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_TitanImageGenerator_section.md)
+ [Teks Amazon Titan](bedrock-runtime_code_examples_amazon_titan_text.md)
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_TitanText_section.md)
+ [Embeddings Teks Amazon Titan](bedrock-runtime_code_examples_amazon_titan_text_embeddings.md)
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModelWithResponseStream_TitanTextEmbeddings_section.md)
+ [Antropik Claude](bedrock-runtime_code_examples_anthropic_claude.md)
+ [Bercakap-cakap](bedrock-runtime_example_bedrock-runtime_Converse_AnthropicClaude_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_AnthropicClaude_section.md)
+ [Pemahaman dokumen](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)
+ [Penalaran](bedrock-runtime_example_bedrock-runtime_Converse_AnthropicClaudeReasoning_section.md)
+ [Penalaran dengan respons streaming](bedrock-runtime_example_bedrock-runtime_ConverseStream_AnthropicClaudeReasoning_section.md)
+ [Skenario: Penggunaan alat dengan API Converse](bedrock-runtime_example_bedrock-runtime_Scenario_ToolUseDemo_AnthropicClaude_section.md)
+ [Perintah Cohere](bedrock-runtime_code_examples_cohere_command.md)
+ [Bercakap-cakap](bedrock-runtime_example_bedrock-runtime_Converse_CohereCommand_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_CohereCommand_section.md)
+ [Pemahaman dokumen](bedrock-runtime_example_bedrock-runtime_DocumentUnderstanding_CohereCommand_section.md)
+ [InvokeModel: Perintah R dan R \$1](bedrock-runtime_example_bedrock-runtime_InvokeModel_CohereCommandR_section.md)
+ [InvokeModelWithResponseStream: Perintah R dan R \$1](bedrock-runtime_example_bedrock-runtime_InvokeModelWithResponseStream_CohereCommandR_section.md)
+ [Skenario: Penggunaan alat dengan API Converse](bedrock-runtime_example_bedrock-runtime_Scenario_ToolUseDemo_CohereCommand_section.md)
+ [DeepSeek](bedrock-runtime_code_examples_deepseek.md)
+ [Pemahaman dokumen](bedrock-runtime_example_bedrock-runtime_DocumentUnderstanding_DeepSeek_section.md)
+ [Meta Llama](bedrock-runtime_code_examples_meta_llama.md)
+ [Bercakap-cakap](bedrock-runtime_example_bedrock-runtime_Converse_MetaLlama_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_MetaLlama_section.md)
+ [Pemahaman dokumen](bedrock-runtime_example_bedrock-runtime_DocumentUnderstanding_MetaLlama_section.md)
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_MetaLlama3_section.md)
+ [InvokeModelWithResponseStream](bedrock-runtime_example_bedrock-runtime_InvokeModelWithResponseStream_MetaLlama3_section.md)
+ [Mistral AI](bedrock-runtime_code_examples_mistral_ai.md)
+ [Bercakap-cakap](bedrock-runtime_example_bedrock-runtime_Converse_Mistral_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_Mistral_section.md)
+ [Pemahaman dokumen](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)
+ [Difusi Stabil](bedrock-runtime_code_examples_stable_diffusion.md)
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_StableDiffusion_section.md)
# Contoh dasar untuk Amazon Bedrock Runtime menggunakan AWS SDKs
Contoh kode berikut menunjukkan cara menggunakan dasar-dasar Amazon Bedrock Runtime dengan. AWS SDKs
**Contents**
+ [Halo Amazon Bedrock](bedrock-runtime_example_bedrock-runtime_Hello_section.md)
# Halo Amazon Bedrock
Contoh kode berikut menunjukkan cara memulai menggunakan Amazon Bedrock.
------
#### [ Go ]
**SDK untuk Go V2**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/bedrock-runtime#code-examples).
```
package main
import (
"context"
"encoding/json"
"flag"
"fmt"
"log"
"os"
"strings"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/service/bedrockruntime"
)
// Each model provider defines their own individual request and response formats.
// For the format, ranges, and default values for the different models, refer to:
// https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters.html
type ClaudeRequest struct {
Prompt string `json:"prompt"`
MaxTokensToSample int `json:"max_tokens_to_sample"`
// Omitting optional request parameters
}
type ClaudeResponse struct {
Completion string `json:"completion"`
}
// main uses the AWS SDK for Go (v2) to create an Amazon Bedrock Runtime client
// and invokes Anthropic Claude 2 inside your account and the chosen region.
// This example uses the default settings specified in your shared credentials
// and config files.
func main() {
region := flag.String("region", "us-east-1", "The AWS region")
flag.Parse()
fmt.Printf("Using AWS region: %s\n", *region)
ctx := context.Background()
sdkConfig, err := config.LoadDefaultConfig(ctx, config.WithRegion(*region))
if err != nil {
fmt.Println("Couldn't load default configuration. Have you set up your AWS account?")
fmt.Println(err)
return
}
client := bedrockruntime.NewFromConfig(sdkConfig)
modelId := "anthropic.claude-v2"
prompt := "Hello, how are you today?"
// Anthropic Claude requires you to enclose the prompt as follows:
prefix := "Human: "
postfix := "\n\nAssistant:"
wrappedPrompt := prefix + prompt + postfix
request := ClaudeRequest{
Prompt: wrappedPrompt,
MaxTokensToSample: 200,
}
body, err := json.Marshal(request)
if err != nil {
log.Panicln("Couldn't marshal the request: ", err)
}
result, err := client.InvokeModel(ctx, &bedrockruntime.InvokeModelInput{
ModelId: aws.String(modelId),
ContentType: aws.String("application/json"),
Body: body,
})
if err != nil {
errMsg := err.Error()
if strings.Contains(errMsg, "no such host") {
fmt.Printf("Error: The Bedrock service is not available in the selected region. Please double-check the service availability for your region at https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/.\n")
} else if strings.Contains(errMsg, "Could not resolve the foundation model") {
fmt.Printf("Error: Could not resolve the foundation model from model identifier: \"%v\". Please verify that the requested model exists and is accessible within the specified region.\n", modelId)
} else {
fmt.Printf("Error: Couldn't invoke Anthropic Claude. Here's why: %v\n", err)
}
os.Exit(1)
}
var response ClaudeResponse
err = json.Unmarshal(result.Body, &response)
if err != nil {
log.Fatal("failed to unmarshal", err)
}
fmt.Println("Prompt:\n", prompt)
fmt.Println("Response from Anthropic Claude:\n", response.Completion)
}
```
+ Untuk detail API, lihat [InvokeModel](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/bedrockruntime#Client.InvokeModel)di *Referensi AWS SDK untuk Go API*.
------
#### [ JavaScript ]
**SDK untuk JavaScript (v3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
```
/**
* @typedef {Object} Content
* @property {string} text
*
* @typedef {Object} Usage
* @property {number} input_tokens
* @property {number} output_tokens
*
* @typedef {Object} ResponseBody
* @property {Content[]} content
* @property {Usage} usage
*/
import { fileURLToPath } from "node:url";
import {
BedrockRuntimeClient,
InvokeModelCommand,
} from "@aws-sdk/client-bedrock-runtime";
const AWS_REGION = "us-east-1";
const MODEL_ID = "anthropic.claude-3-haiku-20240307-v1:0";
const PROMPT = "Hi. In a short paragraph, explain what you can do.";
const hello = async () => {
console.log("=".repeat(35));
console.log("Welcome to the Amazon Bedrock demo!");
console.log("=".repeat(35));
console.log("Model: Anthropic Claude 3 Haiku");
console.log(`Prompt: ${PROMPT}\n`);
console.log("Invoking model...\n");
// Create a new Bedrock Runtime client instance.
const client = new BedrockRuntimeClient({ region: AWS_REGION });
// Prepare the payload for the model.
const payload = {
anthropic_version: "bedrock-2023-05-31",
max_tokens: 1000,
messages: [{ role: "user", content: [{ type: "text", text: PROMPT }] }],
};
// Invoke Claude with the payload and wait for the response.
const apiResponse = await client.send(
new InvokeModelCommand({
contentType: "application/json",
body: JSON.stringify(payload),
modelId: MODEL_ID,
}),
);
// Decode and return the response(s)
const decodedResponseBody = new TextDecoder().decode(apiResponse.body);
/** @type {ResponseBody} */
const responseBody = JSON.parse(decodedResponseBody);
const responses = responseBody.content;
if (responses.length === 1) {
console.log(`Response: ${responses[0].text}`);
} else {
console.log("Haiku returned multiple responses:");
console.log(responses);
}
console.log(`\nNumber of input tokens: ${responseBody.usage.input_tokens}`);
console.log(`Number of output tokens: ${responseBody.usage.output_tokens}`);
};
if (process.argv[1] === fileURLToPath(import.meta.url)) {
await hello();
}
```
+ Untuk detail API, lihat [InvokeModel](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/InvokeModelCommand)di *Referensi AWS SDK untuk JavaScript API*.
------
# Skenario untuk Amazon Bedrock Runtime menggunakan AWS SDKs
Contoh kode berikut menunjukkan cara menerapkan skenario umum di Amazon Bedrock Runtime dengan. AWS SDKs Skenario ini menunjukkan kepada Anda cara menyelesaikan tugas tertentu dengan memanggil beberapa fungsi dalam Amazon Bedrock Runtime atau digabungkan dengan yang lain. Layanan AWS Setiap skenario menyertakan tautan ke kode sumber lengkap, di mana Anda dapat menemukan instruksi tentang cara mengatur dan menjalankan kode.
Skenario menargetkan tingkat pengalaman menengah untuk membantu Anda memahami tindakan layanan dalam konteks.
**Topics**
+ [Buat aplikasi taman bermain untuk berinteraksi dengan model yayasan Amazon Bedrock](bedrock-runtime_example_cross_FMPlayground_section.md)
+ [Membuat dan memanggil prompt terkelola](bedrock-runtime_example_bedrock-agent_GettingStartedWithBedrockPrompts_section.md)
+ [Hasilkan video dari petunjuk teks menggunakan Amazon Bedrock](bedrock-runtime_example_bedrock-runtime_Scenario_GenerateVideos_NovaReel_section.md)
+ [Gunakan beberapa model fondasi di Amazon Bedrock](bedrock-runtime_example_bedrock-runtime_Scenario_InvokeModels_section.md)
+ [Mengatur aplikasi AI generatif dengan Step Functions](bedrock-runtime_example_cross_ServerlessPromptChaining_section.md)
+ [Penggunaan alat dengan API Converse](bedrock-runtime_example_bedrock-runtime_Scenario_ToolUse_section.md)
# Buat contoh aplikasi yang menawarkan taman bermain untuk berinteraksi dengan model foundation Amazon Bedrock menggunakan SDK AWS
Contoh kode berikut menunjukkan cara membuat taman bermain untuk berinteraksi dengan model yayasan Amazon Bedrock melalui modalitas yang berbeda.
------
#### [ .NET ]
**SDK untuk .NET**
.NET Foundation Model (FM) Playground adalah contoh aplikasi .NET MAUI Blazor yang menampilkan cara menggunakan Amazon Bedrock dari kode C\$1. Contoh ini menunjukkan bagaimana pengembang.NET dan C\$1 dapat menggunakan Amazon Bedrock untuk membangun aplikasi generatif berkemampuan AI. Anda dapat menguji dan berinteraksi dengan model yayasan Amazon Bedrock dengan menggunakan empat taman bermain berikut:
+ Taman bermain teks.
+ Taman bermain obrolan.
+ Taman bermain obrolan suara.
+ Taman bermain gambar.
Contoh ini juga mencantumkan dan menampilkan model fondasi yang dapat Anda akses dan karakteristiknya. Untuk kode sumber dan petunjuk penerapan, lihat proyek di [GitHub](https://github.com/build-on-aws/dotnet-fm-playground).
**Layanan yang digunakan dalam contoh ini**
+ Runtime Amazon Bedrock
------
#### [ Java ]
**SDK untuk Java 2.x**
Java Foundation Model (FM) Playground adalah contoh aplikasi Spring Boot yang menampilkan cara menggunakan Amazon Bedrock dengan Java. Contoh ini menunjukkan bagaimana pengembang Java dapat menggunakan Amazon Bedrock untuk membangun aplikasi berkemampuan AI generatif. Anda dapat menguji dan berinteraksi dengan model yayasan Amazon Bedrock dengan menggunakan tiga taman bermain berikut:
+ Taman bermain teks.
+ Taman bermain obrolan.
+ Taman bermain gambar.
Contoh ini juga mencantumkan dan menampilkan model pondasi yang dapat Anda akses, bersama dengan karakteristiknya. Untuk kode sumber dan petunjuk penerapan, lihat proyek di [GitHub](https://github.com/build-on-aws/java-fm-playground).
**Layanan yang digunakan dalam contoh ini**
+ Runtime Amazon Bedrock
------
#### [ Python ]
**SDK untuk Python (Boto3)**
Python Foundation Model (FM) Playground adalah Python/FastAPI contoh aplikasi yang menampilkan cara menggunakan Amazon Bedrock dengan Python. Contoh ini menunjukkan bagaimana pengembang Python dapat menggunakan Amazon Bedrock untuk membangun aplikasi berkemampuan AI generatif. Anda dapat menguji dan berinteraksi dengan model yayasan Amazon Bedrock dengan menggunakan tiga taman bermain berikut:
+ Taman bermain teks.
+ Taman bermain obrolan.
+ Taman bermain gambar.
Contoh ini juga mencantumkan dan menampilkan model pondasi yang dapat Anda akses, bersama dengan karakteristiknya. Untuk kode sumber dan petunjuk penerapan, lihat proyek di [GitHub](https://github.com/build-on-aws/python-fm-playground).
**Layanan yang digunakan dalam contoh ini**
+ Runtime Amazon Bedrock
------
# end-to-endContoh yang menunjukkan cara membuat dan memanggil prompt terkelola Amazon Bedrock menggunakan SDK AWS
Contoh kode berikut ini menunjukkan cara untuk melakukan:
+ Buat prompt terkelola.
+ Buat versi prompt.
+ Panggil prompt menggunakan versi.
+ Bersihkan sumber daya (opsional).
------
#### [ Python ]
**SDK untuk Python (Boto3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-agent#code-examples).
Buat dan panggil prompt terkelola.
```
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()
```
+ Untuk detail API, lihat topik berikut di *Referensi API AWS SDK untuk Python (Boto3)*.
+ [Bercakap-cakap](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)
------
# Hasilkan video dari petunjuk teks menggunakan Amazon Bedrock dan Nova-Reel
Contoh kode berikut menunjukkan cara aplikasi Spring Boot yang menghasilkan video dari prompt teks menggunakan Amazon Bedrock dan model Nova-Reel.
------
#### [ Java ]
**SDK untuk Java 2.x**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Hasilkan video dari petunjuk teks menggunakan Amazon Bedrock dan 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;
}
}
```
+ Untuk detail API, lihat topik berikut di *Referensi API AWS SDK for Java 2.x *.
+ [GetAsyncInvoke](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/GetAsyncInvoke)
+ [StartAsyncInvoke](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/StartAsyncInvoke)
------
# Gunakan beberapa model fondasi di Amazon Bedrock
Contoh kode berikut menunjukkan cara menyiapkan dan mengirim prompt ke berbagai model berbahasa besar (LLMs) di Amazon Bedrock
------
#### [ Go ]
**SDK untuk Go V2**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/bedrock-runtime#code-examples).
Gunakan beberapa model fondasi di Amazon Bedrock.
```
import (
"context"
"encoding/base64"
"fmt"
"log"
"math/rand"
"os"
"path/filepath"
"strings"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/bedrockruntime"
"github.com/awsdocs/aws-doc-sdk-examples/gov2/bedrock-runtime/actions"
"github.com/awsdocs/aws-doc-sdk-examples/gov2/demotools"
)
// InvokeModelsScenario demonstrates how to use the Amazon Bedrock Runtime client
// to invoke various foundation models for text and image generation
//
// 1. Generate text with Anthropic Claude 2
// 2. Generate text with Meta Llama 2 Chat
// 3. Generate text and asynchronously process the response stream with Anthropic Claude 2
// 4. Generate an image with the Amazon Titan image generation model
type InvokeModelsScenario struct {
sdkConfig aws.Config
invokeModelWrapper actions.InvokeModelWrapper
responseStreamWrapper actions.InvokeModelWithResponseStreamWrapper
questioner demotools.IQuestioner
}
// NewInvokeModelsScenario constructs an InvokeModelsScenario instance from a configuration.
// It uses the specified config to get a Bedrock Runtime client and create wrappers for the
// actions used in the scenario.
func NewInvokeModelsScenario(sdkConfig aws.Config, questioner demotools.IQuestioner) InvokeModelsScenario {
client := bedrockruntime.NewFromConfig(sdkConfig)
return InvokeModelsScenario{
sdkConfig: sdkConfig,
invokeModelWrapper: actions.InvokeModelWrapper{BedrockRuntimeClient: client},
responseStreamWrapper: actions.InvokeModelWithResponseStreamWrapper{BedrockRuntimeClient: client},
questioner: questioner,
}
}
// Runs the interactive scenario.
func (scenario InvokeModelsScenario) Run(ctx context.Context) {
defer func() {
if r := recover(); r != nil {
log.Printf("Something went wrong with the demo: %v\n", r)
}
}()
log.Println(strings.Repeat("=", 77))
log.Println("Welcome to the Amazon Bedrock Runtime model invocation demo.")
log.Println(strings.Repeat("=", 77))
log.Printf("First, let's invoke a few large-language models using the synchronous client:\n\n")
text2textPrompt := "In one paragraph, who are you?"
log.Println(strings.Repeat("-", 77))
log.Printf("Invoking Claude with prompt: %v\n", text2textPrompt)
scenario.InvokeClaude(ctx, text2textPrompt)
log.Println(strings.Repeat("=", 77))
log.Printf("Now, let's invoke Claude with the asynchronous client and process the response stream:\n\n")
log.Println(strings.Repeat("-", 77))
log.Printf("Invoking Claude with prompt: %v\n", text2textPrompt)
scenario.InvokeWithResponseStream(ctx, text2textPrompt)
log.Println(strings.Repeat("=", 77))
log.Printf("Now, let's create an image with the Amazon Titan image generation model:\n\n")
text2ImagePrompt := "stylized picture of a cute old steampunk robot"
seed := rand.Int63n(2147483648)
log.Println(strings.Repeat("-", 77))
log.Printf("Invoking Amazon Titan with prompt: %v\n", text2ImagePrompt)
scenario.InvokeTitanImage(ctx, text2ImagePrompt, seed)
log.Println(strings.Repeat("=", 77))
log.Println("Thanks for watching!")
log.Println(strings.Repeat("=", 77))
}
func (scenario InvokeModelsScenario) InvokeClaude(ctx context.Context, prompt string) {
completion, err := scenario.invokeModelWrapper.InvokeClaude(ctx, prompt)
if err != nil {
panic(err)
}
log.Printf("\nClaude : %v\n", strings.TrimSpace(completion))
}
func (scenario InvokeModelsScenario) InvokeWithResponseStream(ctx context.Context, prompt string) {
log.Println("\nClaude with response stream:")
_, err := scenario.responseStreamWrapper.InvokeModelWithResponseStream(ctx, prompt)
if err != nil {
panic(err)
}
log.Println()
}
func (scenario InvokeModelsScenario) InvokeTitanImage(ctx context.Context, prompt string, seed int64) {
base64ImageData, err := scenario.invokeModelWrapper.InvokeTitanImage(ctx, prompt, seed)
if err != nil {
panic(err)
}
imagePath := saveImage(base64ImageData, "amazon.titan-image-generator-v2")
fmt.Printf("The generated image has been saved to %s\n", imagePath)
}
```
+ Untuk detail API, lihat topik berikut di *Referensi API AWS SDK untuk Go *.
+ [InvokeModel](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/bedrockruntime#Client.InvokeModel)
+ [InvokeModelWithResponseStream](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/bedrockruntime#Client.InvokeModelWithResponseStream)
------
#### [ JavaScript ]
**SDK untuk JavaScript (v3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkap dan pelajari cara menyiapkan dan menjalankan di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
```
import { fileURLToPath } from "node:url";
import {
Scenario,
ScenarioAction,
ScenarioInput,
ScenarioOutput,
} from "@aws-doc-sdk-examples/lib/scenario/index.js";
import { FoundationModels } from "../config/foundation_models.js";
/**
* @typedef {Object} ModelConfig
* @property {Function} module
* @property {Function} invoker
* @property {string} modelId
* @property {string} modelName
*/
const greeting = new ScenarioOutput(
"greeting",
"Welcome to the Amazon Bedrock Runtime client demo!",
{ header: true },
);
const selectModel = new ScenarioInput("model", "First, select a model:", {
type: "select",
choices: Object.values(FoundationModels).map((model) => ({
name: model.modelName,
value: model,
})),
});
const enterPrompt = new ScenarioInput("prompt", "Now, enter your prompt:", {
type: "input",
});
const printDetails = new ScenarioOutput(
"print details",
/**
* @param {{ model: ModelConfig, prompt: string }} c
*/
(c) => console.log(`Invoking ${c.model.modelName} with '${c.prompt}'...`),
);
const invokeModel = new ScenarioAction(
"invoke model",
/**
* @param {{ model: ModelConfig, prompt: string, response: string }} c
*/
async (c) => {
const modelModule = await c.model.module();
const invoker = c.model.invoker(modelModule);
c.response = await invoker(c.prompt, c.model.modelId);
},
);
const printResponse = new ScenarioOutput(
"print response",
/**
* @param {{ response: string }} c
*/
(c) => c.response,
);
const scenario = new Scenario("Amazon Bedrock Runtime Demo", [
greeting,
selectModel,
enterPrompt,
printDetails,
invokeModel,
printResponse,
]);
if (process.argv[1] === fileURLToPath(import.meta.url)) {
scenario.run();
}
```
+ Untuk detail API, lihat topik berikut di *Referensi API AWS SDK untuk JavaScript *.
+ [InvokeModel](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/InvokeModelCommand)
+ [InvokeModelWithResponseStream](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/InvokeModelWithResponseStreamCommand)
------
#### [ PHP ]
**SDK untuk PHP**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/bedrock-runtime/#code-examples).
Panggil beberapa LLMs di Amazon Bedrock.
```
namespace BedrockRuntime;
class GettingStartedWithBedrockRuntime
{
protected BedrockRuntimeService $bedrockRuntimeService;
public function runExample()
{
echo "\n";
echo "---------------------------------------------------------------------\n";
echo "Welcome to the Amazon Bedrock Runtime getting started demo using PHP!\n";
echo "---------------------------------------------------------------------\n";
$bedrockRuntimeService = new BedrockRuntimeService();
$prompt = 'In one paragraph, who are you?';
echo "\nPrompt: " . $prompt;
echo "\n\nAnthropic Claude:\n";
echo $bedrockRuntimeService->invokeClaude($prompt);
echo "\n---------------------------------------------------------------------\n";
$image_prompt = 'stylized picture of a cute old steampunk robot';
echo "\nImage prompt: " . $image_prompt;
echo "\n\nStability.ai Stable Diffusion XL:\n";
$diffusionSeed = rand(0, 4294967295);
$style_preset = 'photographic';
$base64 = $bedrockRuntimeService->invokeStableDiffusion($image_prompt, $diffusionSeed, $style_preset);
$image_path = $this->saveImage($base64, 'stability.stable-diffusion-xl');
echo "The generated image has been saved to $image_path";
echo "\n\nAmazon Titan Image Generation:\n";
$titanSeed = rand(0, 2147483647);
$base64 = $bedrockRuntimeService->invokeTitanImage($image_prompt, $titanSeed);
$image_path = $this->saveImage($base64, 'amazon.titan-image-generator-v2');
echo "The generated image has been saved to $image_path";
}
private function saveImage($base64_image_data, $model_id): string
{
$output_dir = "output";
if (!file_exists($output_dir)) {
mkdir($output_dir);
}
$i = 1;
while (file_exists("$output_dir/$model_id" . '_' . "$i.png")) {
$i++;
}
$image_data = base64_decode($base64_image_data);
$file_path = "$output_dir/$model_id" . '_' . "$i.png";
$file = fopen($file_path, 'wb');
fwrite($file, $image_data);
fclose($file);
return $file_path;
}
}
```
+ Untuk detail API, lihat topik berikut di *Referensi API AWS SDK untuk PHP *.
+ [InvokeModel](https://docs.aws.amazon.com/goto/SdkForPHPV3/bedrock-runtime-2023-09-30/InvokeModel)
+ [InvokeModelWithResponseStream](https://docs.aws.amazon.com/goto/SdkForPHPV3/bedrock-runtime-2023-09-30/InvokeModelWithResponseStream)
------
# Membangun dan mengatur aplikasi AI generatif dengan Amazon Bedrock dan Step Functions
Contoh kode berikut menunjukkan cara membangun dan mengatur aplikasi AI generatif dengan Amazon Bedrock dan Step Functions.
------
#### [ Python ]
**SDK untuk Python (Boto3)**
Skenario Amazon Bedrock Serverless Prompt Chaining menunjukkan bagaimana [AWS Step Functions](https://docs.aws.amazon.com/step-functions/latest/dg/welcome.html), [Amazon](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html) Bedrock, [https://docs.aws.amazon.com/bedrock/latest/userguide/agents.html](https://docs.aws.amazon.com/bedrock/latest/userguide/agents.html) dan dapat digunakan untuk membangun dan mengatur aplikasi AI generatif yang kompleks, tanpa server, dan sangat skalabel. Ini berisi contoh kerja berikut:
+ Tulis analisis novel yang diberikan untuk blog sastra. Contoh ini menggambarkan rantai petunjuk yang sederhana dan berurutan.
+ Hasilkan cerita pendek tentang topik tertentu. Contoh ini menggambarkan bagaimana AI dapat secara iteratif memproses daftar item yang dihasilkan sebelumnya.
+ Buat rencana perjalanan untuk liburan akhir pekan ke tujuan tertentu. Contoh ini menggambarkan cara memparalelkan beberapa prompt yang berbeda.
+ Pitch ide film untuk pengguna manusia yang bertindak sebagai produser film. Contoh ini menggambarkan cara memparalelkan prompt yang sama dengan parameter inferensi yang berbeda, cara mundur ke langkah sebelumnya dalam rantai, dan cara memasukkan input manusia sebagai bagian dari alur kerja.
+ Rencanakan makanan berdasarkan bahan-bahan yang dimiliki pengguna. Contoh ini menggambarkan bagaimana rantai cepat dapat menggabungkan dua percakapan AI yang berbeda, dengan dua persona AI terlibat dalam debat satu sama lain untuk meningkatkan hasil akhir.
+ Temukan dan rangkum repositori tren GitHub tertinggi hari ini. Contoh ini menggambarkan rantai beberapa agen AI yang berinteraksi dengan eksternal. APIs
Untuk kode sumber lengkap dan instruksi untuk menyiapkan dan menjalankan, lihat proyek lengkap di [GitHub](https://github.com/aws-samples/amazon-bedrock-serverless-prompt-chaining).
**Layanan yang digunakan dalam contoh ini**
+ Amazon Bedrock
+ Runtime Amazon Bedrock
+ Agen Batuan Dasar Amazon
+ Runtime Agen Batuan Dasar Amazon
+ Step Functions
------
# Contoh penggunaan alat yang menggambarkan cara menghubungkan model AI di Amazon Bedrock dengan alat atau API khusus
Contoh kode berikut menunjukkan bagaimana membangun interaksi khas antara aplikasi, model AI generatif, dan alat yang terhubung atau APIs untuk memediasi interaksi antara AI dan dunia luar. Ini menggunakan contoh menghubungkan API cuaca eksternal ke model AI sehingga dapat memberikan informasi cuaca real-time berdasarkan input pengguna.
------
#### [ .NET ]
**SDK untuk .NET**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime/Scenarios/ConverseToolScenario#code-examples).
Eksekusi utama dari alur skenario. Skenario ini mengatur percakapan antara pengguna, Amazon Bedrock Converse API, dan alat cuaca.
```
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();
}
}
```
Alat cuaca yang digunakan oleh demo. File ini mendefinisikan spesifikasi alat dan mengimplementasikan logika untuk mengambil data cuaca menggunakan dari 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;
}
}
}
```
Tindakan Converse API dengan konfigurasi alat.
```
///
/// 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;
}
}
}
```
+ Untuk detail API, lihat [Converse](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/Converse) di *Referensi AWS SDK untuk .NET API*.
------
#### [ Java ]
**SDK untuk Java 2.x**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Eksekusi utama dari alur skenario. Skenario ini mengatur percakapan antara pengguna, Amazon Bedrock Converse API, dan alat cuaca.
```
/*
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
=================================================
""");
}
}
```
Alat cuaca yang digunakan oleh demo. File ini mendefinisikan spesifikasi alat dan mengimplementasikan logika untuk mengambil data cuaca menggunakan dari 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
}
}
```
Tindakan Converse API dengan konfigurasi alat.
```
/**
* 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);
}
}
```
+ Untuk detail API, lihat [Converse](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/Converse) di *Referensi AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK untuk JavaScript (v3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime/scenarios/converse_tool_scenario#code-examples).
Eksekusi utama dari alur skenario. Skenario ini mengatur percakapan antara pengguna, Amazon Bedrock Converse API, dan alat cuaca.
```
/* 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 });
}
```
+ Untuk detail API, lihat [Converse](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseCommand) di *Referensi AWS SDK untuk JavaScript API*.
------
#### [ Python ]
**SDK untuk Python (Boto3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Skrip eksekusi utama dari demo. Skrip ini mengatur percakapan antara pengguna, Amazon Bedrock Converse API, dan alat cuaca.
```
"""
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()
```
Alat cuaca yang digunakan oleh demo. Skrip ini mendefinisikan spesifikasi alat dan mengimplementasikan logika untuk mengambil data cuaca menggunakan dari 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)}
```
+ Untuk detail API, lihat [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) in *AWS SDK for Python (Boto3) Referensi* API.
------
#### [ Rust ]
**SDK for Rust**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/bedrock-runtime#code-examples).
Skenario utama dan logika untuk demo. Ini mengatur percakapan antara pengguna, Amazon Bedrock Converse API, dan alat cuaca.
```
#[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();
}
```
Alat cuaca yang digunakan oleh demo. Skrip ini mendefinisikan spesifikasi alat dan mengimplementasikan logika untuk mengambil data cuaca menggunakan dari 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()?)
}
```
Utilitas untuk mencetak Blok Konten Pesan.
```
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:?})"
)))
}
}
```
Gunakan pernyataan, utilitas Kesalahan, dan konstanta.
```
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(),
})
}
}
```
+ Untuk detail API, lihat [Converse](https://docs.rs/aws-sdk-bedrockruntime/latest/aws_sdk_bedrockruntime/client/struct.Client.html#method.converse) di *AWS SDK untuk referensi Rust API*.
------
# Amazon Nova untuk Amazon Bedrock Runtime
Contoh kode berikut menunjukkan cara menggunakan Amazon Bedrock Runtime dengan. AWS SDKs
**Topics**
+ [Bercakap-cakap](bedrock-runtime_example_bedrock-runtime_Converse_AmazonNovaText_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_AmazonNovaText_section.md)
+ [Pemahaman dokumen](bedrock-runtime_example_bedrock-runtime_DocumentUnderstanding_AmazonNova_section.md)
+ [Skenario: Penggunaan alat dengan API Converse](bedrock-runtime_example_bedrock-runtime_Scenario_ToolUseDemo_AmazonNova_section.md)
# Panggil Amazon Nova di Amazon Bedrock menggunakan API Converse Bedrock
Contoh kode berikut menunjukkan cara mengirim pesan teks ke Amazon Nova, menggunakan API Converse Bedrock.
------
#### [ .NET ]
**SDK untuk .NET**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime#code-examples).
Kirim pesan teks ke Amazon Nova, menggunakan API Converse Bedrock.
```
// Use the Converse API to send a text message to Amazon Nova.
using System;
using System.Collections.Generic;
using Amazon;
using Amazon.BedrockRuntime;
using Amazon.BedrockRuntime.Model;
// Create a Bedrock Runtime client in the AWS Region you want to use.
var client = new AmazonBedrockRuntimeClient(RegionEndpoint.USEast1);
// Set the model ID, e.g., Amazon Nova Lite.
var modelId = "amazon.nova-lite-v1:0";
// Define the user message.
var userMessage = "Describe the purpose of a 'hello world' program in one line.";
// Create a request with the model ID, the user message, and an inference configuration.
var request = new ConverseRequest
{
ModelId = modelId,
Messages = new List
{
new Message
{
Role = ConversationRole.User,
Content = new List { new ContentBlock { Text = userMessage } }
}
},
InferenceConfig = new InferenceConfiguration()
{
MaxTokens = 512,
Temperature = 0.5F,
TopP = 0.9F
}
};
try
{
// Send the request to the Bedrock Runtime and wait for the result.
var response = await client.ConverseAsync(request);
// Extract and print the response text.
string responseText = response?.Output?.Message?.Content?[0]?.Text ?? "";
Console.WriteLine(responseText);
}
catch (AmazonBedrockRuntimeException e)
{
Console.WriteLine($"ERROR: Can't invoke '{modelId}'. Reason: {e.Message}");
throw;
}
```
Kirim percakapan pesan ke Amazon Nova menggunakan API Converse Bedrock dengan konfigurasi alat.
```
///
/// 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;
}
}
}
```
+ Untuk detail API, lihat [Converse](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/Converse) di *Referensi AWS SDK untuk .NET API*.
------
#### [ Java ]
**SDK untuk Java 2.x**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Kirim pesan teks ke Amazon Nova menggunakan API Converse Bedrock dengan klien Java async.
```
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);
}
}
```
Kirim pesan teks ke Amazon Nova, menggunakan API Converse Bedrock.
```
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.core.exception.SdkClientException;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.bedrockruntime.BedrockRuntimeClient;
import software.amazon.awssdk.services.bedrockruntime.model.*;
/**
* This example demonstrates how to use the Amazon Nova foundation models
* with a synchronous Amazon Bedrock runtime client to generate text.
* It shows how to:
* - Set up the Amazon Bedrock runtime client
* - Create a message
* - Configure and send a request
* - Process the response
*/
public class Converse {
public static String converse() {
// Step 1: Create the Amazon Bedrock runtime client
// The runtime client handles the communication with AI models on Amazon Bedrock
BedrockRuntimeClient client = BedrockRuntimeClient.builder()
.credentialsProvider(DefaultCredentialsProvider.create())
.region(Region.US_EAST_1)
.build();
// Step 2: Specify which model to use
// Available Amazon Nova models and their characteristics:
// - Amazon Nova Micro: Text-only model optimized for lowest latency and cost
// - Amazon Nova Lite: Fast, low-cost multimodal model for image, video, and text
// - Amazon Nova Pro: Advanced multimodal model balancing accuracy, speed, and cost
//
// For the latest available models, see:
// https://docs.aws.amazon.com/bedrock/latest/userguide/models-supported.html
String modelId = "amazon.nova-lite-v1:0";
// Step 3: Create the message
// The message includes the text prompt and specifies that it comes from the user
var inputText = "Describe the purpose of a 'hello world' program in one line.";
var message = Message.builder()
.content(ContentBlock.fromText(inputText))
.role(ConversationRole.USER)
.build();
// Step 4: Configure the request
// Optional parameters to control the model's response:
// - maxTokens: maximum number of tokens to generate
// - temperature: randomness (max: 1.0, default: 0.7)
// OR
// - topP: diversity of word choice (max: 1.0, default: 0.9)
// Note: Use either temperature OR topP, but not both
ConverseRequest request = ConverseRequest.builder()
.modelId(modelId)
.messages(message)
.inferenceConfig(config -> config
.maxTokens(500) // The maximum response length
.temperature(0.5F) // Using temperature for randomness control
//.topP(0.9F) // Alternative: use topP instead of temperature
).build();
// Step 5: Send and process the request
// - Send the request to the model
// - Extract and return the generated text from the response
try {
ConverseResponse response = client.converse(request);
return response.output().message().content().get(0).text();
} catch (SdkClientException e) {
System.err.printf("ERROR: Can't invoke '%s'. Reason: %s", modelId, e.getMessage());
throw new RuntimeException(e);
}
}
public static void main(String[] args) {
String response = converse();
System.out.println(response);
}
}
```
+ Untuk detail API, lihat [Converse](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/Converse) di *Referensi AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK untuk JavaScript (v3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Kirim pesan teks ke Amazon Nova, menggunakan API Converse Bedrock.
```
// This example demonstrates how to use the Amazon Nova foundation models to generate text.
// It shows how to:
// - Set up the Amazon Bedrock runtime client
// - Create a message
// - Configure and send a request
// - Process the response
import {
BedrockRuntimeClient,
ConversationRole,
ConverseCommand,
} from "@aws-sdk/client-bedrock-runtime";
// Step 1: Create the Amazon Bedrock runtime client
// Credentials will be automatically loaded from the environment.
const client = new BedrockRuntimeClient({ region: "us-east-1" });
// Step 2: Specify which model to use:
// Available Amazon Nova models and their characteristics:
// - Amazon Nova Micro: Text-only model optimized for lowest latency and cost
// - Amazon Nova Lite: Fast, low-cost multimodal model for image, video, and text
// - Amazon Nova Pro: Advanced multimodal model balancing accuracy, speed, and cost
//
// For the most current model IDs, see:
// https://docs.aws.amazon.com/bedrock/latest/userguide/models-supported.html
const modelId = "amazon.nova-lite-v1:0";
// Step 3: Create the message
// The message includes the text prompt and specifies that it comes from the user
const inputText =
"Describe the purpose of a 'hello world' program in one line.";
const message = {
content: [{ text: inputText }],
role: ConversationRole.USER,
};
// Step 4: Configure the request
// Optional parameters to control the model's response:
// - maxTokens: maximum number of tokens to generate
// - temperature: randomness (max: 1.0, default: 0.7)
// OR
// - topP: diversity of word choice (max: 1.0, default: 0.9)
// Note: Use either temperature OR topP, but not both
const request = {
modelId,
messages: [message],
inferenceConfig: {
maxTokens: 500, // The maximum response length
temperature: 0.5, // Using temperature for randomness control
//topP: 0.9, // Alternative: use topP instead of temperature
},
};
// Step 5: Send and process the request
// - Send the request to the model
// - Extract and return the generated text from the response
try {
const response = await client.send(new ConverseCommand(request));
console.log(response.output.message.content[0].text);
} catch (error) {
console.error(`ERROR: Can't invoke '${modelId}'. Reason: ${error.message}`);
throw error;
}
```
Kirim percakapan pesan ke Amazon Nova menggunakan API Converse Bedrock dengan konfigurasi alat.
```
// 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);
```
+ Untuk detail API, lihat [Converse](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseCommand) di *Referensi AWS SDK untuk JavaScript API*.
------
#### [ Kotlin ]
**SDK untuk Kotlin**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/bedrock-runtime#code-examples).
Kirim pesan teks ke Amazon Nova, menggunakan API Converse Bedrock.
```
import aws.sdk.kotlin.services.bedrockruntime.BedrockRuntimeClient
import aws.sdk.kotlin.services.bedrockruntime.model.ContentBlock
import aws.sdk.kotlin.services.bedrockruntime.model.ConversationRole
import aws.sdk.kotlin.services.bedrockruntime.model.ConverseRequest
import aws.sdk.kotlin.services.bedrockruntime.model.Message
/**
* This example demonstrates how to use the Amazon Nova foundation models to generate text.
* It shows how to:
* - Set up the Amazon Bedrock runtime client
* - Create a message
* - Configure and send a request
* - Process the response
*/
suspend fun main() {
converse().also { println(it) }
}
suspend fun converse(): String {
// Create and configure the Bedrock runtime client
BedrockRuntimeClient { region = "us-east-1" }.use { client ->
// Specify the model ID. For the latest available models, see:
// https://docs.aws.amazon.com/bedrock/latest/userguide/models-supported.html
val modelId = "amazon.nova-lite-v1:0"
// Create the message with the user's prompt
val prompt = "Describe the purpose of a 'hello world' program in one line."
val message = Message {
role = ConversationRole.User
content = listOf(ContentBlock.Text(prompt))
}
// Configure the request with optional model parameters
val request = ConverseRequest {
this.modelId = modelId
messages = listOf(message)
inferenceConfig {
maxTokens = 500 // Maximum response length
temperature = 0.5F // Lower values: more focused output
// topP = 0.8F // Alternative to temperature
}
}
// Send the request and process the model's response
runCatching {
val response = client.converse(request)
return response.output!!.asMessage().content.first().asText()
}.getOrElse { error ->
error.message?.let { e -> System.err.println("ERROR: Can't invoke '$modelId'. Reason: $e") }
throw RuntimeException("Failed to generate text with model $modelId", error)
}
}
}
```
+ Untuk detail API, lihat [Converse](https://sdk.amazonaws.com/kotlin/api/latest/index.html) in *AWS SDK untuk referensi API Kotlin*.
------
#### [ PHP ]
**SDK untuk PHP**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/bedrock-runtime#code-examples).
Kirim pesan teks ke Amazon Nova, menggunakan API Converse Bedrock.
```
// Use the Conversation API to send a text message to Amazon Nova.
use Aws\BedrockRuntime\BedrockRuntimeClient;
use Aws\Exception\AwsException;
use RuntimeException;
class Converse
{
public function converse(): string
{
// Create a Bedrock Runtime client in the AWS Region you want to use.
$client = new BedrockRuntimeClient([
'region' => 'us-east-1',
'profile' => 'default'
]);
// Set the model ID, e.g., Amazon Nova Lite.
$modelId = 'amazon.nova-lite-v1:0';
// Start a conversation with the user message.
$userMessage = "Describe the purpose of a 'hello world' program in one line.";
$conversation = [
[
"role" => "user",
"content" => [["text" => $userMessage]]
]
];
try {
// Send the message to the model, using a basic inference configuration.
$response = $client->converse([
'modelId' => $modelId,
'messages' => $conversation,
'inferenceConfig' => [
'maxTokens' => 512,
'temperature' => 0.5
]
]);
// Extract and return the response text.
$responseText = $response['output']['message']['content'][0]['text'];
return $responseText;
} catch (AwsException $e) {
echo "ERROR: Can't invoke {$modelId}. Reason: {$e->getAwsErrorMessage()}";
throw new RuntimeException("Failed to invoke model: " . $e->getAwsErrorMessage(), 0, $e);
}
}
}
$demo = new Converse();
echo $demo->converse();
```
+ Untuk detail API, lihat [Converse](https://docs.aws.amazon.com/goto/SdkForPHPV3/bedrock-runtime-2023-09-30/Converse) di *Referensi AWS SDK untuk PHP API*.
------
#### [ Python ]
**SDK untuk Python (Boto3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Kirim pesan teks ke Amazon Nova, menggunakan API Converse Bedrock.
```
# Use the Conversation API to send a text message to Amazon Nova.
import boto3
from botocore.exceptions import ClientError
# Create a Bedrock Runtime client in the AWS Region you want to use.
client = boto3.client("bedrock-runtime", region_name="us-east-1")
# Set the model ID, e.g., Amazon Nova Lite.
model_id = "amazon.nova-lite-v1:0"
# Start a conversation with the user message.
user_message = "Describe the purpose of a 'hello world' program in one line."
conversation = [
{
"role": "user",
"content": [{"text": user_message}],
}
]
try:
# Send the message to the model, using a basic inference configuration.
response = client.converse(
modelId=model_id,
messages=conversation,
inferenceConfig={"maxTokens": 512, "temperature": 0.5, "topP": 0.9},
)
# Extract and print the response text.
response_text = response["output"]["message"]["content"][0]["text"]
print(response_text)
except (ClientError, Exception) as e:
print(f"ERROR: Can't invoke '{model_id}'. Reason: {e}")
exit(1)
```
+ Untuk detail API, lihat [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) in *AWS SDK for Python (Boto3) Referensi* API.
------
#### [ Swift ]
**SDK para Swift**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/bedrock-runtime#code-examples).
Kirim pesan teks ke Amazon Nova, menggunakan API Converse Bedrock.
```
// An example demonstrating how to use the Conversation API to send
// a text message to Amazon Nova.
import AWSBedrockRuntime
func converse(_ textPrompt: String) async throws -> String {
// Create a Bedrock Runtime client in the AWS Region you want to use.
let config =
try await BedrockRuntimeClient.BedrockRuntimeClientConfiguration(
region: "us-east-1"
)
let client = BedrockRuntimeClient(config: config)
// Set the model ID.
let modelId = "amazon.nova-micro-v1:0"
// Start a conversation with the user message.
let message = BedrockRuntimeClientTypes.Message(
content: [.text(textPrompt)],
role: .user
)
// Optionally use inference parameters
let inferenceConfig =
BedrockRuntimeClientTypes.InferenceConfiguration(
maxTokens: 512,
stopSequences: ["END"],
temperature: 0.5,
topp: 0.9
)
// Create the ConverseInput to send to the model
let input = ConverseInput(
inferenceConfig: inferenceConfig, messages: [message], modelId: modelId)
// Send the ConverseInput to the model
let response = try await client.converse(input: input)
// Extract and return the response text.
if case let .message(msg) = response.output {
if case let .text(textResponse) = msg.content![0] {
return textResponse
} else {
return "No text response found in message content"
}
} else {
return "No message found in converse output"
}
}
```
+ Untuk detail API, lihat [Converse](https://sdk.amazonaws.com/swift/api/awsbedrockruntime/latest/documentation/awsbedrockruntime/bedrockruntimeclient/converse(input:)) di *AWS SDK untuk referensi Swift* API.
------
# Panggil Amazon Nova di Amazon Bedrock menggunakan API Converse Bedrock dengan aliran respons
Contoh kode berikut menunjukkan cara mengirim pesan teks ke Amazon Nova, menggunakan API Converse Bedrock dan memproses aliran respons secara real-time.
------
#### [ .NET ]
**SDK untuk .NET**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime#code-examples).
Kirim pesan teks ke Amazon Nova, menggunakan API Converse Bedrock dan proses aliran respons secara real-time.
```
// Use the Converse API to send a text message to Amazon Nova
// and print the response stream.
using System;
using System.Collections.Generic;
using System.Linq;
using Amazon;
using Amazon.BedrockRuntime;
using Amazon.BedrockRuntime.Model;
// Create a Bedrock Runtime client in the AWS Region you want to use.
var client = new AmazonBedrockRuntimeClient(RegionEndpoint.USEast1);
// Set the model ID, e.g., Amazon Nova Lite.
var modelId = "amazon.nova-lite-v1:0";
// Define the user message.
var userMessage = "Describe the purpose of a 'hello world' program in one line.";
// Create a request with the model ID, the user message, and an inference configuration.
var request = new ConverseStreamRequest
{
ModelId = modelId,
Messages = new List
{
new Message
{
Role = ConversationRole.User,
Content = new List { new ContentBlock { Text = userMessage } }
}
},
InferenceConfig = new InferenceConfiguration()
{
MaxTokens = 512,
Temperature = 0.5F,
TopP = 0.9F
}
};
try
{
// Send the request to the Bedrock Runtime and wait for the result.
var response = await client.ConverseStreamAsync(request);
// Extract and print the streamed response text in real-time.
foreach (var chunk in response.Stream.AsEnumerable())
{
if (chunk is ContentBlockDeltaEvent)
{
Console.Write((chunk as ContentBlockDeltaEvent).Delta.Text);
}
}
}
catch (AmazonBedrockRuntimeException e)
{
Console.WriteLine($"ERROR: Can't invoke '{modelId}'. Reason: {e.Message}");
throw;
}
```
+ Untuk detail API, lihat [ConverseStream](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/ConverseStream)di *Referensi AWS SDK untuk .NET API*.
------
#### [ Java ]
**SDK untuk Java 2.x**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Kirim pesan teks ke Amazon Nova menggunakan API Converse Bedrock dan proses aliran respons secara real-time.
```
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.bedrockruntime.BedrockRuntimeAsyncClient;
import software.amazon.awssdk.services.bedrockruntime.model.*;
import java.util.concurrent.ExecutionException;
/**
* This example demonstrates how to use the Amazon Nova foundation models with an
* asynchronous Amazon Bedrock runtime client to generate streaming text responses.
* It shows how to:
* - Set up the Amazon Bedrock runtime client
* - Create a message
* - Configure a streaming request
* - Set up a stream handler to process the response chunks
* - Process the streaming response
*/
public class ConverseStream {
public static void converseStream() {
// Step 1: Create the Amazon Bedrock runtime client
// The runtime client handles the communication with AI models on Amazon Bedrock
BedrockRuntimeAsyncClient client = BedrockRuntimeAsyncClient.builder()
.credentialsProvider(DefaultCredentialsProvider.create())
.region(Region.US_EAST_1)
.build();
// Step 2: Specify which model to use
// Available Amazon Nova models and their characteristics:
// - Amazon Nova Micro: Text-only model optimized for lowest latency and cost
// - Amazon Nova Lite: Fast, low-cost multimodal model for image, video, and text
// - Amazon Nova Pro: Advanced multimodal model balancing accuracy, speed, and cost
//
// For the latest available models, see:
// https://docs.aws.amazon.com/bedrock/latest/userguide/models-supported.html
String modelId = "amazon.nova-lite-v1:0";
// Step 3: Create the message
// The message includes the text prompt and specifies that it comes from the user
var inputText = "Describe the purpose of a 'hello world' program in one paragraph";
var message = Message.builder()
.content(ContentBlock.fromText(inputText))
.role(ConversationRole.USER)
.build();
// Step 4: Configure the request
// Optional parameters to control the model's response:
// - maxTokens: maximum number of tokens to generate
// - temperature: randomness (max: 1.0, default: 0.7)
// OR
// - topP: diversity of word choice (max: 1.0, default: 0.9)
// Note: Use either temperature OR topP, but not both
ConverseStreamRequest request = ConverseStreamRequest.builder()
.modelId(modelId)
.messages(message)
.inferenceConfig(config -> config
.maxTokens(500) // The maximum response length
.temperature(0.5F) // Using temperature for randomness control
//.topP(0.9F) // Alternative: use topP instead of temperature
).build();
// Step 5: Set up the stream handler
// The stream handler processes chunks of the response as they arrive
// - onContentBlockDelta: Processes each text chunk
// - onError: Handles any errors during streaming
var streamHandler = ConverseStreamResponseHandler.builder()
.subscriber(ConverseStreamResponseHandler.Visitor.builder()
.onContentBlockDelta(chunk -> {
System.out.print(chunk.delta().text());
System.out.flush(); // Ensure immediate output of each chunk
}).build())
.onError(err -> System.err.printf("Can't invoke '%s': %s", modelId, err.getMessage()))
.build();
// Step 6: Send the streaming request and process the response
// - Send the request to the model
// - Attach the handler to process response chunks as they arrive
// - Handle any errors during streaming
try {
client.converseStream(request, streamHandler).get();
} catch (ExecutionException | InterruptedException e) {
System.err.printf("Can't invoke '%s': %s", modelId, e.getCause().getMessage());
}
}
public static void main(String[] args) {
converseStream();
}
}
```
+ Untuk detail API, lihat [ConverseStream](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/ConverseStream)di *Referensi AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK untuk JavaScript (v3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Kirim pesan teks ke Amazon Nova menggunakan API Converse Bedrock dan proses aliran respons secara real-time.
```
// This example demonstrates how to use the Amazon Nova foundation models
// to generate streaming text responses.
// It shows how to:
// - Set up the Amazon Bedrock runtime client
// - Create a message
// - Configure a streaming request
// - Process the streaming response
import {
BedrockRuntimeClient,
ConversationRole,
ConverseStreamCommand,
} from "@aws-sdk/client-bedrock-runtime";
// Step 1: Create the Amazon Bedrock runtime client
// Credentials will be automatically loaded from the environment
const client = new BedrockRuntimeClient({ region: "us-east-1" });
// Step 2: Specify which model to use
// Available Amazon Nova models and their characteristics:
// - Amazon Nova Micro: Text-only model optimized for lowest latency and cost
// - Amazon Nova Lite: Fast, low-cost multimodal model for image, video, and text
// - Amazon Nova Pro: Advanced multimodal model balancing accuracy, speed, and cost
//
// For the most current model IDs, see:
// https://docs.aws.amazon.com/bedrock/latest/userguide/models-supported.html
const modelId = "amazon.nova-lite-v1:0";
// Step 3: Create the message
// The message includes the text prompt and specifies that it comes from the user
const inputText =
"Describe the purpose of a 'hello world' program in one paragraph";
const message = {
content: [{ text: inputText }],
role: ConversationRole.USER,
};
// Step 4: Configure the streaming request
// Optional parameters to control the model's response:
// - maxTokens: maximum number of tokens to generate
// - temperature: randomness (max: 1.0, default: 0.7)
// OR
// - topP: diversity of word choice (max: 1.0, default: 0.9)
// Note: Use either temperature OR topP, but not both
const request = {
modelId,
messages: [message],
inferenceConfig: {
maxTokens: 500, // The maximum response length
temperature: 0.5, // Using temperature for randomness control
//topP: 0.9, // Alternative: use topP instead of temperature
},
};
// Step 5: Send and process the streaming request
// - Send the request to the model
// - Process each chunk of the streaming response
try {
const response = await client.send(new ConverseStreamCommand(request));
for await (const chunk of response.stream) {
if (chunk.contentBlockDelta) {
// Print each text chunk as it arrives
process.stdout.write(chunk.contentBlockDelta.delta?.text || "");
}
}
} catch (error) {
console.error(`ERROR: Can't invoke '${modelId}'. Reason: ${error.message}`);
process.exitCode = 1;
}
```
+ Untuk detail API, lihat [ConverseStream](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseStreamCommand)di *Referensi AWS SDK untuk JavaScript API*.
------
#### [ Kotlin ]
**SDK untuk Kotlin**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/bedrock-runtime#code-examples).
Kirim pesan teks ke Amazon Nova menggunakan API Converse Bedrock dan proses aliran respons secara real-time.
```
import aws.sdk.kotlin.services.bedrockruntime.BedrockRuntimeClient
import aws.sdk.kotlin.services.bedrockruntime.model.ContentBlock
import aws.sdk.kotlin.services.bedrockruntime.model.ConversationRole
import aws.sdk.kotlin.services.bedrockruntime.model.ConverseStreamOutput
import aws.sdk.kotlin.services.bedrockruntime.model.ConverseStreamRequest
import aws.sdk.kotlin.services.bedrockruntime.model.Message
/**
* This example demonstrates how to use the Amazon Nova foundation models
* to generate streaming text responses.
* It shows how to:
* - Set up the Amazon Bedrock runtime client
* - Create a message with a prompt
* - Configure a streaming request with parameters
* - Process the response stream in real time
*/
suspend fun main() {
converseStream()
}
suspend fun converseStream(): String {
// A buffer to collect the complete response
val completeResponseBuffer = StringBuilder()
// Create and configure the Bedrock runtime client
BedrockRuntimeClient { region = "us-east-1" }.use { client ->
// Specify the model ID. For the latest available models, see:
// https://docs.aws.amazon.com/bedrock/latest/userguide/models-supported.html
val modelId = "amazon.nova-lite-v1:0"
// Create the message with the user's prompt
val prompt = "Describe the purpose of a 'hello world' program in a paragraph."
val message = Message {
role = ConversationRole.User
content = listOf(ContentBlock.Text(prompt))
}
// Configure the request with optional model parameters
val request = ConverseStreamRequest {
this.modelId = modelId
messages = listOf(message)
inferenceConfig {
maxTokens = 500 // Maximum response length
temperature = 0.5F // Lower values: more focused output
// topP = 0.8F // Alternative to temperature
}
}
// Process the streaming response
runCatching {
client.converseStream(request) { response ->
response.stream?.collect { chunk ->
when (chunk) {
is ConverseStreamOutput.ContentBlockDelta -> {
// Process each text chunk as it arrives
chunk.value.delta?.asText()?.let { text ->
print(text)
System.out.flush() // Ensure immediate output
completeResponseBuffer.append(text)
}
}
else -> {} // Other output block types can be handled as needed
}
}
}
}.onFailure { error ->
error.message?.let { e -> System.err.println("ERROR: Can't invoke '$modelId'. Reason: $e") }
throw RuntimeException("Failed to generate text with model $modelId: $error", error)
}
}
return completeResponseBuffer.toString()
}
```
+ Untuk detail API, lihat [ConverseStream](https://sdk.amazonaws.com/kotlin/api/latest/index.html)di *AWS SDK untuk referensi API Kotlin*.
------
#### [ Python ]
**SDK untuk Python (Boto3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Kirim pesan teks ke Amazon Nova, menggunakan API Converse Bedrock dan proses aliran respons secara real-time.
```
# Use the Conversation API to send a text message to Amazon Nova Text
# and print the response stream.
import boto3
from botocore.exceptions import ClientError
# Create a Bedrock Runtime client in the AWS Region you want to use.
client = boto3.client("bedrock-runtime", region_name="us-east-1")
# Set the model ID, e.g., Amazon Nova Lite.
model_id = "amazon.nova-lite-v1:0"
# Start a conversation with the user message.
user_message = "Describe the purpose of a 'hello world' program in one line."
conversation = [
{
"role": "user",
"content": [{"text": user_message}],
}
]
try:
# Send the message to the model, using a basic inference configuration.
streaming_response = client.converse_stream(
modelId=model_id,
messages=conversation,
inferenceConfig={"maxTokens": 512, "temperature": 0.5, "topP": 0.9},
)
# Extract and print the streamed response text in real-time.
for chunk in streaming_response["stream"]:
if "contentBlockDelta" in chunk:
text = chunk["contentBlockDelta"]["delta"]["text"]
print(text, end="")
except (ClientError, Exception) as e:
print(f"ERROR: Can't invoke '{model_id}'. Reason: {e}")
exit(1)
```
+ Untuk detail API, lihat [ConverseStream](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/ConverseStream)di *AWS SDK for Python (Boto3) Referensi* API.
------
#### [ Swift ]
**SDK para Swift**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/bedrock-runtime#code-examples).
Kirim pesan teks ke Amazon Nova, menggunakan API Converse Bedrock dan proses aliran respons secara real-time.
```
// An example demonstrating how to use the Conversation API to send a text message
// to Amazon Nova and print the response stream
import AWSBedrockRuntime
func printConverseStream(_ textPrompt: String) async throws {
// Create a Bedrock Runtime client in the AWS Region you want to use.
let config =
try await BedrockRuntimeClient.BedrockRuntimeClientConfiguration(
region: "us-east-1"
)
let client = BedrockRuntimeClient(config: config)
// Set the model ID.
let modelId = "amazon.nova-lite-v1:0"
// Start a conversation with the user message.
let message = BedrockRuntimeClientTypes.Message(
content: [.text(textPrompt)],
role: .user
)
// Optionally use inference parameters.
let inferenceConfig =
BedrockRuntimeClientTypes.InferenceConfiguration(
maxTokens: 512,
stopSequences: ["END"],
temperature: 0.5,
topp: 0.9
)
// Create the ConverseStreamInput to send to the model.
let input = ConverseStreamInput(
inferenceConfig: inferenceConfig, messages: [message], modelId: modelId)
// Send the ConverseStreamInput to the model.
let response = try await client.converseStream(input: input)
// Extract the streaming response.
guard let stream = response.stream else {
print("No stream available")
return
}
// Extract and print the streamed response text in real-time.
for try await event in stream {
switch event {
case .messagestart(_):
print("\nNova Lite:")
case .contentblockdelta(let deltaEvent):
if case .text(let text) = deltaEvent.delta {
print(text, terminator: "")
}
default:
break
}
}
}
```
+ Untuk detail API, lihat referensi [ConverseStream AWS](https://sdk.amazonaws.com/swift/api/awsbedrockruntime/latest/documentation/awsbedrockruntime/bedrockruntimeclient/conversestream(input:))*SDK untuk Swift API*.
------
# Kirim dan proses dokumen dengan Amazon Nova di Amazon Bedrock
Contoh kode berikut menunjukkan cara mengirim dan memproses dokumen dengan Amazon Nova di Amazon Bedrock.
------
#### [ Python ]
**SDK untuk Python (Boto3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Kirim dan proses dokumen dengan Amazon Nova di 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)
```
+ Untuk detail API, lihat [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) in *AWS SDK for Python (Boto3) Referensi* API.
------
# Alat menggunakan demo yang menggambarkan cara menghubungkan model AI di Amazon Bedrock dengan alat atau API khusus
Contoh kode berikut menunjukkan bagaimana membangun interaksi khas antara aplikasi, model AI generatif, dan alat yang terhubung atau APIs untuk memediasi interaksi antara AI dan dunia luar. Ini menggunakan contoh menghubungkan API cuaca eksternal ke model AI sehingga dapat memberikan informasi cuaca real-time berdasarkan input pengguna.
------
#### [ .NET ]
**SDK untuk .NET**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime/Scenarios/ConverseToolScenario#code-examples).
Eksekusi utama dari alur skenario. Skenario ini mengatur percakapan antara pengguna, Amazon Bedrock Converse API, dan alat cuaca.
```
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();
}
}
```
Alat cuaca yang digunakan oleh demo. File ini mendefinisikan spesifikasi alat dan mengimplementasikan logika untuk mengambil data cuaca menggunakan dari 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;
}
}
}
```
Tindakan Converse API dengan konfigurasi alat.
```
///
/// 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;
}
}
}
```
+ Untuk detail API, lihat [Converse](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/Converse) di *Referensi AWS SDK untuk .NET API*.
------
#### [ Java ]
**SDK untuk Java 2.x**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Eksekusi utama dari alur skenario. Skenario ini mengatur percakapan antara pengguna, Amazon Bedrock Converse API, dan alat cuaca.
```
/*
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
=================================================
""");
}
}
```
Alat cuaca yang digunakan oleh demo. File ini mendefinisikan spesifikasi alat dan mengimplementasikan logika untuk mengambil data cuaca menggunakan dari 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
}
}
```
Tindakan Converse API dengan konfigurasi alat.
```
/**
* 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);
}
}
```
+ Untuk detail API, lihat [Converse](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/Converse) di *Referensi AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK untuk JavaScript (v3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime/scenarios/converse_tool_scenario#code-examples).
Eksekusi utama dari alur skenario. Skenario ini mengatur percakapan antara pengguna, Amazon Bedrock Converse API, dan alat cuaca.
```
/* 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 });
}
```
+ Untuk detail API, lihat [Converse](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseCommand) di *Referensi AWS SDK untuk JavaScript API*.
------
# Amazon Nova Canvas untuk Amazon Bedrock Runtime
Contoh kode berikut menunjukkan cara menggunakan Amazon Bedrock Runtime dengan. AWS SDKs
**Topics**
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_AmazonNovaImageGeneration_section.md)
# Panggil Amazon Nova Canvas di Amazon Bedrock untuk menghasilkan gambar
Contoh kode berikut menunjukkan cara memanggil Amazon Nova Canvas di Amazon Bedrock untuk menghasilkan gambar.
------
#### [ .NET ]
**SDK untuk .NET**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime#code-examples).
Buat gambar dengan 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;
}
```
+ Untuk detail API, lihat [InvokeModel](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/InvokeModel)di *Referensi AWS SDK untuk .NET API*.
------
#### [ Java ]
**SDK untuk Java 2.x**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Buat gambar dengan 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);
}
}
```
+ Untuk detail API, lihat [InvokeModel](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModel)di *Referensi AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK untuk JavaScript (v3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Buat gambar dengan 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;
});
}
```
+ Untuk detail API, lihat [InvokeModel](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/InvokeModelCommand)di *Referensi AWS SDK untuk JavaScript API*.
------
#### [ Python ]
**SDK untuk Python (Boto3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Buat gambar dengan 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}")
```
+ Untuk detail API, lihat [InvokeModel](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModel)di *AWS SDK for Python (Boto3) Referensi* API.
------
#### [ Swift ]
**SDK para Swift**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/bedrock-runtime#code-examples).
Buat gambar dengan 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)")
}
```
+ Untuk detail API, lihat referensi [InvokeModel AWS](https://sdk.amazonaws.com/swift/api/awsbedrockruntime/latest/documentation/awsbedrockruntime/bedrockruntimeclient/invokemodel(input:))*SDK untuk Swift API*.
------
# Amazon Nova Reel untuk Runtime Amazon Bedrock
Contoh kode berikut menunjukkan cara menggunakan Amazon Bedrock Runtime dengan. AWS SDKs
**Topics**
+ [T ext-to-video](bedrock-runtime_example_bedrock-runtime_Scenario_AmazonNova_TextToVideo_section.md)
# Gunakan Amazon Nova Reel untuk menghasilkan video dari prompt teks
Contoh kode berikut menunjukkan cara menggunakan Amazon Nova Reel untuk menghasilkan video dari prompt teks.
------
#### [ Python ]
**SDK untuk Python (Boto3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Gunakan Amazon Nova Reel untuk menghasilkan video dari prompt teks.
```
"""
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()
```
+ Untuk detail API, lihat topik berikut di *Referensi API AWS SDK untuk Python (Boto3)*.
+ [GetAsyncInvoke](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/GetAsyncInvoke)
+ [StartAsyncInvoke](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/StartAsyncInvoke)
------
#### [ Swift ]
**SDK para Swift**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/bedrock-runtime#code-examples).
Gunakan Amazon Nova Reel untuk menghasilkan video dari prompt teks.
```
// 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)")
}
```
+ Untuk detail API, lihat topik berikut di *Referensi API AWS SDK untuk 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:))
------
# Generator Gambar Amazon Titan untuk Runtime Amazon Bedrock
Contoh kode berikut menunjukkan cara menggunakan Amazon Bedrock Runtime dengan. AWS SDKs
**Topics**
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_TitanImageGenerator_section.md)
# Panggil Amazon Titan Image di Amazon Bedrock untuk menghasilkan gambar
Contoh kode berikut menunjukkan cara memanggil Amazon Titan Image di Amazon Bedrock untuk menghasilkan gambar.
------
#### [ Go ]
**SDK untuk Go V2**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/bedrock-runtime#code-examples).
Buat gambar dengan 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
}
```
+ Untuk detail API, lihat [InvokeModel](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/bedrockruntime#Client.InvokeModel)di *Referensi AWS SDK untuk Go API*.
------
#### [ Java ]
**SDK untuk Java 2.x**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Buat gambar dengan 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);
}
}
```
+ Untuk detail API, lihat [InvokeModel](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModel)di *Referensi AWS SDK for Java 2.x API*.
------
#### [ PHP ]
**SDK untuk PHP**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/bedrock-runtime#code-examples).
Buat gambar dengan 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;
}
```
+ Untuk detail API, lihat [InvokeModel](https://docs.aws.amazon.com/goto/SdkForPHPV3/bedrock-runtime-2023-09-30/InvokeModel)di *Referensi AWS SDK untuk PHP API*.
------
#### [ Python ]
**SDK untuk Python (Boto3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Buat gambar dengan 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}")
```
+ Untuk detail API, lihat [InvokeModel](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModel)di *AWS SDK for Python (Boto3) Referensi* API.
------
# Teks Amazon Titan untuk Runtime Amazon Bedrock
Contoh kode berikut menunjukkan cara menggunakan Amazon Bedrock Runtime dengan. AWS SDKs
**Topics**
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_TitanText_section.md)
# Memanggil model Amazon Titan Text di Amazon Bedrock menggunakan Invoke Model API
Contoh kode berikut menunjukkan cara mengirim pesan teks ke Amazon Titan Text, menggunakan Invoke Model API.
------
#### [ Python ]
**SDK untuk Python (Boto3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Gunakan API Invoke Model untuk mengirim pesan teks.
```
# 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)
```
+ Untuk detail API, lihat [InvokeModel](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModel)di *AWS SDK for Python (Boto3) Referensi* API.
------
# Penyematan Teks Amazon Titan untuk Runtime Amazon Bedrock
Contoh kode berikut menunjukkan cara menggunakan Amazon Bedrock Runtime dengan. AWS SDKs
**Topics**
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModelWithResponseStream_TitanTextEmbeddings_section.md)
# Panggil Embeddings Teks Amazon Titan di Amazon Bedrock
Contoh-contoh kode berikut menunjukkan cara:
+ Mulailah membuat penyematan pertama Anda.
+ Buat embeddings yang mengonfigurasi jumlah dimensi dan normalisasi (hanya V2).
------
#### [ Java ]
**SDK untuk Java 2.x**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Buat penyematan pertama Anda dengan 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();
}
}
```
Panggil Titan Text Embeddings V2 yang mengonfigurasi jumlah dimensi dan normalisasi.
```
/**
* 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;
}
```
+ Untuk detail API, lihat [InvokeModel](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModel)di *Referensi AWS SDK for Java 2.x API*.
------
#### [ Python ]
**SDK untuk Python (Boto3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Buat penyematan pertama Anda dengan 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)
```
+ Untuk detail API, lihat [InvokeModel](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModel)di *AWS SDK for Python (Boto3) Referensi* API.
------
# Claude Antropik untuk Runtime Amazon Bedrock
Contoh kode berikut menunjukkan cara menggunakan Amazon Bedrock Runtime dengan. AWS SDKs
**Topics**
+ [Bercakap-cakap](bedrock-runtime_example_bedrock-runtime_Converse_AnthropicClaude_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_AnthropicClaude_section.md)
+ [Pemahaman dokumen](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)
+ [Penalaran](bedrock-runtime_example_bedrock-runtime_Converse_AnthropicClaudeReasoning_section.md)
+ [Penalaran dengan respons streaming](bedrock-runtime_example_bedrock-runtime_ConverseStream_AnthropicClaudeReasoning_section.md)
+ [Skenario: Penggunaan alat dengan API Converse](bedrock-runtime_example_bedrock-runtime_Scenario_ToolUseDemo_AnthropicClaude_section.md)
# Panggil Anthropic Claude di Amazon Bedrock menggunakan API Converse Bedrock
Contoh kode berikut menunjukkan cara mengirim pesan teks ke Anthropic Claude, menggunakan API Converse Bedrock.
------
#### [ .NET ]
**SDK untuk .NET (v4)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Bedrock-runtime#code-examples).
Kirim pesan teks ke Anthropic Claude, menggunakan API Converse 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;
}
```
+ Untuk detail API, lihat [Converse](https://docs.aws.amazon.com/goto/DotNetSDKV4/bedrock-runtime-2023-09-30/Converse) di *Referensi AWS SDK untuk .NET API*.
------
#### [ Go ]
**SDK untuk Go V2**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/bedrock-runtime#code-examples).
Kirim pesan teks ke Anthropic Claude, menggunakan API Converse 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
}
```
+ Untuk detail API, lihat [Converse](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/bedrockruntime#Client.Converse) di *Referensi AWS SDK untuk Go API*.
------
#### [ Java ]
**SDK untuk Java 2.x**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Kirim pesan teks ke Anthropic Claude, menggunakan API Converse 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();
}
}
```
Kirim pesan teks ke Anthropic Claude, menggunakan API Converse Bedrock dengan klien Java async.
```
// 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();
}
}
```
+ Untuk detail API, lihat [Converse](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/Converse) di *Referensi AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK untuk JavaScript (v3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Kirim pesan teks ke Anthropic Claude, menggunakan API Converse 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);
}
```
+ Untuk detail API, lihat [Converse](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseCommand) di *Referensi AWS SDK untuk JavaScript API*.
------
#### [ Python ]
**SDK untuk Python (Boto3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Kirim pesan teks ke Anthropic Claude, menggunakan API Converse 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)
```
+ Untuk detail API, lihat [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) in *AWS SDK for Python (Boto3) Referensi* API.
------
#### [ Rust ]
**SDK for Rust**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/bedrock-runtime#code-examples).
Kirim pesan teks ke Anthropic Claude, menggunakan API Converse 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)
}
```
Gunakan pernyataan, utilitas Kesalahan, dan konstanta.
```
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",
})
}
}
```
+ Untuk detail API, lihat [Converse](https://docs.rs/aws-sdk-bedrockruntime/latest/aws_sdk_bedrockruntime/client/struct.Client.html#method.converse) di *AWS SDK untuk referensi Rust API*.
------
#### [ Swift ]
**SDK para Swift**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/bedrock-runtime#code-examples).
Kirim pesan teks ke Anthropic Claude, menggunakan API Converse 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"
}
}
```
+ Untuk detail API, lihat [Converse](https://sdk.amazonaws.com/swift/api/awsbedrockruntime/latest/documentation/awsbedrockruntime/bedrockruntimeclient/converse(input:)) di *AWS SDK untuk referensi Swift* API.
------
# Panggil Anthropic Claude di Amazon Bedrock menggunakan API Converse Bedrock dengan aliran respons
Contoh kode berikut menunjukkan cara mengirim pesan teks ke Anthropic Claude, menggunakan API Converse Bedrock dan memproses aliran respons secara real-time.
------
#### [ .NET ]
**SDK untuk .NET (v4)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Bedrock-runtime#code-examples).
Kirim pesan teks ke Anthropic Claude, menggunakan API Converse Bedrock dan proses aliran respons secara real-time.
```
// Use the Converse API to send a text message to Anthropic Claude
// and print the response stream.
using System;
using System.Collections.Generic;
using System.Linq;
using Amazon;
using Amazon.BedrockRuntime;
using Amazon.BedrockRuntime.Model;
// Create a Bedrock Runtime client in the AWS Region you want to use.
var client = new AmazonBedrockRuntimeClient(RegionEndpoint.USEast1);
// Set the model ID, e.g., Claude 3 Haiku.
var modelId = "anthropic.claude-3-haiku-20240307-v1:0";
// Define the user message.
var userMessage = "Describe the purpose of a 'hello world' program in one line.";
// Create a request with the model ID, the user message, and an inference configuration.
var request = new ConverseStreamRequest
{
ModelId = modelId,
Messages = new List
{
new Message
{
Role = ConversationRole.User,
Content = new List { new ContentBlock { Text = userMessage } }
}
},
InferenceConfig = new InferenceConfiguration()
{
MaxTokens = 512,
Temperature = 0.5F,
TopP = 0.9F
}
};
try
{
// Send the request to the Bedrock Runtime and wait for the result.
var response = await client.ConverseStreamAsync(request);
// Extract and print the streamed response text in real-time.
foreach (var chunk in response.Stream.AsEnumerable())
{
if (chunk is ContentBlockDeltaEvent)
{
Console.Write((chunk as ContentBlockDeltaEvent).Delta.Text);
}
}
}
catch (AmazonBedrockRuntimeException e)
{
Console.WriteLine($"ERROR: Can't invoke '{modelId}'. Reason: {e.Message}");
throw;
}
```
+ Untuk detail API, lihat [ConverseStream](https://docs.aws.amazon.com/goto/DotNetSDKV4/bedrock-runtime-2023-09-30/ConverseStream)di *Referensi AWS SDK untuk .NET API*.
------
#### [ Java ]
**SDK untuk Java 2.x**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Kirim pesan teks ke Anthropic Claude, menggunakan API Converse Bedrock dan proses aliran respons secara real-time.
```
// Use the Converse API to send a text message to Anthropic Claude
// and print the response stream.
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.bedrockruntime.BedrockRuntimeAsyncClient;
import software.amazon.awssdk.services.bedrockruntime.model.ContentBlock;
import software.amazon.awssdk.services.bedrockruntime.model.ConversationRole;
import software.amazon.awssdk.services.bedrockruntime.model.ConverseStreamResponseHandler;
import software.amazon.awssdk.services.bedrockruntime.model.Message;
import java.util.concurrent.ExecutionException;
public class ConverseStream {
public static void main(String[] args) {
// Create a Bedrock Runtime client in the AWS Region you want to use.
// Replace the DefaultCredentialsProvider with your preferred credentials provider.
var client = BedrockRuntimeAsyncClient.builder()
.credentialsProvider(DefaultCredentialsProvider.create())
.region(Region.US_EAST_1)
.build();
// Set the model ID, e.g., Claude 3 Haiku.
var modelId = "anthropic.claude-3-haiku-20240307-v1:0";
// Create the input text and embed it in a message object with the user role.
var inputText = "Describe the purpose of a 'hello world' program in one line.";
var message = Message.builder()
.content(ContentBlock.fromText(inputText))
.role(ConversationRole.USER)
.build();
// Create a handler to extract and print the response text in real-time.
var responseStreamHandler = ConverseStreamResponseHandler.builder()
.subscriber(ConverseStreamResponseHandler.Visitor.builder()
.onContentBlockDelta(chunk -> {
String responseText = chunk.delta().text();
System.out.print(responseText);
}).build()
).onError(err ->
System.err.printf("Can't invoke '%s': %s", modelId, err.getMessage())
).build();
try {
// Send the message with a basic inference configuration and attach the handler.
client.converseStream(request -> request.modelId(modelId)
.messages(message)
.inferenceConfig(config -> config
.maxTokens(512)
.temperature(0.5F)
.topP(0.9F)
), responseStreamHandler).get();
} catch (ExecutionException | InterruptedException e) {
System.err.printf("Can't invoke '%s': %s", modelId, e.getCause().getMessage());
}
}
}
```
+ Untuk detail API, lihat [ConverseStream](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/ConverseStream)di *Referensi AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK untuk JavaScript (v3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Kirim pesan teks ke Anthropic Claude, menggunakan API Converse Bedrock dan proses aliran respons secara real-time.
```
// Use the Conversation API to send a text message to Anthropic Claude.
import {
BedrockRuntimeClient,
ConverseStreamCommand,
} from "@aws-sdk/client-bedrock-runtime";
// Create a Bedrock Runtime client in the AWS Region you want to use.
const client = new BedrockRuntimeClient({ region: "us-east-1" });
// Set the model ID, e.g., Claude 3 Haiku.
const modelId = "anthropic.claude-3-haiku-20240307-v1:0";
// Start a conversation with the user message.
const userMessage =
"Describe the purpose of a 'hello world' program in one line.";
const conversation = [
{
role: "user",
content: [{ text: userMessage }],
},
];
// Create a command with the model ID, the message, and a basic configuration.
const command = new ConverseStreamCommand({
modelId,
messages: conversation,
inferenceConfig: { maxTokens: 512, temperature: 0.5, topP: 0.9 },
});
try {
// Send the command to the model and wait for the response
const response = await client.send(command);
// Extract and print the streamed response text in real-time.
for await (const item of response.stream) {
if (item.contentBlockDelta) {
process.stdout.write(item.contentBlockDelta.delta?.text);
}
}
} catch (err) {
console.log(`ERROR: Can't invoke '${modelId}'. Reason: ${err}`);
process.exit(1);
}
```
+ Untuk detail API, lihat [ConverseStream](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseStreamCommand)di *Referensi AWS SDK untuk JavaScript API*.
------
#### [ Python ]
**SDK untuk Python (Boto3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Kirim pesan teks ke Anthropic Claude, menggunakan API Converse Bedrock dan proses aliran respons secara real-time.
```
# Use the Conversation API to send a text message to Anthropic Claude
# and print the response stream.
import boto3
from botocore.exceptions import ClientError
# Create a Bedrock Runtime client in the AWS Region you want to use.
client = boto3.client("bedrock-runtime", region_name="us-east-1")
# Set the model ID, e.g., Claude 3 Haiku.
model_id = "anthropic.claude-3-haiku-20240307-v1:0"
# Start a conversation with the user message.
user_message = "Describe the purpose of a 'hello world' program in one line."
conversation = [
{
"role": "user",
"content": [{"text": user_message}],
}
]
try:
# Send the message to the model, using a basic inference configuration.
streaming_response = client.converse_stream(
modelId=model_id,
messages=conversation,
inferenceConfig={"maxTokens": 512, "temperature": 0.5, "topP": 0.9},
)
# Extract and print the streamed response text in real-time.
for chunk in streaming_response["stream"]:
if "contentBlockDelta" in chunk:
text = chunk["contentBlockDelta"]["delta"]["text"]
print(text, end="")
except (ClientError, Exception) as e:
print(f"ERROR: Can't invoke '{model_id}'. Reason: {e}")
exit(1)
```
+ Untuk detail API, lihat [ConverseStream](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/ConverseStream)di *AWS SDK for Python (Boto3) Referensi* API.
------
#### [ Rust ]
**SDK for Rust**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/bedrock-runtime#code-examples).
Kirim pesan teks ke Anthropic Claude dan streaming token balasan, menggunakan API Bedrock. ConverseStream
```
#[tokio::main]
async fn main() -> Result<(), BedrockConverseStreamError> {
tracing_subscriber::fmt::init();
let sdk_config = aws_config::defaults(BehaviorVersion::latest())
.region(CLAUDE_REGION)
.load()
.await;
let client = Client::new(&sdk_config);
let response = client
.converse_stream()
.model_id(MODEL_ID)
.messages(
Message::builder()
.role(ConversationRole::User)
.content(ContentBlock::Text(USER_MESSAGE.to_string()))
.build()
.map_err(|_| "failed to build message")?,
)
.send()
.await;
let mut stream = match response {
Ok(output) => Ok(output.stream),
Err(e) => Err(BedrockConverseStreamError::from(
e.as_service_error().unwrap(),
)),
}?;
loop {
let token = stream.recv().await;
match token {
Ok(Some(text)) => {
let next = get_converse_output_text(text)?;
print!("{}", next);
Ok(())
}
Ok(None) => break,
Err(e) => Err(e
.as_service_error()
.map(BedrockConverseStreamError::from)
.unwrap_or(BedrockConverseStreamError(
"Unknown error receiving stream".into(),
))),
}?
}
println!();
Ok(())
}
fn get_converse_output_text(
output: ConverseStreamOutputType,
) -> Result {
Ok(match output {
ConverseStreamOutputType::ContentBlockDelta(event) => match event.delta() {
Some(delta) => delta.as_text().cloned().unwrap_or_else(|_| "".into()),
None => "".into(),
},
_ => "".into(),
})
}
```
Gunakan pernyataan, utilitas Kesalahan, dan konstanta.
```
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(),
),
}
}
}
```
+ Untuk detail API, lihat [ConverseStream](https://docs.rs/aws-sdk-bedrockruntime/latest/aws_sdk_bedrockruntime/client/struct.Client.html#method.converse_stream)*referensi AWS SDK for Rust API*.
------
#### [ Swift ]
**SDK para Swift**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/bedrock-runtime#code-examples).
Kirim pesan teks ke Anthropic Claude, menggunakan API Converse Bedrock dan proses aliran respons secara real-time.
```
// An example demonstrating how to use the Conversation API to send a text message
// to Anthropic Claude and print the response stream
import AWSBedrockRuntime
func printConverseStream(_ textPrompt: String) async throws {
// Create a Bedrock Runtime client in the AWS Region you want to use.
let config =
try await BedrockRuntimeClient.BedrockRuntimeClientConfiguration(
region: "us-east-1"
)
let client = BedrockRuntimeClient(config: config)
// Set the model ID.
let modelId = "anthropic.claude-3-haiku-20240307-v1:0"
// Start a conversation with the user message.
let message = BedrockRuntimeClientTypes.Message(
content: [.text(textPrompt)],
role: .user
)
// Optionally use inference parameters.
let inferenceConfig =
BedrockRuntimeClientTypes.InferenceConfiguration(
maxTokens: 512,
stopSequences: ["END"],
temperature: 0.5,
topp: 0.9
)
// Create the ConverseStreamInput to send to the model.
let input = ConverseStreamInput(
inferenceConfig: inferenceConfig, messages: [message], modelId: modelId)
// Send the ConverseStreamInput to the model.
let response = try await client.converseStream(input: input)
// Extract the streaming response.
guard let stream = response.stream else {
print("No stream available")
return
}
// Extract and print the streamed response text in real-time.
for try await event in stream {
switch event {
case .messagestart(_):
print("\nAnthropic Claude:")
case .contentblockdelta(let deltaEvent):
if case .text(let text) = deltaEvent.delta {
print(text, terminator: "")
}
default:
break
}
}
}
```
+ Untuk detail API, lihat referensi [ConverseStream AWS](https://sdk.amazonaws.com/swift/api/awsbedrockruntime/latest/documentation/awsbedrockruntime/bedrockruntimeclient/conversestream(input:))*SDK untuk Swift API*.
------
# Kirim dan proses dokumen dengan Anthropic Claude di Amazon Bedrock
Contoh kode berikut menunjukkan cara mengirim dan memproses dokumen dengan Anthropic Claude di Amazon Bedrock.
------
#### [ Python ]
**SDK untuk Python (Boto3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Kirim dan proses dokumen dengan Anthropic Claude di 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)
```
+ Untuk detail API, lihat [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) in *AWS SDK for Python (Boto3) Referensi* API.
------
# Panggil Anthropic Claude di Amazon Bedrock menggunakan API Model Invoke
Contoh kode berikut menunjukkan cara mengirim pesan teks ke Anthropic Claude, menggunakan Invoke Model API.
------
#### [ .NET ]
**SDK untuk .NET (v4)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Bedrock-runtime#code-examples).
Gunakan API Invoke Model untuk mengirim pesan teks.
```
// 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;
}
```
+ Untuk detail API, lihat [InvokeModel](https://docs.aws.amazon.com/goto/DotNetSDKV4/bedrock-runtime-2023-09-30/InvokeModel)di *Referensi AWS SDK untuk .NET API*.
------
#### [ Go ]
**SDK untuk Go V2**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/bedrock-runtime#code-examples).
Gunakan model dasar Anthropic Claude 2 untuk menghasilkan teks.
```
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
}
```
+ Untuk detail API, lihat [InvokeModel](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/bedrockruntime#Client.InvokeModel)di *Referensi AWS SDK untuk Go API*.
------
#### [ Java ]
**SDK untuk Java 2.x**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Gunakan API Invoke Model untuk mengirim pesan teks.
```
// 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();
}
}
```
+ Untuk detail API, lihat [InvokeModel](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModel)di *Referensi AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK untuk JavaScript (v3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Gunakan API Invoke Model untuk mengirim pesan teks.
```
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}`);
}
}
```
+ Untuk detail API, lihat [InvokeModel](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/InvokeModelCommand)di *Referensi AWS SDK untuk JavaScript API*.
------
#### [ PHP ]
**SDK untuk PHP**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/bedrock-runtime#code-examples).
Gunakan model dasar Anthropic Claude 2 untuk menghasilkan teks.
```
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;
}
```
+ Untuk detail API, lihat [InvokeModel](https://docs.aws.amazon.com/goto/SdkForPHPV3/bedrock-runtime-2023-09-30/InvokeModel)di *Referensi AWS SDK untuk PHP API*.
------
#### [ Python ]
**SDK untuk Python (Boto3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Gunakan API Invoke Model untuk mengirim pesan teks.
```
# 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)
```
+ Untuk detail API, lihat [InvokeModel](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModel)di *AWS SDK for Python (Boto3) Referensi* API.
------
#### [ SAP ABAP ]
**SDK for SAP ABAP**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/bdr#code-examples).
Gunakan model dasar Anthropic Claude 2 untuk menghasilkan teks. Contoh ini menggunakan fitur US2 //CL\$1JSON yang mungkin tidak tersedia pada beberapa versi. 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.
```
Panggil model dasar Anthropic Claude 2 untuk menghasilkan teks menggunakan klien tingkat tinggi L2.
```
TRY.
DATA(lo_bdr_l2_claude) = /aws1/cl_bdr_l2_factory=>create_claude_2( lo_bdr ).
" iv_prompt can contain a prompt like 'tell me a joke about Java programmers'.
DATA(lv_answer) = lo_bdr_l2_claude->prompt_for_text( iv_prompt ).
CATCH /aws1/cx_bdraccessdeniedex INTO DATA(lo_ex).
WRITE / lo_ex->get_text( ).
WRITE / |Don't forget to enable model access at https://console.aws.amazon.com/bedrock/home?#/modelaccess|.
ENDTRY.
```
Panggil model dasar Anthropic Claude 3 untuk menghasilkan teks menggunakan klien tingkat tinggi L2.
```
TRY.
" Choose a model ID from Anthropic that supports the Messages API - currently this is
" Claude v2, Claude v3 and v3.5. For the list of model ID, see:
" https://docs.aws.amazon.com/bedrock/latest/userguide/model-ids.html
" for the list of models that support the Messages API see:
" https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-anthropic-claude-messages.html
DATA(lo_bdr_l2_claude) = /aws1/cl_bdr_l2_factory=>create_anthropic_msg_api(
io_bdr = lo_bdr
iv_model_id = 'anthropic.claude-3-sonnet-20240229-v1:0' ). " choosing Claude v3 Sonnet
" iv_prompt can contain a prompt like 'tell me a joke about Java programmers'.
DATA(lv_answer) = lo_bdr_l2_claude->prompt_for_text( iv_prompt = iv_prompt
iv_max_tokens = 100 ).
CATCH /aws1/cx_bdraccessdeniedex INTO DATA(lo_ex).
WRITE / lo_ex->get_text( ).
WRITE / |Don't forget to enable model access at https://console.aws.amazon.com/bedrock/home?#/modelaccess|.
ENDTRY.
```
+ Untuk detail API, lihat [InvokeModel](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)di *AWS SDK untuk referensi SAP ABAP* API.
------
# Memanggil model Anthropic Claude di Amazon Bedrock menggunakan Invoke Model API dengan aliran respons
Contoh kode berikut menunjukkan cara mengirim pesan teks ke model Anthropic Claude, menggunakan Invoke Model API, dan mencetak aliran respons.
------
#### [ .NET ]
**SDK untuk .NET**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime#code-examples).
Gunakan API Invoke Model untuk mengirim pesan teks dan memproses aliran respons secara real-time.
```
// Use the native inference API to send a text message to Anthropic Claude
// and print the response stream.
using System;
using System.IO;
using System.Text.Json;
using System.Text.Json.Nodes;
using Amazon;
using Amazon.BedrockRuntime;
using Amazon.BedrockRuntime.Model;
// Create a Bedrock Runtime client in the AWS Region you want to use.
var client = new AmazonBedrockRuntimeClient(RegionEndpoint.USEast1);
// Set the model ID, e.g., Claude 3 Haiku.
var modelId = "anthropic.claude-3-haiku-20240307-v1:0";
// Define the user message.
var userMessage = "Describe the purpose of a 'hello world' program in one line.";
//Format the request payload using the model's native structure.
var nativeRequest = JsonSerializer.Serialize(new
{
anthropic_version = "bedrock-2023-05-31",
max_tokens = 512,
temperature = 0.5,
messages = new[]
{
new { role = "user", content = userMessage }
}
});
// Create a request with the model ID, the user message, and an inference configuration.
var request = new InvokeModelWithResponseStreamRequest()
{
ModelId = modelId,
Body = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(nativeRequest)),
ContentType = "application/json"
};
try
{
// Send the request to the Bedrock Runtime and wait for the response.
var streamingResponse = await client.InvokeModelWithResponseStreamAsync(request);
// Extract and print the streamed response text in real-time.
foreach (var item in streamingResponse.Body)
{
var chunk = JsonSerializer.Deserialize((item as PayloadPart).Bytes);
var text = chunk["delta"]?["text"] ?? "";
Console.Write(text);
}
}
catch (AmazonBedrockRuntimeException e)
{
Console.WriteLine($"ERROR: Can't invoke '{modelId}'. Reason: {e.Message}");
throw;
}
```
+ Untuk detail API, lihat [InvokeModelWithResponseStream](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/InvokeModelWithResponseStream)di *Referensi AWS SDK untuk .NET API*.
------
#### [ Go ]
**SDK untuk Go V2**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/bedrock-runtime#code-examples).
Gunakan API Invoke Model untuk mengirim pesan teks dan memproses aliran respons secara real-time.
```
import (
"bytes"
"context"
"encoding/json"
"fmt"
"log"
"strings"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/bedrockruntime"
"github.com/aws/aws-sdk-go-v2/service/bedrockruntime/types"
)
// InvokeModelWithResponseStreamWrapper encapsulates Amazon Bedrock actions used in the examples.
// It contains a Bedrock Runtime client that is used to invoke foundation models.
type InvokeModelWithResponseStreamWrapper struct {
BedrockRuntimeClient *bedrockruntime.Client
}
// Each model provider defines their own individual request and response formats.
// For the format, ranges, and default values for the different models, refer to:
// https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters.html
type Request struct {
Prompt string `json:"prompt"`
MaxTokensToSample int `json:"max_tokens_to_sample"`
Temperature float64 `json:"temperature,omitempty"`
}
type Response struct {
Completion string `json:"completion"`
}
// Invokes Anthropic Claude on Amazon Bedrock to run an inference and asynchronously
// process the response stream.
func (wrapper InvokeModelWithResponseStreamWrapper) InvokeModelWithResponseStream(ctx context.Context, prompt string) (string, error) {
modelId := "anthropic.claude-v2"
// Anthropic Claude requires you to enclose the prompt as follows:
prefix := "Human: "
postfix := "\n\nAssistant:"
prompt = prefix + prompt + postfix
request := ClaudeRequest{
Prompt: prompt,
MaxTokensToSample: 200,
Temperature: 0.5,
StopSequences: []string{"\n\nHuman:"},
}
body, err := json.Marshal(request)
if err != nil {
log.Panicln("Couldn't marshal the request: ", err)
}
output, err := wrapper.BedrockRuntimeClient.InvokeModelWithResponseStream(ctx, &bedrockruntime.InvokeModelWithResponseStreamInput{
Body: body,
ModelId: aws.String(modelId),
ContentType: aws.String("application/json"),
})
if err != nil {
errMsg := err.Error()
if strings.Contains(errMsg, "no such host") {
log.Printf("The Bedrock service is not available in the selected region. Please double-check the service availability for your region at https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/.\n")
} else if strings.Contains(errMsg, "Could not resolve the foundation model") {
log.Printf("Could not resolve the foundation model from model identifier: \"%v\". Please verify that the requested model exists and is accessible within the specified region.\n", modelId)
} else {
log.Printf("Couldn't invoke Anthropic Claude. Here's why: %v\n", err)
}
}
resp, err := processStreamingOutput(ctx, output, func(ctx context.Context, part []byte) error {
fmt.Print(string(part))
return nil
})
if err != nil {
log.Fatal("streaming output processing error: ", err)
}
return resp.Completion, nil
}
type StreamingOutputHandler func(ctx context.Context, part []byte) error
func processStreamingOutput(ctx context.Context, output *bedrockruntime.InvokeModelWithResponseStreamOutput, handler StreamingOutputHandler) (Response, error) {
var combinedResult string
resp := Response{}
for event := range output.GetStream().Events() {
switch v := event.(type) {
case *types.ResponseStreamMemberChunk:
//fmt.Println("payload", string(v.Value.Bytes))
var resp Response
err := json.NewDecoder(bytes.NewReader(v.Value.Bytes)).Decode(&resp)
if err != nil {
return resp, err
}
err = handler(ctx, []byte(resp.Completion))
if err != nil {
return resp, err
}
combinedResult += resp.Completion
case *types.UnknownUnionMember:
fmt.Println("unknown tag:", v.Tag)
default:
fmt.Println("union is nil or unknown type")
}
}
resp.Completion = combinedResult
return resp, nil
}
```
+ Untuk detail API, lihat [InvokeModelWithResponseStream](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/bedrockruntime#Client.InvokeModelWithResponseStream)di *Referensi AWS SDK untuk Go API*.
------
#### [ Java ]
**SDK untuk Java 2.x**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Gunakan API Invoke Model untuk mengirim pesan teks dan memproses aliran respons secara real-time.
```
// Use the native inference API to send a text message to Anthropic Claude
// and print the response stream.
import org.json.JSONObject;
import org.json.JSONPointer;
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.core.SdkBytes;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.bedrockruntime.BedrockRuntimeAsyncClient;
import software.amazon.awssdk.services.bedrockruntime.model.InvokeModelWithResponseStreamRequest;
import software.amazon.awssdk.services.bedrockruntime.model.InvokeModelWithResponseStreamResponseHandler;
import java.util.Objects;
import java.util.concurrent.ExecutionException;
import static software.amazon.awssdk.services.bedrockruntime.model.InvokeModelWithResponseStreamResponseHandler.Visitor;
public class InvokeModelWithResponseStream {
public static String invokeModelWithResponseStream() {
// Create a Bedrock Runtime client in the AWS Region you want to use.
// Replace the DefaultCredentialsProvider with your preferred credentials provider.
var client = BedrockRuntimeAsyncClient.builder()
.credentialsProvider(DefaultCredentialsProvider.create())
.region(Region.US_EAST_1)
.build();
// Set the model ID, e.g., Claude 3 Haiku.
var modelId = "anthropic.claude-3-haiku-20240307-v1:0";
// The InvokeModelWithResponseStream API uses the model's native payload.
// Learn more about the available inference parameters and response fields at:
// https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-anthropic-claude-messages.html
var nativeRequestTemplate = """
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 512,
"temperature": 0.5,
"messages": [{
"role": "user",
"content": "{{prompt}}"
}]
}""";
// Define the prompt for the model.
var prompt = "Describe the purpose of a 'hello world' program in one line.";
// Embed the prompt in the model's native request payload.
String nativeRequest = nativeRequestTemplate.replace("{{prompt}}", prompt);
// Create a request with the model ID and the model's native request payload.
var request = InvokeModelWithResponseStreamRequest.builder()
.body(SdkBytes.fromUtf8String(nativeRequest))
.modelId(modelId)
.build();
// Prepare a buffer to accumulate the generated response text.
var completeResponseTextBuffer = new StringBuilder();
// Prepare a handler to extract, accumulate, and print the response text in real-time.
var responseStreamHandler = InvokeModelWithResponseStreamResponseHandler.builder()
.subscriber(Visitor.builder().onChunk(chunk -> {
var response = new JSONObject(chunk.bytes().asUtf8String());
// Extract and print the text from the content blocks.
if (Objects.equals(response.getString("type"), "content_block_delta")) {
var text = new JSONPointer("/delta/text").queryFrom(response);
System.out.print(text);
// Append the text to the response text buffer.
completeResponseTextBuffer.append(text);
}
}).build()).build();
try {
// Send the request and wait for the handler to process the response.
client.invokeModelWithResponseStream(request, responseStreamHandler).get();
// Return the complete response text.
return completeResponseTextBuffer.toString();
} catch (ExecutionException | InterruptedException e) {
System.err.printf("Can't invoke '%s': %s", modelId, e.getCause().getMessage());
throw new RuntimeException(e);
}
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
invokeModelWithResponseStream();
}
}
```
+ Untuk detail API, lihat [InvokeModelWithResponseStream](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModelWithResponseStream)di *Referensi AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK untuk JavaScript (v3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Gunakan API Invoke Model untuk mengirim pesan teks dan memproses aliran respons secara real-time.
```
import { fileURLToPath } from "node:url";
import { FoundationModels } from "../../config/foundation_models.js";
import {
BedrockRuntimeClient,
InvokeModelCommand,
InvokeModelWithResponseStreamCommand,
} from "@aws-sdk/client-bedrock-runtime";
/**
* @typedef {Object} ResponseContent
* @property {string} text
*
* @typedef {Object} MessagesResponseBody
* @property {ResponseContent[]} content
*
* @typedef {Object} Delta
* @property {string} text
*
* @typedef {Object} Message
* @property {string} role
*
* @typedef {Object} Chunk
* @property {string} type
* @property {Delta} delta
* @property {Message} message
*/
/**
* Invokes Anthropic Claude 3 using the Messages API.
*
* To learn more about the Anthropic Messages API, go to:
* https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-anthropic-claude-messages.html
*
* @param {string} prompt - The input text prompt for the model to complete.
* @param {string} [modelId] - The ID of the model to use. Defaults to "anthropic.claude-3-haiku-20240307-v1:0".
*/
export const invokeModel = async (
prompt,
modelId = "anthropic.claude-3-haiku-20240307-v1:0",
) => {
// Create a new Bedrock Runtime client instance.
const client = new BedrockRuntimeClient({ region: "us-east-1" });
// Prepare the payload for the model.
const payload = {
anthropic_version: "bedrock-2023-05-31",
max_tokens: 1000,
messages: [
{
role: "user",
content: [{ type: "text", text: prompt }],
},
],
};
// Invoke Claude with the payload and wait for the response.
const command = new InvokeModelCommand({
contentType: "application/json",
body: JSON.stringify(payload),
modelId,
});
const apiResponse = await client.send(command);
// Decode and return the response(s)
const decodedResponseBody = new TextDecoder().decode(apiResponse.body);
/** @type {MessagesResponseBody} */
const responseBody = JSON.parse(decodedResponseBody);
return responseBody.content[0].text;
};
/**
* Invokes Anthropic Claude 3 and processes the response stream.
*
* To learn more about the Anthropic Messages API, go to:
* https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-anthropic-claude-messages.html
*
* @param {string} prompt - The input text prompt for the model to complete.
* @param {string} [modelId] - The ID of the model to use. Defaults to "anthropic.claude-3-haiku-20240307-v1:0".
*/
export const invokeModelWithResponseStream = async (
prompt,
modelId = "anthropic.claude-3-haiku-20240307-v1:0",
) => {
// Create a new Bedrock Runtime client instance.
const client = new BedrockRuntimeClient({ region: "us-east-1" });
// Prepare the payload for the model.
const payload = {
anthropic_version: "bedrock-2023-05-31",
max_tokens: 1000,
messages: [
{
role: "user",
content: [{ type: "text", text: prompt }],
},
],
};
// Invoke Claude with the payload and wait for the API to respond.
const command = new InvokeModelWithResponseStreamCommand({
contentType: "application/json",
body: JSON.stringify(payload),
modelId,
});
const apiResponse = await client.send(command);
let completeMessage = "";
// Decode and process the response stream
for await (const item of apiResponse.body) {
/** @type Chunk */
const chunk = JSON.parse(new TextDecoder().decode(item.chunk.bytes));
const chunk_type = chunk.type;
if (chunk_type === "content_block_delta") {
const text = chunk.delta.text;
completeMessage = completeMessage + text;
process.stdout.write(text);
}
}
// Return the final response
return completeMessage;
};
// Invoke the function if this file was run directly.
if (process.argv[1] === fileURLToPath(import.meta.url)) {
const prompt = 'Write a paragraph starting with: "Once upon a time..."';
const modelId = FoundationModels.CLAUDE_3_HAIKU.modelId;
console.log(`Prompt: ${prompt}`);
console.log(`Model ID: ${modelId}`);
try {
console.log("-".repeat(53));
const response = await invokeModel(prompt, modelId);
console.log(`\n${"-".repeat(53)}`);
console.log("Final structured response:");
console.log(response);
} catch (err) {
console.log(`\n${err}`);
}
}
```
+ Untuk detail API, lihat [InvokeModelWithResponseStream](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/InvokeModelWithResponseStreamCommand)di *Referensi AWS SDK untuk JavaScript API*.
------
#### [ Python ]
**SDK untuk Python (Boto3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Gunakan API Invoke Model untuk mengirim pesan teks dan memproses aliran respons secara real-time.
```
# Use the native inference API to send a text message to Anthropic Claude
# and print the response stream.
import boto3
import json
# Create a Bedrock Runtime client in the AWS Region of your choice.
client = boto3.client("bedrock-runtime", region_name="us-east-1")
# Set the model ID, e.g., Claude 3 Haiku.
model_id = "anthropic.claude-3-haiku-20240307-v1:0"
# Define the prompt for the model.
prompt = "Describe the purpose of a 'hello world' program in one line."
# Format the request payload using the model's native structure.
native_request = {
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 512,
"temperature": 0.5,
"messages": [
{
"role": "user",
"content": [{"type": "text", "text": prompt}],
}
],
}
# Convert the native request to JSON.
request = json.dumps(native_request)
# Invoke the model with the request.
streaming_response = client.invoke_model_with_response_stream(
modelId=model_id, body=request
)
# Extract and print the response text in real-time.
for event in streaming_response["body"]:
chunk = json.loads(event["chunk"]["bytes"])
if chunk["type"] == "content_block_delta":
print(chunk["delta"].get("text", ""), end="")
```
+ Untuk detail API, lihat [InvokeModelWithResponseStream](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModelWithResponseStream)di *AWS SDK for Python (Boto3) Referensi* API.
------
# Gunakan kemampuan penalaran Anthropic Claude 3.7 Sonnet di Amazon Bedrock
Contoh kode berikut menunjukkan cara menggunakan kemampuan penalaran Anthropic Claude 3.7 Sonnet di Amazon Bedrock
------
#### [ Java ]
**SDK untuk Java 2.x**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Gunakan kemampuan penalaran Anthropic Claude 3.7 Sonnet dengan klien runtime Bedrock asinkron.
```
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());
}
}
```
Gunakan kemampuan penalaran Anthropic Claude 3.7 Sonnet dengan klien runtime Bedrock sinkron.
```
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());
}
}
```
+ Untuk detail API, lihat [Converse](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/Converse) di *Referensi AWS SDK for Java 2.x API*.
------
# Gunakan kemampuan penalaran Anthropic Claude 3.7 Sonnet di Amazon Bedrock
Contoh kode berikut menunjukkan cara menggunakan kemampuan penalaran Anthropic Claude 3.7 Sonnet di Amazon Bedrock
------
#### [ Java ]
**SDK untuk Java 2.x**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Gunakan kemampuan penalaran Anthropic Claude 3.7 Sonnet untuk menghasilkan respons teks streaming.
```
import com.example.bedrockruntime.models.anthropicClaude.lib.ReasoningResponse;
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.core.document.Document;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.bedrockruntime.BedrockRuntimeAsyncClient;
import software.amazon.awssdk.services.bedrockruntime.model.*;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.atomic.AtomicReference;
/**
* This example demonstrates how to use Anthropic Claude 3.7 Sonnet's reasoning
* capability to generate streaming text responses.
* It shows how to:
* - Set up the Amazon Bedrock runtime client
* - Create a message
* - Configure a streaming request
* - Set up a stream handler to process the response chunks
* - Process the streaming response
*/
public class ReasoningStream {
public static ReasoningResponse reasoningStream() {
// Create the Amazon Bedrock runtime client
var client = BedrockRuntimeAsyncClient.builder()
.credentialsProvider(DefaultCredentialsProvider.create())
.region(Region.US_EAST_1)
.build();
// Specify the model ID. For the latest available models, see:
// https://docs.aws.amazon.com/bedrock/latest/userguide/models-supported.html
var modelId = "us.anthropic.claude-3-7-sonnet-20250219-v1:0";
// Create the message with the user's prompt
var prompt = "Describe the purpose of a 'hello world' program in one line.";
var message = Message.builder()
.content(ContentBlock.fromText(prompt))
.role(ConversationRole.USER)
.build();
// Configure reasoning parameters with a 2000 token budget
Document reasoningConfig = Document.mapBuilder()
.putDocument("thinking", Document.mapBuilder()
.putString("type", "enabled")
.putNumber("budget_tokens", 2000)
.build())
.build();
// Configure the request with the message, model ID, and reasoning config
ConverseStreamRequest request = ConverseStreamRequest.builder()
.additionalModelRequestFields(reasoningConfig)
.messages(message)
.modelId(modelId)
.build();
StringBuilder reasoning = new StringBuilder();
StringBuilder text = new StringBuilder();
AtomicReference finalresponse = new AtomicReference<>();
// Set up the stream handler to processes chunks of the response as they arrive
var streamHandler = ConverseStreamResponseHandler.builder()
.subscriber(ConverseStreamResponseHandler.Visitor.builder()
.onContentBlockDelta(chunk -> {
ContentBlockDelta delta = chunk.delta();
if (delta.reasoningContent() != null) {
if (reasoning.isEmpty()) {
System.out.println("\n");
}
if (delta.reasoningContent().text() != null) {
System.out.print(delta.reasoningContent().text());
reasoning.append(delta.reasoningContent().text());
}
} else if (delta.text() != null) {
if (text.isEmpty()) {
System.out.println("\n\n");
}
System.out.print(delta.text());
text.append(delta.text());
}
System.out.flush(); // Ensure immediate output of each chunk
}).build())
.onComplete(() -> finalresponse.set(new ReasoningResponse(
ReasoningContentBlock.fromReasoningText(t -> t.text(reasoning.toString())),
text.toString()
)))
.onError(err -> System.err.printf("Can't invoke '%s': %s", modelId, err.getMessage()))
.build();
// Step 6: Send the streaming request and process the response
// - Send the request to the model
// - Attach the handler to process response chunks as they arrive
// - Handle any errors during streaming
try {
client.converseStream(request, streamHandler).get();
return finalresponse.get();
} catch (ExecutionException | InterruptedException e) {
System.err.printf("Can't invoke '%s': %s", modelId, e.getCause().getMessage());
throw new RuntimeException(e);
} catch (Exception e) {
System.err.printf("Can't invoke '%s': %s", modelId, e.getMessage());
throw new RuntimeException(e);
}
}
public static void main(String[] args) {
reasoningStream();
}
}
```
+ Untuk detail API, lihat [Converse](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/Converse) di *Referensi AWS SDK for Java 2.x API*.
------
# Alat menggunakan demo yang menggambarkan cara menghubungkan model AI di Amazon Bedrock dengan alat atau API khusus
Contoh kode berikut menunjukkan bagaimana membangun interaksi khas antara aplikasi, model AI generatif, dan alat yang terhubung atau APIs untuk memediasi interaksi antara AI dan dunia luar. Ini menggunakan contoh menghubungkan API cuaca eksternal ke model AI sehingga dapat memberikan informasi cuaca real-time berdasarkan input pengguna.
------
#### [ Python ]
**SDK untuk Python (Boto3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Skrip eksekusi utama dari demo. Skrip ini mengatur percakapan antara pengguna, Amazon Bedrock Converse API, dan alat cuaca.
```
"""
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()
```
Alat cuaca yang digunakan oleh demo. Skrip ini mendefinisikan spesifikasi alat dan mengimplementasikan logika untuk mengambil data cuaca menggunakan dari 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)}
```
+ Untuk detail API, lihat [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) in *AWS SDK for Python (Boto3) Referensi* API.
------
#### [ Rust ]
**SDK for Rust**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/bedrock-runtime#code-examples).
Skenario utama dan logika untuk demo. Ini mengatur percakapan antara pengguna, Amazon Bedrock Converse API, dan alat cuaca.
```
#[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();
}
```
Alat cuaca yang digunakan oleh demo. Skrip ini mendefinisikan spesifikasi alat dan mengimplementasikan logika untuk mengambil data cuaca menggunakan dari 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()?)
}
```
Utilitas untuk mencetak Blok Konten Pesan.
```
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:?})"
)))
}
}
```
Gunakan pernyataan, utilitas Kesalahan, dan konstanta.
```
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(),
})
}
}
```
+ Untuk detail API, lihat [Converse](https://docs.rs/aws-sdk-bedrockruntime/latest/aws_sdk_bedrockruntime/client/struct.Client.html#method.converse) di *AWS SDK untuk referensi Rust API*.
------
# Perintah Cohere untuk Runtime Amazon Bedrock
Contoh kode berikut menunjukkan cara menggunakan Amazon Bedrock Runtime dengan. AWS SDKs
**Topics**
+ [Bercakap-cakap](bedrock-runtime_example_bedrock-runtime_Converse_CohereCommand_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_CohereCommand_section.md)
+ [Pemahaman dokumen](bedrock-runtime_example_bedrock-runtime_DocumentUnderstanding_CohereCommand_section.md)
+ [InvokeModel: Perintah R dan R \$1](bedrock-runtime_example_bedrock-runtime_InvokeModel_CohereCommandR_section.md)
+ [InvokeModelWithResponseStream: Perintah R dan R \$1](bedrock-runtime_example_bedrock-runtime_InvokeModelWithResponseStream_CohereCommandR_section.md)
+ [Skenario: Penggunaan alat dengan API Converse](bedrock-runtime_example_bedrock-runtime_Scenario_ToolUseDemo_CohereCommand_section.md)
# Memanggil Perintah Cohere di Amazon Bedrock menggunakan API Converse Bedrock
Contoh kode berikut menunjukkan cara mengirim pesan teks ke Cohere Command, menggunakan API Converse Bedrock.
------
#### [ .NET ]
**SDK untuk .NET (v4)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Bedrock-runtime#code-examples).
Kirim pesan teks ke Cohere Command, menggunakan API Converse Bedrock.
```
// Use the Converse API to send a text message to Cohere Command.
using System;
using System.Collections.Generic;
using Amazon;
using Amazon.BedrockRuntime;
using Amazon.BedrockRuntime.Model;
// Create a Bedrock Runtime client in the AWS Region you want to use.
var client = new AmazonBedrockRuntimeClient(RegionEndpoint.USEast1);
// Set the model ID, e.g., Command R.
var modelId = "cohere.command-r-v1:0";
// Define the user message.
var userMessage = "Describe the purpose of a 'hello world' program in one line.";
// Create a request with the model ID, the user message, and an inference configuration.
var request = new ConverseRequest
{
ModelId = modelId,
Messages = new List
{
new Message
{
Role = ConversationRole.User,
Content = new List { new ContentBlock { Text = userMessage } }
}
},
InferenceConfig = new InferenceConfiguration()
{
MaxTokens = 512,
Temperature = 0.5F,
TopP = 0.9F
}
};
try
{
// Send the request to the Bedrock Runtime and wait for the result.
var response = await client.ConverseAsync(request);
// Extract and print the response text.
string responseText = response?.Output?.Message?.Content?[0]?.Text ?? "";
Console.WriteLine(responseText);
}
catch (AmazonBedrockRuntimeException e)
{
Console.WriteLine($"ERROR: Can't invoke '{modelId}'. Reason: {e.Message}");
throw;
}
```
+ Untuk detail API, lihat [Converse](https://docs.aws.amazon.com/goto/DotNetSDKV4/bedrock-runtime-2023-09-30/Converse) di *Referensi AWS SDK untuk .NET API*.
------
#### [ Java ]
**SDK untuk Java 2.x**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Kirim pesan teks ke Cohere Command, menggunakan API Converse Bedrock.
```
// Use the Converse API to send a text message to Cohere Command.
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.core.exception.SdkClientException;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.bedrockruntime.BedrockRuntimeClient;
import software.amazon.awssdk.services.bedrockruntime.model.ContentBlock;
import software.amazon.awssdk.services.bedrockruntime.model.ConversationRole;
import software.amazon.awssdk.services.bedrockruntime.model.ConverseResponse;
import software.amazon.awssdk.services.bedrockruntime.model.Message;
public class Converse {
public static String converse() {
// Create a Bedrock Runtime client in the AWS Region you want to use.
// Replace the DefaultCredentialsProvider with your preferred credentials provider.
var client = BedrockRuntimeClient.builder()
.credentialsProvider(DefaultCredentialsProvider.create())
.region(Region.US_EAST_1)
.build();
// Set the model ID, e.g., Command R.
var modelId = "cohere.command-r-v1:0";
// Create the input text and embed it in a message object with the user role.
var inputText = "Describe the purpose of a 'hello world' program in one line.";
var message = Message.builder()
.content(ContentBlock.fromText(inputText))
.role(ConversationRole.USER)
.build();
try {
// Send the message with a basic inference configuration.
ConverseResponse response = client.converse(request -> request
.modelId(modelId)
.messages(message)
.inferenceConfig(config -> config
.maxTokens(512)
.temperature(0.5F)
.topP(0.9F)));
// Retrieve the generated text from Bedrock's response object.
var responseText = response.output().message().content().get(0).text();
System.out.println(responseText);
return responseText;
} catch (SdkClientException e) {
System.err.printf("ERROR: Can't invoke '%s'. Reason: %s", modelId, e.getMessage());
throw new RuntimeException(e);
}
}
public static void main(String[] args) {
converse();
}
}
```
Kirim pesan teks ke Cohere Command, menggunakan API Converse Bedrock dengan klien Java async.
```
// 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();
}
}
```
+ Untuk detail API, lihat [Converse](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/Converse) di *Referensi AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK untuk JavaScript (v3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Kirim pesan teks ke Cohere Command, menggunakan API Converse Bedrock.
```
// Use the Conversation API to send a text message to Cohere Command.
import {
BedrockRuntimeClient,
ConverseCommand,
} from "@aws-sdk/client-bedrock-runtime";
// Create a Bedrock Runtime client in the AWS Region you want to use.
const client = new BedrockRuntimeClient({ region: "us-east-1" });
// Set the model ID, e.g., Command R.
const modelId = "cohere.command-r-v1:0";
// Start a conversation with the user message.
const userMessage =
"Describe the purpose of a 'hello world' program in one line.";
const conversation = [
{
role: "user",
content: [{ text: userMessage }],
},
];
// Create a command with the model ID, the message, and a basic configuration.
const command = new ConverseCommand({
modelId,
messages: conversation,
inferenceConfig: { maxTokens: 512, temperature: 0.5, topP: 0.9 },
});
try {
// Send the command to the model and wait for the response
const response = await client.send(command);
// Extract and print the response text.
const responseText = response.output.message.content[0].text;
console.log(responseText);
} catch (err) {
console.log(`ERROR: Can't invoke '${modelId}'. Reason: ${err}`);
process.exit(1);
}
```
+ Untuk detail API, lihat [Converse](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseCommand) di *Referensi AWS SDK untuk JavaScript API*.
------
#### [ Python ]
**SDK untuk Python (Boto3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Kirim pesan teks ke Cohere Command, menggunakan API Converse Bedrock.
```
# Use the Conversation API to send a text message to Cohere Command.
import boto3
from botocore.exceptions import ClientError
# Create a Bedrock Runtime client in the AWS Region you want to use.
client = boto3.client("bedrock-runtime", region_name="us-east-1")
# Set the model ID, e.g., Command R.
model_id = "cohere.command-r-v1:0"
# Start a conversation with the user message.
user_message = "Describe the purpose of a 'hello world' program in one line."
conversation = [
{
"role": "user",
"content": [{"text": user_message}],
}
]
try:
# Send the message to the model, using a basic inference configuration.
response = client.converse(
modelId=model_id,
messages=conversation,
inferenceConfig={"maxTokens": 512, "temperature": 0.5, "topP": 0.9},
)
# Extract and print the response text.
response_text = response["output"]["message"]["content"][0]["text"]
print(response_text)
except (ClientError, Exception) as e:
print(f"ERROR: Can't invoke '{model_id}'. Reason: {e}")
exit(1)
```
+ Untuk detail API, lihat [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) in *AWS SDK for Python (Boto3) Referensi* API.
------
# Panggil Perintah Cohere di Amazon Bedrock menggunakan API Converse Bedrock dengan aliran respons
Contoh kode berikut menunjukkan cara mengirim pesan teks ke Cohere Command, menggunakan API Converse Bedrock dan memproses aliran respons secara real-time.
------
#### [ .NET ]
**SDK untuk .NET (v4)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Bedrock-runtime#code-examples).
Kirim pesan teks ke Cohere Command, menggunakan API Converse Bedrock dan proses aliran respons secara real-time.
```
// Use the Converse API to send a text message to Cohere Command
// and print the response stream.
using System;
using System.Collections.Generic;
using System.Linq;
using Amazon;
using Amazon.BedrockRuntime;
using Amazon.BedrockRuntime.Model;
// Create a Bedrock Runtime client in the AWS Region you want to use.
var client = new AmazonBedrockRuntimeClient(RegionEndpoint.USEast1);
// Set the model ID, e.g., Command R.
var modelId = "cohere.command-r-v1:0";
// Define the user message.
var userMessage = "Describe the purpose of a 'hello world' program in one line.";
// Create a request with the model ID, the user message, and an inference configuration.
var request = new ConverseStreamRequest
{
ModelId = modelId,
Messages = new List
{
new Message
{
Role = ConversationRole.User,
Content = new List { new ContentBlock { Text = userMessage } }
}
},
InferenceConfig = new InferenceConfiguration()
{
MaxTokens = 512,
Temperature = 0.5F,
TopP = 0.9F
}
};
try
{
// Send the request to the Bedrock Runtime and wait for the result.
var response = await client.ConverseStreamAsync(request);
// Extract and print the streamed response text in real-time.
foreach (var chunk in response.Stream.AsEnumerable())
{
if (chunk is ContentBlockDeltaEvent)
{
Console.Write((chunk as ContentBlockDeltaEvent).Delta.Text);
}
}
}
catch (AmazonBedrockRuntimeException e)
{
Console.WriteLine($"ERROR: Can't invoke '{modelId}'. Reason: {e.Message}");
throw;
}
```
+ Untuk detail API, lihat [ConverseStream](https://docs.aws.amazon.com/goto/DotNetSDKV4/bedrock-runtime-2023-09-30/ConverseStream)di *Referensi AWS SDK untuk .NET API*.
------
#### [ Java ]
**SDK untuk Java 2.x**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Kirim pesan teks ke Cohere Command, menggunakan API Converse Bedrock dan proses aliran respons secara real-time.
```
// Use the Converse API to send a text message to Cohere Command
// and print the response stream.
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.bedrockruntime.BedrockRuntimeAsyncClient;
import software.amazon.awssdk.services.bedrockruntime.model.ContentBlock;
import software.amazon.awssdk.services.bedrockruntime.model.ConversationRole;
import software.amazon.awssdk.services.bedrockruntime.model.ConverseStreamResponseHandler;
import software.amazon.awssdk.services.bedrockruntime.model.Message;
import java.util.concurrent.ExecutionException;
public class ConverseStream {
public static void main(String[] args) {
// Create a Bedrock Runtime client in the AWS Region you want to use.
// Replace the DefaultCredentialsProvider with your preferred credentials provider.
var client = BedrockRuntimeAsyncClient.builder()
.credentialsProvider(DefaultCredentialsProvider.create())
.region(Region.US_EAST_1)
.build();
// Set the model ID, e.g., Command R.
var modelId = "cohere.command-r-v1:0";
// Create the input text and embed it in a message object with the user role.
var inputText = "Describe the purpose of a 'hello world' program in one line.";
var message = Message.builder()
.content(ContentBlock.fromText(inputText))
.role(ConversationRole.USER)
.build();
// Create a handler to extract and print the response text in real-time.
var responseStreamHandler = ConverseStreamResponseHandler.builder()
.subscriber(ConverseStreamResponseHandler.Visitor.builder()
.onContentBlockDelta(chunk -> {
String responseText = chunk.delta().text();
System.out.print(responseText);
}).build()
).onError(err ->
System.err.printf("Can't invoke '%s': %s", modelId, err.getMessage())
).build();
try {
// Send the message with a basic inference configuration and attach the handler.
client.converseStream(request -> request.modelId(modelId)
.messages(message)
.inferenceConfig(config -> config
.maxTokens(512)
.temperature(0.5F)
.topP(0.9F)
), responseStreamHandler).get();
} catch (ExecutionException | InterruptedException e) {
System.err.printf("Can't invoke '%s': %s", modelId, e.getCause().getMessage());
}
}
}
```
+ Untuk detail API, lihat [ConverseStream](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/ConverseStream)di *Referensi AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK untuk JavaScript (v3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Kirim pesan teks ke Cohere Command, menggunakan API Converse Bedrock dan proses aliran respons secara real-time.
```
// Use the Conversation API to send a text message to Cohere Command.
import {
BedrockRuntimeClient,
ConverseStreamCommand,
} from "@aws-sdk/client-bedrock-runtime";
// Create a Bedrock Runtime client in the AWS Region you want to use.
const client = new BedrockRuntimeClient({ region: "us-east-1" });
// Set the model ID, e.g., Command R.
const modelId = "cohere.command-r-v1:0";
// Start a conversation with the user message.
const userMessage =
"Describe the purpose of a 'hello world' program in one line.";
const conversation = [
{
role: "user",
content: [{ text: userMessage }],
},
];
// Create a command with the model ID, the message, and a basic configuration.
const command = new ConverseStreamCommand({
modelId,
messages: conversation,
inferenceConfig: { maxTokens: 512, temperature: 0.5, topP: 0.9 },
});
try {
// Send the command to the model and wait for the response
const response = await client.send(command);
// Extract and print the streamed response text in real-time.
for await (const item of response.stream) {
if (item.contentBlockDelta) {
process.stdout.write(item.contentBlockDelta.delta?.text);
}
}
} catch (err) {
console.log(`ERROR: Can't invoke '${modelId}'. Reason: ${err}`);
process.exit(1);
}
```
+ Untuk detail API, lihat [ConverseStream](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseStreamCommand)di *Referensi AWS SDK untuk JavaScript API*.
------
#### [ Python ]
**SDK untuk Python (Boto3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Kirim pesan teks ke Cohere Command, menggunakan API Converse Bedrock dan proses aliran respons secara real-time.
```
# Use the Conversation API to send a text message to Cohere Command
# and print the response stream.
import boto3
from botocore.exceptions import ClientError
# Create a Bedrock Runtime client in the AWS Region you want to use.
client = boto3.client("bedrock-runtime", region_name="us-east-1")
# Set the model ID, e.g., Command R.
model_id = "cohere.command-r-v1:0"
# Start a conversation with the user message.
user_message = "Describe the purpose of a 'hello world' program in one line."
conversation = [
{
"role": "user",
"content": [{"text": user_message}],
}
]
try:
# Send the message to the model, using a basic inference configuration.
streaming_response = client.converse_stream(
modelId=model_id,
messages=conversation,
inferenceConfig={"maxTokens": 512, "temperature": 0.5, "topP": 0.9},
)
# Extract and print the streamed response text in real-time.
for chunk in streaming_response["stream"]:
if "contentBlockDelta" in chunk:
text = chunk["contentBlockDelta"]["delta"]["text"]
print(text, end="")
except (ClientError, Exception) as e:
print(f"ERROR: Can't invoke '{model_id}'. Reason: {e}")
exit(1)
```
+ Untuk detail API, lihat [ConverseStream](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/ConverseStream)di *AWS SDK for Python (Boto3) Referensi* API.
------
# Kirim dan proses dokumen dengan model Cohere Command di Amazon Bedrock
Contoh kode berikut menunjukkan cara mengirim dan memproses dokumen dengan model Cohere Command di Amazon Bedrock.
------
#### [ Python ]
**SDK untuk Python (Boto3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Kirim dan proses dokumen dengan model Cohere Command di 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)
```
+ Untuk detail API, lihat [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) in *AWS SDK for Python (Boto3) Referensi* API.
------
# Memanggil Cohere Command R dan R\$1di Amazon Bedrock menggunakan Invoke Model API
Contoh kode berikut menunjukkan cara mengirim pesan teks ke Cohere Command R dan R \$1, menggunakan Invoke Model API.
------
#### [ .NET ]
**SDK untuk .NET**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime#code-examples).
Gunakan API Invoke Model untuk mengirim pesan teks.
```
// 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;
}
```
+ Untuk detail API, lihat [InvokeModel](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/InvokeModel)di *Referensi AWS SDK untuk .NET API*.
------
#### [ Java ]
**SDK untuk Java 2.x**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Gunakan API Invoke Model untuk mengirim pesan teks.
```
// 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();
}
}
```
+ Untuk detail API, lihat [InvokeModel](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModel)di *Referensi AWS SDK for Java 2.x API*.
------
#### [ Python ]
**SDK untuk Python (Boto3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Gunakan API Invoke Model untuk mengirim pesan teks.
```
# 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)
```
+ Untuk detail API, lihat [InvokeModel](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModel)di *AWS SDK for Python (Boto3) Referensi* API.
------
# Memanggil Cohere Command R dan R\$1di Amazon Bedrock menggunakan Invoke Model API dengan aliran respons
Contoh kode berikut menunjukkan cara mengirim pesan teks ke Cohere Command, menggunakan Invoke Model API dengan aliran respons.
------
#### [ .NET ]
**SDK untuk .NET**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime#code-examples).
Gunakan API Invoke Model untuk mengirim pesan teks dan memproses aliran respons secara real-time.
```
// Use the native inference API to send a text message to Cohere Command R
// and print the response stream.
using System;
using System.IO;
using System.Text.Json;
using System.Text.Json.Nodes;
using Amazon;
using Amazon.BedrockRuntime;
using Amazon.BedrockRuntime.Model;
// Create a Bedrock Runtime client in the AWS Region you want to use.
var client = new AmazonBedrockRuntimeClient(RegionEndpoint.USEast1);
// Set the model ID, e.g., Command R.
var modelId = "cohere.command-r-v1:0";
// Define the user message.
var userMessage = "Describe the purpose of a 'hello world' program in one line.";
//Format the request payload using the model's native structure.
var nativeRequest = JsonSerializer.Serialize(new
{
message = userMessage,
max_tokens = 512,
temperature = 0.5
});
// Create a request with the model ID and the model's native request payload.
var request = new InvokeModelWithResponseStreamRequest()
{
ModelId = modelId,
Body = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(nativeRequest)),
ContentType = "application/json"
};
try
{
// Send the request to the Bedrock Runtime and wait for the response.
var streamingResponse = await client.InvokeModelWithResponseStreamAsync(request);
// Extract and print the streamed response text in real-time.
foreach (var item in streamingResponse.Body)
{
var chunk = JsonSerializer.Deserialize((item as PayloadPart).Bytes);
var text = chunk["text"] ?? "";
Console.Write(text);
}
}
catch (AmazonBedrockRuntimeException e)
{
Console.WriteLine($"ERROR: Can't invoke '{modelId}'. Reason: {e.Message}");
throw;
}
```
+ Untuk detail API, lihat [InvokeModel](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/InvokeModel)di *Referensi AWS SDK untuk .NET API*.
------
#### [ Java ]
**SDK untuk Java 2.x**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Gunakan API Invoke Model untuk mengirim pesan teks dan memproses aliran respons secara real-time.
```
// Use the native inference API to send a text message to Cohere Command R
// and print the response stream.
import org.json.JSONObject;
import org.json.JSONPointer;
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.core.SdkBytes;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.bedrockruntime.BedrockRuntimeAsyncClient;
import software.amazon.awssdk.services.bedrockruntime.model.InvokeModelWithResponseStreamRequest;
import software.amazon.awssdk.services.bedrockruntime.model.InvokeModelWithResponseStreamResponseHandler;
import java.util.concurrent.ExecutionException;
import static software.amazon.awssdk.services.bedrockruntime.model.InvokeModelWithResponseStreamResponseHandler.Visitor;
public class Command_R_InvokeModelWithResponseStream {
public static String invokeModelWithResponseStream() {
// Create a Bedrock Runtime client in the AWS Region you want to use.
// Replace the DefaultCredentialsProvider with your preferred credentials provider.
var client = BedrockRuntimeAsyncClient.builder()
.credentialsProvider(DefaultCredentialsProvider.create())
.region(Region.US_EAST_1)
.build();
// Set the model ID, e.g., Command R.
var modelId = "cohere.command-r-v1:0";
// The InvokeModelWithResponseStream API uses the model's native payload.
// Learn more about the available inference parameters and response fields at:
// https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-cohere-command-r-plus.html
var nativeRequestTemplate = "{ \"message\": \"{{prompt}}\" }";
// Define the prompt for the model.
var prompt = "Describe the purpose of a 'hello world' program in one line.";
// Embed the prompt in the model's native request payload.
String nativeRequest = nativeRequestTemplate.replace("{{prompt}}", prompt);
// Create a request with the model ID and the model's native request payload.
var request = InvokeModelWithResponseStreamRequest.builder()
.body(SdkBytes.fromUtf8String(nativeRequest))
.modelId(modelId)
.build();
// Prepare a buffer to accumulate the generated response text.
var completeResponseTextBuffer = new StringBuilder();
// Prepare a handler to extract, accumulate, and print the response text in real-time.
var responseStreamHandler = InvokeModelWithResponseStreamResponseHandler.builder()
.subscriber(Visitor.builder().onChunk(chunk -> {
// Extract and print the text from the model's native response.
var response = new JSONObject(chunk.bytes().asUtf8String());
var text = new JSONPointer("/text").queryFrom(response);
System.out.print(text);
// Append the text to the response text buffer.
completeResponseTextBuffer.append(text);
}).build()).build();
try {
// Send the request and wait for the handler to process the response.
client.invokeModelWithResponseStream(request, responseStreamHandler).get();
// Return the complete response text.
return completeResponseTextBuffer.toString();
} catch (ExecutionException | InterruptedException e) {
System.err.printf("Can't invoke '%s': %s", modelId, e.getCause().getMessage());
throw new RuntimeException(e);
}
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
invokeModelWithResponseStream();
}
}
```
+ Untuk detail API, lihat [InvokeModel](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModel)di *Referensi AWS SDK for Java 2.x API*.
------
#### [ Python ]
**SDK untuk Python (Boto3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Gunakan API Invoke Model untuk mengirim pesan teks dan memproses aliran respons secara real-time.
```
# Use the native inference API to send a text message to Cohere Command R and R+
# and print the response stream.
import boto3
import json
from botocore.exceptions import ClientError
# Create a Bedrock Runtime client in the AWS Region of your choice.
client = boto3.client("bedrock-runtime", region_name="us-east-1")
# Set the model ID, e.g., Command R.
model_id = "cohere.command-r-v1:0"
# Define the prompt for the model.
prompt = "Describe the purpose of a 'hello world' program in one line."
# Format the request payload using the model's native structure.
native_request = {
"message": prompt,
"max_tokens": 512,
"temperature": 0.5,
}
# Convert the native request to JSON.
request = json.dumps(native_request)
try:
# Invoke the model with the request.
streaming_response = client.invoke_model_with_response_stream(
modelId=model_id, body=request
)
# Extract and print the response text in real-time.
for event in streaming_response["body"]:
chunk = json.loads(event["chunk"]["bytes"])
if "generations" in chunk:
print(chunk["generations"][0]["text"], end="")
except (ClientError, Exception) as e:
print(f"ERROR: Can't invoke '{model_id}'. Reason: {e}")
exit(1)
```
+ Untuk detail API, lihat [InvokeModel](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModel)di *AWS SDK for Python (Boto3) Referensi* API.
------
# Alat menggunakan demo yang menggambarkan cara menghubungkan model AI di Amazon Bedrock dengan alat atau API khusus
Contoh kode berikut menunjukkan bagaimana membangun interaksi khas antara aplikasi, model AI generatif, dan alat yang terhubung atau APIs untuk memediasi interaksi antara AI dan dunia luar. Ini menggunakan contoh menghubungkan API cuaca eksternal ke model AI sehingga dapat memberikan informasi cuaca real-time berdasarkan input pengguna.
------
#### [ Python ]
**SDK untuk Python (Boto3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Skrip eksekusi utama dari demo. Skrip ini mengatur percakapan antara pengguna, Amazon Bedrock Converse API, dan alat cuaca.
```
"""
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()
```
Alat cuaca yang digunakan oleh demo. Skrip ini mendefinisikan spesifikasi alat dan mengimplementasikan logika untuk mengambil data cuaca menggunakan dari 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)}
```
+ Untuk detail API, lihat [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) in *AWS SDK for Python (Boto3) Referensi* API.
------
# DeepSeek untuk Amazon Bedrock Runtime
Contoh kode berikut menunjukkan cara menggunakan Amazon Bedrock Runtime dengan. AWS SDKs
**Topics**
+ [Pemahaman dokumen](bedrock-runtime_example_bedrock-runtime_DocumentUnderstanding_DeepSeek_section.md)
# Mengirim dan memproses dokumen dengan DeepSeek di Amazon Bedrock
Contoh kode berikut menunjukkan cara mengirim dan memproses dokumen dengan DeepSeek di Amazon Bedrock.
------
#### [ Python ]
**SDK untuk Python (Boto3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Kirim dan proses dokumen dengan DeepSeek di 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)
```
+ Untuk detail API, lihat [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) in *AWS SDK for Python (Boto3) Referensi* API.
------
# Meta Llama untuk Runtime Amazon Bedrock
Contoh kode berikut menunjukkan cara menggunakan Amazon Bedrock Runtime dengan. AWS SDKs
**Topics**
+ [Bercakap-cakap](bedrock-runtime_example_bedrock-runtime_Converse_MetaLlama_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_MetaLlama_section.md)
+ [Pemahaman dokumen](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)
# Panggil Meta Llama di Amazon Bedrock menggunakan API Converse Bedrock
Contoh kode berikut menunjukkan cara mengirim pesan teks ke Meta Llama, menggunakan API Converse Bedrock.
------
#### [ .NET ]
**SDK untuk .NET (v4)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Bedrock-runtime#code-examples).
Kirim pesan teks ke Meta Llama, menggunakan API Converse Bedrock.
```
// Use the Converse API to send a text message to Meta Llama.
using System;
using System.Collections.Generic;
using Amazon;
using Amazon.BedrockRuntime;
using Amazon.BedrockRuntime.Model;
// Create a Bedrock Runtime client in the AWS Region you want to use.
var client = new AmazonBedrockRuntimeClient(RegionEndpoint.USEast1);
// Set the model ID, e.g., Llama 3 8b Instruct.
var modelId = "meta.llama3-8b-instruct-v1:0";
// Define the user message.
var userMessage = "Describe the purpose of a 'hello world' program in one line.";
// Create a request with the model ID, the user message, and an inference configuration.
var request = new ConverseRequest
{
ModelId = modelId,
Messages = new List
{
new Message
{
Role = ConversationRole.User,
Content = new List { new ContentBlock { Text = userMessage } }
}
},
InferenceConfig = new InferenceConfiguration()
{
MaxTokens = 512,
Temperature = 0.5F,
TopP = 0.9F
}
};
try
{
// Send the request to the Bedrock Runtime and wait for the result.
var response = await client.ConverseAsync(request);
// Extract and print the response text.
string responseText = response?.Output?.Message?.Content?[0]?.Text ?? "";
Console.WriteLine(responseText);
}
catch (AmazonBedrockRuntimeException e)
{
Console.WriteLine($"ERROR: Can't invoke '{modelId}'. Reason: {e.Message}");
throw;
}
```
+ Untuk detail API, lihat [Converse](https://docs.aws.amazon.com/goto/DotNetSDKV4/bedrock-runtime-2023-09-30/Converse) di *Referensi AWS SDK untuk .NET API*.
------
#### [ Java ]
**SDK untuk Java 2.x**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Kirim pesan teks ke Meta Llama, menggunakan API Converse Bedrock.
```
// Use the Converse API to send a text message to Meta Llama.
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.core.exception.SdkClientException;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.bedrockruntime.BedrockRuntimeClient;
import software.amazon.awssdk.services.bedrockruntime.model.ContentBlock;
import software.amazon.awssdk.services.bedrockruntime.model.ConversationRole;
import software.amazon.awssdk.services.bedrockruntime.model.ConverseResponse;
import software.amazon.awssdk.services.bedrockruntime.model.Message;
public class Converse {
public static String converse() {
// Create a Bedrock Runtime client in the AWS Region you want to use.
// Replace the DefaultCredentialsProvider with your preferred credentials provider.
var client = BedrockRuntimeClient.builder()
.credentialsProvider(DefaultCredentialsProvider.create())
.region(Region.US_EAST_1)
.build();
// Set the model ID, e.g., Llama 3 8b Instruct.
var modelId = "meta.llama3-8b-instruct-v1:0";
// Create the input text and embed it in a message object with the user role.
var inputText = "Describe the purpose of a 'hello world' program in one line.";
var message = Message.builder()
.content(ContentBlock.fromText(inputText))
.role(ConversationRole.USER)
.build();
try {
// Send the message with a basic inference configuration.
ConverseResponse response = client.converse(request -> request
.modelId(modelId)
.messages(message)
.inferenceConfig(config -> config
.maxTokens(512)
.temperature(0.5F)
.topP(0.9F)));
// Retrieve the generated text from Bedrock's response object.
var responseText = response.output().message().content().get(0).text();
System.out.println(responseText);
return responseText;
} catch (SdkClientException e) {
System.err.printf("ERROR: Can't invoke '%s'. Reason: %s", modelId, e.getMessage());
throw new RuntimeException(e);
}
}
public static void main(String[] args) {
converse();
}
}
```
Kirim pesan teks ke Meta Llama, menggunakan API Converse Bedrock dengan klien Java async.
```
// 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();
}
}
```
+ Untuk detail API, lihat [Converse](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/Converse) di *Referensi AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK untuk JavaScript (v3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Kirim pesan teks ke Meta Llama, menggunakan API Converse Bedrock.
```
// Use the Conversation API to send a text message to Meta Llama.
import {
BedrockRuntimeClient,
ConverseCommand,
} from "@aws-sdk/client-bedrock-runtime";
// Create a Bedrock Runtime client in the AWS Region you want to use.
const client = new BedrockRuntimeClient({ region: "us-east-1" });
// Set the model ID, e.g., Llama 3 8b Instruct.
const modelId = "meta.llama3-8b-instruct-v1:0";
// Start a conversation with the user message.
const userMessage =
"Describe the purpose of a 'hello world' program in one line.";
const conversation = [
{
role: "user",
content: [{ text: userMessage }],
},
];
// Create a command with the model ID, the message, and a basic configuration.
const command = new ConverseCommand({
modelId,
messages: conversation,
inferenceConfig: { maxTokens: 512, temperature: 0.5, topP: 0.9 },
});
try {
// Send the command to the model and wait for the response
const response = await client.send(command);
// Extract and print the response text.
const responseText = response.output.message.content[0].text;
console.log(responseText);
} catch (err) {
console.log(`ERROR: Can't invoke '${modelId}'. Reason: ${err}`);
process.exit(1);
}
```
+ Untuk detail API, lihat [Converse](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseCommand) di *Referensi AWS SDK untuk JavaScript API*.
------
#### [ Python ]
**SDK untuk Python (Boto3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Kirim pesan teks ke Meta Llama, menggunakan API Converse Bedrock.
```
# Use the Conversation API to send a text message to Meta Llama.
import boto3
from botocore.exceptions import ClientError
# Create a Bedrock Runtime client in the AWS Region you want to use.
client = boto3.client("bedrock-runtime", region_name="us-east-1")
# Set the model ID, e.g., Llama 3 8b Instruct.
model_id = "meta.llama3-8b-instruct-v1:0"
# Start a conversation with the user message.
user_message = "Describe the purpose of a 'hello world' program in one line."
conversation = [
{
"role": "user",
"content": [{"text": user_message}],
}
]
try:
# Send the message to the model, using a basic inference configuration.
response = client.converse(
modelId=model_id,
messages=conversation,
inferenceConfig={"maxTokens": 512, "temperature": 0.5, "topP": 0.9},
)
# Extract and print the response text.
response_text = response["output"]["message"]["content"][0]["text"]
print(response_text)
except (ClientError, Exception) as e:
print(f"ERROR: Can't invoke '{model_id}'. Reason: {e}")
exit(1)
```
+ Untuk detail API, lihat [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) in *AWS SDK for Python (Boto3) Referensi* API.
------
#### [ Swift ]
**SDK para Swift**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/bedrock-runtime#code-examples).
Kirim pesan teks ke Meta Llama, menggunakan API Converse Bedrock.
```
// An example demonstrating how to use the Conversation API to send
// a text message to Meta Llama.
import AWSBedrockRuntime
func converse(_ textPrompt: String) async throws -> String {
// Create a Bedrock Runtime client in the AWS Region you want to use.
let config =
try await BedrockRuntimeClient.BedrockRuntimeClientConfiguration(
region: "us-east-1"
)
let client = BedrockRuntimeClient(config: config)
// Set the model ID.
let modelId = "meta.llama3-8b-instruct-v1:0"
// Start a conversation with the user message.
let message = BedrockRuntimeClientTypes.Message(
content: [.text(textPrompt)],
role: .user
)
// Optionally use inference parameters
let inferenceConfig =
BedrockRuntimeClientTypes.InferenceConfiguration(
maxTokens: 512,
stopSequences: ["END"],
temperature: 0.5,
topp: 0.9
)
// Create the ConverseInput to send to the model
let input = ConverseInput(
inferenceConfig: inferenceConfig, messages: [message], modelId: modelId)
// Send the ConverseInput to the model
let response = try await client.converse(input: input)
// Extract and return the response text.
if case let .message(msg) = response.output {
if case let .text(textResponse) = msg.content![0] {
return textResponse
} else {
return "No text response found in message content"
}
} else {
return "No message found in converse output"
}
}
```
+ Untuk detail API, lihat [Converse](https://sdk.amazonaws.com/swift/api/awsbedrockruntime/latest/documentation/awsbedrockruntime/bedrockruntimeclient/converse(input:)) di *AWS SDK untuk referensi Swift* API.
------
# Panggil Meta Llama di Amazon Bedrock menggunakan API Converse Bedrock dengan aliran respons
Contoh kode berikut menunjukkan cara mengirim pesan teks ke Meta Llama, menggunakan API Converse Bedrock dan memproses aliran respons secara real-time.
------
#### [ .NET ]
**SDK untuk .NET (v4)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Bedrock-runtime#code-examples).
Kirim pesan teks ke Meta Llama, menggunakan API Converse Bedrock dan proses aliran respons secara real-time.
```
// Use the Converse API to send a text message to Meta Llama
// and print the response stream.
using System;
using System.Collections.Generic;
using System.Linq;
using Amazon;
using Amazon.BedrockRuntime;
using Amazon.BedrockRuntime.Model;
// Create a Bedrock Runtime client in the AWS Region you want to use.
var client = new AmazonBedrockRuntimeClient(RegionEndpoint.USEast1);
// Set the model ID, e.g., Llama 3 8b Instruct.
var modelId = "meta.llama3-8b-instruct-v1:0";
// Define the user message.
var userMessage = "Describe the purpose of a 'hello world' program in one line.";
// Create a request with the model ID, the user message, and an inference configuration.
var request = new ConverseStreamRequest
{
ModelId = modelId,
Messages = new List
{
new Message
{
Role = ConversationRole.User,
Content = new List { new ContentBlock { Text = userMessage } }
}
},
InferenceConfig = new InferenceConfiguration()
{
MaxTokens = 512,
Temperature = 0.5F,
TopP = 0.9F
}
};
try
{
// Send the request to the Bedrock Runtime and wait for the result.
var response = await client.ConverseStreamAsync(request);
// Extract and print the streamed response text in real-time.
foreach (var chunk in response.Stream.AsEnumerable())
{
if (chunk is ContentBlockDeltaEvent)
{
Console.Write((chunk as ContentBlockDeltaEvent).Delta.Text);
}
}
}
catch (AmazonBedrockRuntimeException e)
{
Console.WriteLine($"ERROR: Can't invoke '{modelId}'. Reason: {e.Message}");
throw;
}
```
+ Untuk detail API, lihat [ConverseStream](https://docs.aws.amazon.com/goto/DotNetSDKV4/bedrock-runtime-2023-09-30/ConverseStream)di *Referensi AWS SDK untuk .NET API*.
------
#### [ Java ]
**SDK untuk Java 2.x**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Kirim pesan teks ke Meta Llama, menggunakan API Converse Bedrock dan proses aliran respons secara real-time.
```
// Use the Converse API to send a text message to Meta Llama
// and print the response stream.
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.bedrockruntime.BedrockRuntimeAsyncClient;
import software.amazon.awssdk.services.bedrockruntime.model.ContentBlock;
import software.amazon.awssdk.services.bedrockruntime.model.ConversationRole;
import software.amazon.awssdk.services.bedrockruntime.model.ConverseStreamResponseHandler;
import software.amazon.awssdk.services.bedrockruntime.model.Message;
import java.util.concurrent.ExecutionException;
public class ConverseStream {
public static void main(String[] args) {
// Create a Bedrock Runtime client in the AWS Region you want to use.
// Replace the DefaultCredentialsProvider with your preferred credentials provider.
var client = BedrockRuntimeAsyncClient.builder()
.credentialsProvider(DefaultCredentialsProvider.create())
.region(Region.US_EAST_1)
.build();
// Set the model ID, e.g., Llama 3 8b Instruct.
var modelId = "meta.llama3-8b-instruct-v1:0";
// Create the input text and embed it in a message object with the user role.
var inputText = "Describe the purpose of a 'hello world' program in one line.";
var message = Message.builder()
.content(ContentBlock.fromText(inputText))
.role(ConversationRole.USER)
.build();
// Create a handler to extract and print the response text in real-time.
var responseStreamHandler = ConverseStreamResponseHandler.builder()
.subscriber(ConverseStreamResponseHandler.Visitor.builder()
.onContentBlockDelta(chunk -> {
String responseText = chunk.delta().text();
System.out.print(responseText);
}).build()
).onError(err ->
System.err.printf("Can't invoke '%s': %s", modelId, err.getMessage())
).build();
try {
// Send the message with a basic inference configuration and attach the handler.
client.converseStream(request -> request
.modelId(modelId)
.messages(message)
.inferenceConfig(config -> config
.maxTokens(512)
.temperature(0.5F)
.topP(0.9F)
), responseStreamHandler).get();
} catch (ExecutionException | InterruptedException e) {
System.err.printf("Can't invoke '%s': %s", modelId, e.getCause().getMessage());
}
}
}
```
+ Untuk detail API, lihat [ConverseStream](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/ConverseStream)di *Referensi AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK untuk JavaScript (v3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Kirim pesan teks ke Meta Llama, menggunakan API Converse Bedrock dan proses aliran respons secara real-time.
```
// Use the Conversation API to send a text message to Meta Llama.
import {
BedrockRuntimeClient,
ConverseStreamCommand,
} from "@aws-sdk/client-bedrock-runtime";
// Create a Bedrock Runtime client in the AWS Region you want to use.
const client = new BedrockRuntimeClient({ region: "us-east-1" });
// Set the model ID, e.g., Llama 3 8b Instruct.
const modelId = "meta.llama3-8b-instruct-v1:0";
// Start a conversation with the user message.
const userMessage =
"Describe the purpose of a 'hello world' program in one line.";
const conversation = [
{
role: "user",
content: [{ text: userMessage }],
},
];
// Create a command with the model ID, the message, and a basic configuration.
const command = new ConverseStreamCommand({
modelId,
messages: conversation,
inferenceConfig: { maxTokens: 512, temperature: 0.5, topP: 0.9 },
});
try {
// Send the command to the model and wait for the response
const response = await client.send(command);
// Extract and print the streamed response text in real-time.
for await (const item of response.stream) {
if (item.contentBlockDelta) {
process.stdout.write(item.contentBlockDelta.delta?.text);
}
}
} catch (err) {
console.log(`ERROR: Can't invoke '${modelId}'. Reason: ${err}`);
process.exit(1);
}
```
+ Untuk detail API, lihat [ConverseStream](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseStreamCommand)di *Referensi AWS SDK untuk JavaScript API*.
------
#### [ Python ]
**SDK untuk Python (Boto3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Kirim pesan teks ke Meta Llama, menggunakan API Converse Bedrock dan proses aliran respons secara real-time.
```
# Use the Conversation API to send a text message to Meta Llama
# and print the response stream.
import boto3
from botocore.exceptions import ClientError
# Create a Bedrock Runtime client in the AWS Region you want to use.
client = boto3.client("bedrock-runtime", region_name="us-east-1")
# Set the model ID, e.g., Llama 3 8b Instruct.
model_id = "meta.llama3-8b-instruct-v1:0"
# Start a conversation with the user message.
user_message = "Describe the purpose of a 'hello world' program in one line."
conversation = [
{
"role": "user",
"content": [{"text": user_message}],
}
]
try:
# Send the message to the model, using a basic inference configuration.
streaming_response = client.converse_stream(
modelId=model_id,
messages=conversation,
inferenceConfig={"maxTokens": 512, "temperature": 0.5, "topP": 0.9},
)
# Extract and print the streamed response text in real-time.
for chunk in streaming_response["stream"]:
if "contentBlockDelta" in chunk:
text = chunk["contentBlockDelta"]["delta"]["text"]
print(text, end="")
except (ClientError, Exception) as e:
print(f"ERROR: Can't invoke '{model_id}'. Reason: {e}")
exit(1)
```
+ Untuk detail API, lihat [ConverseStream](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/ConverseStream)di *AWS SDK for Python (Boto3) Referensi* API.
------
#### [ Swift ]
**SDK para Swift**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/bedrock-runtime#code-examples).
Kirim pesan teks ke Meta Llama, menggunakan API Converse Bedrock dan proses aliran respons secara real-time.
```
// An example demonstrating how to use the Conversation API to send a text message
// to Meta Llama and print the response stream.
import AWSBedrockRuntime
func printConverseStream(_ textPrompt: String) async throws {
// Create a Bedrock Runtime client in the AWS Region you want to use.
let config =
try await BedrockRuntimeClient.BedrockRuntimeClientConfiguration(
region: "us-east-1"
)
let client = BedrockRuntimeClient(config: config)
// Set the model ID.
let modelId = "meta.llama3-8b-instruct-v1:0"
// Start a conversation with the user message.
let message = BedrockRuntimeClientTypes.Message(
content: [.text(textPrompt)],
role: .user
)
// Optionally use inference parameters.
let inferenceConfig =
BedrockRuntimeClientTypes.InferenceConfiguration(
maxTokens: 512,
stopSequences: ["END"],
temperature: 0.5,
topp: 0.9
)
// Create the ConverseStreamInput to send to the model.
let input = ConverseStreamInput(
inferenceConfig: inferenceConfig, messages: [message], modelId: modelId)
// Send the ConverseStreamInput to the model.
let response = try await client.converseStream(input: input)
// Extract the streaming response.
guard let stream = response.stream else {
print("No stream available")
return
}
// Extract and print the streamed response text in real-time.
for try await event in stream {
switch event {
case .messagestart(_):
print("\nMeta Llama:")
case .contentblockdelta(let deltaEvent):
if case .text(let text) = deltaEvent.delta {
print(text, terminator: "")
}
default:
break
}
}
}
```
+ Untuk detail API, lihat referensi [ConverseStream AWS](https://sdk.amazonaws.com/swift/api/awsbedrockruntime/latest/documentation/awsbedrockruntime/bedrockruntimeclient/conversestream(input:))*SDK untuk Swift API*.
------
# Kirim dan proses dokumen dengan Llama di Amazon Bedrock
Contoh kode berikut menunjukkan cara mengirim dan memproses dokumen dengan Llama di Amazon Bedrock.
------
#### [ Python ]
**SDK untuk Python (Boto3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Kirim dan proses dokumen dengan Llama di 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)
```
+ Untuk detail API, lihat [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) in *AWS SDK for Python (Boto3) Referensi* API.
------
# Panggil Meta Llama di Amazon Bedrock menggunakan API Model Invoke
Contoh kode berikut menunjukkan cara mengirim pesan teks ke Meta Llama, menggunakan Invoke Model API.
------
#### [ .NET ]
**SDK untuk .NET**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime#code-examples).
Gunakan API Invoke Model untuk mengirim pesan teks.
```
// 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;
}
```
+ Untuk detail API, lihat [InvokeModel](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/InvokeModel)di *Referensi AWS SDK untuk .NET API*.
------
#### [ Java ]
**SDK untuk Java 2.x**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Gunakan API Invoke Model untuk mengirim pesan teks.
```
// 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();
}
}
```
+ Untuk detail API, lihat [InvokeModel](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModel)di *Referensi AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK untuk JavaScript (v3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Gunakan API Invoke Model untuk mengirim pesan teks.
```
// 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
```
+ Untuk detail API, lihat [InvokeModel](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/InvokeModelCommand)di *Referensi AWS SDK untuk JavaScript API*.
------
#### [ Python ]
**SDK untuk Python (Boto3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Gunakan API Invoke Model untuk mengirim pesan teks.
```
# 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)
```
+ Untuk detail API, lihat [InvokeModel](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModel)di *AWS SDK for Python (Boto3) Referensi* API.
------
# Panggil Meta Llama di Amazon Bedrock menggunakan API Model Invoke dengan aliran respons
Contoh kode berikut menunjukkan cara mengirim pesan teks ke Meta Llama, menggunakan Invoke Model API, dan mencetak aliran respons.
------
#### [ .NET ]
**SDK untuk .NET**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime#code-examples).
Gunakan API Invoke Model untuk mengirim pesan teks dan memproses aliran respons secara real-time.
```
// Use the native inference API to send a text message to Meta Llama 3
// and print the response stream.
using System;
using System.IO;
using System.Text.Json;
using System.Text.Json.Nodes;
using Amazon;
using Amazon.BedrockRuntime;
using Amazon.BedrockRuntime.Model;
// Create a Bedrock Runtime client in the AWS Region you want to use.
var client = new AmazonBedrockRuntimeClient(RegionEndpoint.USWest2);
// Set the model ID, e.g., Llama 3 70b Instruct.
var modelId = "meta.llama3-70b-instruct-v1:0";
// Define the prompt for the model.
var prompt = "Describe the purpose of a 'hello world' program in one line.";
// Embed the prompt in Llama 2's instruction format.
var formattedPrompt = $@"
<|begin_of_text|><|start_header_id|>user<|end_header_id|>
{prompt}
<|eot_id|>
<|start_header_id|>assistant<|end_header_id|>
";
//Format the request payload using the model's native structure.
var nativeRequest = JsonSerializer.Serialize(new
{
prompt = formattedPrompt,
max_gen_len = 512,
temperature = 0.5
});
// Create a request with the model ID and the model's native request payload.
var request = new InvokeModelWithResponseStreamRequest()
{
ModelId = modelId,
Body = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(nativeRequest)),
ContentType = "application/json"
};
try
{
// Send the request to the Bedrock Runtime and wait for the response.
var streamingResponse = await client.InvokeModelWithResponseStreamAsync(request);
// Extract and print the streamed response text in real-time.
foreach (var item in streamingResponse.Body)
{
var chunk = JsonSerializer.Deserialize((item as PayloadPart).Bytes);
var text = chunk["generation"] ?? "";
Console.Write(text);
}
}
catch (AmazonBedrockRuntimeException e)
{
Console.WriteLine($"ERROR: Can't invoke '{modelId}'. Reason: {e.Message}");
throw;
}
```
+ Untuk detail API, lihat [InvokeModelWithResponseStream](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/InvokeModelWithResponseStream)di *Referensi AWS SDK untuk .NET API*.
------
#### [ Java ]
**SDK untuk Java 2.x**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Gunakan API Invoke Model untuk mengirim pesan teks dan memproses aliran respons secara real-time.
```
// Use the native inference API to send a text message to Meta Llama 3
// and print the response stream.
import org.json.JSONObject;
import org.json.JSONPointer;
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.core.SdkBytes;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.bedrockruntime.BedrockRuntimeAsyncClient;
import software.amazon.awssdk.services.bedrockruntime.model.InvokeModelWithResponseStreamRequest;
import software.amazon.awssdk.services.bedrockruntime.model.InvokeModelWithResponseStreamResponseHandler;
import java.util.concurrent.ExecutionException;
import static software.amazon.awssdk.services.bedrockruntime.model.InvokeModelWithResponseStreamResponseHandler.Visitor;
public class Llama3_InvokeModelWithResponseStream {
public static String invokeModelWithResponseStream() {
// Create a Bedrock Runtime client in the AWS Region you want to use.
// Replace the DefaultCredentialsProvider with your preferred credentials provider.
var client = BedrockRuntimeAsyncClient.builder()
.credentialsProvider(DefaultCredentialsProvider.create())
.region(Region.US_WEST_2)
.build();
// Set the model ID, e.g., Llama 3 70b Instruct.
var modelId = "meta.llama3-70b-instruct-v1:0";
// The InvokeModelWithResponseStream API uses the model's native payload.
// Learn more about the available inference parameters and response fields at:
// https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-meta.html
var nativeRequestTemplate = "{ \"prompt\": \"{{instruction}}\" }";
// Define the prompt for the model.
var prompt = "Describe the purpose of a 'hello world' program in one line.";
// Embed the prompt in Llama 3's instruction format.
var instruction = (
"<|begin_of_text|><|start_header_id|>user<|end_header_id|>\\n" +
"{{prompt}} <|eot_id|>\\n" +
"<|start_header_id|>assistant<|end_header_id|>\\n"
).replace("{{prompt}}", prompt);
// Embed the instruction in the the native request payload.
var nativeRequest = nativeRequestTemplate.replace("{{instruction}}", instruction);
// Create a request with the model ID and the model's native request payload.
var request = InvokeModelWithResponseStreamRequest.builder()
.body(SdkBytes.fromUtf8String(nativeRequest))
.modelId(modelId)
.build();
// Prepare a buffer to accumulate the generated response text.
var completeResponseTextBuffer = new StringBuilder();
// Prepare a handler to extract, accumulate, and print the response text in real-time.
var responseStreamHandler = InvokeModelWithResponseStreamResponseHandler.builder()
.subscriber(Visitor.builder().onChunk(chunk -> {
// Extract and print the text from the model's native response.
var response = new JSONObject(chunk.bytes().asUtf8String());
var text = new JSONPointer("/generation").queryFrom(response);
System.out.print(text);
// Append the text to the response text buffer.
completeResponseTextBuffer.append(text);
}).build()).build();
try {
// Send the request and wait for the handler to process the response.
client.invokeModelWithResponseStream(request, responseStreamHandler).get();
// Return the complete response text.
return completeResponseTextBuffer.toString();
} catch (ExecutionException | InterruptedException e) {
System.err.printf("Can't invoke '%s': %s", modelId, e.getCause().getMessage());
throw new RuntimeException(e);
}
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
invokeModelWithResponseStream();
}
}
```
+ Untuk detail API, lihat [InvokeModelWithResponseStream](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModelWithResponseStream)di *Referensi AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK untuk JavaScript (v3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Gunakan API Invoke Model untuk mengirim pesan teks dan memproses aliran respons secara real-time.
```
// Send a prompt to Meta Llama 3 and print the response stream in real-time.
import {
BedrockRuntimeClient,
InvokeModelWithResponseStreamCommand,
} from "@aws-sdk/client-bedrock-runtime";
// Create a Bedrock Runtime client in the AWS Region of your choice.
const client = new BedrockRuntimeClient({ region: "us-west-2" });
// Set the model ID, e.g., Llama 3 70B Instruct.
const modelId = "meta.llama3-70b-instruct-v1:0";
// Define the user message to send.
const userMessage =
"Describe the purpose of a 'hello world' program in one sentence.";
// Embed the message in Llama 3's prompt format.
const prompt = `
<|begin_of_text|><|start_header_id|>user<|end_header_id|>
${userMessage}
<|eot_id|>
<|start_header_id|>assistant<|end_header_id|>
`;
// Format the request payload using the model's native structure.
const request = {
prompt,
// Optional inference parameters:
max_gen_len: 512,
temperature: 0.5,
top_p: 0.9,
};
// Encode and send the request.
const responseStream = await client.send(
new InvokeModelWithResponseStreamCommand({
contentType: "application/json",
body: JSON.stringify(request),
modelId,
}),
);
// Extract and print the response stream in real-time.
for await (const event of responseStream.body) {
/** @type {{ generation: string }} */
const chunk = JSON.parse(new TextDecoder().decode(event.chunk.bytes));
if (chunk.generation) {
process.stdout.write(chunk.generation);
}
}
// Learn more about the Llama 3 prompt format at:
// https://llama.meta.com/docs/model-cards-and-prompt-formats/meta-llama-3/#special-tokens-used-with-meta-llama-3
```
+ Untuk detail API, lihat [InvokeModelWithResponseStream](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/InvokeModelWithResponseStreamCommand)di *Referensi AWS SDK untuk JavaScript API*.
------
#### [ Python ]
**SDK untuk Python (Boto3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Gunakan API Invoke Model untuk mengirim pesan teks dan memproses aliran respons secara real-time.
```
# Use the native inference API to send a text message to Meta Llama 3
# and print the response stream.
import boto3
import json
from botocore.exceptions import ClientError
# Create a Bedrock Runtime client in the AWS Region of your choice.
client = boto3.client("bedrock-runtime", region_name="us-west-2")
# Set the model ID, e.g., Llama 3 70b Instruct.
model_id = "meta.llama3-70b-instruct-v1:0"
# Define the prompt for the model.
prompt = "Describe the purpose of a 'hello world' program in one line."
# Embed the prompt in Llama 3's instruction format.
formatted_prompt = f"""
<|begin_of_text|><|start_header_id|>user<|end_header_id|>
{prompt}
<|eot_id|>
<|start_header_id|>assistant<|end_header_id|>
"""
# Format the request payload using the model's native structure.
native_request = {
"prompt": formatted_prompt,
"max_gen_len": 512,
"temperature": 0.5,
}
# Convert the native request to JSON.
request = json.dumps(native_request)
try:
# Invoke the model with the request.
streaming_response = client.invoke_model_with_response_stream(
modelId=model_id, body=request
)
# Extract and print the response text in real-time.
for event in streaming_response["body"]:
chunk = json.loads(event["chunk"]["bytes"])
if "generation" in chunk:
print(chunk["generation"], end="")
except (ClientError, Exception) as e:
print(f"ERROR: Can't invoke '{model_id}'. Reason: {e}")
exit(1)
```
+ Untuk detail API, lihat [InvokeModelWithResponseStream](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModelWithResponseStream)di *AWS SDK for Python (Boto3) Referensi* API.
------
# AI Mistral untuk Runtime Amazon Bedrock
Contoh kode berikut menunjukkan cara menggunakan Amazon Bedrock Runtime dengan. AWS SDKs
**Topics**
+ [Bercakap-cakap](bedrock-runtime_example_bedrock-runtime_Converse_Mistral_section.md)
+ [ConverseStream](bedrock-runtime_example_bedrock-runtime_ConverseStream_Mistral_section.md)
+ [Pemahaman dokumen](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)
# Panggil Mistral di Amazon Bedrock menggunakan API Converse Bedrock
Contoh kode berikut menunjukkan cara mengirim pesan teks ke Mistral, menggunakan API Converse Bedrock.
------
#### [ .NET ]
**SDK untuk .NET (v4)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Bedrock-runtime#code-examples).
Kirim pesan teks ke Mistral, menggunakan API Converse Bedrock.
```
// Use the Converse API to send a text message to Mistral.
using System;
using System.Collections.Generic;
using Amazon;
using Amazon.BedrockRuntime;
using Amazon.BedrockRuntime.Model;
// Create a Bedrock Runtime client in the AWS Region you want to use.
var client = new AmazonBedrockRuntimeClient(RegionEndpoint.USEast1);
// Set the model ID, e.g., Mistral Large.
var modelId = "mistral.mistral-large-2402-v1:0";
// Define the user message.
var userMessage = "Describe the purpose of a 'hello world' program in one line.";
// Create a request with the model ID, the user message, and an inference configuration.
var request = new ConverseRequest
{
ModelId = modelId,
Messages = new List
{
new Message
{
Role = ConversationRole.User,
Content = new List { new ContentBlock { Text = userMessage } }
}
},
InferenceConfig = new InferenceConfiguration()
{
MaxTokens = 512,
Temperature = 0.5F,
TopP = 0.9F
}
};
try
{
// Send the request to the Bedrock Runtime and wait for the result.
var response = await client.ConverseAsync(request);
// Extract and print the response text.
string responseText = response?.Output?.Message?.Content?[0]?.Text ?? "";
Console.WriteLine(responseText);
}
catch (AmazonBedrockRuntimeException e)
{
Console.WriteLine($"ERROR: Can't invoke '{modelId}'. Reason: {e.Message}");
throw;
}
```
+ Untuk detail API, lihat [Converse](https://docs.aws.amazon.com/goto/DotNetSDKV4/bedrock-runtime-2023-09-30/Converse) di *Referensi AWS SDK untuk .NET API*.
------
#### [ Java ]
**SDK untuk Java 2.x**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Kirim pesan teks ke Mistral, menggunakan API Converse Bedrock.
```
// Use the Converse API to send a text message to Mistral.
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.core.exception.SdkClientException;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.bedrockruntime.BedrockRuntimeClient;
import software.amazon.awssdk.services.bedrockruntime.model.ContentBlock;
import software.amazon.awssdk.services.bedrockruntime.model.ConversationRole;
import software.amazon.awssdk.services.bedrockruntime.model.ConverseResponse;
import software.amazon.awssdk.services.bedrockruntime.model.Message;
public class Converse {
public static String converse() {
// Create a Bedrock Runtime client in the AWS Region you want to use.
// Replace the DefaultCredentialsProvider with your preferred credentials provider.
var client = BedrockRuntimeClient.builder()
.credentialsProvider(DefaultCredentialsProvider.create())
.region(Region.US_EAST_1)
.build();
// Set the model ID, e.g., Mistral Large.
var modelId = "mistral.mistral-large-2402-v1:0";
// Create the input text and embed it in a message object with the user role.
var inputText = "Describe the purpose of a 'hello world' program in one line.";
var message = Message.builder()
.content(ContentBlock.fromText(inputText))
.role(ConversationRole.USER)
.build();
try {
// Send the message with a basic inference configuration.
ConverseResponse response = client.converse(request -> request
.modelId(modelId)
.messages(message)
.inferenceConfig(config -> config
.maxTokens(512)
.temperature(0.5F)
.topP(0.9F)));
// Retrieve the generated text from Bedrock's response object.
var responseText = response.output().message().content().get(0).text();
System.out.println(responseText);
return responseText;
} catch (SdkClientException e) {
System.err.printf("ERROR: Can't invoke '%s'. Reason: %s", modelId, e.getMessage());
throw new RuntimeException(e);
}
}
public static void main(String[] args) {
converse();
}
}
```
Kirim pesan teks ke Mistral, menggunakan API Converse Bedrock dengan klien Java async.
```
// 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();
}
}
```
+ Untuk detail API, lihat [Converse](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/Converse) di *Referensi AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK untuk JavaScript (v3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Kirim pesan teks ke Mistral, menggunakan API Converse Bedrock.
```
// Use the Conversation API to send a text message to Mistral.
import {
BedrockRuntimeClient,
ConverseCommand,
} from "@aws-sdk/client-bedrock-runtime";
// Create a Bedrock Runtime client in the AWS Region you want to use.
const client = new BedrockRuntimeClient({ region: "us-east-1" });
// Set the model ID, e.g., Mistral Large.
const modelId = "mistral.mistral-large-2402-v1:0";
// Start a conversation with the user message.
const userMessage =
"Describe the purpose of a 'hello world' program in one line.";
const conversation = [
{
role: "user",
content: [{ text: userMessage }],
},
];
// Create a command with the model ID, the message, and a basic configuration.
const command = new ConverseCommand({
modelId,
messages: conversation,
inferenceConfig: { maxTokens: 512, temperature: 0.5, topP: 0.9 },
});
try {
// Send the command to the model and wait for the response
const response = await client.send(command);
// Extract and print the response text.
const responseText = response.output.message.content[0].text;
console.log(responseText);
} catch (err) {
console.log(`ERROR: Can't invoke '${modelId}'. Reason: ${err}`);
process.exit(1);
}
```
+ Untuk detail API, lihat [Converse](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseCommand) di *Referensi AWS SDK untuk JavaScript API*.
------
#### [ Python ]
**SDK untuk Python (Boto3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Kirim pesan teks ke Mistral, menggunakan API Converse Bedrock.
```
# Use the Conversation API to send a text message to Mistral.
import boto3
from botocore.exceptions import ClientError
# Create a Bedrock Runtime client in the AWS Region you want to use.
client = boto3.client("bedrock-runtime", region_name="us-east-1")
# Set the model ID, e.g., Mistral Large.
model_id = "mistral.mistral-large-2402-v1:0"
# Start a conversation with the user message.
user_message = "Describe the purpose of a 'hello world' program in one line."
conversation = [
{
"role": "user",
"content": [{"text": user_message}],
}
]
try:
# Send the message to the model, using a basic inference configuration.
response = client.converse(
modelId=model_id,
messages=conversation,
inferenceConfig={"maxTokens": 512, "temperature": 0.5, "topP": 0.9},
)
# Extract and print the response text.
response_text = response["output"]["message"]["content"][0]["text"]
print(response_text)
except (ClientError, Exception) as e:
print(f"ERROR: Can't invoke '{model_id}'. Reason: {e}")
exit(1)
```
+ Untuk detail API, lihat [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) in *AWS SDK for Python (Boto3) Referensi* API.
------
# Panggil Mistral di Amazon Bedrock menggunakan API Converse Bedrock dengan aliran respons
Contoh kode berikut menunjukkan cara mengirim pesan teks ke Mistral, menggunakan API Converse Bedrock dan memproses aliran respons secara real-time.
------
#### [ .NET ]
**SDK untuk .NET (v4)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Bedrock-runtime#code-examples).
Kirim pesan teks ke Mistral, menggunakan API Converse Bedrock dan proses aliran respons secara real-time.
```
// Use the Converse API to send a text message to Mistral
// and print the response stream.
using System;
using System.Collections.Generic;
using System.Linq;
using Amazon;
using Amazon.BedrockRuntime;
using Amazon.BedrockRuntime.Model;
// Create a Bedrock Runtime client in the AWS Region you want to use.
var client = new AmazonBedrockRuntimeClient(RegionEndpoint.USEast1);
// Set the model ID, e.g., Mistral Large.
var modelId = "mistral.mistral-large-2402-v1:0";
// Define the user message.
var userMessage = "Describe the purpose of a 'hello world' program in one line.";
// Create a request with the model ID, the user message, and an inference configuration.
var request = new ConverseStreamRequest
{
ModelId = modelId,
Messages = new List
{
new Message
{
Role = ConversationRole.User,
Content = new List { new ContentBlock { Text = userMessage } }
}
},
InferenceConfig = new InferenceConfiguration()
{
MaxTokens = 512,
Temperature = 0.5F,
TopP = 0.9F
}
};
try
{
// Send the request to the Bedrock Runtime and wait for the result.
var response = await client.ConverseStreamAsync(request);
// Extract and print the streamed response text in real-time.
foreach (var chunk in response.Stream.AsEnumerable())
{
if (chunk is ContentBlockDeltaEvent)
{
Console.Write((chunk as ContentBlockDeltaEvent).Delta.Text);
}
}
}
catch (AmazonBedrockRuntimeException e)
{
Console.WriteLine($"ERROR: Can't invoke '{modelId}'. Reason: {e.Message}");
throw;
}
```
+ Untuk detail API, lihat [ConverseStream](https://docs.aws.amazon.com/goto/DotNetSDKV4/bedrock-runtime-2023-09-30/ConverseStream)di *Referensi AWS SDK untuk .NET API*.
------
#### [ Java ]
**SDK untuk Java 2.x**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Kirim pesan teks ke Mistral, menggunakan API Converse Bedrock dan proses aliran respons secara real-time.
```
// Use the Converse API to send a text message to Mistral
// and print the response stream.
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.bedrockruntime.BedrockRuntimeAsyncClient;
import software.amazon.awssdk.services.bedrockruntime.model.ContentBlock;
import software.amazon.awssdk.services.bedrockruntime.model.ConversationRole;
import software.amazon.awssdk.services.bedrockruntime.model.ConverseStreamResponseHandler;
import software.amazon.awssdk.services.bedrockruntime.model.Message;
import java.util.concurrent.ExecutionException;
public class ConverseStream {
public static void main(String[] args) {
// Create a Bedrock Runtime client in the AWS Region you want to use.
// Replace the DefaultCredentialsProvider with your preferred credentials provider.
var client = BedrockRuntimeAsyncClient.builder()
.credentialsProvider(DefaultCredentialsProvider.create())
.region(Region.US_EAST_1)
.build();
// Set the model ID, e.g., Mistral Large.
var modelId = "mistral.mistral-large-2402-v1:0";
// Create the input text and embed it in a message object with the user role.
var inputText = "Describe the purpose of a 'hello world' program in one line.";
var message = Message.builder()
.content(ContentBlock.fromText(inputText))
.role(ConversationRole.USER)
.build();
// Create a handler to extract and print the response text in real-time.
var responseStreamHandler = ConverseStreamResponseHandler.builder()
.subscriber(ConverseStreamResponseHandler.Visitor.builder()
.onContentBlockDelta(chunk -> {
String responseText = chunk.delta().text();
System.out.print(responseText);
}).build()
).onError(err ->
System.err.printf("Can't invoke '%s': %s", modelId, err.getMessage())
).build();
try {
// Send the message with a basic inference configuration and attach the handler.
client.converseStream(request -> request.modelId(modelId)
.messages(message)
.inferenceConfig(config -> config
.maxTokens(512)
.temperature(0.5F)
.topP(0.9F)
), responseStreamHandler).get();
} catch (ExecutionException | InterruptedException e) {
System.err.printf("Can't invoke '%s': %s", modelId, e.getCause().getMessage());
}
}
}
```
+ Untuk detail API, lihat [ConverseStream](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/ConverseStream)di *Referensi AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK untuk JavaScript (v3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Kirim pesan teks ke Mistral, menggunakan API Converse Bedrock dan proses aliran respons secara real-time.
```
// Use the Conversation API to send a text message to Mistral.
import {
BedrockRuntimeClient,
ConverseStreamCommand,
} from "@aws-sdk/client-bedrock-runtime";
// Create a Bedrock Runtime client in the AWS Region you want to use.
const client = new BedrockRuntimeClient({ region: "us-east-1" });
// Set the model ID, e.g., Mistral Large.
const modelId = "mistral.mistral-large-2402-v1:0";
// Start a conversation with the user message.
const userMessage =
"Describe the purpose of a 'hello world' program in one line.";
const conversation = [
{
role: "user",
content: [{ text: userMessage }],
},
];
// Create a command with the model ID, the message, and a basic configuration.
const command = new ConverseStreamCommand({
modelId,
messages: conversation,
inferenceConfig: { maxTokens: 512, temperature: 0.5, topP: 0.9 },
});
try {
// Send the command to the model and wait for the response
const response = await client.send(command);
// Extract and print the streamed response text in real-time.
for await (const item of response.stream) {
if (item.contentBlockDelta) {
process.stdout.write(item.contentBlockDelta.delta?.text);
}
}
} catch (err) {
console.log(`ERROR: Can't invoke '${modelId}'. Reason: ${err}`);
process.exit(1);
}
```
+ Untuk detail API, lihat [ConverseStream](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/ConverseStreamCommand)di *Referensi AWS SDK untuk JavaScript API*.
------
#### [ Python ]
**SDK untuk Python (Boto3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Kirim pesan teks ke Mistral, menggunakan API Converse Bedrock dan proses aliran respons secara real-time.
```
# Use the Conversation API to send a text message to Mistral
# and print the response stream.
import boto3
from botocore.exceptions import ClientError
# Create a Bedrock Runtime client in the AWS Region you want to use.
client = boto3.client("bedrock-runtime", region_name="us-east-1")
# Set the model ID, e.g., Mistral Large.
model_id = "mistral.mistral-large-2402-v1:0"
# Start a conversation with the user message.
user_message = "Describe the purpose of a 'hello world' program in one line."
conversation = [
{
"role": "user",
"content": [{"text": user_message}],
}
]
try:
# Send the message to the model, using a basic inference configuration.
streaming_response = client.converse_stream(
modelId=model_id,
messages=conversation,
inferenceConfig={"maxTokens": 512, "temperature": 0.5, "topP": 0.9},
)
# Extract and print the streamed response text in real-time.
for chunk in streaming_response["stream"]:
if "contentBlockDelta" in chunk:
text = chunk["contentBlockDelta"]["delta"]["text"]
print(text, end="")
except (ClientError, Exception) as e:
print(f"ERROR: Can't invoke '{model_id}'. Reason: {e}")
exit(1)
```
+ Untuk detail API, lihat [ConverseStream](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/ConverseStream)di *AWS SDK for Python (Boto3) Referensi* API.
------
# Kirim dan proses dokumen dengan model Mistral di Amazon Bedrock
Contoh kode berikut menunjukkan cara mengirim dan memproses dokumen dengan model Mistral di Amazon Bedrock.
------
#### [ Python ]
**SDK untuk Python (Boto3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Kirim dan proses dokumen dengan model Mistral di 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)
```
+ Untuk detail API, lihat [Converse](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/Converse) in *AWS SDK for Python (Boto3) Referensi* API.
------
# Memanggil model AI Mistral di Amazon Bedrock menggunakan API Model Invoke
Contoh kode berikut menunjukkan cara mengirim pesan teks ke model Mistral, menggunakan Invoke Model API.
------
#### [ .NET ]
**SDK untuk .NET**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime#code-examples).
Gunakan API Invoke Model untuk mengirim pesan teks.
```
// 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;
}
```
+ Untuk detail API, lihat [InvokeModel](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/InvokeModel)di *Referensi AWS SDK untuk .NET API*.
------
#### [ Java ]
**SDK untuk Java 2.x**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Gunakan API Invoke Model untuk mengirim pesan teks.
```
// 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();
}
}
```
+ Untuk detail API, lihat [InvokeModel](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModel)di *Referensi AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK untuk JavaScript (v3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/bedrock-runtime#code-examples).
Gunakan API Invoke Model untuk mengirim pesan teks.
```
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);
}
}
```
+ Untuk detail API, lihat [InvokeModel](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/bedrock-runtime/command/InvokeModelCommand)di *Referensi AWS SDK untuk JavaScript API*.
------
#### [ Python ]
**SDK untuk Python (Boto3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Gunakan API Invoke Model untuk mengirim pesan teks.
```
# 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)
```
+ Untuk detail API, lihat [InvokeModel](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModel)di *AWS SDK for Python (Boto3) Referensi* API.
------
# Panggil model AI Mistral di Amazon Bedrock menggunakan API Model Invoke dengan aliran respons
Contoh kode berikut menunjukkan cara mengirim pesan teks ke model AI Mistral, menggunakan API Model Invoke, dan mencetak aliran respons.
------
#### [ .NET ]
**SDK untuk .NET**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/Bedrock-runtime#code-examples).
Gunakan API Invoke Model untuk mengirim pesan teks dan memproses aliran respons secara real-time.
```
// Use the native inference API to send a text message to Mistral
// and print the response stream.
using System;
using System.IO;
using System.Text.Json;
using System.Text.Json.Nodes;
using Amazon;
using Amazon.BedrockRuntime;
using Amazon.BedrockRuntime.Model;
// Create a Bedrock Runtime client in the AWS Region you want to use.
var client = new AmazonBedrockRuntimeClient(RegionEndpoint.USEast1);
// Set the model ID, e.g., Mistral Large.
var modelId = "mistral.mistral-large-2402-v1:0";
// Define the prompt for the model.
var prompt = "Describe the purpose of a 'hello world' program in one line.";
// Embed the prompt in Mistral's instruction format.
var formattedPrompt = $"[INST] {prompt} [/INST]";
//Format the request payload using the model's native structure.
var nativeRequest = JsonSerializer.Serialize(new
{
prompt = formattedPrompt,
max_tokens = 512,
temperature = 0.5
});
// Create a request with the model ID and the model's native request payload.
var request = new InvokeModelWithResponseStreamRequest()
{
ModelId = modelId,
Body = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(nativeRequest)),
ContentType = "application/json"
};
try
{
// Send the request to the Bedrock Runtime and wait for the response.
var streamingResponse = await client.InvokeModelWithResponseStreamAsync(request);
// Extract and print the streamed response text in real-time.
foreach (var item in streamingResponse.Body)
{
var chunk = JsonSerializer.Deserialize((item as PayloadPart).Bytes);
var text = chunk["outputs"]?[0]?["text"] ?? "";
Console.Write(text);
}
}
catch (AmazonBedrockRuntimeException e)
{
Console.WriteLine($"ERROR: Can't invoke '{modelId}'. Reason: {e.Message}");
throw;
}
```
+ Untuk detail API, lihat [InvokeModelWithResponseStream](https://docs.aws.amazon.com/goto/DotNetSDKV3/bedrock-runtime-2023-09-30/InvokeModelWithResponseStream)di *Referensi AWS SDK untuk .NET API*.
------
#### [ Java ]
**SDK untuk Java 2.x**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Gunakan API Invoke Model untuk mengirim pesan teks dan memproses aliran respons secara real-time.
```
// Use the native inference API to send a text message to Mistral
// and print the response stream.
import org.json.JSONObject;
import org.json.JSONPointer;
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.core.SdkBytes;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.bedrockruntime.BedrockRuntimeAsyncClient;
import software.amazon.awssdk.services.bedrockruntime.model.InvokeModelWithResponseStreamRequest;
import software.amazon.awssdk.services.bedrockruntime.model.InvokeModelWithResponseStreamResponseHandler;
import java.util.concurrent.ExecutionException;
import static software.amazon.awssdk.services.bedrockruntime.model.InvokeModelWithResponseStreamResponseHandler.Visitor;
public class InvokeModelWithResponseStream {
public static String invokeModelWithResponseStream() {
// Create a Bedrock Runtime client in the AWS Region you want to use.
// Replace the DefaultCredentialsProvider with your preferred credentials provider.
var client = BedrockRuntimeAsyncClient.builder()
.credentialsProvider(DefaultCredentialsProvider.create())
.region(Region.US_EAST_1)
.build();
// Set the model ID, e.g., Mistral Large.
var modelId = "mistral.mistral-large-2402-v1:0";
// The InvokeModelWithResponseStream API uses the model's native payload.
// Learn more about the available inference parameters and response fields at:
// https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-mistral-text-completion.html
var nativeRequestTemplate = "{ \"prompt\": \"{{instruction}}\" }";
// Define the prompt for the model.
var prompt = "Describe the purpose of a 'hello world' program in one line.";
// Embed the prompt in Mistral's instruction format.
var instruction = "[INST] {{prompt}} [/INST]\\n".replace("{{prompt}}", prompt);
// Embed the instruction in the the native request payload.
var nativeRequest = nativeRequestTemplate.replace("{{instruction}}", instruction);
// Create a request with the model ID and the model's native request payload.
var request = InvokeModelWithResponseStreamRequest.builder()
.body(SdkBytes.fromUtf8String(nativeRequest))
.modelId(modelId)
.build();
// Prepare a buffer to accumulate the generated response text.
var completeResponseTextBuffer = new StringBuilder();
// Prepare a handler to extract, accumulate, and print the response text in real-time.
var responseStreamHandler = InvokeModelWithResponseStreamResponseHandler.builder()
.subscriber(Visitor.builder().onChunk(chunk -> {
// Extract and print the text from the model's native response.
var response = new JSONObject(chunk.bytes().asUtf8String());
var text = new JSONPointer("/outputs/0/text").queryFrom(response);
System.out.print(text);
// Append the text to the response text buffer.
completeResponseTextBuffer.append(text);
}).build()).build();
try {
// Send the request and wait for the handler to process the response.
client.invokeModelWithResponseStream(request, responseStreamHandler).get();
// Return the complete response text.
return completeResponseTextBuffer.toString();
} catch (ExecutionException | InterruptedException e) {
System.err.printf("Can't invoke '%s': %s", modelId, e.getCause().getMessage());
throw new RuntimeException(e);
}
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
invokeModelWithResponseStream();
}
}
```
+ Untuk detail API, lihat [InvokeModelWithResponseStream](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModelWithResponseStream)di *Referensi AWS SDK for Java 2.x API*.
------
#### [ Python ]
**SDK untuk Python (Boto3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Gunakan API Invoke Model untuk mengirim pesan teks dan memproses aliran respons secara real-time.
```
# Use the native inference API to send a text message to Mistral
# and print the response stream.
import boto3
import json
from botocore.exceptions import ClientError
# Create a Bedrock Runtime client in the AWS Region of your choice.
client = boto3.client("bedrock-runtime", region_name="us-east-1")
# Set the model ID, e.g., Mistral Large.
model_id = "mistral.mistral-large-2402-v1:0"
# Define the prompt for the model.
prompt = "Describe the purpose of a 'hello world' program in one line."
# Embed the prompt in Mistral's instruction format.
formatted_prompt = f"[INST] {prompt} [/INST]"
# Format the request payload using the model's native structure.
native_request = {
"prompt": formatted_prompt,
"max_tokens": 512,
"temperature": 0.5,
}
# Convert the native request to JSON.
request = json.dumps(native_request)
try:
# Invoke the model with the request.
streaming_response = client.invoke_model_with_response_stream(
modelId=model_id, body=request
)
# Extract and print the response text in real-time.
for event in streaming_response["body"]:
chunk = json.loads(event["chunk"]["bytes"])
if "outputs" in chunk:
print(chunk["outputs"][0].get("text"), end="")
except (ClientError, Exception) as e:
print(f"ERROR: Can't invoke '{model_id}''. Reason: {e}")
exit(1)
```
+ Untuk detail API, lihat [InvokeModelWithResponseStream](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModelWithResponseStream)di *AWS SDK for Python (Boto3) Referensi* API.
------
# Difusi Stabil untuk Runtime Amazon Bedrock
Contoh kode berikut menunjukkan cara menggunakan Amazon Bedrock Runtime dengan. AWS SDKs
**Topics**
+ [InvokeModel](bedrock-runtime_example_bedrock-runtime_InvokeModel_StableDiffusion_section.md)
# Panggil Stability.ai Stable Diffusion XL di Amazon Bedrock untuk menghasilkan gambar
Contoh kode berikut menunjukkan cara memanggil Stability.ai Stable Diffusion XL di Amazon Bedrock untuk menghasilkan gambar.
------
#### [ Java ]
**SDK untuk Java 2.x**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/bedrock-runtime#code-examples).
Buat gambar dengan Difusi Stabil.
```
// 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);
}
}
```
+ Untuk detail API, lihat [InvokeModel](https://docs.aws.amazon.com/goto/SdkForJavaV2/bedrock-runtime-2023-09-30/InvokeModel)di *Referensi AWS SDK for Java 2.x API*.
------
#### [ PHP ]
**SDK untuk PHP**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/bedrock-runtime#code-examples).
Buat gambar dengan Difusi Stabil.
```
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;
}
```
+ Untuk detail API, lihat [InvokeModel](https://docs.aws.amazon.com/goto/SdkForPHPV3/bedrock-runtime-2023-09-30/InvokeModel)di *Referensi AWS SDK untuk PHP API*.
------
#### [ Python ]
**SDK untuk Python (Boto3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/bedrock-runtime#code-examples).
Buat gambar dengan Difusi Stabil.
```
# 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}")
```
+ Untuk detail API, lihat [InvokeModel](https://docs.aws.amazon.com/goto/boto3/bedrock-runtime-2023-09-30/InvokeModel)di *AWS SDK for Python (Boto3) Referensi* API.
------
#### [ SAP ABAP ]
**SDK for SAP ABAP**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/bdr#code-examples).
Buat gambar dengan Difusi Stabil.
```
"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.
```
Panggil model pondasi Stability.ai Stable Diffusion XL untuk menghasilkan gambar menggunakan klien tingkat tinggi L2.
```
TRY.
DATA(lo_bdr_l2_sd) = /aws1/cl_bdr_l2_factory=>create_stable_diffusion_xl_1( lo_bdr ).
" iv_prompt contains a prompt like 'Show me a picture of a unicorn reading an enterprise financial report'.
DATA(lv_image) = lo_bdr_l2_sd->text_to_image( iv_prompt ).
CATCH /aws1/cx_bdraccessdeniedex INTO DATA(lo_ex).
WRITE / lo_ex->get_text( ).
WRITE / |Don't forget to enable model access at https://console.aws.amazon.com/bedrock/home?#/modelaccess|.
ENDTRY.
```
+ Untuk detail API, lihat [InvokeModel](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)di *AWS SDK untuk referensi SAP ABAP* API.
------