Modèles pris en charge et caractéristiques des modèles Utilisation de la Converse API Exemples de Converse API

Utilisez la Converse API

Vous pouvez utiliser Amazon Bedrock Converse API pour créer des applications conversationnelles qui envoient et reçoivent des messages depuis et vers un modèle Amazon Bedrock. Par exemple, vous pouvez créer un chatbot qui entretient une conversation à plusieurs reprises et utilise une personnalisation du personnage ou du ton adaptée à vos besoins, par exemple un assistant de support technique utile.

Pour utiliser ConverseAPI, vous devez utiliser les opérations Converse ou ConverseStream(pour les réponses en streaming) pour envoyer des messages à un modèle. Il est possible d'utiliser les opérations d'inférence existantes (InvokeModelou InvokeModelWithResponseStream) pour les applications de conversation. Cependant, nous vous recommandons d'utiliser la Converse API car elle est cohérente API et fonctionne avec tous les modèles Amazon Bedrock compatibles avec les messages. Cela signifie que vous pouvez écrire du code une seule fois et l'utiliser avec différents modèles. Si un modèle possède des paramètres d'inférence uniques, le Converse vous permet API également de transmettre ces paramètres uniques dans une structure spécifique au modèle.

Vous pouvez utiliser le Converse API pour implémenter l'utilisation d'outils et de garde-fous dans vos applications.

Note

Avec Mistral AI et Meta models, la Converse API intègre vos entrées dans un modèle d'invite spécifique au modèle qui permet les conversations.

Rubriques

Modèles pris en charge et caractéristiques des modèles
Utilisation de la Converse API
Exemples de Converse API

Modèles pris en charge et caractéristiques des modèles

La Converse est API compatible avec les modèles et fonctionnalités Amazon Bedrock suivants. La Converse API ne prend en charge aucun modèle d'intégration (tel queTitan Embeddings G1 - Text) ni aucun modèle de génération d'image (tel queStability AI).

Modèle	Converse	ConverseStream	Invitations du système	Conversation de documents	Vision	Utilisation de l'outil	Utilisation de l'outil de streaming	Barrières de sécurité
AI21 Jamba-Instruct	Oui	Oui	Oui	Non	Non	Non	Non	Non
AI21 LabsJurassic-2(Texte)	Limité. Aucune assistance par chat.	Non	Non	Non	Non	Non	Non	Oui
TitanModèles Amazon	Oui	Oui	Non	Oui (saufTitan Text Premier)	Non	Non	Non	Oui
AnthropicClaude2 et versions antérieures	Oui	Oui	Oui	Oui	Non	Non	Non	Oui
AnthropicClaude3	Oui	Oui	Oui	Oui	Oui	Oui	Oui	Oui
AnthropicClaude3,5	Oui	Oui	Oui	Non	Oui	Oui	Oui	Oui
Cohere Command	Limité. Aucune assistance par chat.	Limité. Aucune assistance par chat.	Non	Oui	Non	Non	Non	Oui
Cohere Command Light	Limité. Aucune assistance par chat.	Limité. Aucune assistance par chat.	Non	Non	Non	Non	Non	Oui
Cohere et Command R Command R+	Oui	Oui	Oui	Oui	Non	Oui	Non	Non
Meta et Llama 2 Llama 3	Oui	Oui	Oui	Oui	Non	Non	Non	Oui
Meta Llama 3.1	Oui	Oui	Oui	Oui	Non	Oui	Non	Oui
Mistral AI Instruct	Oui	Oui	Non	Oui	Non	Non	Non	Oui
Mistral Large	Oui	Oui	Oui	Oui	Non	Oui	Non	Oui
Mistral Large 2 (24.07)	Oui	Oui	Oui	Oui	Non	Oui	Non	Oui
Mistral Small	Oui	Oui	Oui	Non	Non	Oui	Non	Oui

Note

CohereCommand(Text) et AI21 Labs Jurassic-2 (Text) ne permettent pas de discuter avec les Converse. API Les modèles ne peuvent traiter qu'un seul message utilisateur à la fois et ne peuvent pas conserver l'historique d'une conversation. Un message d'erreur s'affiche si vous tentez de transmettre plusieurs messages.

Utilisation de la Converse API

Pour utiliser les ConverseAPI, vous devez appeler les ConverseStream opérations Converse or pour envoyer des messages à un modèle. Pour appelerConverse, vous devez disposer d'une autorisation pour effectuer l'bedrock:InvokeModelopération. Pour appelerConverseStream, vous devez disposer d'une autorisation pour effectuer l'bedrock:InvokeModelWithResponseStreamopération.

Demande

Vous spécifiez le modèle que vous souhaitez utiliser en définissant le modelId champ. Pour obtenir la liste des modèles pris IDs en charge par Amazon Bedrock, consultezModèle Amazon Bedrock IDs.

