Model dan fitur model yang didukung Menggunakan Converse API Contoh API Converse

Menggunakan 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 atau ConverseStream(untuk respons streaming) untuk mengirim pesan ke model. Dimungkinkan untuk menggunakan operasi inferensi yang ada (InvokeModelatau InvokeModelWithResponseStream) 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 dan pagar pembatas dalam aplikasi Anda.

catatan

Dengan Mistral AI dan model Meta open source, Converse API menyematkan masukan Anda dalam template prompt khusus model yang memungkinkan percakapan.

Model dan fitur model yang didukung

Converse API mendukung model dan fitur model Amazon Bedrock berikut. Converse API tidak mendukung model penyematan apa pun (sepertiTitan Embeddings G1 - Text) atau model pembuatan gambar (sepertiStability AI).

Model	Bercakap-cakap	ConverseStream	Permintaan sistem	Obrolan dokumen	Visi	Penggunaan alat	Penggunaan alat streaming	Pagar pembatas
AI21 Jamba-Instruct	Ya	Tidak	Ya	Tidak	Tidak	Tidak	Tidak	Tidak
AI21 LabsJurassic-2(Teks)	Terbatas. Tidak ada dukungan obrolan.	Tidak	Tidak	Tidak	Tidak	Tidak	Tidak	Ya
TitanModel Amazon	Ya	Ya	Tidak	Ya (kecualiTitan Text Premier)	Tidak	Tidak	Tidak	Ya
AnthropicClaude2 dan sebelumnya	Ya	Ya	Ya	Ya	Tidak	Tidak	Tidak	Ya
AnthropicClaude3	Ya	Ya	Ya	Ya	Ya	Ya	Ya	Ya
AnthropicClaude3.5	Ya	Ya	Ya	Tidak	Ya	Ya	Ya	Ya
Cohere Command	Terbatas. Tidak ada dukungan obrolan.	Terbatas. Tidak ada dukungan obrolan.	Tidak	Ya	Tidak	Tidak	Tidak	Ya
Cohere Command Light	Terbatas. Tidak ada dukungan obrolan.	Terbatas. Tidak ada dukungan obrolan.	Tidak	Tidak	Tidak	Tidak	Tidak	Ya
Cohere dan Command R Command R+	Ya	Ya	Ya	Ya	Tidak	Ya	Tidak	Tidak
Meta dan Llama 2 Llama 3	Ya	Ya	Ya	Ya	Tidak	Tidak	Tidak	Ya
Mistral AI Instruct	Ya	Ya	Tidak	Ya	Tidak	Tidak	Tidak	Ya
Mistral Large	Ya	Ya	Ya	Ya	Tidak	Ya	Tidak	Ya
Mistral Small	Ya	Ya	Ya	Tidak	Tidak	Ya	Tidak	Ya

catatan

CohereCommand(Teks) dan AI21 Labs Jurassic-2 (Teks) tidak mendukung obrolan dengan API Converse. 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 Converse API

Untuk menggunakan Converse API, Anda memanggil ConverseStream operasi Converse atau untuk mengirim pesan ke model. Untuk meneleponConverse, Anda memerlukan izin untuk bedrock:InvokeModel operasi. Untuk meneleponConverseStream, Anda memerlukan izin untuk bedrock:InvokeModelWithResponseStream operasi.

Topik

Permintaan
Respons

Permintaan

Anda menentukan model yang ingin Anda gunakan dengan mengatur modelId bidang. Untuk daftar ID model yang didukung Amazon Bedrock, lihatID model Amazon Bedrock.

Percakapan adalah serangkaian pesan antara pengguna dan model. Anda memulai percakapan dengan mengirim pesan sebagai pengguna (peran pengguna) ke model. Model, bertindak sebagai asisten (peran asisten), kemudian menghasilkan respons yang dikembalikan dalam pesan. Jika diinginkan, Anda dapat melanjutkan percakapan dengan mengirimkan pesan peran pengguna lebih lanjut ke model. Untuk mempertahankan konteks percakapan, pastikan untuk menyertakan pesan peran asisten yang Anda terima dari model dalam permintaan berikutnya. Untuk kode sampel, lihat Contoh API Converse.

