Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Kirim prompt dan hasilkan respons menggunakan API
Amazon Bedrock menawarkan operasi API berikut untuk melakukan inferensi model:
+ [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)— Kirim prompt dan hasilkan respons. Badan permintaan adalah model-spesifik. Untuk menghasilkan respons streaming, gunakan [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html).
+ [Converse](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html) — Kirim prompt dan hasilkan respons dengan struktur yang disatukan di semua model. Bidang permintaan khusus model dapat ditentukan di bidang. `additionalModelRequestFields` Anda juga dapat menyertakan prompt sistem dan percakapan sebelumnya untuk konteks. Untuk menghasilkan respons streaming, gunakan [ConverseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ConverseStream.html).
+ [StartAsyncInvoke](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_StartAsyncInvoke.html)— Kirim prompt dan hasilkan respons secara asinkron yang dapat diambil nanti. Digunakan untuk menghasilkan video.
+ [InvokeModelWithBidirectionalStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithBidirectionalStream.html) –
+ OpenAIAPI penyelesaian obrolan — Gunakan API [Penyelesaian OpenAI Obrolan](https://platform.openai.com/docs/api-reference/chat/create) dengan model yang didukung oleh Amazon Bedrock untuk menghasilkan respons.
**catatan**
Pembatasan berlaku untuk operasi berikut:`InvokeModel`,`InvokeModelWithResponseStream`,`Converse`, dan`ConverseStream`. Lihat [pembatasan API](inference-api-restrictions.md) untuk detailnya.
Untuk inferensi model, Anda perlu menentukan parameter berikut:
+ ID Model — ID atau Nama Sumber Daya Amazon (ARN) dari model atau profil inferensi yang akan digunakan di `modelId` bidang untuk inferensi. Tabel berikut menjelaskan cara menemukan IDs berbagai jenis sumber daya:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/bedrock/latest/userguide/inference-api.html)
+ Badan permintaan - Berisi parameter inferensi untuk model dan konfigurasi lainnya. Setiap model dasar memiliki parameter inferensi sendiri. Parameter inferensi untuk model khusus atau yang disediakan tergantung pada model dasar dari mana ia dibuat. Untuk informasi selengkapnya, lihat [Parameter permintaan inferensi dan bidang respons untuk model dasar](model-parameters.md).
Pilih topik untuk mempelajari cara menggunakan pemanggilan APIs model.
**Topics**
+ [Kirim satu prompt dengan InvokeModel](inference-invoke.md)
+ [Memanggil model dengan OpenAI Chat Completions API](inference-chat-completions.md)
+ [Melakukan percakapan dengan operasi Converse API](conversation-inference.md)
+ [Pembatasan API](inference-api-restrictions.md)
# Kirim satu prompt dengan InvokeModel
Anda menjalankan inferensi pada satu prompt dengan menggunakan operasi [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)dan [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)API dan menentukan model. Model Amazon Bedrock berbeda dalam apakah mereka menerima input teks, gambar, atau video dan apakah mereka dapat menghasilkan output teks, gambar, atau embeddings. Beberapa model dapat mengembalikan respons dalam aliran. Untuk memeriksa dukungan model untuk dukungan input, output, dan streaming, lakukan salah satu hal berikut:
+ Periksa nilai dalam modalitas **input, modalitas** **Output**, atau kolom yang **didukung Streaming** untuk model di. [Model pondasi yang didukung di Amazon Bedrock](models-supported.md)
+ Kirim [GetFoundationModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_GetFoundationModel.html)permintaan dengan ID model dan periksa nilai di `responseStreamingSupported` bidang `inputModalities``outputModalities`,, dan.
Jalankan inferensi model pada prompt dengan mengirimkan [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)atau [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)permintaan dengan titik akhir [runtime Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#br-rt).
**catatan**
Pembatasan berlaku untuk operasi berikut:`InvokeModel`,`InvokeModelWithResponseStream`,`Converse`, dan`ConverseStream`. Lihat [pembatasan API](inference-api-restrictions.md) untuk detailnya.
Bidang berikut diperlukan:
****
| Bidang | Kasus penggunaan |
| --- | --- |
| modelId | Untuk menentukan model, profil inferensi, atau prompt dari manajemen Prompt untuk digunakan. Untuk mempelajari cara menemukan nilai ini, lihat[Kirim prompt dan hasilkan respons menggunakan API](inference-api.md). |
| body | Untuk menentukan parameter inferensi untuk model. Untuk melihat parameter inferensi untuk model yang berbeda, lihat[Parameter permintaan inferensi dan bidang respons untuk model dasar](model-parameters.md). Jika Anda menentukan prompt dari manajemen Prompt di modelId bidang, hilangkan bidang ini (jika Anda memasukkannya, itu akan diabaikan). |
Bidang berikut adalah opsional:
****
| Bidang | Kasus penggunaan |
| --- | --- |
| menerima | Untuk menentukan jenis media untuk badan permintaan. Untuk informasi selengkapnya, lihat Jenis Media di [Swaggersitus web](https://swagger.io/specification/). |
| ContentType | Untuk menentukan jenis media untuk badan respons. Untuk informasi selengkapnya, lihat Jenis Media di [Swaggersitus web](https://swagger.io/specification/). |
| performanceConfigLatency | Untuk menentukan apakah akan mengoptimalkan model untuk latensi. Untuk informasi selengkapnya, lihat [Optimalkan inferensi model untuk latensi](latency-optimized-inference.md). |
| GuardraIlidentifier | Untuk menentukan pagar pembatas untuk diterapkan pada prompt dan respons. Untuk informasi selengkapnya, lihat [Uji pagar pembatas Anda](guardrails-test.md). |
| GuardrailVersion | Untuk menentukan pagar pembatas untuk diterapkan pada prompt dan respons. Untuk informasi selengkapnya, lihat [Uji pagar pembatas Anda](guardrails-test.md). |
| jejak | Untuk menentukan apakah akan mengembalikan jejak untuk pagar pembatas yang Anda tentukan. Untuk informasi selengkapnya, lihat [Uji pagar pembatas Anda](guardrails-test.md). |
| ServiceTier | Untuk menentukan tingkat layanan untuk permintaan. Untuk informasi selengkapnya, lihat [Tingkat layanan untuk mengoptimalkan kinerja dan biaya](service-tiers-inference.md). |
## Memanggil contoh kode model
Topik ini memberikan beberapa contoh dasar untuk menjalankan inferensi menggunakan satu prompt dengan [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)API. Untuk contoh lainnya dengan model yang berbeda, kunjungi sumber daya berikut:
+ Pilih contoh di bawah [Contoh kode untuk Amazon Bedrock Runtime menggunakan AWS SDKs](service_code_examples_bedrock-runtime.md) topik.
+ Kunjungi referensi parameter inferensi untuk model yang diinginkan di[Parameter permintaan inferensi dan bidang respons untuk model dasar](model-parameters.md).
Contoh berikut mengasumsikan bahwa Anda telah menyiapkan akses terprogram sehingga Anda secara otomatis mengautentikasi ke AWS CLI dan SDK for Python (Boto3) secara default ketika Anda menjalankan contoh ini. Wilayah AWS Untuk informasi tentang pengaturan akses pemrograman, lihat[Memulai dengan API](getting-started-api.md).
**catatan**
Tinjau poin-poin berikut sebelum mencoba contoh:
Anda harus menguji contoh-contoh ini di US East (Virginia N.) (us-east-1), yang mendukung semua model yang digunakan dalam contoh.
`body`Parameternya bisa besar, jadi untuk beberapa contoh CLI, Anda akan diminta untuk membuat file JSON dan memberikan file itu ke dalam `--body` argumen alih-alih menentukannya di baris perintah.
Untuk contoh gambar dan video, Anda akan diminta untuk menggunakan gambar dan video Anda sendiri. Contohnya mengasumsikan bahwa file gambar Anda diberi nama *image.png* dan file video Anda diberi nama*video.mp4*.
Anda mungkin harus mengonversi gambar atau video menjadi string yang dikodekan base64 atau mengunggahnya ke lokasi Amazon S3. Dalam contoh, Anda harus mengganti placeholder dengan string yang dikodekan base64 atau lokasi S3 yang sebenarnya.
Perluas bagian untuk mencoba beberapa contoh kode dasar.
### Hasilkan teks dengan prompt teks
Contoh berikut menghasilkan respons teks ke prompt teks menggunakan Titan Text Premier model Amazon. Pilih tab untuk metode pilihan Anda, lalu ikuti langkah-langkahnya:
------
#### [ CLI ]
Jalankan perintah berikut di terminal dan temukan respons yang dihasilkan dalam file bernama*invoke-model-output.txt*.
```
aws bedrock-runtime invoke-model \
--model-id amazon.titan-text-premier-v1:0 \
--body '{
"inputText": "Describe the purpose of a 'hello world' program in one line.",
"textGenerationConfig": {
"maxTokenCount": 512,
"temperature": 0.5
}
}' \
--cli-binary-format raw-in-base64-out \
invoke-model-output.txt
```
------
#### [ Python ]
Jalankan contoh kode Python berikut untuk menghasilkan respons 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)
```
------
### Hasilkan teks dengan prompt teks menggunakan tingkat layanan
Contoh berikut menghasilkan respons teks ke prompt teks menggunakan model OpenAI GPT dengan tingkat layanan untuk memprioritaskan permintaan. Pilih tab untuk metode pilihan Anda, lalu ikuti langkah-langkahnya:
------
#### [ CLI ]
Jalankan perintah berikut di terminal dan validasi tingkat layanan dalam respons.
```
aws bedrock-runtime invoke-model \
--model-id openai.gpt-oss-120b-1:0 \
--body '{
"messages": [
{
"role": "user",
"content": "Describe the purpose of a '\''hello world'\'' program in one line."
}
],
"max_tokens": 512,
"temperature": 0.7
}' \
--content-type application/json \
--accept application/json \
--service-tier priority \
--cli-binary-format raw-in-base64-out
```
------
#### [ Python ]
Jalankan contoh kode Python berikut untuk menghasilkan respons teks dengan tingkat layanan:
```
import boto3
import json
# Create a Bedrock Runtime client
bedrock_runtime = boto3.client(
service_name="bedrock-runtime",
region_name="us-east-1"
)
# Define the model ID and request body
model_id = "openai.gpt-oss-120b-1:0"
body = json.dumps({
"messages": [
{
"role": "user",
"content": "Describe the purpose of a 'hello world' program in one line."
}
],
"max_tokens": 512,
"temperature": 0.7
})
# Make the request with service tier
response = bedrock_runtime.invoke_model(
modelId=model_id,
body=body,
contentType="application/json",
accept="application/json",
serviceTier="priority"
)
# Parse and print the response
response_body = json.loads(response["body"])
print(response_body)
```
------
### Hasilkan gambar dengan prompt teks
Contoh kode berikut menghasilkan gambar menggunakan prompt teks dengan model Stable Diffusion XL 1.0. Pilih tab untuk metode pilihan Anda, lalu ikuti langkah-langkahnya:
------
#### [ CLI ]
Jalankan perintah berikut di terminal dan temukan respons yang dihasilkan dalam file bernama*invoke-model-output.txt*. Byte yang mewakili gambar dapat ditemukan di `base64` bidang dalam respons:
```
aws bedrock-runtime invoke-model \
--model-id stability.stable-diffusion-xl-v1 \
--body '{
"text_prompts": [{"text": "A stylized picture of a cute old steampunk robot."}],
"style_preset": "photographic",
"seed": 0,
"cfg_scale": 10,
"steps": 30
}' \
--cli-binary-format raw-in-base64-out \
invoke-model-output.txt
```
------
#### [ Python ]
Jalankan contoh kode Python berikut untuk menghasilkan gambar dan menemukan file *stability\$11.png* gambar yang dihasilkan dalam folder bernama. *output*
```
# 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}")
```
------
### Hasilkan embeddings dari teks
Contoh berikut menggunakan Titan Text Embeddings V2 model Amazon untuk menghasilkan embeddings biner untuk input teks. Pilih tab untuk metode pilihan Anda, lalu ikuti langkah-langkahnya:
------
#### [ CLI ]
Jalankan perintah berikut di terminal dan temukan respons yang dihasilkan dalam file bernama*invoke-model-output.txt*. Embeddings yang dihasilkan ada di lapangan. `binary`
```
aws bedrock-runtime invoke-model \
--model-id amazon.titan-embed-text-v2:0 \
--body '{
"inputText": "What are the different services that you offer?",
"embeddingTypes": ["binary"]
}' \
--cli-binary-format raw-in-base64-out \
invoke-model-output.txt
```
------
#### [ Python ]
Jalankan contoh kode Python berikut untuk menghasilkan embeddings untuk teks yang disediakan:
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate an embedding with the Amazon Titan Text Embeddings V2 Model
"""
import json
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_embedding(model_id, body):
"""
Generate an embedding with the vector representation of a text input using Amazon Titan Text Embeddings G1 on demand.
Args:
model_id (str): The model ID to use.
body (str) : The request body to use.
Returns:
response (JSON): The embedding created by the model and the number of input tokens.
"""
logger.info("Generating an embedding with Amazon Titan Text Embeddings V2 model %s", model_id)
bedrock = boto3.client(service_name='bedrock-runtime')
accept = "application/json"
content_type = "application/json"
response = bedrock.invoke_model(
body=body, modelId=model_id, accept=accept, contentType=content_type
)
response_body = json.loads(response.get('body').read())
return response_body
def main():
"""
Entrypoint for Amazon Titan Embeddings V2 - Text example.
"""
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
model_id = "amazon.titan-embed-text-v2:0"
input_text = "What are the different services that you offer?"
# Create request body.
body = json.dumps({
"inputText": input_text,
"embeddingTypes": ["binary"]
})
try:
response = generate_embedding(model_id, body)
print(f"Generated an embedding: {response['embeddingsByType']['binary']}") # returns binary embedding
print(f"Input text: {input_text}")
print(f"Input Token count: {response['inputTextTokenCount']}")
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occured: " +
format(message))
else:
print(f"Finished generating an embedding with Amazon Titan Text Embeddings V2 model {model_id}.")
if __name__ == "__main__":
main()
```
------
### Hasilkan embeddings dari gambar
Contoh berikut menggunakan Titan Multimodal Embeddings G1 model Amazon untuk menghasilkan embeddings untuk input gambar. Pilih tab untuk metode pilihan Anda, lalu ikuti langkah-langkahnya:
------
#### [ CLI ]
Buka terminal dan lakukan hal berikut:
1. Ubah gambar berjudul *image.png* di folder Anda saat ini menjadi string yang dikodekan base64 dan tulis ke file berjudul dengan menjalankan perintah berikut*image.txt*:
```
base64 -i image.png -o image.txt
```
1. Buat file JSON yang disebut *image-input-embeddings-output.json* dan tempel JSON berikut, ganti *\$1\$1image-base64\$1* dengan isi *image.txt* file (pastikan tidak ada baris baru di akhir string):
```
{
"inputImage": "${image-base64}",
"embeddingConfig": {
"outputEmbeddingLength": 256
}
}
```
1. Jalankan perintah berikut, tentukan *image-input-embeddings-output.json* file sebagai tubuh.
```
aws bedrock-runtime invoke-model \
--model-id amazon.titan-embed-image-v1 \
--body file://image-input-embeddings-output.json \
--cli-binary-format raw-in-base64-out \
invoke-model-output.txt
```
1. Temukan embeddings yang dihasilkan dalam file. *invoke-model-output.txt*
------
#### [ Python ]
Dalam skrip Python berikut, ganti */path/to/image* dengan jalur ke gambar yang sebenarnya. Kemudian jalankan skrip untuk menghasilkan embeddings:
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate embeddings from an image with the Amazon Titan Multimodal Embeddings G1 model (on demand).
"""
import base64
import json
import logging
import boto3
from botocore.exceptions import ClientError
class EmbedError(Exception):
"Custom exception for errors returned by Amazon Titan Multimodal Embeddings G1"
def __init__(self, message):
self.message = message
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_embeddings(model_id, body):
"""
Generate a vector of embeddings for an image input using Amazon Titan Multimodal Embeddings G1 on demand.
Args:
model_id (str): The model ID to use.
body (str) : The request body to use.
Returns:
response (JSON): The embeddings that the model generated, token information, and the
reason the model stopped generating embeddings.
"""
logger.info("Generating embeddings with Amazon Titan Multimodal Embeddings G1 model %s", model_id)
bedrock = boto3.client(service_name='bedrock-runtime')
accept = "application/json"
content_type = "application/json"
response = bedrock.invoke_model(
body=body, modelId=model_id, accept=accept, contentType=content_type
)
response_body = json.loads(response.get('body').read())
finish_reason = response_body.get("message")
if finish_reason is not None:
raise EmbedError(f"Embeddings generation error: {finish_reason}")
return response_body
def main():
"""
Entrypoint for Amazon Titan Multimodal Embeddings G1 example.
"""
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
# Read image from file and encode it as base64 string.
with open("/path/to/image", "rb") as image_file:
input_image = base64.b64encode(image_file.read()).decode('utf8')
model_id = 'amazon.titan-embed-image-v1'
output_embedding_length = 256
# Create request body.
body = json.dumps({
"inputImage": input_image,
"embeddingConfig": {
"outputEmbeddingLength": output_embedding_length
}
})
try:
response = generate_embeddings(model_id, body)
print(f"Generated image embeddings of length {output_embedding_length}: {response['embedding']}")
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occured: " +
format(message))
except EmbedError as err:
logger.error(err.message)
print(err.message)
else:
print(f"Finished generating image embeddings with Amazon Titan Multimodal Embeddings G1 model {model_id}.")
if __name__ == "__main__":
main()
```
------
### Hasilkan respons teks ke gambar dengan prompt teks yang menyertainya
Pilih tab untuk metode pilihan Anda, lalu ikuti langkah-langkahnya:
------
#### [ CLI ]
Contoh berikut menggunakan Anthropic Claude 3 Haiku model untuk menghasilkan respons, diberikan gambar dan prompt teks yang menanyakan isi gambar. Buka terminal dan lakukan hal berikut:
1. Ubah gambar berjudul *image.png* di folder Anda saat ini menjadi string yang dikodekan base64 dan tulis ke file berjudul dengan menjalankan perintah berikut*image.txt*:
```
base64 -i image.png -o image.txt
```
1. Buat file JSON yang disebut *image-text-input.json* dan tempel JSON berikut, ganti *\$1\$1image-base64\$1* dengan isi *image.txt* file (pastikan tidak ada baris baru di akhir string):
```
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 1000,
"messages": [
{
"role": "user",
"content": [
{
"type": "image",
"source": {
"type": "base64",
"media_type": "image/png",
"data": "${image-base64}"
}
},
{
"type": "text",
"text": "What's in this image?"
}
]
}
]
}
```
1. Jalankan perintah berikut untuk menghasilkan output teks, berdasarkan gambar dan prompt teks yang menyertainya, ke file bernama: *invoke-model-output.txt*
```
aws bedrock-runtime invoke-model \
--model-id anthropic.claude-3-haiku-20240307-v1:0 \
--body file://image-text-input.json \
--cli-binary-format raw-in-base64-out \
invoke-model-output.txt
```
1. Temukan output dalam *invoke-model-output.txt* file di folder saat ini.
------
#### [ Python ]
Dalam skrip python berikut, ganti */path/to/image.png* dengan jalur aktual ke gambar sebelum menjalankan skrip:
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to run a multimodal prompt with Anthropic Claude (on demand) and InvokeModel.
"""
import json
import logging
import base64
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def run_multi_modal_prompt(bedrock_runtime, model_id, messages, max_tokens):
"""
Invokes a model with a multimodal prompt.
Args:
bedrock_runtime: The Amazon Bedrock boto3 client.
model_id (str): The model ID to use.
messages (JSON) : The messages to send to the model.
max_tokens (int) : The maximum number of tokens to generate.
Returns:
None.
"""
body = json.dumps(
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": max_tokens,
"messages": messages
}
)
response = bedrock_runtime.invoke_model(
body=body, modelId=model_id)
response_body = json.loads(response.get('body').read())
return response_body
def main():
"""
Entrypoint for Anthropic Claude multimodal prompt example.
"""
try:
bedrock_runtime = boto3.client(service_name='bedrock-runtime')
model_id = 'anthropic.claude-3-sonnet-20240229-v1:0'
max_tokens = 1000
input_text = "What's in this image?"
input_image = "/path/to/image" # Replace with actual path to image file
# Read reference image from file and encode as base64 strings.
image_ext = input_image.split(".")[-1]
with open(input_image, "rb") as image_file:
content_image = base64.b64encode(image_file.read()).decode('utf8')
message = {
"role": "user",
"content": [
{
"type": "image",
"source": {
"type": "base64",
"media_type": f"image/{image_ext}",
"data": content_image
}
},
{
"type": "text",
"text": input_text
}
]
}
messages = [message]
response = run_multi_modal_prompt(
bedrock_runtime, model_id, messages, max_tokens)
print(json.dumps(response, indent=4))
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occurred: " +
format(message))
if __name__ == "__main__":
main()
```
------
### Hasilkan respons teks ke video yang diunggah ke Amazon S3 dengan prompt teks yang menyertainya
Contoh berikut menunjukkan cara menghasilkan respons dengan Amazon Nova Lite model, mengingat video yang Anda unggah ke bucket S3 dan prompt teks yang menyertainya.
**Prasyarat:** Unggah video berjudul bucket *video.mp4* Amazon S3 di akun Anda dengan mengikuti langkah-langkah di Mengunggah [objek di](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html#upload-objects-procedure) Panduan Pengguna Layanan Penyimpanan Sederhana Amazon. Catat URI S3 dari video tersebut.
Pilih tab untuk metode pilihan Anda, lalu ikuti langkah-langkahnya:
------
#### [ CLI ]
Buka terminal dan jalankan perintah berikut, ganti *s3://amzn-s3-demo-bucket/video.mp4* dengan lokasi S3 sebenarnya dari video Anda:
```
aws bedrock-runtime invoke-model \
--model-id amazon.nova-lite-v1:0 \
--body '{
"messages": [
{
"role": "user",
"content": [
{
"video": {
"format": "mp4",
"source": {
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/video.mp4"
}
}
}
},
{
"text": "What happens in this video?"
}
]
}
]
}' \
--cli-binary-format raw-in-base64-out \
invoke-model-output.txt
```
Temukan output dalam *invoke-model-output.txt* file di folder saat ini.
------
#### [ Python ]
Dalam skrip Python berikut, ganti *s3://amzn-s3-demo-bucket/video.mp4* dengan lokasi S3 sebenarnya dari video Anda. Kemudian jalankan skrip:
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to run a multimodal prompt with Nova Lite (on demand) and InvokeModel.
"""
import json
import logging
import base64
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def run_multi_modal_prompt(bedrock_runtime, model_id, messages, max_tokens):
"""
Invokes a model with a multimodal prompt.
Args:
bedrock_runtime: The Amazon Bedrock boto3 client.
model_id (str): The model ID to use.
messages (JSON) : The messages to send to the model.
max_tokens (int) : The maximum number of tokens to generate.
Returns:
None.
"""
body = json.dumps(
{
"messages": messages,
"inferenceConfig": {
"maxTokens": max_tokens
}
}
)
response = bedrock_runtime.invoke_model(
body=body, modelId=model_id)
response_body = json.loads(response.get('body').read())
return response_body
def main():
"""
Entrypoint for Nova Lite video prompt example.
"""
try:
bedrock_runtime = boto3.client(service_name='bedrock-runtime')
model_id = "amazon.nova-lite-v1:0"
max_tokens = 1000
input_video_s3_uri = "s3://amzn-s3-demo-bucket/video.mp4" # Replace with real S3 URI
video_ext = input_video_s3_uri.split(".")[-1]
input_text = "What happens in this video?"
message = {
"role": "user",
"content": [
{
"video": {
"format": video_ext,
"source": {
"s3Location": {
"uri": input_video_s3_uri
}
}
}
},
{
"text": input_text
}
]
}
messages = [message]
response = run_multi_modal_prompt(
bedrock_runtime, model_id, messages, max_tokens)
print(json.dumps(response, indent=4))
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occured: " +
format(message))
if __name__ == "__main__":
main()
```
------
### Hasilkan respons teks ke video yang dikonversi ke string berenkode base64 dengan prompt teks yang menyertainya
Contoh berikut menunjukkan cara menghasilkan respons dengan Amazon Nova Lite model, mengingat video yang dikonversi ke string yang dikodekan base64 dan prompt teks yang menyertainya. Pilih tab untuk metode pilihan Anda, lalu ikuti langkah-langkahnya:
------
#### [ CLI ]
Lakukan hal-hal berikut:
1. Ubah video berjudul *video.mp4* di folder Anda saat ini menjadi base64 dengan menjalankan perintah berikut:
```
base64 -i video.mp4 -o video.txt
```
1. Buat file JSON bernama *video-text-input.json* dan tempel JSON berikut, ganti *\$1\$1video-base64\$1* dengan isi `video.txt` file (pastikan tidak ada baris baru di akhir):
```
{
"messages": [
{
"role": "user",
"content": [
{
"video": {
"format": "mp4",
"source": {
"bytes": ${video-base64}
}
}
},
{
"text": "What happens in this video?"
}
]
}
]
}
```
1. Jalankan perintah berikut untuk menghasilkan output teks berdasarkan video dan prompt teks yang menyertainya ke file bernama: *invoke-model-output.txt*
```
aws bedrock-runtime invoke-model \
--model-id amazon.nova-lite-v1:0 \
--body file://video-text-input.json \
--cli-binary-format raw-in-base64-out \
invoke-model-output.txt
```
1. Temukan output dalam *invoke-model-output.txt* file di folder saat ini.
------
#### [ Python ]
Dalam skrip Python berikut, ganti */path/to/video.mp4* dengan jalur sebenarnya ke video. Kemudian jalankan skrip:
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to run a multimodal prompt with Nova Lite (on demand) and InvokeModel.
"""
import json
import logging
import base64
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def run_multi_modal_prompt(bedrock_runtime, model_id, messages, max_tokens):
"""
Invokes a model with a multimodal prompt.
Args:
bedrock_runtime: The Amazon Bedrock boto3 client.
model_id (str): The model ID to use.
messages (JSON) : The messages to send to the model.
max_tokens (int) : The maximum number of tokens to generate.
Returns:
None.
"""
body = json.dumps(
{
"messages": messages,
"inferenceConfig": {
"maxTokens": max_tokens
}
}
)
response = bedrock_runtime.invoke_model(
body=body, modelId=model_id)
response_body = json.loads(response.get('body').read())
return response_body
def main():
"""
Entrypoint for Nova Lite video prompt example.
"""
try:
bedrock_runtime = boto3.client(service_name='bedrock-runtime')
model_id = "amazon.nova-lite-v1:0"
max_tokens = 1000
input_video = "/path/to/video.mp4" # Replace with real path to video
video_ext = input_video.split(".")[-1]
input_text = "What happens in this video?"
# Read reference video from file and encode as base64 string.
with open(input_video, "rb") as video_file:
content_video = base64.b64encode(video_file.read()).decode('utf8')\
message = {
"role": "user",
"content": [
{
"video": {
"format": video_ext,
"source": {
"bytes": content_video
}
}
},
{
"text": input_text
}
]
}
messages = [message]
response = run_multi_modal_prompt(
bedrock_runtime, model_id, messages, max_tokens)
print(json.dumps(response, indent=4))
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occured: " +
format(message))
if __name__ == "__main__":
main()
```
------
## Memanggil model dengan contoh kode streaming
**catatan**
AWS CLI Tidak mendukung streaming.
Contoh berikut menunjukkan cara menggunakan [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)API untuk menghasilkan teks streaming dengan Python menggunakan prompt. *write an essay for living on mars in 1000 words*
```
import boto3
import json
brt = boto3.client(service_name='bedrock-runtime')
body = json.dumps({
'prompt': '\n\nHuman: write an essay for living on mars in 1000 words\n\nAssistant:',
'max_tokens_to_sample': 4000
})
response = brt.invoke_model_with_response_stream(
modelId='anthropic.claude-v2',
body=body
)
stream = response.get('body')
if stream:
for event in stream:
chunk = event.get('chunk')
if chunk:
print(json.loads(chunk.get('bytes').decode()))
```
# Memanggil model dengan OpenAI Chat Completions API
Anda dapat menjalankan inferensi model menggunakan [OpenAICreate chat completion API](https://platform.openai.com/docs/api-reference/chat/create) dengan model Amazon Bedrock.
Anda dapat memanggil Create chat completion API dengan cara berikut:
+ Buat permintaan HTTP dengan endpoint Amazon Bedrock Runtime.
+ Gunakan permintaan OpenAI SDK dengan titik akhir Amazon Bedrock Runtime.
Pilih topik untuk mempelajari lebih lanjut:
**Topics**
+ [Model dan Wilayah yang didukung untuk API Penyelesaian OpenAI Obrolan](#inference-chat-completions-supported)
+ [Prasyarat untuk menggunakan API Penyelesaian Obrolan](#inference-chat-completions-prereq)
+ [Buat penyelesaian obrolan](#inference-chat-completions-create)
+ [Sertakan pagar pembatas dalam penyelesaian obrolan](#inference-chat-completions-guardrails)
## Model dan Wilayah yang didukung untuk API Penyelesaian OpenAI Obrolan
Anda dapat menggunakan API penyelesaian obrolan Buat dengan semua OpenAI model yang didukung di Amazon Bedrock dan di AWS Wilayah yang mendukung model ini. Untuk informasi selengkapnya tentang model dan wilayah yang didukung, lihat[Model pondasi yang didukung di Amazon Bedrock](models-supported.md).
## Prasyarat untuk menggunakan API Penyelesaian Obrolan
Untuk melihat prasyarat untuk menggunakan API Penyelesaian Obrolan, pilih tab untuk metode pilihan Anda, lalu ikuti langkah-langkahnya:
------
#### [ OpenAI SDK ]
+ **Otentikasi** — OpenAI SDK hanya mendukung otentikasi dengan kunci Amazon Bedrock API. Buat kunci Amazon Bedrock API untuk mengautentikasi permintaan Anda. Untuk mempelajari kunci Amazon Bedrock API dan cara membuatnya, lihat bagian Kunci API di chapter Build.
+ **Endpoint** — Temukan titik akhir yang sesuai dengan AWS Wilayah yang akan digunakan di titik akhir dan kuota [Amazon Bedrock Runtime](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#br-rt). Jika Anda menggunakan AWS SDK, Anda mungkin hanya perlu menentukan kode wilayah dan bukan seluruh titik akhir saat menyiapkan klien.
+ **Menginstal OpenAI SDK** — Untuk informasi selengkapnya, lihat [Pustaka](https://platform.openai.com/docs/libraries) dalam dokumentasi. OpenAI
------
#### [ HTTP request ]
+ **Otentikasi** - Anda dapat mengautentikasi dengan AWS kredensi Anda atau dengan kunci Amazon Bedrock API.
Siapkan AWS kredensi Anda atau buat kunci Amazon Bedrock API untuk mengautentikasi permintaan Anda.
+ Untuk mempelajari cara menyiapkan AWS kredensil Anda, lihat [Akses terprogram dengan AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/security-creds-programmatic-access.html) kredensial keamanan.
+ Untuk mempelajari kunci Amazon Bedrock API dan cara membuatnya, lihat bagian Kunci API di chapter Build.
+ **Endpoint** — Temukan titik akhir yang sesuai dengan AWS Wilayah yang akan digunakan di titik akhir dan kuota [Amazon Bedrock Runtime](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#br-rt). Jika Anda menggunakan AWS SDK, Anda mungkin hanya perlu menentukan kode wilayah dan bukan seluruh titik akhir saat menyiapkan klien.
------
## Buat penyelesaian obrolan
Lihat sumber daya berikut dalam OpenAI dokumentasi untuk detail tentang Create chat completion API:
+ [Minta parameter tubuh](https://platform.openai.com/docs/api-reference/chat/create)
+ [Parameter tubuh respons](https://platform.openai.com/docs/api-reference/chat/object)
**catatan**
Amazon Bedrock saat ini tidak mendukung operasi API penyelesaian OpenAI Obrolan lainnya.
Untuk mempelajari cara menggunakan OpenAI Create chat completion API, pilih tab untuk metode pilihan Anda, lalu ikuti langkah-langkahnya:
------
#### [ OpenAI SDK (Python) ]
Untuk membuat penyelesaian obrolan dengan OpenAI SDK, lakukan hal berikut:
1. Impor OpenAI SDK dan atur klien dengan bidang berikut:
+ `base_url`— Awali titik akhir Amazon Bedrock Runtime ke`/openai/v1`, seperti dalam format berikut:
```
https://${bedrock-runtime-endpoint}/openai/v1
```
+ `api_key`— Tentukan kunci API Amazon Bedrock.
+ `default_headers`— Jika Anda perlu menyertakan header apa pun, Anda dapat memasukkannya sebagai pasangan kunci-nilai dalam objek ini. Anda juga dapat menentukan header di `extra_headers` saat melakukan panggilan API tertentu.
1. Gunakan `chat.completions.create()` metode dengan klien dan tentukan secara minimal `model` dan `messages` di badan permintaan.
Contoh berikut memanggil Create chat completion API di`us-west-2`. Ganti *\$1AWS\$1BEARER\$1TOKEN\$1BEDROCK* dengan kunci API Anda yang sebenarnya.
```
from openai import OpenAI
client = OpenAI(
base_url="https://bedrock-runtime.us-west-2.amazonaws.com/openai/v1",
api_key="$AWS_BEARER_TOKEN_BEDROCK" # Replace with actual API key
)
completion = client.chat.completions.create(
model="openai.gpt-oss-20b-1:0",
messages=[
{
"role": "developer",
"content": "You are a helpful assistant."
},
{
"role": "user",
"content": "Hello!"
}
]
)
print(completion.choices[0].message)
```
------
#### [ HTTP request ]
Untuk membuat penyelesaian obrolan dengan permintaan HTTTP langsung, lakukan hal berikut:
1. Tentukan URL dengan mengawali titik akhir Amazon Bedrock Runtime ke`/openai/v1/chat/completions`, seperti dalam format berikut:
```
https://${bedrock-runtime-endpoint}/openai/v1/chat/completions
```
1. Tentukan AWS kredensil Anda atau kunci Amazon Bedrock API di header. `Authorization`
1. Di badan permintaan, tentukan setidaknya `model` dan `messages` di badan permintaan.
Contoh berikut menggunakan curl untuk memanggil Create chat completion API di`us-west-2`. Ganti *\$1AWS\$1BEARER\$1TOKEN\$1BEDROCK* dengan kunci API Anda yang sebenarnya:
```
curl -X POST https://bedrock-runtime.us-west-2.amazonaws.com/openai/v1/chat/completions \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $AWS_BEARER_TOKEN_BEDROCK" \
-d '{
"model": "openai.gpt-oss-20b-1:0",
"messages": [
{
"role": "developer",
"content": "You are a helpful assistant."
},
{
"role": "user",
"content": "Hello!"
}
]
}'
```
------
## Sertakan pagar pembatas dalam penyelesaian obrolan
Untuk menyertakan perlindungan dalam input dan respons model, terapkan [pagar pembatas](guardrails.md) saat menjalankan pemanggilan model dengan menyertakan [parameter tambahan](https://github.com/openai/openai-python#undocumented-request-params) berikut sebagai bidang di badan permintaan:
+ `extra_headers`— Peta ke objek yang berisi bidang berikut, yang menentukan header tambahan dalam permintaan:
+ `X-Amzn-Bedrock-GuardrailIdentifier`(wajib) — ID pagar pembatas.
+ `X-Amzn-Bedrock-GuardrailVersion`(wajib) — Versi pagar pembatas.
+ `X-Amzn-Bedrock-Trace`(opsional) - Apakah akan mengaktifkan jejak pagar pembatas atau tidak.
+ `extra_body`— Peta ke suatu objek. Dalam objek itu, Anda dapat menyertakan `amazon-bedrock-guardrailConfig` bidang, yang memetakan ke objek yang berisi bidang berikut:
+ `tagSuffix`(opsional) - Sertakan bidang ini untuk [penandaan input](guardrails-tagging.md).
Untuk informasi selengkapnya tentang parameter ini di Amazon Bedrock Guardrails, lihat. [Uji pagar pembatas Anda](guardrails-test.md)
Untuk melihat contoh penggunaan pagar pembatas dengan penyelesaian OpenAI obrolan, pilih tab untuk metode pilihan Anda, lalu ikuti langkah-langkahnya:
------
#### [ OpenAI SDK (Python) ]
```
import openai
from openai import OpenAIError
# Endpoint for Amazon Bedrock Runtime
bedrock_endpoint = "https://bedrock-runtime.us-west-2.amazonaws.com/openai/v1"
# Model ID
model_id = "openai.gpt-oss-20b-1:0"
# Replace with actual values
bedrock_api_key = "$AWS_BEARER_TOKEN_BEDROCK"
guardrail_id = "GR12345"
guardrail_version = "DRAFT"
client = openai.OpenAI(
api_key=bedrock_api_key,
base_url=bedrock_endpoint,
)
try:
response = client.chat.completions.create(
model=model_id,
# Specify guardrail information in the header
extra_headers={
"X-Amzn-Bedrock-GuardrailIdentifier": guardrail_id,
"X-Amzn-Bedrock-GuardrailVersion": guardrail_version,
"X-Amzn-Bedrock-Trace": "ENABLED",
},
# Additional guardrail information can be specified in the body
extra_body={
"amazon-bedrock-guardrailConfig": {
"tagSuffix": "xyz" # Used for input tagging
}
},
messages=[
{
"role": "system",
"content": "You are a helpful assistant."
},
{
"role": "assistant",
"content": "Hello! How can I help you today?"
},
{
"role": "user",
"content": "What is the weather like today?"
}
]
)
request_id = response._request_id
print(f"Request ID: {request_id}")
print(response)
except OpenAIError as e:
print(f"An error occurred: {e}")
if hasattr(e, 'response') and e.response is not None:
request_id = e.response.headers.get("x-request-id")
print(f"Request ID: {request_id}")
```
------
#### [ OpenAI SDK (Java) ]
```
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.core.http.HttpResponseFor;
import com.openai.models.chat.completions.ChatCompletion;
import com.openai.models.chat.completions.ChatCompletionCreateParams;
// Endpoint for Amazon Bedrock Runtime
String bedrockEndpoint = "http://bedrock-runtime.us-west-2.amazonaws.com/openai/v1"
// Model ID
String modelId = "openai.gpt-oss-20b-1:0"
// Replace with actual values
String bedrockApiKey = "$AWS_BEARER_TOKEN_BEDROCK"
String guardrailId = "GR12345"
String guardrailVersion = "DRAFT"
OpenAIClient client = OpenAIOkHttpClient.builder()
.apiKey(bedrockApiKey)
.baseUrl(bedrockEndpoint)
.build()
ChatCompletionCreateParams request = ChatCompletionCreateParams.builder()
.addUserMessage("What is the temperature in Seattle?")
.model(modelId)
// Specify additional headers for the guardrail
.putAdditionalHeader("X-Amzn-Bedrock-GuardrailIdentifier", guardrailId)
.putAdditionalHeader("X-Amzn-Bedrock-GuardrailVersion", guardrailVersion)
// Specify additional body parameters for the guardrail
.putAdditionalBodyProperty(
"amazon-bedrock-guardrailConfig",
JsonValue.from(Map.of("tagSuffix", JsonValue.of("xyz"))) // Allows input tagging
)
.build();
HttpResponseFor rawChatCompletionResponse =
client.chat().completions().withRawResponse().create(request);
final ChatCompletion chatCompletion = rawChatCompletionResponse.parse();
System.out.println(chatCompletion);
```
------
# Melakukan percakapan dengan operasi Converse API
Anda dapat menggunakan Amazon Bedrock Converse API untuk membuat aplikasi percakapan yang mengirim dan menerima pesan ke dan dari model Amazon Bedrock. Misalnya, Anda dapat membuat bot obrolan yang mempertahankan percakapan dalam banyak putaran dan menggunakan penyesuaian persona atau nada yang unik untuk kebutuhan Anda, seperti asisten dukungan teknis yang membantu.
Untuk menggunakan Converse API, Anda menggunakan operasi [Converse](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html) atau [ConverseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ConverseStream.html)(untuk respons streaming) untuk mengirim pesan ke model. Dimungkinkan untuk menggunakan operasi inferensi dasar yang ada ([InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)atau [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)) untuk aplikasi percakapan. Namun, sebaiknya gunakan Converse API karena menyediakan API yang konsisten, yang berfungsi dengan semua model Amazon Bedrock yang mendukung pesan. Ini berarti Anda dapat menulis kode sekali dan menggunakannya dengan model yang berbeda. Jika model memiliki parameter inferensi yang unik, Converse API juga memungkinkan Anda untuk meneruskan parameter unik tersebut dalam struktur khusus model.
Anda dapat menggunakan Converse API untuk mengimplementasikan [penggunaan alat](tool-use.md) dan [pagar pembatas dalam aplikasi](guardrails-use-converse-api.md) Anda.
**catatan**
Dengan Mistral AI dan Meta model, Converse API menyematkan input Anda dalam template prompt khusus model yang memungkinkan percakapan.
Pembatasan berlaku untuk operasi berikut:`InvokeModel`,`InvokeModelWithResponseStream`,`Converse`, dan`ConverseStream`. Lihat [pembatasan API](inference-api-restrictions.md) untuk detailnya.
Untuk contoh kode, lihat berikut ini:
+ PythonContoh untuk topik ini — [ConverseContoh API](conversation-inference-examples.md)
+ Berbagai bahasa dan model — [Contoh kode untuk Amazon Bedrock Runtime menggunakan AWS SDKs](service_code_examples_bedrock-runtime.md)
+ Tutorial [Java - Panduan pengembang Java untuk API baru Converse Bedrock](https://community.aws/content/2hUiEkO83hpoGF5nm3FWrdfYvPt/amazon-bedrock-converse-api-java-developer-guide)
+ JavaScript tutorial — [Panduan pengembang untuk API baru Converse Bedrock](https://community.aws/content/2dtauBCeDa703x7fDS9Q30MJoBA/amazon-bedrock-converse-api-developer-guide)
**Topics**
+ [Model dan fitur model yang didukung](conversation-inference-supported-models-features.md)
+ [Menggunakan API Converse ini](conversation-inference-call.md)
+ [ConverseContoh API](conversation-inference-examples.md)
# Model dan fitur model yang didukung
ConverseAPI mendukung model dan fitur model Amazon Bedrock berikut. ConverseAPI tidak mendukung model penyematan atau pembuatan gambar apa pun.
| Model | Bercakap | ConverseStream | Permintaan sistem | Obrolan dokumen | Visi | Penggunaan alat | Penggunaan alat streaming | Pagar pembatas | Tautan Amazon S3 untuk multimedia |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| AI21 Jamba-Instruct | Ya | Ya | Ya | Tidak | Tidak | Tidak | Tidak | Tidak | Tidak |
| AI21 LabsJurassic-2(Teks) | Terbatas. Tidak ada dukungan obrolan. | Tidak | Tidak | Tidak | Tidak | Tidak | Tidak | Ya | Tidak |
| AI21 Labs Jamba 1.5 Large | Ya | Ya | Ya | Ya | Tidak | Ya | Ya | Ya | Tidak |
| AI21 Labs Jamba 1.5 Mini | Ya | Ya | Ya | Ya | Tidak | Ya | Ya | Ya | Tidak |
| Amazon Nova Premier | Ya | Ya | Ya | Ya | Ya | Ya | Ya | Ya | Ya |
| Amazon Nova Pro | Ya | Ya | Ya | Ya | Ya | Ya | Ya | Ya | Ya |
| Amazon Nova Lite | Ya | Ya | Ya | Ya | Ya | Ya | Ya | Ya | Ya |
| Amazon Nova Micro | Ya | Ya | Ya | Tidak | Tidak | Ya | Ya | Ya | Tidak |
| TitanModel Amazon | Ya | Ya | Tidak | Ya (kecualiTitan Text Premier) | Tidak | Tidak | Tidak | Ya | Tidak |
| AnthropicClaude2.x dan model sebelumnya | Ya | Ya | Ya | Ya | Tidak | Tidak | Tidak | Ya | Tidak |
| AnthropicClaude3 model | Ya | Ya | Ya | Ya | Ya | Ya | Ya | Ya | Tidak |
| Anthropic Claude 3.5 Sonnet | Ya | Ya | Ya | Ya | Ya | Ya | Ya | Ya | Tidak |
| AnthropicClaude 3.5 Sonnetv2 | Ya | Ya | Ya | Ya | Ya | Ya | Ya | Ya | Tidak |
| Anthropic Claude 3.7 Sonnet | Ya | Ya | Ya | Ya | Ya | Ya | Ya | Ya | Tidak |
| Anthropic Claude 3.5 Haiku | Ya | Ya | Ya | Ya | Tidak | Ya | Ya | Tidak | Tidak |
| Anthropic Claude Sonnet 4 | Ya | Ya | Ya | Ya | Ya | Ya | Ya | Tidak | Tidak |
| AnthropicClaude Opus4 | Ya | Ya | Ya | Ya | Ya | Ya | Ya | Tidak | Tidak |
| Anthropic Claude Sonnet 4.5 | Ya | Ya | Ya | Ya | Ya | Ya | Ya | Tidak | Tidak |
| Anthropic Claude Haiku 4.5 | Ya | Ya | Ya | Ya | Ya | Ya | Ya | Tidak | Tidak |
| AnthropicClaude Opus4.1 | Ya | Ya | Ya | Ya | Ya | Ya | Ya | Tidak | Tidak |
| Claude Opus4.5 | Ya | Ya | Ya | Ya | Ya | Ya | Ya | Tidak | Tidak |
| Cohere Command | Terbatas. Tidak ada dukungan obrolan. | Terbatas. Tidak ada dukungan obrolan. | Tidak | Ya | Tidak | Tidak | Tidak | Ya | Tidak |
| Cohere Command Light | Terbatas. Tidak ada dukungan obrolan. | Terbatas. Tidak ada dukungan obrolan. | Tidak | Tidak | Tidak | Tidak | Tidak | Ya | Tidak |
| Cohere dan Command R Command R\$1 | Ya | Ya | Ya | Ya | Tidak | Ya | Ya | Tidak | Tidak |
| DeepSeek-R1 | Ya | Ya | Ya | Ya | Tidak | Tidak | Tidak | Ya | Tidak |
| Meta dan Llama 2 Llama 3 | Ya | Ya | Ya | Ya | Tidak | Tidak | Tidak | Ya | Tidak |
| Meta Llama 3.1 | Ya | Ya | Ya | Ya | Tidak | Ya | Tidak | Ya | Tidak |
| Meta Llama 3.2 1b and Llama 3.2 3b | Ya | Ya | Ya | Ya | Tidak | Tidak | Tidak | Ya | Tidak |
| Meta Llama 3.2 11b and Llama 3.2 90b | Ya | Ya | Ya | Ya | Ya | Ya | Tidak | Ya | Tidak |
| Meta Llama 4 Maverick 17B and Llama 4.0 Scout 17B | Ya | Ya | Ya | Ya | Ya | Ya | Tidak | Ya | Tidak |
| Mistral AI Instruct | Ya | Ya | Tidak | Ya | Tidak | Tidak | Tidak | Ya | Tidak |
| Mistral Large | Ya | Ya | Ya | Ya | Tidak | Ya | Tidak | Ya | Tidak |
| Mistral Large 2 (24.07) | Ya | Ya | Ya | Ya | Tidak | Ya | Tidak | Ya | Tidak |
| Mistral Small | Ya | Ya | Ya | Tidak | Tidak | Ya | Tidak | Ya | Tidak |
| Pixtral Large (25.02) | Ya | Ya | Ya | Ya | Tidak | Ya | Tidak | Ya | Tidak |
| Writer Palmyra X4 | Ya | Ya | Ya | Ya | Tidak | Ya | Tidak | Ya | Tidak |
| Writer Palmyra X5 | Ya | Ya | Ya | Ya | Tidak | Ya | Tidak | Ya | Tidak |
Untuk tabel Wilayah yang mendukung setiap model, lihat[Dukungan model oleh Wilayah AWS di Amazon Bedrock](models-regions.md).
**catatan**
CohereCommand(Teks) dan AI21 Labs Jurassic-2 (Teks) tidak mendukung obrolan dengan Converse API. Model hanya dapat menangani satu pesan pengguna pada satu waktu dan tidak dapat mempertahankan riwayat percakapan. Anda mendapatkan kesalahan jika Anda mencoba untuk meneruskan lebih dari satu pesan.
# Menggunakan API Converse ini
Untuk menggunakan Converse API, Anda memanggil `ConverseStream` operasi `Converse` atau untuk mengirim pesan ke model. Untuk menelepon`Converse`, Anda memerlukan izin untuk `bedrock:InvokeModel` operasi. Untuk menelepon`ConverseStream`, Anda memerlukan izin untuk `bedrock:InvokeModelWithResponseStream` operasi.
**Topics**
+ [Permintaan](#conversation-inference-call-request)
+ [Respons](#conversation-inference-call-response)
**catatan**
Pembatasan berlaku untuk operasi berikut: InvokeModel, InvokeModelWithResponseStream, Converse, dan ConverseStream. Lihat [pembatasan API](inference-api-restrictions.md) untuk detailnya.
## Permintaan
Saat membuat permintaan [Converse](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html) dengan [titik akhir runtime Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#br-rt), Anda dapat menyertakan bidang berikut:
+ **ModelID** — Parameter yang diperlukan di header yang memungkinkan Anda menentukan sumber daya yang akan digunakan untuk inferensi.
+ Bidang berikut memungkinkan Anda menyesuaikan prompt:
+ **pesan** — Gunakan untuk menentukan konten dan peran petunjuknya.
+ **sistem** — Gunakan untuk menentukan prompt sistem, yang menentukan instruksi atau konteks untuk model.
+ **InferenceConfig** — Gunakan untuk menentukan parameter inferensi yang umum untuk semua model. Parameter inferensi mempengaruhi generasi respons.
+ **additionalModelRequestFields** — Gunakan untuk menentukan parameter inferensi yang spesifik untuk model yang Anda jalankan inferensi dengan.
+ **PromptVariables** - (Jika Anda menggunakan prompt dari manajemen Prompt) Gunakan bidang ini untuk menentukan variabel dalam prompt untuk mengisi dan nilai-nilai yang digunakan untuk mengisinya.
+ Bidang berikut memungkinkan Anda menyesuaikan bagaimana respons dikembalikan:
+ **GuardrailConfig** — Gunakan bidang ini untuk menyertakan pagar pembatas untuk diterapkan ke seluruh prompt.
+ **ToolConfig** — Gunakan bidang ini untuk menyertakan alat untuk membantu model menghasilkan respons.
+ **additionalModelResponseFieldPaths**— Gunakan bidang ini untuk menentukan bidang untuk kembali sebagai objek penunjuk JSON.
+ **ServiceTier** - Gunakan bidang ini untuk menentukan tingkat layanan untuk permintaan tertentu
+ **RequestMetadata** — Gunakan bidang ini untuk menyertakan metadata yang dapat difilter saat menggunakan log pemanggilan.
**catatan**
Pembatasan berikut berlaku saat Anda menggunakan prompt manajemen Prompt dengan `Converse` atau`ConverseStream`:
Anda tidak dapat menyertakan`additionalModelRequestFields`,`inferenceConfig`,`system`, atau `toolConfig` bidang.
Jika Anda menyertakan `messages` bidang, pesan akan ditambahkan setelah pesan yang ditentukan dalam prompt.
Jika Anda menyertakan `guardrailConfig` bidang, pagar pembatas diterapkan ke seluruh prompt. Jika Anda memasukkan `guardContent` blok di [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html)lapangan, pagar pembatas hanya akan diterapkan pada blok tersebut.
Perluas bagian untuk mempelajari lebih lanjut tentang bidang di badan `Converse` permintaan:
### pesan
`messages`Bidang adalah array objek [Pesan](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Message.html), yang masing-masing mendefinisikan pesan antara pengguna dan model. Sebuah `Message` objek berisi bidang-bidang berikut:
+ **peran** — Mendefinisikan apakah pesan berasal dari `user` (prompt yang dikirim ke model) atau `assistant` (respons model).
+ **content** — Mendefinisikan konten dalam prompt.
**catatan**
Amazon Bedrock tidak menyimpan teks, gambar, atau dokumen apa pun yang Anda berikan sebagai konten. Data hanya digunakan untuk menghasilkan respons.
Anda dapat mempertahankan konteks percakapan dengan menyertakan semua pesan dalam percakapan dalam `Converse` permintaan berikutnya dan menggunakan `role` bidang untuk menentukan apakah pesan tersebut berasal dari pengguna atau model.
`content`Bidang memetakan ke array [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html)objek. Dalam masing-masing [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html), Anda dapat menentukan salah satu bidang berikut (untuk melihat model apa yang mendukung blok apa, lihat[Model dan fitur model yang didukung](conversation-inference-supported-models-features.md)):
------
#### [ text ]
`text`Bidang memetakan ke string yang menentukan prompt. `text`Bidang ditafsirkan bersama bidang lain yang ditentukan dalam hal yang sama [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html).
Berikut ini menunjukkan objek [Pesan](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Message.html) dengan `content` array yang hanya berisi teks [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html):
```
{
"role": "user",
"content": [
{
"text": "string"
}
]
}
```
------
#### [ image ]
`image`Bidang memetakan ke sebuah [ImageBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ImageBlock.html). Lulus byte mentah, dikodekan dalam base64, untuk gambar di lapangan. `bytes` Jika Anda menggunakan AWS SDK, Anda tidak perlu menyandikan byte di base64.
Jika Anda mengecualikan `text` bidang, model menjelaskan gambar.
Berikut ini menunjukkan contoh objek [Pesan](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Message.html) dengan `content` array yang hanya berisi gambar [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html):
```
{
"role": "user",
"content": [
{
"image": {
"format": "png",
"source": {
"bytes": "image in bytes"
}
}
}
]
}
```
Anda juga dapat menentukan URI Amazon S3 alih-alih meneruskan byte langsung di badan permintaan. Berikut ini menunjukkan `Message` objek sampel dengan larik konten yang berisi sumber yang dilewatkan melalui URI Amazon S3.
```
{
"role": "user",
"content": [
{
"image": {
"format": "png",
"source": {
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/myImage",
"bucketOwner": "111122223333"
}
}
}
}
]
}
```
------
#### [ document ]
`document`Bidang memetakan ke sebuah [DocumentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_DocumentBlock.html). Jika Anda menyertakan`DocumentBlock`, periksa apakah permintaan Anda sesuai dengan batasan berikut:
+ Di `content` bidang objek [Pesan](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Message.html), Anda juga harus menyertakan `text` bidang dengan prompt yang terkait dengan dokumen.
+ Lulus byte mentah, dikodekan dalam base64, untuk dokumen di lapangan. `bytes` Jika Anda menggunakan AWS SDK, Anda tidak perlu menyandikan byte dokumen di base64.
+ `name`Bidang hanya dapat berisi karakter berikut:
+ Karakter alfanumerik
+ Karakter spasi (tidak lebih dari satu berturut-turut)
+ Tanda hubung
+ Tanda kurung
+ Kurung persegi
**catatan**
`name`Bidang ini rentan terhadap suntikan cepat, karena model mungkin secara tidak sengaja menafsirkannya sebagai instruksi. Oleh karena itu, kami menyarankan Anda menentukan nama netral.
Saat menggunakan dokumen, Anda dapat mengaktifkan `citations` tag, yang akan memberikan kutipan khusus dokumen dalam respons panggilan API. Lihat [DocumentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_DocumentBlock.html)API untuk detail selengkapnya.
Berikut ini menunjukkan contoh objek [Pesan](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Message.html) dengan `content` array yang hanya berisi dokumen [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html)dan teks yang menyertainya diperlukan. [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html)
```
{
"role": "user",
"content": [
{
"text": "string"
},
{
"document": {
"format": "pdf",
"name": "MyDocument",
"source": {
"bytes": "document in bytes"
}
}
}
]
}
```
Anda juga dapat menentukan URI Amazon S3 alih-alih meneruskan byte langsung di badan permintaan. Berikut ini menunjukkan `Message` objek sampel dengan larik konten yang berisi sumber yang dilewatkan melalui URI Amazon S3.
```
{
"role": "user",
"content": [
{
"text": "string"
},
{
"document": {
"format": "pdf",
"name": "MyDocument",
"source": {
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/myDocument",
"bucketOwner": "111122223333"
}
}
}
}
]
}
```
------
#### [ video ]
`video`Bidang memetakan ke [VideoBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_VideoBlock.html)objek. Lulus byte mentah di `bytes` lapangan, dikodekan dalam base64. Jika Anda menggunakan AWS SDK, Anda tidak perlu menyandikan byte di base64.
Jika Anda tidak menyertakan `text` bidang, model akan menjelaskan video.
Berikut ini menunjukkan contoh objek [Pesan](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Message.html) dengan `content` array yang hanya berisi video [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html).
```
{
"role": "user",
"content": [
{
"video": {
"format": "mp4",
"source": {
"bytes": "video in bytes"
}
}
}
]
}
```
Anda juga dapat menentukan URI Amazon S3 alih-alih meneruskan byte langsung di badan permintaan. Berikut ini menunjukkan `Message` objek sampel dengan larik konten yang berisi sumber yang dilewatkan melalui URI Amazon S3.
```
{
"role": "user",
"content": [
{
"video": {
"format": "mp4",
"source": {
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/myVideo",
"bucketOwner": "111122223333"
}
}
}
}
]
}
```
**catatan**
Peran yang diasumsikan harus memiliki `s3:GetObject` izin ke URI Amazon S3. `bucketOwner`Kolom ini opsional tetapi harus ditentukan jika akun yang membuat permintaan tidak memiliki keranjang tempat URI Amazon S3 ditemukan. Untuk informasi selengkapnya, lihat [Konfigurasikan akses ke bucket Amazon S3](s3-bucket-access.md).
------
#### [ cachePoint ]
Anda dapat menambahkan pos pemeriksaan cache sebagai blok dalam pesan di samping prompt yang menyertainya dengan menggunakan `cachePoint` bidang untuk memanfaatkan caching prompt. Prompt caching adalah fitur yang memungkinkan Anda memulai cache konteks percakapan untuk mencapai penghematan biaya dan latensi. Untuk informasi selengkapnya, lihat [Caching cepat untuk inferensi model yang lebih cepat](prompt-caching.md).
Berikut ini menunjukkan contoh objek [Pesan](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Message.html) dengan `content` array yang berisi dokumen [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html)dan teks yang menyertainya yang diperlukan [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html), serta **CachePoint** yang menambahkan dokumen dan isi teks ke cache.
```
{
"role": "user",
"content": [
{
"text": "string"
},
{
"document": {
"format": "pdf",
"name": "string",
"source": {
"bytes": "document in bytes"
}
}
},
{
"cachePoint": {
"type": "default"
}
}
]
}
```
------
#### [ guardContent ]
`guardContent`Bidang memetakan ke [GuardrailConverseContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_GuardrailConverseContentBlock.html)objek. Anda dapat menggunakan bidang ini untuk menargetkan input yang akan dievaluasi oleh pagar pembatas yang ditentukan di bidang. `guardrailConfig` Jika Anda tidak menentukan bidang ini, pagar pembatas akan mengevaluasi semua pesan di badan permintaan. Anda dapat meneruskan jenis konten berikut di`GuardBlock`:
+ **text** - Berikut ini menunjukkan contoh objek [Pesan](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Message.html) dengan `content` array yang hanya berisi teks [GuardrailConverseContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_GuardrailConverseContentBlock.html):
```
{
"role": "user",
"content": [
{
"text": "Tell me what stocks to buy.",
"qualifiers": [
"guard_content"
]
}
]
}
```
Anda menentukan teks yang akan dievaluasi dan menyertakan kualifikasi apa pun yang akan digunakan untuk landasan [kontekstual](guardrails-contextual-grounding-check.md).
+ **image** — Berikut ini menunjukkan objek [Message](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Message.html) dengan `content` array yang hanya berisi gambar [GuardrailConverseContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_GuardrailConverseContentBlock.html):
```
{
"role": "user",
"content": [
{
"format": "png",
"source": {
"bytes": "image in bytes"
}
}
]
}
```
Anda menentukan format gambar dan menentukan gambar dalam byte.
Untuk informasi selengkapnya tentang penggunaan pagar pembatas, lihat. [Mendeteksi dan memfilter konten berbahaya dengan menggunakan Amazon Bedrock Guardrails](guardrails.md)
------
#### [ reasoningContent ]
`reasoningContent`Bidang memetakan ke a [ReasoningContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ReasoningContentBlock.html). Blok ini berisi konten mengenai alasan yang dilakukan oleh model untuk menghasilkan respons yang menyertainya`ContentBlock`.
Berikut ini menunjukkan `Message` objek dengan `content` array yang hanya berisi `ReasoningContentBlock` dan teks yang menyertainya. `ContentBlock`
```
{
"role": "user",
"content": [
{
"text": "string"
},
{
"reasoningContent": {
"reasoningText": {
"text": "string",
"signature": "string"
}
"redactedContent": "base64-encoded binary data object"
}
}
]
}
```
`ReasoningContentBlock`Berisi alasan yang digunakan untuk menghasilkan konten yang menyertainya di `reasoningText` lapangan, di samping konten apa pun dalam alasan yang dienkripsi oleh penyedia model untuk alasan kepercayaan dan keamanan di lapangan. `redactedContent`
Di dalam `reasoningText` lapangan, `text` bidang menjelaskan alasannya. `signature`Bidang adalah hash dari semua pesan dalam percakapan dan merupakan perlindungan terhadap gangguan penalaran yang digunakan oleh model. Anda harus menyertakan tanda tangan dan semua pesan sebelumnya dalam `Converse` permintaan berikutnya. Jika ada pesan yang diubah, respons akan menimbulkan kesalahan.
------
#### [ toolUse ]
Berisi informasi tentang alat untuk model yang akan digunakan. Untuk informasi selengkapnya, lihat [Gunakan alat untuk menyelesaikan respons model Amazon Bedrock](tool-use.md).
------
#### [ toolResult ]
Berisi informasi tentang hasil dari model menggunakan alat. Untuk informasi selengkapnya, lihat [Gunakan alat untuk menyelesaikan respons model Amazon Bedrock](tool-use.md).
------
Dalam `messages` contoh berikut, pengguna meminta daftar tiga lagu pop, dan model menghasilkan daftar lagu.
```
[
{
"role": "user",
"content": [
{
"text": "Create a list of 3 pop songs."
}
]
},
{
"role": "assistant",
"content": [
{
"text": "Here is a list of 3 pop songs by artists from the United Kingdom:\n\n1. \"As It Was\" by Harry Styles\n2. \"Easy On Me\" by Adele\n3. \"Unholy\" by Sam Smith and Kim Petras"
}
]
}
]
```
### sistem
Prompt sistem adalah jenis prompt yang memberikan instruksi atau konteks kepada model tentang tugas yang harus dilakukan, atau persona yang harus diadopsi selama percakapan. Anda dapat menentukan daftar prompt sistem untuk permintaan di bidang `system` ([SystemContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_SystemContentBlock.html)), seperti yang ditunjukkan pada contoh berikut.
```
[
{
"text": "You are an app that creates play lists for a radio station that plays rock and pop music. Only return song names and the artist. "
}
]
```
### InferensiConfig
ConverseAPI mendukung kumpulan dasar parameter inferensi yang Anda tetapkan di `inferenceConfig` field ([InferenceConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InferenceConfiguration.html)). Set dasar parameter inferensi adalah:
+ **MaxTokens** — Jumlah maksimum token untuk memungkinkan respons yang dihasilkan.
+ **StopSequences** — Daftar urutan berhenti. Urutan berhenti adalah urutan karakter yang menyebabkan model berhenti menghasilkan respons.
+ **suhu** — Kemungkinan model memilih opsi probabilitas yang lebih tinggi sambil menghasilkan respons.
+ **TopP** — Persentase kandidat yang paling mungkin yang dipertimbangkan model untuk token berikutnya.
Untuk informasi selengkapnya, lihat [Mempengaruhi generasi respons dengan parameter inferensi](inference-parameters.md).
Contoh berikut JSON menetapkan parameter `temperature` inferensi.
```
{"temperature": 0.5}
```
### additionalModelRequestBidang
Jika model yang Anda gunakan memiliki parameter inferensi tambahan, Anda dapat mengatur parameter tersebut dengan menentukannya sebagai JSON di lapangan. `additionalModelRequestFields` Contoh berikut JSON menunjukkan cara menyetel`top_k`, yang tersedia dalam Anthropic Claude model, tetapi bukan merupakan parameter inferensi dasar di API pesan.
```
{"top_k": 200}
```
### PromptVariables
Jika Anda menentukan [prompt dari manajemen Prompt](prompt-management.md) `modelId` sebagai sumber daya untuk menjalankan inferensi, gunakan bidang ini untuk mengisi variabel prompt dengan nilai aktual. `promptVariables`Bidang memetakan ke objek JSON dengan kunci yang sesuai dengan variabel yang ditentukan dalam prompt dan nilai untuk mengganti variabel dengan.
Misalnya, katakanlah Anda memiliki prompt yang mengatakan**Make me a *\$1\$1genre\$1\$1* playlist consisting of the following number of songs: *\$1\$1number\$1\$1*.**. ID prompt adalah `PROMPT12345` dan versinya adalah`1`. Anda dapat mengirim `Converse` permintaan berikut untuk mengganti variabel:
```
POST /model/arn:aws:bedrock:us-east-1:111122223333:prompt/PROMPT12345:1/converse HTTP/1.1
Content-type: application/json
{
"promptVariables": {
"genre" : "pop",
"number": 3
}
}
```
### GuardrailConfig
Anda dapat menerapkan pagar pembatas yang Anda buat dengan [Amazon Bedrock Guardrails](guardrails.md) dengan menyertakan bidang ini. Untuk menerapkan pagar pembatas ke pesan tertentu dalam percakapan, sertakan pesan dalam file. [GuardrailConverseContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_GuardrailConverseContentBlock.html) Jika Anda tidak menyertakan `GuardrailConverseContentBlock` s apa pun di badan permintaan, pagar pembatas diterapkan ke semua pesan di `messages` bidang. Sebagai contoh, lihat [Sertakan pagar pembatas dengan API Converse](guardrails-use-converse-api.md).
### ToolConfig
Bidang ini memungkinkan Anda menentukan alat untuk model yang akan digunakan untuk membantunya menghasilkan respons. Untuk informasi selengkapnya, lihat [Gunakan alat untuk menyelesaikan respons model Amazon Bedrock](tool-use.md).
### additionalModelResponseFieldPaths
Anda dapat menentukan jalur untuk parameter model tambahan di `additionalModelResponseFieldPaths` lapangan, seperti yang ditunjukkan pada contoh berikut.
```
[ "/stop_sequence" ]
```
API mengembalikan bidang tambahan yang Anda minta di `additionalModelResponseFields` bidang tersebut.
### PermintaMetadata
Bidang ini memetakan ke objek JSON. Anda dapat menentukan kunci metadata dan nilai yang mereka petakan ke dalam objek ini. Anda dapat menggunakan metadata permintaan untuk membantu Anda memfilter log pemanggilan model.
### ServiceTier
Bidang ini memetakan ke objek JSON. Anda dapat menentukan tingkat layanan untuk permintaan tertentu.
Contoh berikut menunjukkan `serviceTier` struktur:
```
"serviceTier": {
"type": "reserved" | "priority" | "default" | "flex"
}
```
Untuk informasi rinci tentang tingkatan layanan, termasuk karakteristik harga dan kinerja, lihat[Tingkat layanan untuk mengoptimalkan kinerja dan biaya](service-tiers-inference.md).
Anda juga dapat secara opsional menambahkan pos pemeriksaan cache ke `tools` bidang `system` atau untuk menggunakan caching prompt, tergantung pada model yang Anda gunakan. Untuk informasi selengkapnya, lihat [Caching cepat untuk inferensi model yang lebih cepat](prompt-caching.md).
## Respons
Respons yang Anda dapatkan dari Converse API tergantung pada operasi yang Anda panggil, `Converse` atau`ConverseStream`.
**Topics**
+ [Tanggapan Converse](#conversation-inference-call-response-converse)
+ [ConverseStream respon](#conversation-inference-call-response-converse-stream)
### Tanggapan Converse
Dalam tanggapan dari`Converse`, `output` bidang ([ConverseOutput](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ConverseOutput.html)) berisi pesan ([Pesan](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Message.html)) yang dihasilkan model. Konten pesan ada di bidang `content` ([ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html)) dan peran (`user`atau`assistant`) yang sesuai dengan pesan ada di `role` bidang.
Jika Anda menggunakan [caching prompt](prompt-caching.md), maka di bidang penggunaan, `cacheReadInputTokensCount` dan `cacheWriteInputTokensCount` memberi tahu Anda berapa banyak total token yang dibaca dari cache dan ditulis ke cache, masing-masing.
Jika Anda menggunakan [tingkatan layanan](#inference-service-tiers), maka di bidang respons, `service tier` akan memberi tahu Anda tingkat layanan mana yang digunakan untuk permintaan tersebut.
`metrics`Bidang ([ConverseMetrics](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ConverseMetrics.html)) menyertakan metrik untuk panggilan. Untuk menentukan mengapa model berhenti menghasilkan konten, periksa `stopReason` bidangnya. Anda bisa mendapatkan informasi tentang token yang diteruskan ke model dalam permintaan, dan token yang dihasilkan dalam respons, dengan memeriksa `usage` bidang ([TokenUsage](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_TokenUsage.html)). Jika Anda menetapkan bidang respons tambahan dalam permintaan, API akan mengembalikannya sebagai JSON di `additionalModelResponseFields` bidang tersebut.
Contoh berikut menunjukkan respons dari `Converse` saat Anda meneruskan prompt yang dibahas di[Permintaan](#conversation-inference-call-request).
```
{
"output": {
"message": {
"role": "assistant",
"content": [
{
"text": "Here is a list of 3 pop songs by artists from the United Kingdom:\n\n1. \"Wannabe\" by Spice Girls\n2. \"Bitter Sweet Symphony\" by The Verve \n3. \"Don't Look Back in Anger\" by Oasis"
}
]
}
},
"stopReason": "end_turn",
"usage": {
"inputTokens": 125,
"outputTokens": 60,
"totalTokens": 185
},
"metrics": {
"latencyMs": 1175
}
}
```
### ConverseStream respon
Jika Anda memanggil `ConverseStream` untuk mengalirkan respons dari model, aliran dikembalikan di bidang `stream` respons. Aliran memancarkan peristiwa berikut dalam urutan sebagai berikut.
1. `messageStart`([MessageStartEvent](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_MessageStartEvent.html)). Acara awal untuk sebuah pesan. Termasuk peran untuk pesan.
1. `contentBlockStart`([ContentBlockStartEvent](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlockStartEvent.html)). Acara mulai blok Konten. Hanya menggunakan alat.
1. `contentBlockDelta`([ContentBlockDeltaEvent](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlockDeltaEvent.html)). Acara delta blok Konten. Termasuk salah satu dari berikut ini:
+ `text`— Teks parsi yang dihasilkan model.
+ `reasoningContent`— Penalaran sebagian yang dilakukan oleh model untuk menghasilkan respons. Anda harus mengirimkan yang dikembalikan`signature`, selain semua pesan sebelumnya dalam `Converse` permintaan berikutnya. Jika ada pesan yang diubah, respons akan menimbulkan kesalahan.
+ `toolUse`— Masukan sebagian objek JSON untuk penggunaan alat.
1. `contentBlockStop`([ContentBlockStopEvent](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlockStopEvent.html)). Peristiwa penghentian blok Konten.
1. `messageStop`([MessageStopEvent](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_MessageStopEvent.html)). Acara berhenti untuk pesan. Termasuk alasan mengapa model berhenti menghasilkan output.
1. `metadata`([ConverseStreamMetadataEvent](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ConverseStreamMetadataEvent.html)). Metadata untuk permintaan. Metadata mencakup penggunaan token in `usage` ([TokenUsage](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_TokenUsage.html)) dan metrik untuk panggilan in `metrics` (). [ConverseStreamMetadataEvent](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ConverseStreamMetadataEvent.html)
ConverseStream mengalirkan blok konten lengkap sebagai `ContentBlockStartEvent` acara, satu atau beberapa `ContentBlockDeltaEvent` acara, dan `ContentBlockStopEvent` acara. Gunakan `contentBlockIndex` bidang sebagai indeks untuk mengkorelasikan peristiwa yang membentuk blok konten.
Contoh berikut adalah sebagian respon dari`ConverseStream`.
```
{'messageStart': {'role': 'assistant'}}
{'contentBlockDelta': {'delta': {'text': ''}, 'contentBlockIndex': 0}}
{'contentBlockDelta': {'delta': {'text': ' Title'}, 'contentBlockIndex': 0}}
{'contentBlockDelta': {'delta': {'text': ':'}, 'contentBlockIndex': 0}}
.
.
.
{'contentBlockDelta': {'delta': {'text': ' The'}, 'contentBlockIndex': 0}}
{'messageStop': {'stopReason': 'max_tokens'}}
{'metadata': {'usage': {'inputTokens': 47, 'outputTokens': 20, 'totalTokens': 67}, 'metrics': {'latencyMs': 100.0}}}
```
# ConverseContoh API
Contoh berikut menunjukkan kepada Anda cara menggunakan `Converse` dan `ConverseStream` operasi.
------
#### [ Text ]
Contoh ini menunjukkan cara memanggil `Converse` operasi dengan *AnthropicClaude 3 Sonnet*model. Contoh menunjukkan cara mengirim teks input, parameter inferensi, dan parameter tambahan yang unik untuk model. Kode memulai percakapan dengan meminta model untuk membuat daftar lagu. Kemudian melanjutkan percakapan dengan menanyakan bahwa lagu-lagu tersebut dibuat oleh artis dari Britania Raya.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to use the Converse API with Anthropic Claude 3 Sonnet (on demand).
"""
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_conversation(bedrock_client,
model_id,
system_prompts,
messages):
"""
Sends messages to a model.
Args:
bedrock_client: The Boto3 Bedrock runtime client.
model_id (str): The model ID to use.
system_prompts (JSON) : The system prompts for the model to use.
messages (JSON) : The messages to send to the model.
Returns:
response (JSON): The conversation that the model generated.
"""
logger.info("Generating message with model %s", model_id)
# Inference parameters to use.
temperature = 0.5
top_k = 200
# Base inference parameters to use.
inference_config = {"temperature": temperature}
# Additional inference parameters to use.
additional_model_fields = {"top_k": top_k}
# Send the message.
response = bedrock_client.converse(
modelId=model_id,
messages=messages,
system=system_prompts,
inferenceConfig=inference_config,
additionalModelRequestFields=additional_model_fields
)
# Log token usage.
token_usage = response['usage']
logger.info("Input tokens: %s", token_usage['inputTokens'])
logger.info("Output tokens: %s", token_usage['outputTokens'])
logger.info("Total tokens: %s", token_usage['totalTokens'])
logger.info("Stop reason: %s", response['stopReason'])
return response
def main():
"""
Entrypoint for Anthropic Claude 3 Sonnet example.
"""
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
model_id = "anthropic.claude-3-sonnet-20240229-v1:0"
# Setup the system prompts and messages to send to the model.
system_prompts = [{"text": "You are an app that creates playlists for a radio station that plays rock and pop music. Only return song names and the artist."}]
message_1 = {
"role": "user",
"content": [{"text": "Create a list of 3 pop songs."}]
}
message_2 = {
"role": "user",
"content": [{"text": "Make sure the songs are by artists from the United Kingdom."}]
}
messages = []
try:
bedrock_client = boto3.client(service_name='bedrock-runtime')
# Start the conversation with the 1st message.
messages.append(message_1)
response = generate_conversation(
bedrock_client, model_id, system_prompts, messages)
# Add the response message to the conversation.
output_message = response['output']['message']
messages.append(output_message)
# Continue the conversation with the 2nd message.
messages.append(message_2)
response = generate_conversation(
bedrock_client, model_id, system_prompts, messages)
output_message = response['output']['message']
messages.append(output_message)
# Show the complete conversation.
for message in messages:
print(f"Role: {message['role']}")
for content in message['content']:
print(f"Text: {content['text']}")
print()
except ClientError as err:
message = err.response['Error']['Message']
logger.error("A client error occurred: %s", message)
print(f"A client error occured: {message}")
else:
print(
f"Finished generating text with model {model_id}.")
if __name__ == "__main__":
main()
```
------
#### [ Image ]
Contoh ini menunjukkan cara mengirim gambar sebagai bagian dari pesan dan permintaan agar model menggambarkan gambar. Contoh menggunakan `Converse` operasi dan *AnthropicClaude 3 Sonnet*model.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to send an image with the Converse API with an accompanying text prompt to Anthropic Claude 3 Sonnet (on demand).
"""
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_conversation(bedrock_client,
model_id,
input_text,
input_image):
"""
Sends a message to a model.
Args:
bedrock_client: The Boto3 Bedrock runtime client.
model_id (str): The model ID to use.
input text : The text prompt accompanying the image.
input_image : The path to the input image.
Returns:
response (JSON): The conversation that the model generated.
"""
logger.info("Generating message with model %s", model_id)
# Get image extension and read in image as bytes
image_ext = input_image.split(".")[-1]
with open(input_image, "rb") as f:
image = f.read()
message = {
"role": "user",
"content": [
{
"text": input_text
},
{
"image": {
"format": image_ext,
"source": {
"bytes": image
}
}
}
]
}
messages = [message]
# Send the message.
response = bedrock_client.converse(
modelId=model_id,
messages=messages
)
return response
def main():
"""
Entrypoint for Anthropic Claude 3 Sonnet example.
"""
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
model_id = "anthropic.claude-3-sonnet-20240229-v1:0"
input_text = "What's in this image?"
input_image = "path/to/image"
try:
bedrock_client = boto3.client(service_name="bedrock-runtime")
response = generate_conversation(
bedrock_client, model_id, input_text, input_image)
output_message = response['output']['message']
print(f"Role: {output_message['role']}")
for content in output_message['content']:
print(f"Text: {content['text']}")
token_usage = response['usage']
print(f"Input tokens: {token_usage['inputTokens']}")
print(f"Output tokens: {token_usage['outputTokens']}")
print(f"Total tokens: {token_usage['totalTokens']}")
print(f"Stop reason: {response['stopReason']}")
except ClientError as err:
message = err.response['Error']['Message']
logger.error("A client error occurred: %s", message)
print(f"A client error occured: {message}")
else:
print(
f"Finished generating text with model {model_id}.")
if __name__ == "__main__":
main()
```
------
#### [ Document ]
Contoh ini menunjukkan cara mengirim dokumen sebagai bagian dari pesan dan meminta agar model menggambarkan isi dokumen. Contoh menggunakan `Converse` operasi dan *AnthropicClaude 3 Sonnet*model.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to send an document as part of a message to Anthropic Claude 3 Sonnet (on demand).
"""
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_message(bedrock_client,
model_id,
input_text,
input_document_path):
"""
Sends a message to a model.
Args:
bedrock_client: The Boto3 Bedrock runtime client.
model_id (str): The model ID to use.
input text : The input message.
input_document_path : The path to the input document.
Returns:
response (JSON): The conversation that the model generated.
"""
logger.info("Generating message with model %s", model_id)
# Get format from path and read the path
input_document_format = input_document_path.split(".")[-1]
with open(input_document_path, 'rb') as input_document_file:
input_document = input_document_file.read()
# Message to send.
message = {
"role": "user",
"content": [
{
"text": input_text
},
{
"document": {
"name": "MyDocument",
"format": input_document_format,
"source": {
"bytes": input_document
}
}
}
]
}
messages = [message]
# Send the message.
response = bedrock_client.converse(
modelId=model_id,
messages=messages
)
return response
def main():
"""
Entrypoint for Anthropic Claude 3 Sonnet example.
"""
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
model_id = "anthropic.claude-3-sonnet-20240229-v1:0"
input_text = "What's in this document?"
input_document_path = "path/to/document"
try:
bedrock_client = boto3.client(service_name="bedrock-runtime")
response = generate_message(
bedrock_client, model_id, input_text, input_document_path)
output_message = response['output']['message']
print(f"Role: {output_message['role']}")
for content in output_message['content']:
print(f"Text: {content['text']}")
token_usage = response['usage']
print(f"Input tokens: {token_usage['inputTokens']}")
print(f"Output tokens: {token_usage['outputTokens']}")
print(f"Total tokens: {token_usage['totalTokens']}")
print(f"Stop reason: {response['stopReason']}")
except ClientError as err:
message = err.response['Error']['Message']
logger.error("A client error occurred: %s", message)
print(f"A client error occured: {message}")
else:
print(
f"Finished generating text with model {model_id}.")
if __name__ == "__main__":
main()
```
------
#### [ Streaming ]
Contoh ini menunjukkan cara memanggil `ConverseStream` operasi dengan *AnthropicClaude 3 Sonnet*model. Contoh menunjukkan cara mengirim teks input, parameter inferensi, dan parameter tambahan yang unik untuk model.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to use the Converse API to stream a response from Anthropic Claude 3 Sonnet (on demand).
"""
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def stream_conversation(bedrock_client,
model_id,
messages,
system_prompts,
inference_config,
additional_model_fields):
"""
Sends messages to a model and streams the response.
Args:
bedrock_client: The Boto3 Bedrock runtime client.
model_id (str): The model ID to use.
messages (JSON) : The messages to send.
system_prompts (JSON) : The system prompts to send.
inference_config (JSON) : The inference configuration to use.
additional_model_fields (JSON) : Additional model fields to use.
Returns:
Nothing.
"""
logger.info("Streaming messages with model %s", model_id)
response = bedrock_client.converse_stream(
modelId=model_id,
messages=messages,
system=system_prompts,
inferenceConfig=inference_config,
additionalModelRequestFields=additional_model_fields
)
stream = response.get('stream')
if stream:
for event in stream:
if 'messageStart' in event:
print(f"\nRole: {event['messageStart']['role']}")
if 'contentBlockDelta' in event:
print(event['contentBlockDelta']['delta']['text'], end="")
if 'messageStop' in event:
print(f"\nStop reason: {event['messageStop']['stopReason']}")
if 'metadata' in event:
metadata = event['metadata']
if 'usage' in metadata:
print("\nToken usage")
print(f"Input tokens: {metadata['usage']['inputTokens']}")
print(
f":Output tokens: {metadata['usage']['outputTokens']}")
print(f":Total tokens: {metadata['usage']['totalTokens']}")
if 'metrics' in event['metadata']:
print(
f"Latency: {metadata['metrics']['latencyMs']} milliseconds")
def main():
"""
Entrypoint for streaming message API response example.
"""
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
model_id = "anthropic.claude-3-sonnet-20240229-v1:0"
system_prompt = """You are an app that creates playlists for a radio station
that plays rock and pop music. Only return song names and the artist."""
# Message to send to the model.
input_text = "Create a list of 3 pop songs."
message = {
"role": "user",
"content": [{"text": input_text}]
}
messages = [message]
# System prompts.
system_prompts = [{"text" : system_prompt}]
# inference parameters to use.
temperature = 0.5
top_k = 200
# Base inference parameters.
inference_config = {
"temperature": temperature
}
# Additional model inference parameters.
additional_model_fields = {"top_k": top_k}
try:
bedrock_client = boto3.client(service_name='bedrock-runtime')
stream_conversation(bedrock_client, model_id, messages,
system_prompts, inference_config, additional_model_fields)
except ClientError as err:
message = err.response['Error']['Message']
logger.error("A client error occurred: %s", message)
print("A client error occured: " +
format(message))
else:
print(
f"Finished streaming messages with model {model_id}.")
if __name__ == "__main__":
main()
```
------
#### [ Video ]
Contoh ini menunjukkan cara mengirim video sebagai bagian dari pesan dan permintaan agar model menjelaskan video tersebut. Contoh menggunakan `Converse` operasi dan Amazon Nova Pro model.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to send a video with the Converse API to Amazon Nova Pro (on demand).
"""
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_conversation(bedrock_client,
model_id,
input_text,
input_video):
"""
Sends a message to a model.
Args:
bedrock_client: The Boto3 Bedrock runtime client.
model_id (str): The model ID to use.
input text : The input message.
input_video : The input video.
Returns:
response (JSON): The conversation that the model generated.
"""
logger.info("Generating message with model %s", model_id)
# Message to send.
with open(input_video, "rb") as f:
video = f.read()
message = {
"role": "user",
"content": [
{
"text": input_text
},
{
"video": {
"format": 'mp4',
"source": {
"bytes": video
}
}
}
]
}
messages = [message]
# Send the message.
response = bedrock_client.converse(
modelId=model_id,
messages=messages
)
return response
def main():
"""
Entrypoint for Amazon Nova Pro example.
"""
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
model_id = "amazon.nova-pro-v1:0"
input_text = "What's in this video?"
input_video = "path/to/video"
try:
bedrock_client = boto3.client(service_name="bedrock-runtime")
response = generate_conversation(
bedrock_client, model_id, input_text, input_video)
output_message = response['output']['message']
print(f"Role: {output_message['role']}")
for content in output_message['content']:
print(f"Text: {content['text']}")
token_usage = response['usage']
print(f"Input tokens: {token_usage['inputTokens']}")
print(f"Output tokens: {token_usage['outputTokens']}")
print(f"Total tokens: {token_usage['totalTokens']}")
print(f"Stop reason: {response['stopReason']}")
except ClientError as err:
message = err.response['Error']['Message']
logger.error("A client error occurred: %s", message)
print(f"A client error occured: {message}")
else:
print(
f"Finished generating text with model {model_id}.")
if __name__ == "__main__":
main()
```
------
# Pembatasan API
Pembatasan berikut berlaku untuk`InvokeModel`,`InvokeModelWithResponseStream`,`Converse`, dan `ConverseStream` operasi. Beberapa batasan bervariasi menurut operasi atau model seperti yang disebutkan di bawah ini:
+ Saat menggunakan operasi ini, Anda hanya dapat menyertakan gambar dan dokumen jika `role` ada`user`.
+ **Pembuatan video:** Pembuatan video tidak didukung dengan `InvokeModel` dan`InvokeModelWithResponseStream`. Sebagai gantinya, Anda dapat menggunakan [StartAsyncInvoke](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_StartAsyncInvoke.html)operasi. Sebagai contoh, lihat [Menggunakan Amazon Nova Reel untuk menghasilkan video dari prompt teks](https://docs.aws.amazon.com/bedrock/latest/userguide/bedrock-runtime_example_bedrock-runtime_Scenario_AmazonNova_TextToVideo_section.html).
+ **Dukungan dokumen di badan permintaan:** Menyertakan dokumen dalam badan permintaan tidak didukung saat menggunakan `InvokeModel` dan`InvokeModelWithResponseStream`. Untuk menyertakan dokumen selama inferensi, gunakan [taman bermain Obrolan/teks](playgrounds.md) di Konsol Manajemen AWS atau gunakan operasi atau. `Converse` `ConverseStream`
+ **Jumlah dan ukuran dokumen:** Anda dapat menyertakan hingga 5 dokumen per permintaan. Setiap dokumen dapat berukuran tidak lebih dari 4,5 MB. Untuk Claude 4 dan versi berikutnya, batasan ukuran dokumen 4,5 MB tidak berlaku untuk format. `PDF` Untuk model Nova, batasan ukuran dokumen 4,5 MB tidak berlaku untuk `PDF` dan `DOCX` format. Pembatasan ini terus berlaku di Konsol Batuan Dasar. Model individual mungkin memiliki batasan konten tambahan di luar yang diterapkan oleh Amazon Bedrock. Untuk informasi selengkapnya, lihat **Persyaratan penyedia model pihak ketiga**.
+ **Jumlah dan ukuran gambar**: Amazon Bedrock tidak memberlakukan batasan pada jumlah dan ukuran gambar. Namun, model individu mungkin memiliki persyaratan gambar tertentu. Untuk informasi selengkapnya, lihat **Persyaratan penyedia model pihak ketiga**.
+ **Persyaratan penyedia model pihak ketiga:** Persyaratan penyedia model pihak ketiga berlaku saat Anda menggunakan `InvokeModel` `InvokeModelWithResponseStream``Converse`,,, dan `ConverseStream` operasi, dan dapat mengakibatkan kesalahan jika tidak terpenuhi. Jika Anda menggunakan model pihak ketiga melalui Amazon Bedrock (misalnya, Anthropic Claude), tinjau panduan pengguna penyedia dan dokumentasi API untuk menghindari kesalahan yang tidak terduga. Misalnya, titik akhir standar Anthropic Messages mendukung ukuran permintaan maksimum 32 MB. Claude juga memiliki persyaratan konten khusus, seperti maksimum 100 `PDF` halaman per permintaan dan ukuran gambar maksimum 8000x8000 px. [Untuk informasi terbaru tentang permintaan dan tanggapan Anthropic Claude Messages, termasuk ukuran permintaan dan persyaratan konten, lihat dokumentasi Anthropic Claude berikut: [Ikhtisar Anthropic Claude API, Referensi API Pesan Claude Anthropic](https://platform.claude.com/docs/en/api/overview)[, Build with Claude: Vision and Build [with](https://platform.claude.com/docs/en/build-with-claude/vision) Claude](https://docs.anthropic.com/claude/reference/messages_post): PDF Support.](https://platform.claude.com/docs/en/build-with-claude/pdf-support)
**Tip**
Claude mewajibkan dokumen PDF maksimal 100 halaman per permintaan. Jika Anda memiliki dokumen PDF yang lebih besar, kami sarankan untuk membaginya menjadi beberapa PDFs di bawah 100 halaman masing-masing atau menggabungkan lebih banyak teks menjadi halaman yang lebih sedikit.