Use a API Converse

Você pode usar a API Amazon Bedrock Converse para criar aplicativos de conversação que enviam e recebem mensagens de e para um modelo Amazon Bedrock. Por exemplo, você pode criar um bot de bate-papo que mantenha uma conversa por vários turnos e use uma personalização de persona ou tom exclusiva de acordo com suas necessidades, como um útil assistente de suporte técnico.

Para usar a API Converse, você usa as operações Converse ou ConverseStream(para respostas de streaming) para enviar mensagens para um modelo. É possível usar as operações de inferência existentes (InvokeModelou InvokeModelWithResponseStream) para aplicativos de conversação. No entanto, recomendamos o uso da API Converse, pois ela fornece uma API consistente, que funciona com todos os modelos do Amazon Bedrock que oferecem suporte a mensagens. Isso significa que você pode escrever código uma vez e usá-lo com modelos diferentes. Caso um modelo tenha parâmetros de inferência exclusivos, a API Converse também permite que você transmita esses parâmetros exclusivos em uma estrutura específica do modelo.

Você pode usar a API Converse para implementar o uso de ferramentas e proteções em seus aplicativos.

nota

Com modelos Mistral AI de código Meta aberto, a API Converse incorpora sua entrada em um modelo de prompt específico do modelo que permite conversas.

Modelos e recursos do modelo compatíveis

A API Converse é compatível com os seguintes modelos e recursos de modelo do Amazon Bedrock. A API Converse não é compatível com nenhum modelo de incorporação (comoTitan Embeddings G1 - Text) ou modelo de geração de imagem (comoStability AI).

Modelo	Converse	ConverseStream	Solicitações do sistema	Chat de documentos	Visão	Uso de ferramentas	Uso da ferramenta de streaming	Proteções
AI21 Jamba-Instruct	Sim	Não	Sim	Não	Não	Não	Não	Não
AI21 LabsJurassic-2(Texto)	Limitado. Sem suporte por chat.	Não	Não	Não	Não	Não	Não	Sim
TitanModelos da Amazon	Sim	Sim	Não	Sim (excetoTitan Text Premier)	Não	Não	Não	Sim
AnthropicClaude2 e anteriores	Sim	Sim	Sim	Sim	Não	Não	Não	Sim
AnthropicClaude3	Sim	Sim	Sim	Sim	Sim	Sim	Sim	Sim
AnthropicClaude3.5	Sim	Sim	Sim	Não	Sim	Sim	Sim	Sim
Cohere Command	Limitado. Sem suporte por chat.	Limitado. Sem suporte por chat.	Não	Sim	Não	Não	Não	Sim
Cohere Command Light	Limitado. Sem suporte por chat.	Limitado. Sem suporte por chat.	Não	Não	Não	Não	Não	Sim
Cohere e Command R Command R+	Sim	Sim	Sim	Sim	Não	Sim	Não	Não
Meta e Llama 2 Llama 3	Sim	Sim	Sim	Sim	Não	Não	Não	Sim
Mistral AI Instruct	Sim	Sim	Não	Sim	Não	Não	Não	Sim
Mistral Large	Sim	Sim	Sim	Sim	Não	Sim	Não	Sim
Mistral Small	Sim	Sim	Sim	Não	Não	Sim	Não	Sim

nota

CohereCommand(Texto) e AI21 Labs Jurassic-2 (Texto) não oferecem suporte ao bate-papo com a API Converse. Os modelos só conseguem lidar com uma mensagem de usuário por vez e não conseguem manter o histórico de uma conversa. Você receberá um erro se tentar passar mais de uma mensagem.

Usando a API Converse

Para usar a API Converse, você chama as ConverseStream operações Converse ou para enviar mensagens para um modelo. Para ligarConverse, você precisa de permissão para a bedrock:InvokeModel operação. Para ligarConverseStream, você precisa de permissão para a bedrock:InvokeModelWithResponseStream operação.

Tópicos

• Solicitação
• Resposta

Solicitação

Você especifica o modelo que deseja usar definindo o modelId campo. Para obter uma lista de IDs de modelo compatíveis com o Amazon Bedrock, consulteIDs de modelo Amazon Bedrock.