Anda memberikan pesan yang ingin diteruskan ke model di messages bidang, yang memetakan ke array objek Pesan. Setiap Pesan berisi konten untuk pesan dan peran yang dimainkan pesan dalam percakapan.

catatan

Amazon Bedrock tidak menyimpan teks, gambar, atau dokumen apa pun yang Anda berikan sebagai konten. Data hanya digunakan untuk menghasilkan respons.

Anda menyimpan konten untuk pesan di content bidang, yang memetakan ke array ContentBlockobjek. Dalam masing-masing ContentBlock, Anda dapat menentukan salah satu bidang berikut (untuk melihat model apa yang mendukung modalitas apa, lihatModel dan fitur model yang didukung):

text

textBidang memetakan ke string yang menentukan prompt. textBidang ditafsirkan bersama bidang lain yang ditentukan dalam hal yang sama ContentBlock.

Berikut ini menunjukkan objek Message dengan content array yang hanya berisi teks ContentBlock:


{
    "role": "user | assistant",
    "content": [
        {
            "text": "string"
        }
    ]
}

image

imageBidang memetakan ke sebuah ImageBlock. 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 akan menggambarkan gambar.

Berikut ini menunjukkan objek Message dengan content array yang hanya berisi gambar: ContentBlock


{
    "role": "user",
    "content": [
        {
            "image": {
                "format": "png | jpeg | gif | webp",
                "source": {
                    "bytes": "image in bytes"
                }
            }
        }
    ]
}

document

documentBidang memetakan ke sebuah DocumentBlock. Jika Anda menyertakanDocumentBlock, periksa apakah permintaan Anda sesuai dengan batasan berikut:

Di content bidang objek Pesan, 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.
nameBidang hanya dapat berisi karakter berikut:
- Karakter alfanumerik
- Karakter spasi (tidak lebih dari satu berturut-turut)
- Tanda hubung
- Tanda kurung
- Kurung persegi
catatan
nameBidang ini rentan terhadap suntikan cepat, karena model mungkin secara tidak sengaja menafsirkannya sebagai instruksi. Oleh karena itu, kami menyarankan Anda menentukan nama netral.

Berikut ini menunjukkan objek Message dengan content array yang hanya berisi dokumen ContentBlockdan teks yang menyertainya diperlukan. ContentBlock


{
    "role": "user",
    "content": [
        {
            "text": "string"
        },
        {
            "document": {
                "format": "pdf | csv | doc | docx | xls | xlsx | html | txt | md",
                "name": "string",
                "source": {
                    "bytes": "document in bytes"
                }
            }
        }
    ]
}

Bidang lainnya ContentBlock adalah untuk penggunaan alat.

Anda menentukan peran di role lapangan. Peran tersebut dapat berupa salah satu dari yang berikut:

pengguna — Manusia yang mengirim pesan ke model.
asisten — Model yang mengirim pesan kembali ke pengguna manusia.

catatan

Pembatasan berikut berkaitan dengan content bidang:

Anda dapat menyertakan hingga 20 gambar. Ukuran, tinggi, dan lebar setiap gambar harus tidak lebih dari 3,75 MB, 8.000 px, dan 8.000 px, masing-masing.
Anda dapat memasukkan hingga lima dokumen. Ukuran setiap dokumen harus tidak lebih dari 4,5 MB.
Anda hanya dapat menyertakan gambar dan dokumen jika role adauser.

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"
            }
        ]
    }
]

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), seperti yang ditunjukkan pada contoh berikut.


[
    {
        "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. "
    }
]

Parameter inferensi

Converse API mendukung kumpulan dasar parameter inferensi yang Anda tetapkan di inferenceConfig field () InferenceConfiguration. 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 Parameter inferensi.

Contoh berikut JSON menetapkan parameter temperature inferensi.


