Mantén una conversación con Converse

Puede usar Amazon Bedrock Converse API para crear aplicaciones conversacionales que envíen y reciban mensajes desde y hacia un modelo de Amazon Bedrock. Por ejemplo, puede crear un bot de chat que mantenga una conversación durante varios turnos y utilice una personalización de persona o tono que se adapte exclusivamente a sus necesidades, como un útil asistente de soporte técnico.

Para usar ConverseAPI, usa las operaciones de Converse o ConverseStream(para las respuestas de streaming) para enviar mensajes a una modelo. Es posible utilizar las operaciones de inferencia existentes (InvokeModelo InvokeModelWithResponseStream) para aplicaciones de conversación. Sin embargo, recomendamos utilizar ConverseAPI, API ya que es coherente y funciona con todos los modelos de Amazon Bedrock que admiten mensajes. Esto significa que puede escribir el código una vez y usarlo con diferentes modelos. Si un modelo tiene parámetros de inferencia únicos, la tecnología Converse API también le permite pasar esos parámetros únicos a una estructura específica del modelo.

Puede usar Converse API para implementar el uso de herramientas y barreras en sus aplicaciones.

nota

Con Mistral AI y Meta modelos, la Converse API incorpora tu entrada en una plantilla de mensajes específica para cada modelo que permite mantener conversaciones.

Modelos compatibles y características del modelo

La Converse API es compatible con los siguientes modelos y características del modelo de Amazon Bedrock. La Converse API no admite ningún modelo de incrustación (como Titan Embeddings G1 - Text) o modelos de generación de imágenes (como Stability AI).

Modelo	Conversar	ConverseStream	Indicaciones del sistema	Chat de documentos	Visión	Uso de herramientas	Uso de herramientas de streaming	Medidas de seguridad
AI21 Jamba-Instruct	Sí	Sí	Sí	No	No	No	No	No
AI21 Labs Jurassic-2 (Texto)	Limitado. Sin soporte por chat.	No	No	No	No	No	No	Sí
Amazon Titan modelos	Sí	Sí	No	Sí (excepto Titan Text Premier)	No	No	No	Sí
Anthropic Claude 2 y anteriores	Sí	Sí	Sí	Sí	No	No	No	Sí
Anthropic Claude 3	Sí	Sí	Sí	Sí	Sí	Sí	Sí	Sí
Anthropic Claude 3.5	Sí	Sí	Sí	No	Sí	Sí	Sí	Sí
Cohere Command	Limitado. Sin soporte por chat.	Limitado. Sin soporte por chat.	No	Sí	No	No	No	Sí
Cohere Command Light	Limitado. Sin soporte por chat.	Limitado. Sin soporte por chat.	No	No	No	No	No	Sí
Cohere Command R y Command R+	Sí	Sí	Sí	Sí	No	Sí	No	No
Meta Llama 2 y Llama 3	Sí	Sí	Sí	Sí	No	No	No	Sí
Meta Llama 3.1	Sí	Sí	Sí	Sí	No	Sí	No	Sí
Mistral AI Instruct	Sí	Sí	No	Sí	No	No	No	Sí
Mistral Large	Sí	Sí	Sí	Sí	No	Sí	No	Sí
Mistral Large 2 (24.07)	Sí	Sí	Sí	Sí	No	Sí	No	Sí
Mistral Small	Sí	Sí	Sí	No	No	Sí	No	Sí

nota

Cohere Command (Texto) y AI21 Labs Jurassic-2 (Texto) no admiten el chat con las Converse. API Los modelos solo pueden gestionar un mensaje de usuario a la vez y no pueden mantener el historial de una conversación. Se produce un error si intentas pasar más de un mensaje.

Usando el sistema Converse API

Para usar ConverseAPI, se llaman las ConverseStream operaciones Converse o para enviar mensajes a un modelo. Para llamarConverse, necesita permiso para realizar la bedrock:InvokeModel operación. Para llamarConverseStream, necesita un permiso para la bedrock:InvokeModelWithResponseStream operación.

Temas

• Solicitud
• Respuesta

Solicitud

Para especificar el modelo que desea utilizar, defina el modelId campo. Para obtener una lista de los modelos IDs compatibles con Amazon Bedrock, consulteModelo Amazon Bedrock IDs.