Une conversation est une série de messages entre l'utilisateur et le modèle. Vous démarrez une conversation en envoyant un message en tant qu'utilisateur (rôle d'utilisateur) au modèle. Le modèle, agissant en tant qu'assistant (rôle d'assistant), génère ensuite une réponse qu'il renvoie dans un message. Si vous le souhaitez, vous pouvez poursuivre la conversation en envoyant d'autres messages relatifs au rôle d'utilisateur au modèle. Pour conserver le contexte de la conversation, veillez à inclure tous les messages relatifs au rôle d'assistant que vous recevrez du modèle dans les demandes suivantes. Pour obtenir un exemple de code, consultez Exemples de Converse API.

Vous fournissez les messages que vous souhaitez transmettre à un modèle messages sur le terrain, qui correspond à un tableau d'objets Message. Chaque message contient le contenu du message et le rôle que le message joue dans la conversation.

Note

Amazon Bedrock ne stocke aucun texte, image ou document que vous fournissez sous forme de contenu. Les données ne sont utilisées que pour générer la réponse.

Vous stockez le contenu du message dans le content champ, qui correspond à un ensemble d'ContentBlockobjets. Dans chacun d'eux ContentBlock, vous pouvez spécifier l'un des champs suivants (pour savoir quels modèles prennent en charge quelles modalités, voirModèles pris en charge et caractéristiques des modèles) :

text

Le text champ correspond à une chaîne spécifiant l'invite. Le text champ est interprété parallèlement aux autres champs qui y sont spécifiés ContentBlock.

L'image suivante montre un objet Message avec un content tableau contenant uniquement du texte ContentBlock:


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

image

Le image champ correspond à un ImageBlock. Passez les octets bruts, codés en base64, pour une image dans le bytes champ. Si vous utilisez un AWS SDK, vous n'avez pas besoin de coder les octets en base64.

Si vous excluez le text champ, le modèle décrira l'image.

L'image suivante montre un objet Message avec un content tableau contenant uniquement une image : ContentBlock


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

document

Le document champ correspond à un DocumentBlock. Si vous incluez unDocumentBlock, vérifiez que votre demande est conforme aux restrictions suivantes :

Dans le content champ de l'objet Message, vous devez également inclure un text champ contenant une invite liée au document.
Transmettez les octets bruts, codés en base64, pour le document dans le bytes champ. Si vous utilisez un AWS SDK, vous n'avez pas besoin de coder les octets du document en base64.
Le name champ ne peut contenir que les caractères suivants :
- Caractères alphanumériques
- Caractères d'espacement (pas plus d'un par ligne)
- Tirets
- Parenthèses
- Crochets
Note
Le name champ est vulnérable aux injections rapides, car le modèle risque de l'interpréter par inadvertance comme des instructions. Par conséquent, nous vous recommandons de spécifier un nom neutre.

L'image suivante montre un objet Message avec un content tableau contenant uniquement un document ContentBlocket le texte d'accompagnement obligatoire ContentBlock.


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

Les autres champs ContentBlock sont destinés à l'utilisation des outils.

Vous spécifiez le rôle dans le role champ. Le rôle peut être l'un des suivants :

user — L'humain qui envoie des messages au modèle.
assistant — Le modèle qui renvoie des messages à l'utilisateur humain.

Note

Les restrictions suivantes s'appliquent à ce content champ :

Vous pouvez inclure jusqu'à 20 images. La taille, la hauteur et la largeur de chaque image ne doivent pas dépasser 3,75 Mo, 8 000 pixels et 8 000 pixels, respectivement.
Vous pouvez inclure jusqu'à cinq documents. La taille de chaque document ne doit pas dépasser 4,5 Mo.
Vous ne pouvez inclure des images et des documents que si role c'est le casuser.

Dans l'messagesexemple suivant, l'utilisateur demande une liste de trois chansons pop, et le modèle génère une liste de chansons.


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

Une invite système est un type d'invite qui fournit des instructions ou un contexte au modèle concernant la tâche qu'il doit effectuer ou le personnage qu'il doit adopter au cours de la conversation. Vous pouvez spécifier une liste d'invites système pour la demande dans le champ system (SystemContentBlock), comme illustré dans l'exemple suivant.


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

Paramètres d’inférence

Le Converse API prend en charge un ensemble de base de paramètres d'inférence que vous définissez dans le inferenceConfig champ () InferenceConfiguration. L'ensemble de base des paramètres d'inférence est le suivant :

maxTokens— Le nombre maximum de jetons à autoriser dans la réponse générée.
stopSequences— Liste des séquences d'arrêt. Une séquence d'arrêt est une séquence de caractères qui empêche le modèle de générer la réponse.
température — Probabilité que le modèle sélectionne des options à probabilité plus élevée lors de la génération d'une réponse.
TopP — Le pourcentage de candidats les plus probables que le modèle prend en compte pour le jeton suivant.

Pour de plus amples informations, veuillez consulter Paramètres d’inférence.

L'exemple suivant JSON définit le paramètre temperature d'inférence.


{"temperature": 0.5}

Si le modèle que vous utilisez possède des paramètres d'inférence supplémentaires, vous pouvez définir ces paramètres en les spécifiant comme JSON dans le additionalModelRequestFields champ. L'exemple suivant JSON montre comment définirtop_k, ce qui est disponible dans les Anthropic Claude modèles, mais qui n'est pas un paramètre d'inférence de base dans les messagesAPI.


{"top_k": 200}

Vous pouvez spécifier les chemins pour les paramètres de modèle supplémentaires dans le additionalModelResponseFieldPaths champ, comme illustré dans l'exemple suivant.


[ "/stop_sequence" ]

APIRenvoie les champs supplémentaires que vous demandez dans le additionalModelResponseFields champ.

Réponse

La réponse que vous obtenez de la Converse API dépend de l'opération que vous appelez, Converse ouConverseStream.

Rubriques

Réponse inverse
ConverseStream réponse

Réponse inverse

Dans le formulaire de réponseConverse, le output champ (ConverseOutput) contient le message (Message) généré par le modèle. Le contenu du message se trouve dans le champ content (ContentBlock) et le rôle (userouassistant) auquel le message correspond se trouve dans le role champ.

Le metrics champ (ConverseMetrics) inclut les métriques de l'appel. Pour déterminer pourquoi le modèle a cessé de générer du contenu, vérifiez le stopReason champ. Vous pouvez obtenir des informations sur les jetons transmis au modèle dans la demande et sur les jetons générés dans la réponse en cochant le usage champ (TokenUsage). Si vous avez indiqué des champs de réponse supplémentaires dans la demande, ils sont API renvoyés comme JSON dans le additionalModelResponseFields champ.

L'exemple suivant montre la réponse Converse lorsque vous avez répondu à l'invite décrite dansDemande.


{
    "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 réponse

Si vous appelez ConverseStream pour diffuser la réponse d'un modèle, le flux est renvoyé dans le champ de stream réponse. Le flux émet les événements suivants dans l'ordre suivant.

messageStart(MessageStartEvent). L'événement de début d'un message. Inclut le rôle du message.
contentBlockStart(ContentBlockStartEvent). Un événement de démarrage d'un bloc de contenu. Utilisation d'outils uniquement.
contentBlockDelta(ContentBlockDeltaEvent). Un événement delta du bloc de contenu. Inclut le texte partiel généré par le modèle ou le json d'entrée partiel pour l'utilisation de l'outil.
contentBlockStop(ContentBlockStopEvent). Un événement d'arrêt du blocage du contenu.
messageStop(MessageStopEvent). L'événement d'arrêt du message. Inclut la raison pour laquelle le modèle a cessé de générer une sortie.
metadata(ConverseStreamMetadataEvent). Métadonnées pour la demande. Les métadonnées incluent l'utilisation du jeton dans usage (TokenUsage) et les métriques de l'appel dans metrics (ConverseStreamMetadataEvent).

ConverseStream diffuse un bloc de contenu complet sous forme d'ContentBlockStartEventévénement, d'un ou de plusieurs ContentBlockDeltaEvent événements et d'un ContentBlockStopEvent événement. Utilisez le contentBlockIndex champ comme index pour corréler les événements qui constituent un bloc de contenu.

L'exemple suivant est une réponse partielle 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}}}

Exemples de Converse API

Les exemples suivants montrent comment utiliser les ConverseStream opérations Converse et.

Rubriques

Conversation with text message example

Cet exemple montre comment appeler l'Converseopération avec le AnthropicClaude 3 Sonnetmodèle. L'exemple montre comment envoyer le texte d'entrée, les paramètres d'inférence et les paramètres supplémentaires propres au modèle. Le code lance une conversation en demandant au modèle de créer une liste de chansons. Il poursuit ensuite la conversation en demandant que les chansons soient d'artistes du Royaume-Uni.


# 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

Cet exemple montre comment envoyer une image dans le cadre d'un message et demande au modèle de décrire l'image. L'exemple utilise le Converse fonctionnement et le AnthropicClaude 3 Sonnetmodèle.


# 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

Cet exemple montre comment envoyer un document dans le cadre d'un message et demande au modèle de décrire le contenu du document. L'exemple utilise le Converse fonctionnement et le AnthropicClaude 3 Sonnetmodèle.


# 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

Cet exemple montre comment appeler l'ConverseStreamopération avec le AnthropicClaude 3 Sonnetmodèle. L'exemple montre comment envoyer le texte d'entrée, les paramètres d'inférence et les paramètres supplémentaires propres au modèle.


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

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Exécution de l’inférence avec une seule invite

Exécution de l’inférence par lots