{"temperature": 0.5}

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 menyeteltop_k, yang tersedia dalam Anthropic Claude model, tetapi bukan merupakan parameter inferensi dasar di API pesan.


{"top_k": 200}

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.

Respons

Respons yang Anda dapatkan dari Converse API bergantung pada operasi yang Anda panggil, Converse atauConverseStream.

Topik

Tanggapan Converse
ConverseStream respon

Tanggapan Converse

Dalam tanggapan dariConverse, output bidang (ConverseOutput) berisi pesan (Pesan) yang dihasilkan model. Konten pesan ada di bidang content (ContentBlock) dan peran (useratauassistant) yang sesuai dengan pesan ada di role bidang.

metricsBidang (ConverseMetrics) 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). 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 diPermintaan.


{
    "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.

messageStart(MessageStartEvent). Acara awal untuk sebuah pesan. Termasuk peran untuk pesan.
contentBlockStart(ContentBlockStartEvent). Acara mulai blok Konten. Hanya menggunakan alat.
contentBlockDelta(ContentBlockDeltaEvent). Acara delta blok Konten. Termasuk sebagian teks yang dihasilkan model atau json masukan sebagian untuk penggunaan alat.
contentBlockStop(ContentBlockStopEvent). Peristiwa penghentian blok Konten.
messageStop(MessageStopEvent). Acara berhenti untuk pesan. Termasuk alasan mengapa model berhenti menghasilkan output.
metadata(ConverseStreamMetadataEvent). Metadata untuk permintaan. Metadata mencakup penggunaan token in usage (TokenUsage) dan metrik untuk panggilan in metrics (). ConverseStreamMetadataEvent

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 dariConverseStream.


{'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}}}

Contoh API Converse

Contoh berikut menunjukkan kepada Anda cara menggunakan Converse dan ConverseStream operasi.

Topik

Conversation with text message example

Contoh ini menunjukkan cara memanggil Converse operasi dengan AnthropicClaude 3 Sonnetmodel. 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 Inggris.


# 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()

Conversation with image example

Contoh ini menunjukkan cara mengirim gambar sebagai bagian dari pesan dan permintaan agar model menggambarkan gambar. Contoh menggunakan Converse operasi dan AnthropicClaude 3 Sonnetmodel.


# 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 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 input message.
        input_image : The input image.

    Returns:
        response (JSON): The conversation that the model generated.

    """

    logger.info("Generating message with model %s", model_id)

    # Message to send.

    with open(input_image, "rb") as f:
        image = f.read()

    message = {
        "role": "user",
        "content": [
            {
                "text": input_text
            },
            {
                    "image": {
                        "format": 'png',
                        "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()

Conversation with document example

Contoh ini menunjukkan cara mengirim dokumen sebagai bagian dari pesan dan meminta agar model menggambarkan isi dokumen. Contoh menggunakan Converse operasi dan AnthropicClaude 3 Sonnetmodel.


# 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):
    """
    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 : The input document.

    Returns:
        response (JSON): The conversation that the model generated.

    """

    logger.info("Generating message with model %s", model_id)

    # Message to send.

    message = {
        "role": "user",
        "content": [
            {
                "text": input_text
            },
            {
                "document": {
                    "name": "MyDocument",
                    "format": "txt",
                    "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/to/document.pdf'

    try:

        bedrock_client = boto3.client(service_name="bedrock-runtime")


        response = generate_message(
            bedrock_client, model_id, input_text, input_document)

        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()

Conversation streaming example

Contoh ini menunjukkan cara memanggil ConverseStream operasi dengan AnthropicClaude 3 Sonnetmodel. 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()

Awas Javascript dinonaktifkan atau tidak tersedia di browser Anda.

Untuk menggunakan Dokumentasi AWS, Javascript harus diaktifkan. Lihat halaman Bantuan browser Anda untuk petunjuk.

Konvensi Dokumen

Jalankan inferensi single-prompt

Jalankan inferensi batch