Una conversación es una serie de mensajes entre el usuario y la modelo. Se inicia una conversación enviando un mensaje como usuario (rol de usuario) al modelo. El modelo, que actúa como asistente (rol de asistente), genera entonces una respuesta que devuelve en forma de mensaje. Si lo desea, puede continuar la conversación enviando más mensajes sobre el rol de usuario al modelo. Para mantener el contexto de la conversación, asegúrese de incluir cualquier mensaje sobre el rol de asistente que reciba del modelo en las solicitudes posteriores. Para ver el código de ejemplo, consulte Ejemplos de converse API.

Usted proporciona los mensajes que desea pasar a un modelo en el messages campo, que se asigna a una matriz de objetos de Message. Cada mensaje contiene el contenido del mensaje y la función que desempeña el mensaje en la conversación.

nota

Amazon Bedrock no almacena ningún texto, imagen o documento que proporciones como contenido. Los datos solo se utilizan para generar la respuesta. Al usar ConverseAPI, debe usar un documento descomprimido y decodificado que tenga un tamaño inferior a 4,5 MB.

El contenido del mensaje se almacena en el content campo, que se asigna a una matriz de objetos. ContentBlock Dentro de cada uno de ellos ContentBlock, puede especificar uno de los siguientes campos (para ver qué modelos admiten qué modalidades, consulteModelos compatibles y características del modelo):

text

El text campo se asigna a una cadena que especifica la solicitud. El text campo se interpreta junto con otros campos que se especifican en el mismo ContentBlock.

A continuación, se muestra un objeto Message con una content matriz que contiene solo un texto ContentBlock:

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

image

El image campo se asigna a un ImageBlock. Pase los bytes sin procesar, codificados en base64, a una imagen del bytes campo. Si usa un AWS SDK, no necesita codificar los bytes en base64.

Si excluyes el text campo, el modelo describirá la imagen.

A continuación, se muestra un objeto Message con una content matriz que contiene solo una imagen: ContentBlock

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

document

El document campo se asigna a un. DocumentBlock Si incluye unDocumentBlock, compruebe que su solicitud cumpla con las siguientes restricciones:

• En el content campo del objeto Mensaje, también debe incluir un text campo con un mensaje relacionado con el documento.

• Pase los bytes sin procesar, codificados en base64, del documento al bytes campo. Si usa un AWS SDK, no necesita codificar los bytes del documento en base64.

• El name campo solo puede contener los siguientes caracteres:

  • Caracteres alfanuméricos

  • Caracteres de espacio en blanco (no más de uno en una fila)

  • Guiones

  • Paréntesis

  • Corchetes

  nota

  El name campo es vulnerable a las inyecciones rápidas, ya que el modelo podría interpretarlas inadvertidamente como instrucciones. Por lo tanto, le recomendamos que especifique un nombre neutro.

A continuación se muestra un objeto Message con una content matriz que contiene solo un documento ContentBlocky el texto adjunto obligatorio ContentBlock.

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

Los demás campos ContentBlock son para el uso de la herramienta.

El rol se especifica en el role campo. El rol puede ser uno de los siguientes:

• usuario: la persona que envía mensajes al modelo.

• asistente: el modelo que envía mensajes al usuario humano.

nota

Las siguientes restricciones se refieren a content este campo:

• Puedes incluir hasta 20 imágenes. El tamaño, la altura y el ancho de cada imagen no deben ser superiores a 3,75 MB, 8000 px y 8000 px, respectivamente.

• Puedes incluir hasta cinco documentos. El tamaño de cada documento no debe superar los 4,5 MB.

• Solo puede incluir imágenes y documentos si los role hayuser.

En el siguiente messages ejemplo, el usuario solicita una lista de tres canciones pop y el modelo genera una lista de canciones.

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

Un mensaje del sistema es un tipo de mensaje que proporciona instrucciones o contexto al modelo sobre la tarea que debe realizar o la persona que debe adoptar durante la conversación. Puede especificar una lista de mensajes del sistema para la solicitud en el campo system (SystemContentBlock), como se muestra en el siguiente ejemplo.

