Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Mener une conversation avec les opérations d’API Converse
Vous pouvez utiliser l’API Amazon Bedrock Converse 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 bot de discussion 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 l'ConverseAPI, vous devez utiliser les opérations [Converse](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html) ou [ConverseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ConverseStream.html)(pour les réponses en streaming) pour envoyer des messages à un modèle. Il est possible d'utiliser les opérations d'inférence de base existantes ([InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)ou [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)) pour les applications de conversation. Cependant, nous vous recommandons d’utiliser l’API Converse, car elle fournit une API cohérente, qui fonctionne avec tous les modèles Amazon Bedrock qui prennent en charge 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, l’API Converse vous permet également de transmettre ces paramètres uniques dans une structure spécifique au modèle.
Vous pouvez utiliser l’API Converse pour implémenter l’[utilisation d’outils](tool-use.md) et de [barrières de protection](guardrails-use-converse-api.md) dans vos applications.
**Note**
Avec les modèles Mistral AI et Meta, l’API Converse intègre vos entrées dans un modèle d’invite spécifique au modèle qui permet les conversations.
Des restrictions s'appliquent aux opérations suivantes : `InvokeModel``InvokeModelWithResponseStream`,`Converse`, et`ConverseStream`. Consultez les [restrictions relatives aux API](inference-api-restrictions.md) pour plus de détails.
Voici des exemples de code :
+ Exemples Python pour cette rubrique : [Exemples d’API Converse](conversation-inference-examples.md)
+ Différents langages et modèles : [Exemples de code pour Amazon Bedrock Runtime utilisant AWS SDKs](service_code_examples_bedrock-runtime.md)
+ Didacticiel Java : [Guide du développeur Java sur la nouvelle API Converse de Bedrock](https://community.aws/content/2hUiEkO83hpoGF5nm3FWrdfYvPt/amazon-bedrock-converse-api-java-developer-guide)
+ JavaScript tutoriel — [Un guide du développeur sur la nouvelle Converse API de Bedrock](https://community.aws/content/2dtauBCeDa703x7fDS9Q30MJoBA/amazon-bedrock-converse-api-developer-guide)
**Topics**
+ [Modèles et fonctionnalités des modèles pris en charge](conversation-inference-supported-models-features.md)
+ [Utilisation de l’API Converse](conversation-inference-call.md)
+ [Exemples d’API Converse](conversation-inference-examples.md)
# Modèles et fonctionnalités des modèles pris en charge
L’API Converse prend en charge les modèles et fonctionnalités Amazon Bedrock suivants. L’API Converse ne prend en charge aucun modèle de vectorisation ou de génération d’images.
| Modèle | Converse | ConverseStream | Invites du système | Discussion de document | Vision | Utilisation d’outil | Utilisation de l’outil de streaming | Barrières de protection | Liens Amazon S3 pour le multimédia |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| AI21 Jamba-Instruct | Oui | Oui | Oui | Non | Non | Non | Non | Non | Non |
| AI21 Labs Jurassic-2 (Texte) | Limité. Aucune assistance par chat. | Non | Non | Non | Non | Non | Non | Oui | Non |
| AI21 Labs Jamba 1.5 Large | Oui | Oui | Oui | Oui | Non | Oui | Oui | Oui | Non |
| AI21 Labs Jamba 1.5 Mini | Oui | Oui | Oui | Oui | Non | Oui | Oui | Oui | Non |
| Amazon Nova Premier | Oui | Oui | Oui | Oui | Oui | Oui | Oui | Oui | Oui |
| Amazon Nova Pro | Oui | Oui | Oui | Oui | Oui | Oui | Oui | Oui | Oui |
| Amazon Nova Lite | Oui | Oui | Oui | Oui | Oui | Oui | Oui | Oui | Oui |
| Amazon Nova Micro | Oui | Oui | Oui | Non | Non | Oui | Oui | Oui | Non |
| Modèles Amazon Titan | Oui | Oui | Non | Oui (sauf Titan Text Premier) | Non | Non | Non | Oui | Non |
| Modèles Anthropic Claude 2.x et antérieurs | Oui | Oui | Oui | Oui | Non | Non | Non | Oui | Non |
| Modèles Anthropic Claude 3 | Oui | Oui | Oui | Oui | Oui | Oui | Oui | Oui | Non |
| Anthropic Claude 3.5 Sonnet | Oui | Oui | Oui | Oui | Oui | Oui | Oui | Oui | Non |
| Anthropic Claude 3.5 Sonnet v2 | Oui | Oui | Oui | Oui | Oui | Oui | Oui | Oui | Non |
| Anthropic Claude 3.7 Sonnet | Oui | Oui | Oui | Oui | Oui | Oui | Oui | Oui | Non |
| Anthropic Claude 3.5 Haiku | Oui | Oui | Oui | Oui | Non | Oui | Oui | Non | Non |
| Anthropic Claude Sonnet 4 | Oui | Oui | Oui | Oui | Oui | Oui | Oui | Non | Non |
| AnthropicClaude Opus4 | Oui | Oui | Oui | Oui | Oui | Oui | Oui | Non | Non |
| Anthropic Claude Sonnet 4.5 | Oui | Oui | Oui | Oui | Oui | Oui | Oui | Non | Non |
| Anthropic Claude Haiku 4.5 | Oui | Oui | Oui | Oui | Oui | Oui | Oui | Non | Non |
| AnthropicClaude Opus4,1 | Oui | Oui | Oui | Oui | Oui | Oui | Oui | Non | Non |
| Claude Opus4,5 | Oui | Oui | Oui | Oui | Oui | Oui | Oui | Non | Non |
| Cohere Command | Limité. Aucune assistance par chat. | Limité. Aucune assistance par chat. | Non | Oui | Non | Non | Non | Oui | Non |
| Cohere Command Light | Limité. Aucune assistance par chat. | Limité. Aucune assistance par chat. | Non | Non | Non | Non | Non | Oui | Non |
| Cohere et Command R Command R\$1 | Oui | Oui | Oui | Oui | Non | Oui | Oui | Non | Non |
| DeepSeek-R1 | Oui | Oui | Oui | Oui | Non | Non | Non | Oui | Non |
| Meta et Llama 2 Llama 3 | Oui | Oui | Oui | Oui | Non | Non | Non | Oui | Non |
| Meta Llama 3.1 | Oui | Oui | Oui | Oui | Non | Oui | Non | Oui | Non |
| Meta Llama 3.2 1b and Llama 3.2 3b | Oui | Oui | Oui | Oui | Non | Non | Non | Oui | Non |
| Meta Llama 3.2 11b and Llama 3.2 90b | Oui | Oui | Oui | Oui | Oui | Oui | Non | Oui | Non |
| Meta Llama 4 Maverick 17B and Llama 4.0 Scout 17B | Oui | Oui | Oui | Oui | Oui | Oui | Non | Oui | Non |
| Mistral AI Instruct | Oui | Oui | Non | Oui | Non | Non | Non | Oui | Non |
| Mistral Large | Oui | Oui | Oui | Oui | Non | Oui | Non | Oui | Non |
| Mistral Large 2 (24.07) | Oui | Oui | Oui | Oui | Non | Oui | Non | Oui | Non |
| Mistral Small | Oui | Oui | Oui | Non | Non | Oui | Non | Oui | Non |
| Pixtral Large (25.02) | Oui | Oui | Oui | Oui | Non | Oui | Non | Oui | Non |
| Writer Palmyra X4 | Oui | Oui | Oui | Oui | Non | Oui | Non | Oui | Non |
| Writer Palmyra X5 | Oui | Oui | Oui | Oui | Non | Oui | Non | Oui | Non |
Pour un tableau des régions qui prennent en charge chaque modèle, consultez [Support du modèle par Région AWS Amazon Bedrock](models-regions.md).
**Note**
Cohere Command (Texte) et AI21 Labs Jurassic-2 (Texte) ne prennent pas en charge le chat avec l’API Converse. 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 l’API Converse
Pour utiliser l’API Converse, vous devez appeler les opérations `Converse` ou `ConverseStream` pour envoyer des messages à un modèle. Pour appeler `Converse`, vous devez disposer de l’autorisation sur l’opération `bedrock:InvokeModel`. Pour appeler `ConverseStream`, vous devez disposer de l’autorisation sur l’opération `bedrock:InvokeModelWithResponseStream`.
**Topics**
+ [Demande](#conversation-inference-call-request)
+ [Réponse](#conversation-inference-call-response)
**Note**
Des restrictions s'appliquent aux opérations suivantes : InvokeModel, InvokeModelWithResponseStream, Converse et ConverseStream. Consultez les [restrictions relatives aux API](inference-api-restrictions.md) pour plus de détails.
## Demande
Lorsque vous envoyez une demande [Converse](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html) à un [point de terminaison d’exécution Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#br-rt), vous pouvez inclure les champs suivants :
+ **modelId** : paramètre obligatoire dans l’en-tête qui vous permet de spécifier la ressource à utiliser pour l’inférence.
+ Les champs suivants vous permettent de personnaliser l’invite :
+ **messages** : à utiliser pour spécifier le contenu et le rôle des invites.
+ **system** : à utiliser pour spécifier les invites du système, qui définissent les instructions ou le contexte du modèle.
+ **inferenceConfig** : à utiliser pour spécifier les paramètres d’inférence communs à tous les modèles. Les paramètres d’inférence influencent la génération de la réponse.
+ **additionalModelRequestChamps** : à utiliser pour spécifier des paramètres d'inférence spécifiques au modèle avec lequel vous exécutez l'inférence.
+ **promptVariables** : (si vous utilisez une invite de la gestion des invites) utilisez ce champ pour définir les variables de l’invite à renseigner et les valeurs avec lesquelles les remplir.
+ Les champs suivants vous permettent de personnaliser le mode de renvoi de la réponse :
+ **guardrailConfig** : utilisez ce champ pour inclure une barrière de protection à appliquer à l’ensemble de l’invite.
+ **toolConfig** : utilisez ce champ pour inclure un outil permettant à un modèle de générer des réponses.
+ **additionalModelResponseFieldPaths**— Utilisez ce champ pour spécifier les champs à renvoyer sous forme d'objet pointeur JSON.
+ **ServiceTier** — Utilisez ce champ pour spécifier le niveau de service pour une demande particulière
+ **requestMetadata** : utilisez ce champ pour inclure des métadonnées qui peuvent être filtrées lors de l’utilisation des journaux d’invocation.
**Note**
Les restrictions suivantes s’appliquent lorsque vous utilisez une invite de la gestion des invites avec `Converse` ou `ConverseStream` :
Vous ne pouvez pas inclure les champs `additionalModelRequestFields`, `inferenceConfig`, `system` ni `toolConfig`.
Si vous incluez le champ `messages`, les messages sont ajoutés après les messages définis dans l’invite.
Si vous incluez le champ `guardrailConfig`, la barrière de protection est appliquée à l’ensemble de l’invite. Si vous incluez `guardContent` des blocs dans le [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html)champ, le garde-corps ne sera appliqué qu'à ces blocs.
Développez une section pour en savoir plus sur un champ dans le corps de la demande `Converse` :
### messages
Le champ `messages` est un tableau d’objets [Message](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Message.html), dont chacun définit un message entre l’utilisateur et le modèle. Un objet `Message` contient les champs suivants :
+ **rôle** : définit si le message provient de `user` (l’invite envoyée au modèle) ou de `assistant` (la réponse du modèle).
+ **contenu** : définit le contenu de l’invite.
**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 pouvez conserver le contexte de la conversation en incluant tous les messages de la conversation dans les demandes `Converse` suivantes et en utilisant le champ `role` pour spécifier si le message provient de l’utilisateur ou du modèle.
Le `content` champ correspond à un ensemble d'[ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html)objets. Dans chacun d'eux [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html), vous pouvez spécifier l'un des champs suivants (pour savoir quels modèles prennent en charge quels blocs, voir[Modèles et fonctionnalités des modèles pris en charge](conversation-inference-supported-models-features.md)) :
------
#### [ text ]
Le champ `text` correspond à une chaîne spécifiant l’invite. Le `text` champ est interprété en même temps que les autres champs qui y sont spécifiés [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html).
L'image suivante montre un objet [Message](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Message.html) avec un `content` tableau contenant uniquement du texte [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html):
```
{
"role": "user",
"content": [
{
"text": "string"
}
]
}
```
------
#### [ image ]
Le `image` champ correspond à un [ImageBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ImageBlock.html). Passez les octets bruts, codés en Base64, pour une image dans le champ `bytes`. Si vous utilisez un AWS SDK, vous n'avez pas besoin de coder les octets en base64.
Si vous excluez le champ `text`, le modèle décrit l’image.
Voici un exemple d'objet [Message](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Message.html) avec un `content` tableau contenant uniquement une image [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html):
```
{
"role": "user",
"content": [
{
"image": {
"format": "png",
"source": {
"bytes": "image in bytes"
}
}
}
]
}
```
Vous pouvez également spécifier un URI Amazon S3 au lieu de transmettre les octets directement dans le corps de la demande. Voici un exemple d’objet `Message` avec un tableau de contenu contenant la source transmise via un URI Amazon S3.
```
{
"role": "user",
"content": [
{
"image": {
"format": "png",
"source": {
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/myImage",
"bucketOwner": "111122223333"
}
}
}
}
]
}
```
------
#### [ document ]
Le `document` champ correspond à un [DocumentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_DocumentBlock.html). Si vous incluez un `DocumentBlock`, vérifiez que votre demande est conforme aux restrictions suivantes :
+ Dans le champ `content` de l’objet [Message](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Message.html), vous devez également inclure un champ `text` contenant une invite liée au document.
+ Transmettez les octets bruts, codés en Base64, pour le document dans le champ `bytes`. Si vous utilisez un kit AWS SDK, vous n’avez pas besoin de coder les octets du document en Base64.
+ Le champ `name` peut contenir uniquement les caractères suivants :
+ Caractères alphanumériques
+ Caractères d’espacement (pas plus d’un par ligne)
+ Traits d’union
+ Parenthèses
+ Crochets
**Note**
Le champ `name` est vulnérable aux injections d’invite, car le modèle risque de l’interpréter par inadvertance comme des instructions. Nous vous recommandons donc de spécifier un nom neutre.
Lorsque vous utilisez un document, vous pouvez activer la balise `citations`, qui fournira des citations spécifiques au document en réponse à l’appel d’API. Consultez l'[DocumentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_DocumentBlock.html)API pour plus de détails.
Voici un exemple d'objet [Message](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Message.html) avec un `content` tableau contenant uniquement un document [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html)et le texte d'accompagnement obligatoire [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html).
```
{
"role": "user",
"content": [
{
"text": "string"
},
{
"document": {
"format": "pdf",
"name": "MyDocument",
"source": {
"bytes": "document in bytes"
}
}
}
]
}
```
Vous pouvez également spécifier un URI Amazon S3 au lieu de transmettre les octets directement dans le corps de la demande. Voici un exemple d’objet `Message` avec un tableau de contenu contenant la source transmise via un URI Amazon S3.
```
{
"role": "user",
"content": [
{
"text": "string"
},
{
"document": {
"format": "pdf",
"name": "MyDocument",
"source": {
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/myDocument",
"bucketOwner": "111122223333"
}
}
}
}
]
}
```
------
#### [ video ]
Le `video` champ correspond à un [VideoBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_VideoBlock.html)objet. Transmettez les octets bruts dans le champ `bytes`, codés en Base64. Si vous utilisez le AWS SDK, vous n'avez pas besoin de coder les octets en base64.
Si vous n’incluez pas le champ `text`, le modèle décrira la vidéo.
Ce qui suit montre un exemple d'objet [Message](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Message.html) avec un `content` tableau contenant uniquement une vidéo [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html).
```
{
"role": "user",
"content": [
{
"video": {
"format": "mp4",
"source": {
"bytes": "video in bytes"
}
}
}
]
}
```
Vous pouvez également spécifier un URI Amazon S3 au lieu de transmettre les octets directement dans le corps de la demande. Voici un exemple d’objet `Message` avec un tableau de contenu contenant la source transmise via un URI Amazon S3.
```
{
"role": "user",
"content": [
{
"video": {
"format": "mp4",
"source": {
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/myVideo",
"bucketOwner": "111122223333"
}
}
}
}
]
}
```
**Note**
Le rôle assumé doit avoir l’autorisation `s3:GetObject` sur l’URI Amazon S3. Le champ `bucketOwner` est facultatif mais doit être spécifié si le compte à l’origine de la demande ne possède pas le compartiment dans lequel se trouve l’URI Amazon S3. Pour de plus amples informations, veuillez consulter [Configuration de l’accès aux compartiments Amazon S3](s3-bucket-access.md).
------
#### [ cachePoint ]
Vous pouvez ajouter des points de contrôle du cache sous forme de bloc dans un message accompagné d’une invite en utilisant des champs `cachePoint` pour utiliser la mise en cache des invites. La mise en cache des invites est une fonctionnalité qui vous permet de commencer à mettre en cache le contexte des conversations afin de réaliser des économies de coûts et de latence. Pour de plus amples informations, veuillez consulter [Mise en cache des invites pour une inférence de modèle plus rapide](prompt-caching.md).
Voici un exemple d'objet [Message](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Message.html) avec un `content` tableau contenant un document [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html)et le texte d'accompagnement requis [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html), ainsi qu'un **CachePoint** qui ajoute le contenu du document et du texte au cache.
```
{
"role": "user",
"content": [
{
"text": "string"
},
{
"document": {
"format": "pdf",
"name": "string",
"source": {
"bytes": "document in bytes"
}
}
},
{
"cachePoint": {
"type": "default"
}
}
]
}
```
------
#### [ guardContent ]
Le `guardContent` champ correspond à un [GuardrailConverseContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_GuardrailConverseContentBlock.html)objet. Vous pouvez utiliser ce champ pour cibler une entrée à évaluer par la barrière de protection définie dans le champ `guardrailConfig`. Si vous ne spécifiez pas ce champ, la barrière de protection évalue tous les messages du corps de la demande. Vous pouvez transmettre les types de contenu suivants dans un `GuardBlock` :
+ **text** — Voici un exemple d'objet [Message](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Message.html) avec un `content` tableau contenant uniquement du texte [GuardrailConverseContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_GuardrailConverseContentBlock.html):
```
{
"role": "user",
"content": [
{
"text": "Tell me what stocks to buy.",
"qualifiers": [
"guard_content"
]
}
]
}
```
Vous définissez le texte à évaluer et incluez tous les qualificatifs à utiliser pour étayer le [l’ancrage contextuel](guardrails-contextual-grounding-check.md).
+ **image** — Ce qui suit montre un objet [Message](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Message.html) avec un `content` tableau contenant uniquement une image [GuardrailConverseContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_GuardrailConverseContentBlock.html):
```
{
"role": "user",
"content": [
{
"format": "png",
"source": {
"bytes": "image in bytes"
}
}
]
}
```
Vous spécifiez le format de l’image et définissez l’image en octets.
Pour plus d’informations sur les barrières de protection, consultez [Détection et filtrage des contenus préjudiciables à l’aide des barrières de protection Amazon Bedrock](guardrails.md).
------
#### [ reasoningContent ]
Le `reasoningContent` champ correspond à un [ReasoningContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ReasoningContentBlock.html). Ce bloc contient du contenu concernant le raisonnement qui a été appliqué par le modèle pour générer la réponse dans le `ContentBlock` d’accompagnement.
Ce qui suit montre un objet `Message` avec un tableau `content` contenant uniquement un `ReasoningContentBlock` et un `ContentBlock` de texte d’accompagnement.
```
{
"role": "user",
"content": [
{
"text": "string"
},
{
"reasoningContent": {
"reasoningText": {
"text": "string",
"signature": "string"
}
"redactedContent": "base64-encoded binary data object"
}
}
]
}
```
Le `ReasoningContentBlock` contient le raisonnement utilisé pour générer le contenu d’accompagnement dans le champ `reasoningText`, en plus de tout contenu du raisonnement qui a été crypté par le fournisseur du modèle pour des raisons de confiance et de sécurité dans le champ `redactedContent`.
Dans le champ `reasoningText`, les champs `text` décrivent le raisonnement. Le champ `signature` est un hachage de tous les messages de la conversation et constitue une protection contre toute modification du raisonnement utilisé par le modèle. Vous devez inclure la signature et tous les messages précédents dans les demandes `Converse` suivantes. Si l’un des messages est modifié, la réponse génère une erreur.
------
#### [ toolUse ]
Contient des informations sur un outil destiné au modèle à utiliser. Pour de plus amples informations, veuillez consulter [Utilisation d’un outil pour compléter une réponse au modèle Amazon Bedrock](tool-use.md).
------
#### [ toolResult ]
Contient des informations sur le résultat obtenu par le modèle utilisant un outil. Pour de plus amples informations, veuillez consulter [Utilisation d’un outil pour compléter une réponse au modèle Amazon Bedrock](tool-use.md).
------
Dans l’exemple `messages` 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"
}
]
}
]
```
### system
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](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_SystemContentBlock.html)), comme illustré dans l'exemple suivant.
```
[
{
"text": "You are an app that creates play lists for a radio station that plays rock and pop music. Only return song names and the artist. "
}
]
```
### inferenceConfig
L'ConverseAPI prend en charge un ensemble de base de paramètres d'inférence que vous définissez dans le `inferenceConfig` champ ([InferenceConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InferenceConfiguration.html)). Le jeu 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 de 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 tout en générant une réponse.
+ **topP** : pourcentage de candidats les plus probables pris en compte par le modèle pour le jeton suivant.
Pour de plus amples informations, veuillez consulter [Génération de réponse d’influence à l’aide de paramètres d’inférence](inference-parameters.md).
L’exemple JSON suivant définit le paramètre d’inférence `temperature`.
```
{"temperature": 0.5}
```
### additionalModelRequestChamps
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 au format JSON dans le champ `additionalModelRequestFields`. L’exemple JSON suivant montre comment définir `top_k`, qui est disponible dans les modèles Anthropic Claude, mais qui n’est pas un paramètre d’inférence de base dans l’API de messages.
```
{"top_k": 200}
```
### promptVariables
Si vous spécifiez une invite de [Prompt Management](prompt-management.md) dans le `modelId` comme ressource sur laquelle exécuter l’inférence, utilisez ce champ pour renseigner les variables d’invite avec des valeurs réelles. Le champ `promptVariables` correspond à un objet JSON dont les clés correspondent aux variables définies dans les invites et aux valeurs par lesquelles les variables doivent être remplacées.
Par exemple, supposons que vous ayez une invite indiquant **Make me a *\$1\$1genre\$1\$1* playlist consisting of the following number of songs: *\$1\$1number\$1\$1*.** L’ID de l’invite est `PROMPT12345` et sa version est `1`. Vous pouvez envoyer la demande `Converse` suivante pour remplacer les variables :
```
POST /model/arn:aws:bedrock:us-east-1:111122223333:prompt/PROMPT12345:1/converse HTTP/1.1
Content-type: application/json
{
"promptVariables": {
"genre" : "pop",
"number": 3
}
}
```
### guardrailConfig
Vous pouvez appliquer une barrière de protection que vous avez créée avec les [barrières de protection Amazon Bedrock](guardrails.md) en incluant ce champ. Pour appliquer le garde-corps à un message spécifique de la conversation, incluez le message dans un. [GuardrailConverseContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_GuardrailConverseContentBlock.html) Si vous n’incluez aucun `GuardrailConverseContentBlock` dans le corps de la demande, la barrière de protection est appliquée à tous les messages du champ `messages`. Pour obtenir un exemple, consultez [Intégration d’une barrière de protection à l’API Converse](guardrails-use-converse-api.md).
### toolConfig
Ce champ vous permet de définir un outil que le modèle doit utiliser pour l’aider à générer une réponse. Pour de plus amples informations, veuillez consulter [Utilisation d’un outil pour compléter une réponse au modèle Amazon Bedrock](tool-use.md).
### additionalModelResponseFieldPaths
Vous pouvez spécifier les chemins des paramètres de modèle supplémentaires dans le champ `additionalModelResponseFieldPaths`, comme illustré dans l’exemple suivant.
```
[ "/stop_sequence" ]
```
L’API renvoie les champs supplémentaires que vous demandez dans le champ `additionalModelResponseFields`.
### requestMetadata
Ce champ est mappé à un objet JSON. Vous pouvez spécifier les clés de métadonnées et les valeurs auxquelles elles correspondent dans cet objet. Vous pouvez utiliser les métadonnées des demandes pour filtrer les journaux d’invocation des modèles.
### Niveau de service
Ce champ est mappé à un objet JSON. Vous pouvez spécifier le niveau de service pour une demande particulière.
L'exemple suivant illustre la `serviceTier` structure :
```
"serviceTier": {
"type": "reserved" | "priority" | "default" | "flex"
}
```
Pour obtenir des informations détaillées sur les niveaux de service, y compris les caractéristiques de tarification et de performance, consultez[Niveaux de service pour optimiser les performances et les coûts](service-tiers-inference.md).
Vous pouvez également éventuellement ajouter des points de contrôle du cache aux champs `system` ou `tools` pour utiliser la mise en cache des invites, selon le modèle que vous utilisez. Pour de plus amples informations, veuillez consulter [Mise en cache des invites pour une inférence de modèle plus rapide](prompt-caching.md).
## Réponse
La réponse que vous obtenez de l’API Converse dépend de l’opération que vous appelez, `Converse` ou `ConverseStream`.
**Topics**
+ [Réponse inverse](#conversation-inference-call-response-converse)
+ [ConverseStream réponse](#conversation-inference-call-response-converse-stream)
### Réponse inverse
Dans le formulaire de réponse`Converse`, le `output` champ ([ConverseOutput](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ConverseOutput.html)) contient le message ([Message](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Message.html)) généré par le modèle. Le contenu du message se trouve dans le champ `content` ([ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html)) et le rôle (`user`ou`assistant`) auquel le message correspond se trouve dans le `role` champ.
Si vous avez utilisé la [mise en cache des invites](prompt-caching.md), alors dans le champ d’utilisation, `cacheReadInputTokensCount` et `cacheWriteInputTokensCount` vous indiquent combien de jetons au total ont été lus depuis le cache et écrits dans le cache, respectivement.
Si vous avez utilisé [des niveaux de service](#inference-service-tiers), le champ de réponse vous `service tier` indiquera quel niveau de service a été utilisé pour la demande.
Le `metrics` champ ([ConverseMetrics](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ConverseMetrics.html)) 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 champ `stopReason`. 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](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_TokenUsage.html)). Si vous avez spécifié des champs de réponse supplémentaires dans la demande, l’API les renvoie au format JSON dans le champ `additionalModelResponseFields`.
L’exemple suivant montre la réponse de `Converse` lorsque vous avez répondu à l’invite décrite dans [Demande](#conversation-inference-call-request).
```
{
"output": {
"message": {
"role": "assistant",
"content": [
{
"text": "Here is a list of 3 pop songs by artists from the United Kingdom:\n\n1. \"Wannabe\" by Spice Girls\n2. \"Bitter Sweet Symphony\" by The Verve \n3. \"Don't Look Back in Anger\" by Oasis"
}
]
}
},
"stopReason": "end_turn",
"usage": {
"inputTokens": 125,
"outputTokens": 60,
"totalTokens": 185
},
"metrics": {
"latencyMs": 1175
}
}
```
### ConverseStream réponse
Si vous appelez `ConverseStream` pour diffuser la réponse d’un modèle, le flux est renvoyé dans le champ de réponse `stream`. Le flux émet les événements suivants dans l’ordre suivant.
1. `messageStart`([MessageStartEvent](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_MessageStartEvent.html)). L'événement de début d'un message. Inclut le rôle du message.
1. `contentBlockStart`([ContentBlockStartEvent](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlockStartEvent.html)). Un événement de démarrage d'un bloc de contenu. Utilisation d’outils uniquement.
1. `contentBlockDelta`([ContentBlockDeltaEvent](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlockDeltaEvent.html)). Un événement delta du bloc de contenu. Essayez l’une des actions suivantes :
+ `text` : texte partiel généré par le modèle.
+ `reasoningContent` : raisonnement partiel effectué par le modèle pour générer la réponse. Vous devez envoyer le `signature` renvoyé, en plus de tous les messages précédents, dans les demandes `Converse` suivantes. Si l’un des messages est modifié, la réponse génère une erreur.
+ `toolUse` : l’objet JSON d’entrée partielle destiné à l’utilisation de l’outil.
1. `contentBlockStop`([ContentBlockStopEvent](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlockStopEvent.html)). Un événement d'arrêt du blocage du contenu.
1. `messageStop`([MessageStopEvent](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_MessageStopEvent.html)). L'événement d'arrêt du message. Inclut la raison pour laquelle le modèle a cessé de générer une sortie.
1. `metadata`([ConverseStreamMetadataEvent](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ConverseStreamMetadataEvent.html)). Métadonnées relatives à la demande. Les métadonnées incluent l'utilisation du jeton dans `usage` ([TokenUsage](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_TokenUsage.html)) et les métriques de l'appel dans `metrics` ([ConverseStreamMetadataEvent](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ConverseStreamMetadataEvent.html)).
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 champ `contentBlockIndex` comme index pour corréler les événements qui constituent un bloc de contenu.
Voici un exemple de réponse partielle renvoyée par `ConverseStream`.
```
{'messageStart': {'role': 'assistant'}}
{'contentBlockDelta': {'delta': {'text': ''}, 'contentBlockIndex': 0}}
{'contentBlockDelta': {'delta': {'text': ' Title'}, 'contentBlockIndex': 0}}
{'contentBlockDelta': {'delta': {'text': ':'}, 'contentBlockIndex': 0}}
.
.
.
{'contentBlockDelta': {'delta': {'text': ' The'}, 'contentBlockIndex': 0}}
{'messageStop': {'stopReason': 'max_tokens'}}
{'metadata': {'usage': {'inputTokens': 47, 'outputTokens': 20, 'totalTokens': 67}, 'metrics': {'latencyMs': 100.0}}}
```
# Exemples d’API Converse
Le tableau suivant montre des exemples d’utilisation des opérations `Converse` et `ConverseStream`.
------
#### [ Text ]
Cet exemple montre comment appeler l’opération `Converse` avec le modèle *Anthropic Claude 3 Sonnet*. 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()
```
------
#### [ Image ]
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 l’opération `Converse` et le modèle *AnthropicClaude 3 Sonnet*.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to send an image with the Converse API with an accompanying text prompt to Anthropic Claude 3 Sonnet (on demand).
"""
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_conversation(bedrock_client,
model_id,
input_text,
input_image):
"""
Sends a message to a model.
Args:
bedrock_client: The Boto3 Bedrock runtime client.
model_id (str): The model ID to use.
input text : The text prompt accompanying the image.
input_image : The path to the input image.
Returns:
response (JSON): The conversation that the model generated.
"""
logger.info("Generating message with model %s", model_id)
# Get image extension and read in image as bytes
image_ext = input_image.split(".")[-1]
with open(input_image, "rb") as f:
image = f.read()
message = {
"role": "user",
"content": [
{
"text": input_text
},
{
"image": {
"format": image_ext,
"source": {
"bytes": image
}
}
}
]
}
messages = [message]
# Send the message.
response = bedrock_client.converse(
modelId=model_id,
messages=messages
)
return response
def main():
"""
Entrypoint for Anthropic Claude 3 Sonnet example.
"""
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
model_id = "anthropic.claude-3-sonnet-20240229-v1:0"
input_text = "What's in this image?"
input_image = "path/to/image"
try:
bedrock_client = boto3.client(service_name="bedrock-runtime")
response = generate_conversation(
bedrock_client, model_id, input_text, input_image)
output_message = response['output']['message']
print(f"Role: {output_message['role']}")
for content in output_message['content']:
print(f"Text: {content['text']}")
token_usage = response['usage']
print(f"Input tokens: {token_usage['inputTokens']}")
print(f"Output tokens: {token_usage['outputTokens']}")
print(f"Total tokens: {token_usage['totalTokens']}")
print(f"Stop reason: {response['stopReason']}")
except ClientError as err:
message = err.response['Error']['Message']
logger.error("A client error occurred: %s", message)
print(f"A client error occured: {message}")
else:
print(
f"Finished generating text with model {model_id}.")
if __name__ == "__main__":
main()
```
------
#### [ Document ]
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 l’opération `Converse` et le modèle *AnthropicClaude 3 Sonnet*.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to send an document as part of a message to Anthropic Claude 3 Sonnet (on demand).
"""
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_message(bedrock_client,
model_id,
input_text,
input_document_path):
"""
Sends a message to a model.
Args:
bedrock_client: The Boto3 Bedrock runtime client.
model_id (str): The model ID to use.
input text : The input message.
input_document_path : The path to the input document.
Returns:
response (JSON): The conversation that the model generated.
"""
logger.info("Generating message with model %s", model_id)
# Get format from path and read the path
input_document_format = input_document_path.split(".")[-1]
with open(input_document_path, 'rb') as input_document_file:
input_document = input_document_file.read()
# Message to send.
message = {
"role": "user",
"content": [
{
"text": input_text
},
{
"document": {
"name": "MyDocument",
"format": input_document_format,
"source": {
"bytes": input_document
}
}
}
]
}
messages = [message]
# Send the message.
response = bedrock_client.converse(
modelId=model_id,
messages=messages
)
return response
def main():
"""
Entrypoint for Anthropic Claude 3 Sonnet example.
"""
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
model_id = "anthropic.claude-3-sonnet-20240229-v1:0"
input_text = "What's in this document?"
input_document_path = "path/to/document"
try:
bedrock_client = boto3.client(service_name="bedrock-runtime")
response = generate_message(
bedrock_client, model_id, input_text, input_document_path)
output_message = response['output']['message']
print(f"Role: {output_message['role']}")
for content in output_message['content']:
print(f"Text: {content['text']}")
token_usage = response['usage']
print(f"Input tokens: {token_usage['inputTokens']}")
print(f"Output tokens: {token_usage['outputTokens']}")
print(f"Total tokens: {token_usage['totalTokens']}")
print(f"Stop reason: {response['stopReason']}")
except ClientError as err:
message = err.response['Error']['Message']
logger.error("A client error occurred: %s", message)
print(f"A client error occured: {message}")
else:
print(
f"Finished generating text with model {model_id}.")
if __name__ == "__main__":
main()
```
------
#### [ Streaming ]
Cet exemple montre comment appeler l’opération `ConverseStream` avec le modèle *Anthropic Claude 3 Sonnet*. 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()
```
------
#### [ Video ]
Cet exemple montre comment envoyer une vidéo dans le cadre d’un message et demande au modèle de décrire la vidéo. L’exemple utilise l’opération `Converse` et le modèle Amazon Nova Pro.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to send a video with the Converse API to Amazon Nova Pro (on demand).
"""
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_conversation(bedrock_client,
model_id,
input_text,
input_video):
"""
Sends a message to a model.
Args:
bedrock_client: The Boto3 Bedrock runtime client.
model_id (str): The model ID to use.
input text : The input message.
input_video : The input video.
Returns:
response (JSON): The conversation that the model generated.
"""
logger.info("Generating message with model %s", model_id)
# Message to send.
with open(input_video, "rb") as f:
video = f.read()
message = {
"role": "user",
"content": [
{
"text": input_text
},
{
"video": {
"format": 'mp4',
"source": {
"bytes": video
}
}
}
]
}
messages = [message]
# Send the message.
response = bedrock_client.converse(
modelId=model_id,
messages=messages
)
return response
def main():
"""
Entrypoint for Amazon Nova Pro example.
"""
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
model_id = "amazon.nova-pro-v1:0"
input_text = "What's in this video?"
input_video = "path/to/video"
try:
bedrock_client = boto3.client(service_name="bedrock-runtime")
response = generate_conversation(
bedrock_client, model_id, input_text, input_video)
output_message = response['output']['message']
print(f"Role: {output_message['role']}")
for content in output_message['content']:
print(f"Text: {content['text']}")
token_usage = response['usage']
print(f"Input tokens: {token_usage['inputTokens']}")
print(f"Output tokens: {token_usage['outputTokens']}")
print(f"Total tokens: {token_usage['totalTokens']}")
print(f"Stop reason: {response['stopReason']}")
except ClientError as err:
message = err.response['Error']['Message']
logger.error("A client error occurred: %s", message)
print(f"A client error occured: {message}")
else:
print(
f"Finished generating text with model {model_id}.")
if __name__ == "__main__":
main()
```
------