Uma conversa é uma série de mensagens entre o usuário e a modelo. Você inicia uma conversa enviando uma mensagem como usuário (função de usuário) para o modelo. O modelo, atuando como assistente (função de assistente), gera uma resposta que retorna em uma mensagem. Se desejar, você pode continuar a conversa enviando mais mensagens sobre a função do usuário para o modelo. Para manter o contexto da conversa, não se esqueça de incluir todas as mensagens de função de assistente que você receber do modelo nas solicitações subsequentes. Para ver um código demonstrativo, consulte Exemplos da API Converse.

Você fornece as mensagens que deseja passar para um modelo no messages campo, que mapeia para uma matriz de objetos Message. Cada mensagem contém o conteúdo da mensagem e a função que a mensagem desempenha na conversa.

nota

O Amazon Bedrock não armazena nenhum texto, imagem ou documento que você forneça como conteúdo. Os dados são usados somente para gerar a resposta.

Você armazena o conteúdo da mensagem no content campo, que é mapeado para uma matriz de ContentBlockobjetos. Em cada um ContentBlock, você pode especificar um dos seguintes campos (para ver quais modelos suportam quais modalidades, consulteModelos e recursos do modelo compatíveis):

text

O text campo é mapeado para uma string especificando o prompt. O text campo é interpretado junto com outros campos especificados no mesmo ContentBlock.

O seguinte mostra um objeto Message com uma content matriz contendo somente um texto ContentBlock:

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

image

O image campo é mapeado para um ImageBlock. Passe os bytes brutos, codificados em base64, para uma imagem no bytes campo. Se você usa um AWS SDK, não precisa codificar os bytes em base64.

Se você excluir o text campo, o modelo descreverá a imagem.

O seguinte mostra um objeto Message com uma content matriz contendo somente uma imagem: ContentBlock

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

document

O document campo é mapeado para um DocumentBlock. Se você incluir umDocumentBlock, verifique se sua solicitação está em conformidade com as seguintes restrições:

• No content campo do objeto Mensagem, você também deve incluir um text campo com uma solicitação relacionada ao documento.

• Passe os bytes brutos, codificados em base64, para o documento no bytes campo. Se você usa um AWS SDK, não precisa codificar os bytes do documento em base64.

• O name campo só pode conter os seguintes caracteres:

  • Caracteres alfanuméricos

  • Caracteres de espaço em branco (não mais do que um em uma linha)

  • Hífens

  • Parênteses

  • Colchetes

  nota

  O name campo é vulnerável a injeções imediatas, porque o modelo pode inadvertidamente interpretá-lo como instruções. Portanto, recomendamos que você especifique um nome neutro.

O exemplo a seguir mostra um objeto Message com uma content matriz contendo somente um documento ContentBlocke um texto ContentBlockde acompanhamento obrigatório.

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

Os outros campos ContentBlock são para uso de ferramentas.

Você especifica a função no role campo. A função pode ser uma das seguintes:

• usuário — O humano que está enviando mensagens para o modelo.

• assistente — O modelo que está enviando mensagens de volta para o usuário humano.

nota

As seguintes restrições se referem ao content campo:

• Você pode incluir até 20 imagens. O tamanho, a altura e a largura de cada imagem não devem exceder 3,75 MB, 8.000 px e 8.000 px, respectivamente.

• Você pode incluir até cinco documentos. O tamanho de cada documento não deve ser superior a 4,5 MB.

• Você só pode incluir imagens e documentos se role for o casouser.

No messages exemplo a seguir, o usuário solicita uma lista de três músicas pop e o modelo gera uma lista de músicas.

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

Um prompt do sistema é um tipo de aviso que fornece instruções ou contexto ao modelo sobre a tarefa que ele deve realizar ou a personalidade que ele deve adotar durante a conversa. Você pode especificar uma lista de solicitações do sistema para a solicitação no campo system (SystemContentBlock), conforme mostrado no exemplo a seguir.

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

Parâmetros de inferência

A API Converse é compatível com um conjunto básico de parâmetros de inferência que você define no inferenceConfig campo () InferenceConfiguration. O conjunto básico de parâmetros de inferência é:

• maxTokens — O número máximo de tokens a serem permitidos na resposta gerada.

• StopSequences — Uma lista de sequências de parada. Uma sequência de parada é uma sequência de caracteres que faz com que o modelo pare de gerar a resposta.

• temperatura — A probabilidade de o modelo selecionar opções de maior probabilidade ao gerar uma resposta.

• TopP — A porcentagem de candidatos mais prováveis que o modelo considera para o próximo token.

Para ter mais informações, consulte Parâmetros de inferência.