[
    {
        "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 inferencia

Converse API admite un conjunto básico de parámetros de inferencia que se establecen en el inferenceConfig campo (). InferenceConfiguration El conjunto base de parámetros de inferencia es:

• maxTokens— El número máximo de fichas que se pueden introducir en la respuesta generada.

• stopSequences— Una lista de secuencias de paradas. Una secuencia de parada es una secuencia de caracteres que hace que el modelo deje de generar la respuesta.

• temperatura: probabilidad de que el modelo seleccione opciones de mayor probabilidad al generar una respuesta.

• TopP: el porcentaje de candidatos más probables que el modelo considera para el siguiente token.

Para obtener más información, consulte Influya en la generación de respuestas con parámetros de inferencia.

El siguiente ejemplo JSON establece el parámetro de inferencia. temperature

{"temperature": 0.5}

Si el modelo que está utilizando tiene parámetros de inferencia adicionales, puede establecer esos parámetros especificándolos como JSON en el additionalModelRequestFields campo. El siguiente ejemplo JSON muestra cómo configurarlostop_k, que está disponible en Anthropic Claude modela, pero no es un parámetro de inferencia base en los mensajesAPI.

{"top_k": 200}

Puede especificar las rutas de los parámetros de modelo adicionales en el additionalModelResponseFieldPaths campo, como se muestra en el siguiente ejemplo.

[ "/stop_sequence" ]

APIDevuelve los campos adicionales que solicite en el additionalModelResponseFields campo.

Respuesta

La respuesta que reciba de Converse API depende de la operación a la que llame, Converse oConverseStream.

Temas

• Respuesta inversa
• ConverseStream respuesta

Respuesta inversa

En la respuesta deConverse, el output campo (ConverseOutput) contiene el mensaje (Mensaje) que genera el modelo. El contenido del mensaje está en el campo content (ContentBlock) y el rol (useroassistant) al que corresponde el mensaje está en el role campo.

El metrics campo (ConverseMetrics) incluye las métricas de la llamada. Para determinar por qué el modelo dejó de generar contenido, active el stopReason campo. Para obtener información sobre los tokens transferidos al modelo en la solicitud y los tokens generados en la respuesta, marque el usage campo (TokenUsage). Si especificó campos de respuesta adicionales en la solicitud, los API devuelve como JSON en el additionalModelResponseFields campo.

En el siguiente ejemplo, se muestra la respuesta Converse al pasar la solicitud descrita enSolicitud.

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

Si llama ConverseStream para transmitir la respuesta de un modelo, la secuencia se devuelve en el campo de stream respuesta. La transmisión emite los siguientes eventos en el orden siguiente.

1. messageStart(MessageStartEvent). El evento de inicio de un mensaje. Incluye la función del mensaje.

2. contentBlockStart(ContentBlockStartEvent). Un evento de inicio de un bloque de contenido. Solo para uso de herramientas.

3. contentBlockDelta(ContentBlockDeltaEvent). Un evento delta de bloques de contenido. Incluye el texto parcial que genera el modelo o el json de entrada parcial para el uso de la herramienta.

4. contentBlockStop(ContentBlockStopEvent). Un evento de interrupción del bloqueo de contenido.

5. messageStop(MessageStopEvent). El evento de parada del mensaje. Incluye el motivo por el que el modelo dejó de generar resultados.

6. metadata(ConverseStreamMetadataEvent). Metadatos de la solicitud. Los metadatos incluyen el uso del token en usage (TokenUsage) y las métricas de la llamada en metrics (ConverseStreamMetadataEvent).

ConverseStream transmite un bloque de contenido completo como un ContentBlockStartEvent evento, uno o más ContentBlockDeltaEvent eventos y un ContentBlockStopEvent evento. Utilice el contentBlockIndex campo como índice para correlacionar los eventos que componen un bloque de contenido.

El siguiente ejemplo es una respuesta 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}}}

Ejemplos de converse API

Los siguientes ejemplos muestran cómo utilizar las ConverseStream operaciones Converse y.

Temas

Conversation with text message example

En este ejemplo, se muestra cómo llamar a la Converse operación con el Anthropic Claude 3 Sonnetmodelo. El ejemplo muestra cómo enviar el texto de entrada, los parámetros de inferencia y los parámetros adicionales que son exclusivos del modelo. El código inicia una conversación pidiéndole al modelo que cree una lista de canciones. Luego continúa la conversación pidiendo que las canciones sean de artistas del 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

En este ejemplo se muestra cómo enviar una imagen como parte de un mensaje y se solicita a la modelo que describa la imagen. En el ejemplo se utiliza Converse la operación y el Anthropic Claude 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

En este ejemplo se muestra cómo enviar un documento como parte de un mensaje y se solicita que el modelo describa el contenido del documento. En el ejemplo se utiliza Converse la operación y el Anthropic Claude 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

En este ejemplo se muestra cómo llamar a la ConverseStream operación con el Anthropic Claude 3 Sonnetmodelo. El ejemplo muestra cómo enviar el texto de entrada, los parámetros de inferencia y los parámetros adicionales que son exclusivos del 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()