O exemplo a seguir, JSON define o parâmetro de temperature inferência.

{"temperature": 0.5}

Se o modelo que você está usando tiver parâmetros de inferência adicionais, você poderá definir esses parâmetros especificando-os como JSON no campo. additionalModelRequestFields O exemplo de JSON a seguir mostra como definirtop_k, que está disponível em Anthropic Claude modelos, mas não é um parâmetro básico de inferência na API de mensagens.

{"top_k": 200}

Você pode especificar os caminhos para parâmetros adicionais do modelo no additionalModelResponseFieldPaths campo, conforme mostrado no exemplo a seguir.

[ "/stop_sequence" ]

A API retorna os campos adicionais que você solicita no additionalModelResponseFields campo.

Resposta

A resposta que você recebe da API Converse depende de qual operação você chama, Converse ouConverseStream.

Tópicos

• Resposta inversa
• ConverseStream resposta

Resposta inversa

Na resposta deConverse, o output campo (ConverseOutput) contém a mensagem (Mensagem) que o modelo gera. O conteúdo da mensagem está no campo content (ContentBlock) e a função (userouassistant) à qual a mensagem corresponde está no role campo.

O metrics campo (ConverseMetrics) inclui métricas para a chamada. Para determinar por que o modelo parou de gerar conteúdo, verifique o stopReason campo. Você pode obter informações sobre os tokens passados para o modelo na solicitação e os tokens gerados na resposta, verificando o usage campo (TokenUsage). Se você especificou campos de resposta adicionais na solicitação, a API os retornará como JSON no additionalModelResponseFields campo.

O exemplo a seguir mostra a resposta de Converse quando você passa a solicitação discutida emSolicitação.

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

Se você ligar ConverseStream para transmitir a resposta de um modelo, o fluxo será retornado no campo de stream resposta. O stream emite os seguintes eventos na seguinte ordem.

1. messageStart(MessageStartEvent). O evento inicial de uma mensagem. Inclui a função da mensagem.

2. contentBlockStart(ContentBlockStartEvent). Um evento de início do bloco de conteúdo. Somente para uso da ferramenta.

3. contentBlockDelta(ContentBlockDeltaEvent). Um evento delta do bloco de conteúdo. Inclui o texto parcial que o modelo gera ou a entrada parcial json para uso da ferramenta.

4. contentBlockStop(ContentBlockStopEvent). Um evento de interrupção do bloqueio de conteúdo.

5. messageStop(MessageStopEvent). O evento de parada da mensagem. Inclui o motivo pelo qual o modelo parou de gerar saída.

6. metadata(ConverseStreamMetadataEvent). Metadados para a solicitação. Os metadados incluem o uso do token em usage (TokenUsage) e métricas para a chamada em metrics (ConverseStreamMetadataEvent).

ConverseStream transmite um bloco de conteúdo completo como um ContentBlockStartEvent evento, um ou mais ContentBlockDeltaEvent eventos e um ContentBlockStopEvent evento. Use o contentBlockIndex campo como um índice para correlacionar os eventos que compõem um bloco de conteúdo.

O exemplo a seguir é uma resposta parcial deConverseStream.

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

Exemplos da API Converse

Os exemplos a seguir mostram como usar as ConverseStream operações Converse e.

Tópicos

Conversation with text message example

Este exemplo mostra como chamar a Converse operação com o AnthropicClaude 3 Sonnetmodelo. O exemplo mostra como enviar o texto de entrada, os parâmetros de inferência e os parâmetros adicionais exclusivos do modelo. O código inicia uma conversa solicitando que a modelo crie uma lista de músicas. Em seguida, continua a conversa pedindo que as músicas sejam de artistas do Reino Unido.

# 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

Este exemplo mostra como enviar uma imagem como parte de uma mensagem e solicita que o modelo descreva a imagem. O exemplo usa Converse a operação e o AnthropicClaude 3 Sonnetmodelo.

# 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

Este exemplo mostra como enviar um documento como parte de uma mensagem e solicita que o modelo descreva o conteúdo do documento. O exemplo usa Converse a operação e o AnthropicClaude 3 Sonnetmodelo.

# 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

Este exemplo mostra como chamar a ConverseStream operação com o AnthropicClaude 3 Sonnetmodelo. O exemplo mostra como enviar o texto de entrada, os parâmetros de inferência e os parâmetros adicionais exclusivos do modelo.

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