\n\nAssistant:",
"temperature": float,
"top_p": float,
"top_k": int,
"max_tokens_to_sample": int,
"stop_sequences": [string]
}
```
Les paramètres suivants sont obligatoires.
+ **prompt** (obligatoire) : l’invite que vous souhaitez que Claude termine. Pour générer correctement les réponses, vous devez formater votre invite en alternant les tours conversationnels `\n\nHuman:` et `\n\nAssistant:`. Par exemple :
```
"\n\nHuman: {userQuestion}\n\nAssistant:"
```
Pour plus d’informations, consultez [Prompt validation](https://docs.anthropic.com/claude/reference/prompt-validation) dans la documentation Anthropic Claude.
+ **max\$1tokens\$1to\$1sample** (obligatoire) : nombre maximum de jetons à générer avant l’arrêt. Nous recommandons une limite de 4 000 jetons pour des performances optimales.
Notez que les modèles Anthropic Claude peuvent arrêter de générer des jetons avant d’atteindre la valeur `max_tokens_to_sample`. Les différents modèles Anthropic Claude ont des valeurs maximales différentes pour ce paramètre. Pour plus d’informations, consultez [Model comparison](https://docs.anthropic.com/claude/docs/models-overview#model-comparison) fournie dans la documentation Anthropic Claude.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-anthropic-claude-text-completion.html)
Les paramètres suivants sont facultatifs.
+ **stop\$1sequences** (facultatif) : séquences qui empêcheront la génération du modèle.
Les modèles Anthropic Claude s’arrêtent à `"\n\nHuman:"` et peuvent inclure ultérieurement des séquences d’arrêt intégrées supplémentaires. Utilisez le paramètre d’inférence `stop_sequences` pour inclure des chaînes supplémentaires qui signaleront au modèle d’arrêter de générer du texte.
+ **temperature** : (facultatif) quantité de randomisation injectée dans la réponse. Utilisez une valeur plus proche de 0 pour l’analytique/les choix multiples, et une valeur plus proche de 1 pour les tâches créatives et génératives.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-anthropic-claude-text-completion.html)
+ **top\$1p** : (facultatif) utilisez l’échantillonnage du noyau.
Lors de l’échantillonnage du noyau, Anthropic Claude calcule la distribution cumulée de toutes les options pour chaque jeton suivant par ordre de probabilité décroissant et la coupe une fois qu’elle atteint une probabilité particulière spécifiée par `top_p`. Vous devez modifier `temperature` ou `top_p`, mais pas les deux.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-anthropic-claude-text-completion.html)
+ **top\$1k** : (facultatif) échantillonnez uniquement les premières options K pour chaque jeton suivant.
Utilisez `top_k` pour supprimer les réponses à faible probabilité à longue queue.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-anthropic-claude-text-completion.html)
------
#### [ Response ]
Les modèles Anthropic Claude renvoient les champs suivants pour un appel d’inférence Text Completions.
```
{
"completion": string,
"stop_reason": string,
"stop": string
}
```
+ **completion** : la complétion résultante jusqu’aux séquences d’arrêt et à l’exclusion de celles-ci.
+ **stop\$1reason** : raison pour laquelle le modèle a cessé de générer la réponse.
+ **"stop\$1sequence"** : le modèle a atteint une séquence d’arrêt, soit fournie par vous avec le paramètre d’inférence `stop_sequences`, soit une séquence d’arrêt intégrée au modèle.
+ **"max\$1tokens"** : le modèle a dépassé `max_tokens_to_sample` ou le nombre maximum de jetons du modèle.
+ **stop** : si vous spécifiez le paramètre d’inférence `stop_sequences`, `stop` contient la séquence d’arrêt qui a indiqué au modèle d’arrêter de générer du texte. Par exemple, `holes` dans la réponse suivante.
```
{
"completion": " Here is a simple explanation of black ",
"stop_reason": "stop_sequence",
"stop": "holes"
}
```
Si vous ne spécifiez pas le paramètre `stop_sequences`, la valeur `stop` est vide.
------
## Exemple de code
Ces exemples montrent comment appeler le modèle *Anthropic Claude V2* avec un débit à la demande. Pour utiliser Anthropic Claude version 2.1, remplacez la valeur de `modelId` par `anthropic.claude-v2:1`.
```
import boto3
import json
brt = boto3.client(service_name='bedrock-runtime')
body = json.dumps({
"prompt": "\n\nHuman: explain black holes to 8th graders\n\nAssistant:",
"max_tokens_to_sample": 300,
"temperature": 0.1,
"top_p": 0.9,
})
modelId = 'anthropic.claude-v2'
accept = 'application/json'
contentType = 'application/json'
response = brt.invoke_model(body=body, modelId=modelId, accept=accept, contentType=contentType)
response_body = json.loads(response.get('body').read())
# text
print(response_body.get('completion'))
```
L’exemple suivant montre comment générer du texte en streaming avec Python à l’aide de l’invite *write an essay for living on Mars in 1000 words* (écris un essai sur la vie sur Mars en 1 000 mots) et du modèle Anthropic Claude V2 :
```
import boto3
import json
brt = boto3.client(service_name='bedrock-runtime')
body = json.dumps({
'prompt': '\n\nHuman: write an essay for living on mars in 1000 words\n\nAssistant:',
'max_tokens_to_sample': 4000
})
response = brt.invoke_model_with_response_stream(
modelId='anthropic.claude-v2',
body=body
)
stream = response.get('body')
if stream:
for event in stream:
chunk = event.get('chunk')
if chunk:
print(json.loads(chunk.get('bytes').decode()))
```
# API Anthropic Claude Message
Cette section fournit les paramètres d’inférence et des exemples de code pour l’utilisation de l’API Anthropic Claude Messages.
**Topics**
+ [Présentation de l’API Anthropic Claude Messages](#model-parameters-anthropic-claude-messages-overview)
+ [Utilisation d’outil](model-parameters-anthropic-claude-messages-tool-use.md)
+ [Réflexion étendue](claude-messages-extended-thinking.md)
+ [Pensée adaptative](claude-messages-adaptive-thinking.md)
+ [Chiffrement des raisonnements](claude-messages-thinking-encryption.md)
+ [Différences de raisonnement entre les versions du modèle](claude-messages-thinking-differences.md)
+ [Compactage](claude-messages-compaction.md)
+ [Obtenez des résultats JSON validés à partir de modèles](claude-messages-structured-outputs.md)
+ [Demande et réponse](model-parameters-anthropic-claude-messages-request-response.md)
+ [Exemples de code](api-inference-examples-claude-messages-code-examples.md)
+ [Modèles pris en charge](claude-messages-supported-models.md)
## Présentation de l’API Anthropic Claude Messages
Vous pouvez utiliser l’API Messages pour créer des bots vocaux ou des applications d’assistant virtuel. L’API gère les échanges conversationnels entre un utilisateur et un modèle Anthropic Claude (assistant).
**Note**
Cette rubrique explique comment utiliser l'API des Anthropic Claude messages avec les opérations d'inférence de base ([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)). Toutefois, nous vous recommandons d’utiliser l’API Converse pour mettre en œuvre des messages dans votre application. L’API Converse fournit un ensemble unifié de paramètres qui fonctionnent sur tous les modèles prenant en charge les messages. Pour de plus amples informations, veuillez consulter [Mener une conversation avec les opérations d’API Converse](conversation-inference.md).
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.
Anthropic entraîne les modèles Claude à utiliser en alternant les tours de conversation entre l’utilisateur et l’assistant. Lorsque vous créez un nouveau message, vous spécifiez les tours de conversation précédents à l’aide du paramètre de message. Le modèle génère ensuite le message suivant de la conversation.
Chaque message d’entrée doit être un objet doté d’un rôle et d’un contenu. Vous pouvez spécifier un seul message de rôle d’utilisateur ou inclure plusieurs messages d’utilisateur et d’assistant.
Si vous utilisez la technique qui consiste à préremplir le formulaire de réponse de Claude (en remplissant le début de la réponse de Claude en utilisant un dernier rôle d’assistant, Message), Claude répondra en reprenant là où vous vous êtes arrêté. Avec cette technique, Claude renverra toujours une réponse avec le rôle d’assistant.
Si le message final utilise le rôle d’assistant, le contenu de la réponse se poursuivra immédiatement à partir du contenu de ce message. Vous pouvez l’utiliser pour restreindre une partie de la réponse du modèle.
Exemple avec un message destiné à un seul utilisateur :
```
[{"role": "user", "content": "Hello, Claude"}]
```
Exemple avec plusieurs tours de conversation :
```
[
{"role": "user", "content": "Hello there."},
{"role": "assistant", "content": "Hi, I'm Claude. How can I help you?"},
{"role": "user", "content": "Can you explain LLMs in plain English?"},
]
```
Exemple avec une réponse partiellement remplie de Claude :
```
[
{"role": "user", "content": "Please describe yourself using only JSON"},
{"role": "assistant", "content": "Here is my JSON description:\n{"},
]
```
Le contenu de chaque message d’entrée peut être une chaîne unique ou un tableau de blocs de contenu, chaque bloc ayant un type spécifique. L’utilisation d’une chaîne est un raccourci pour désigner un tableau d’un bloc de contenu de type « texte ». Les messages d’entrée suivants sont équivalents :
```
{"role": "user", "content": "Hello, Claude"}
```
```
{"role": "user", "content": [{"type": "text", "text": "Hello, Claude"}]}
```
Pour plus d’informations sur la création d’invites pour les modèles Anthropic Claude, consultez [Intro to prompting](https://docs.anthropic.com/claude/docs/intro-to-prompting) dans la documentation Anthropic Claude. Si vous avez déjà reçu des invites [Text Completion](model-parameters-anthropic-claude-text-completion.md) que vous souhaitez migrer vers l’API des messages, consultez [Migrating from Text Completions](https://docs.anthropic.com/claude/reference/migrating-from-text-completions-to-messages).
**Important**
Le délai d’expiration pour les appels d’inférence vers les modèles Anthropic Claude 3.7 Sonnet et Claude 4 est de 60 minutes. Par défaut, les clients du AWS SDK expirent au bout d'une minute. Nous vous recommandons d'augmenter le délai de lecture de votre client AWS SDK à au moins 60 minutes. Par exemple, dans le kit SDK AWS Python botocore, modifiez la valeur du champ `read_timeout` dans [botocore.config](https://botocore.amazonaws.com/v1/documentation/api/latest/reference/config.html#) à au moins 3 600.
### Invites du système
Vous pouvez également inclure une invite du système dans la demande. Une invite système vous permet de fournir du contexte et des instructions Anthropic Claude, par exemple en spécifiant un objectif ou un rôle en particulier. Spécifiez une invite du système dans le champ `system`, comme indiqué dans l’exemple suivant.
```
"system": "You are Claude, an AI assistant created by Anthropic to be helpful,
harmless, and honest. Your goal is to provide informative and substantive responses
to queries while avoiding potential harms."
```
Pour plus d’informations, consultez [System prompts](https://docs.anthropic.com/en/docs/system-prompts) dans la documentation Anthropic.
### Invites multimodales
Une invite multimodale combine plusieurs modalités (images et texte) dans une seule invite. Vous spécifiez les modalités dans le champ d’entrée `content`. L’exemple suivant montre comment vous pouvez demander Anthropic Claude de décrire le contenu d’une image fournie. Pour obtenir un exemple de code, consultez [Exemples de code multimodal](api-inference-examples-claude-messages-code-examples.md#api-inference-examples-claude-multimodal-code-example).
```
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 1024,
"messages": [
{
"role": "user",
"content": [
{
"type": "image",
"source": {
"type": "base64",
"media_type": "image/jpeg",
"data": "iVBORw..."
}
},
{
"type": "text",
"text": "What's in these images?"
}
]
}
]
}
```
Chaque image que vous incluez dans une demande est prise en compte dans l’utilisation de votre jeton. Pour plus d’informations, consultez [Image costs](https://docs.anthropic.com/claude/docs/vision#image-costs) dans la documentation Anthropic.
# Utilisation d’outil
**Avertissement**
Plusieurs fonctions ci-dessous sont proposées en version bêta comme indiqué. Ces fonctionnalités sont mises à votre disposition sous la forme d'un « service bêta » tel que défini dans les conditions AWS de service. Il est soumis à votre accord AWS et aux conditions de AWS service, ainsi qu'au modèle EULA applicable.
Avec les modèles Anthropic Claude, vous pouvez spécifier un outil que le modèle peut utiliser pour répondre à un message. Par exemple, vous pouvez spécifier un outil qui capte la chanson la plus populaire d’une station de radio. Si l’utilisateur passe le message *Quelle est la chanson la plus populaire sur WZPZ ?*, le modèle détermine que l’outil que vous avez spécifié peut aider à répondre à la question. Dans sa réponse, le modèle vous demande d’exécuter l’outil en son nom. Vous exécutez ensuite l’outil et transmettez le résultat de l’outil au modèle, qui génère alors une réponse pour le message d’origine. Pour plus d’informations, consultez la section [Utilisation de l’outil (appel de fonction)](https://docs.anthropic.com/en/docs/tool-use) dans la documentation Anthropic Claude.
**Astuce**
Nous vous recommandons d’utiliser l’API Converse pour intégrer l’utilisation des outils dans votre application. 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).
**Important**
Claude Sonnet 4.5 préserve désormais le formatage intentionnel dans les paramètres de la chaîne d’appel de l’outil. Auparavant, les sauts de ligne de fin des paramètres de chaîne étaient parfois supprimées de manière incorrecte. Ce correctif garantit que les outils nécessitant un formatage précis (comme les éditeurs de texte) reçoivent les paramètres exactement comme prévu. Il s'agit d'une behind-the-scenes amélioration qui ne nécessite aucune modification de l'API. Cependant, les outils dotés de paramètres de chaîne peuvent désormais recevoir des valeurs avec des sauts de ligne de fin qui ont été précédemment supprimées.
**Note**
Claude Sonnet 4.5 inclut des optimisations automatiques pour améliorer les performances du modèle. Ces optimisations peuvent ajouter de petites quantités de jetons aux demandes, mais ces jetons ajoutés par le système ne vous sont pas facturés.
Vous spécifiez les outils que vous souhaitez mettre à la disposition d’un modèle dans le champ `tools`. L’exemple suivant concerne un outil qui obtient les chansons les plus populaires d’une station de radio.
```
[
{
"name": "top_song",
"description": "Get the most popular song played on a radio station.",
"input_schema": {
"type": "object",
"properties": {
"sign": {
"type": "string",
"description": "The call sign for the radio station for which you want the most popular song. Example calls signs are WZPZ and WKRP."
}
},
"required": [
"sign"
]
}
}
]
```
Lorsque le modèle a besoin d’un outil pour générer une réponse à un message, il renvoie des informations sur l’outil demandé, ainsi que l’entrée de l’outil, dans le champ `content` du message. Il définit également le motif d’arrêt de la réponse à `tool_use`.
```
{
"id": "msg_bdrk_01USsY5m3XRUF4FCppHP8KBx",
"type": "message",
"role": "assistant",
"model": "claude-3-sonnet-20240229",
"stop_sequence": null,
"usage": {
"input_tokens": 375,
"output_tokens": 36
},
"content": [
{
"type": "tool_use",
"id": "toolu_bdrk_01SnXQc6YVWD8Dom5jz7KhHy",
"name": "top_song",
"input": {
"sign": "WZPZ"
}
}
],
"stop_reason": "tool_use"
}
```
Dans votre code, vous appelez l’outil en son nom. Vous transmettez ensuite le résultat de l’outil (`tool_result`) dans un message utilisateur au modèle.
```
{
"role": "user",
"content": [
{
"type": "tool_result",
"tool_use_id": "toolu_bdrk_01SnXQc6YVWD8Dom5jz7KhHy",
"content": "Elemental Hotel"
}
]
}
```
Dans sa réponse, le modèle utilise le résultat de l’outil pour générer une réponse pour le message d’origine.
```
{
"id": "msg_bdrk_012AaqvTiKuUSc6WadhUkDLP",
"type": "message",
"role": "assistant",
"model": "claude-3-sonnet-20240229",
"content": [
{
"type": "text",
"text": "According to the tool, the most popular song played on radio station WZPZ is \"Elemental Hotel\"."
}
],
"stop_reason": "end_turn"
}
```
## Streaming d’outil affiné
Le streaming d’outil affiné est une capacité du modèle Anthropic Claude disponible avec Claude Sonnet 4.5, Claude Haiku 4.5, Claude Sonnet 4 et Claude Opus 4. Grâce au streaming d’outil affiné, les développeurs Claude peuvent diffuser les paramètres d’utilisation d’outil sans mise en mémoire tampon ni validation JSON, réduisant ainsi le temps de latence nécessaire pour commencer à recevoir des paramètres de grande taille.
**Note**
Lorsque vous utilisez un streaming d’outil affiné, vous risquez de recevoir des entrées JSON non valides ou partielles. Assurez-vous de tenir compte de ces cas périphériques dans votre code.
Pour utiliser cette fonctionnalité, il suffit d’ajouter l’en-tête `fine-grained-tool-streaming-2025-05-14` à une demande d’utilisation d’outil.
Voici un exemple de la manière de spécifier l’en-tête de streaming d’outil affiné :
```
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 1024,
"anthropic_beta": ["fine-grained-tool-streaming-2025-05-14"],
"messages": [
{
"role": "user",
"content": "Can you write a long poem and make a file called poem.txt?"
}
],
"tools": [
{
"name": "make_file",
"description": "Write text to a file",
"input_schema": {
"type": "object",
"properties": {
"filename": {
"type": "string",
"description": "The filename to write text to"
},
"lines_of_text": {
"type": "array",
"description": "An array of lines of text to write to the file"
}
},
"required": [
"filename",
"lines_of_text"
]
}
}
]
}
```
Dans cet exemple, le streaming d’outil affiné permet à Claude de diffuser les lignes d’un long poème dans l’appel d’outil `make_file` sans mise en mémoire tampon pour valider si le paramètre `lines_of_text` est un JSON valide. Cela signifie que vous pouvez voir le flux de paramètres tel qu’il arrive, sans avoir à attendre que l’intégralité du paramètre soit mise en mémoire tampon et validée.
Grâce au streaming d’outil affiné, les segments d’utilisation d’outil commencent à être diffusés plus rapidement, sont souvent plus longs et contiennent moins de sauts de mots. Cela est dû à des différences de comportement de segmentation.
Par exemple, sans streaming affiné (délai de 15 s) :
```
Chunk 1: '{"'
Chunk 2: 'query": "Ty'
Chunk 3: 'peScri'
Chunk 4: 'pt 5.0 5.1 '
Chunk 5: '5.2 5'
Chunk 6: '.3'
Chunk 8: ' new f'
Chunk 9: 'eatur'
...
```
Avec streaming affiné (délai de 3 s) :
```
Chunk 1: '{"query": "TypeScript 5.0 5.1 5.2 5.3'
Chunk 2: ' new features comparison'
```
**Note**
Étant donné que le streaming affiné envoie des paramètres sans mise en mémoire tampon ni validation JSON, rien ne garantit que le flux résultant sera complété par une chaîne JSON valide. En particulier, si le motif d’arrêt `max_tokens` est atteint, le flux peut se terminer à mi-chemin d’un paramètre et peut être incomplet. Vous devrez généralement rédiger un support spécifique pour gérer le moment où le `max_tokens` est atteint.
## Utilisation d’ordinateur (version bêta)
L’utilisation d’ordinateur est une capacité du modèle Anthropic Claude (en version bêta) disponible avec Claude 3.5 Sonnet v2, Claude Sonnet 4.5, Claude Haiku 4.5, Claude 3.7 Sonnet, Claude Sonnet 4 et Claude Opus 4. Grâce à l’utilisation d’ordinateur, Claude peut vous aider à automatiser les tâches à travers des actions de base de l’interface graphique.
**Avertissement**
La fonctionnalité d'utilisation de l'ordinateur est mise à votre disposition en tant que « service bêta » tel que défini dans les conditions de AWS service. Il est soumis à votre accord AWS et aux conditions de AWS service, ainsi qu'au modèle EULA applicable. Sachez que l’API d’utilisation d’un ordinateur présente des risques uniques qui sont distincts des fonctionnalités d’API standard ou des interfaces de chat. Ces risques sont accrus lors de l’utilisation de l’API d’utilisation d’ordinateur pour interagir avec Internet. Pour minimiser les risques, pensez à prendre les précautions suivantes :
Exploitez les fonctionnalités d’utilisation d’un ordinateur dans une machine virtuelle ou un conteneur dédié avec des privilèges minimaux afin de prévenir les attaques directes du système ou les accidents.
Pour éviter le vol d’informations, évitez de donner à l’API d’utilisation d’ordinateur l’accès à des comptes ou à des données sensibles.
Limiter l'accès à APIs Internet de l'ordinateur aux domaines requis afin de réduire l'exposition au contenu malveillant.
Pour garantir une supervision adéquate, gardez une intervention humaine pour les tâches sensibles (telles que la prise de décisions susceptibles d’avoir des conséquences importantes dans le monde réel) et pour tout ce qui nécessite un consentement affirmatif (comme l’acceptation de cookies, l’exécution de transactions financières ou l’acceptation des conditions de service).
Tout contenu que vous autorisez Claude à afficher ou auquel vous l’autorisez à accéder peut potentiellement entraîner l’annulation d’instructions ou amener Claude à commettre des erreurs ou à effectuer des actions involontaires. Il est essentiel de prendre les précautions appropriées, telles que l’isolement de Claude des surfaces sensibles, notamment pour éviter les risques liés à une injection d’invite. Avant d’activer ou de demander les autorisations nécessaires pour activer les fonctionnalités d’utilisation d’ordinateur dans vos propres produits, informez les utilisateurs finaux de tout risque pertinent et obtenez leur consentement le cas échéant.
L’API d’utilisation d’ordinateur propose plusieurs outils d’utilisation d’ordinateur prédéfinis que vous pouvez utiliser. Vous pouvez ensuite créer une invite avec votre demande, telle que « envoyer un e-mail à Ben avec les notes de ma dernière réunion » et une capture d’écran (si nécessaire). La réponse contient une liste d’actions `tool_use` au format JSON (par exemple, scroll\$1down, left\$1button\$1press, screenshot). Votre code exécute les actions de l’ordinateur et fournit une capture d’écran à Claude présentant les sorties (sur demande).
Depuis la sortie de Claude 3.5 v2, le paramètre tools a été mis à jour pour accepter les types d’outils polymorphes ; une propriété `tool.type` a été ajoutée pour les distinguer. Le `type` est facultatif ; s’il est omis, l’outil est supposé être un outil personnalisé (auparavant le seul type d’outil pris en charge). Pour accéder à l’utilisation d’ordinateur, vous devez utiliser le paramètre `anthropic_beta`, avec une énumération correspondante, dont la valeur dépend de la version du modèle utilisée. Pour plus d’informations, consultez le tableau suivant.
Seules les requêtes effectuées avec ce paramètre et enum peuvent utiliser les outils d’utilisation d’ordinateur. Cela peut être spécifié comme suit : `"anthropic_beta": ["computer-use-2025-01-24"]`.
| Modèle | En-tête bêta |
| --- | --- |
| Claude Opus4,5 Claude Opus4,1 Claude Opus 4 Claude Sonnet 4.5 Claude Haiku 4.5 Claude Sonnet 4 Claude 3.7 Sonnet | computer-use-2025-01-24 |
| Claude 3.5 Sonnet v2 | computer-use-2024-10-22 |
Pour plus d’informations, consultez [Utilisation d’ordinateur (version bêta)](https://docs.anthropic.com/en/docs/build-with-claude/computer-use) dans la documentation Anthropic.
Voici un exemple de réponse qui suppose que la demande contenait une capture d’écran de votre bureau avec une icône Firefox.
```
{
"id": "msg_123",
"type": "message",
"role": "assistant",
"model": "anthropic.claude-3-5-sonnet-20241022-v2:0",
"content": [
{
"type": "text",
"text": "I see the Firefox icon. Let me click on it and then navigate to a weather website."
},
{
"type": "tool_use",
"id": "toolu_123",
"name": "computer",
"input": {
"action": "mouse_move",
"coordinate": [
708,
736
]
}
},
{
"type": "tool_use",
"id": "toolu_234",
"name": "computer",
"input": {
"action": "left_click"
}
}
],
"stop_reason": "tool_use",
"stop_sequence": null,
"usage": {
"input_tokens": 3391,
"output_tokens": 132
}
}
```
## Outils définis par Anthropic
Anthropic fournit un ensemble d’outils permettant à certains modèles Claude d’utiliser efficacement les ordinateurs. Lorsque vous spécifiez un outil défini par Anthropic, les champs `description` et `tool_schema` ne sont ni nécessaires ni autorisés. Les outils définis par Anthropic sont définis par Anthropic, mais vous devez évaluer explicitement les résultats de l’outil et renvoyer les `tool_results` à Claude. Comme pour tout outil, le modèle n’exécute pas automatiquement l’outil. Chaque outil défini par Anthropic possède des versions optimisées pour des modèles spécifiques Claude 3.5 Sonnet (nouveaux) et Claude 3.7 Sonnet :
| Modèle | Outil | Remarques |
| --- | --- | --- |
| ClaudeClaude Opus4,1 ClaudeClaude Opus4 Claude Sonnet 4.5 Claude Haiku 4.5 Claude Sonnet 4 | {
"type": "text_editor_20250124",
"name": "str_replace_based_edit_tool"
} | Mise à jour de l’outil `str_replace_editor` existant |
| Claude 3.7 Sonnet | {
"type": "computer_20250124",
"name": "computer"
} | Inclut de nouvelles actions pour un contrôle plus précis |
| Claude 3.7 Sonnet | {
"type": "text_editor_20250124",
"name": "str_replace_editor"
} | Mêmes fonctionnalités que la version 20241022 |
| Claude 3.5 Sonnet v2 | {
"type": "bash_20250124",
"name": "bash"
} | Mêmes fonctionnalités que la version 20241022 |
| Claude 3.5 Sonnet v2 | {
"type": "text_editor_20241022",
"name": "str_replace_editor"
} |
| Claude 3.5 Sonnet v2 | {
"type": "bash_20241022",
"name": "bash"
} |
| Claude 3.5 Sonnet v2 | {
"type": "computer_20241022",
"name": "computer"
} |
Le champ `type` identifie l’outil et ses paramètres à des fins de validation, le champ `name` est le nom de l’outil exposé au modèle.
Si vous souhaitez inviter le modèle à utiliser l’un de ces outils, vous pouvez référencer explicitement l’outil par le champ `name`. Le champ `name` doit être unique dans la liste d’outils ; vous ne pouvez pas définir un outil avec le même `name` qu’un outil défini par Anthropic dans le même appel d’API.
## Effacement automatique des appels d’outil (version bêta)
**Avertissement**
L'outil automatique de suppression des appels est disponible en tant que « service bêta » tel que défini dans les conditions AWS de service.
**Note**
Cette fonctionnalité est actuellement prise en charge sur Claude Sonnet 4/4.5, Claude Haiku 4.5 et Claude Opus 4/4.1/4.5.
L'effacement automatique des appels de l'outil est une fonctionnalité du modèle Anthropic Claude (en version bêta). Grâce à cette fonctionnalité, Claude peut automatiquement effacer les anciens résultats d'utilisation des outils lorsque vous approchez des limites de jetons, ce qui permet une gestion du contexte plus efficace dans les scénarios d'utilisation d'outils à plusieurs tours. Pour utiliser l’effacement de l’utilisation d’outil, vous devez ajouter `context-management-2025-06-27` à la liste des en-têtes bêta sur le paramètre de demande anthropic\$1beta. Vous devrez également spécifier l'utilisation des options de configuration suivantes `clear_tool_uses_20250919` et choisir parmi celles-ci.
Voici les contrôles disponibles pour la stratégie de gestion du contexte `clear_tool_uses_20250919`. Elles sont toutes facultatives ou comportent des valeurs par défaut :
| **Option de configuration** | **Description** |
| --- | --- |
| `trigger` par défaut : 100 000 jetons d’entrée | Définit le moment où la stratégie d’édition du contexte est activée. Une fois que l’invite dépasse ce seuil, l’effacement commence. Vous pouvez spécifier cette valeur dans input\$1tokens ou tool\$1uses. |
| `keep` par défaut : 3 utilisations d’outil | Définit le nombre de use/result paires d'outils récentes à conserver après l'effacement. L’API supprime d’abord les interactions d’outil les plus anciennes, en préservant les plus récentes. Utile lorsque le modèle a besoin d’accéder aux interactions d’outil récentes pour poursuivre efficacement la conversation. |
| `clear_at_least` (facultatif) | Garantit qu’un nombre minimum de jetons sont effacés chaque fois que la stratégie est activée. Si l’API ne parvient pas à effacer au moins le nombre spécifié, la stratégie ne sera pas appliquée. Cela est utile pour déterminer si l’effacement du contexte vaut la peine de supprimer votre mise en cache des invites. |
| `exclude_tools` (facultatif) | Liste des noms d’outil dont les utilisations et les résultats ne doivent jamais être effacés. Utile pour préserver un contexte important. |
| `clear_tool_inputs` (facultatif, par défaut : False) | Contrôle si les paramètres d’appel d’outil sont effacés ainsi que les résultats de l’outil. Par défaut, seuls les résultats de l’outil sont effacés tout en gardant visibles les appels d’outil d’origine de Claude, afin que Claude puisse voir quelles opérations ont été effectuées même après la suppression des résultats. |
**Note**
L’effacement d’outil invalidera votre cache si vos préfixes contiennent vos outils.
------
#### [ Request ]
```
response = client.beta.messages.create(
betas=["context-management-2025-06-27"],
model="claude-sonnet-4-20250514",
max_tokens=4096,
messages=[
{
"role": "user",
"content": "Create a simple command line calculator app using Python"
}
],
tools=[
{
"type": "text_editor_20250728",
"name": "str_replace_based_edit_tool",
"max_characters": 10000
},
{
"type": "web_search_20250305",
"name": "web_search",
"max_uses": 3
}
],
extra_body={
"context_management": {
"edits": [
{
"type": "clear_tool_uses_20250919",
# The below parameters are OPTIONAL:
# Trigger clearing when threshold is exceeded
"trigger": {
"type": "input_tokens",
"value": 30000
},
# Number of tool uses to keep after clearing
"keep": {
"type": "tool_uses",
"value": 3
},
# Optional: Clear at least this many tokens
"clear_at_least": {
"type": "input_tokens",
"value": 5000
},
# Exclude these tools uses from being cleared
"exclude_tools": ["web_search"]
}
]
}
}
)
```
------
#### [ Response ]
```
{
"id": "msg_123",
"type": "message",
"role": "assistant",
"content": [
{
"type": "tool_use",
"id": "toolu_456",
"name": "data_analyzer",
"input": {
"data": "sample data"
}
}
],
"context_management": {
"applied_edits": [
{
"type": "clear_tool_uses_20250919",
"cleared_tool_uses": 8, # Number of tool use/result pairs that were cleared
"cleared_input_tokens": 50000 # Total number of input tokens removed from the prompt
}
]
}
"stop_reason": "tool_use",
"usage": {
"input_tokens": 150,
"output_tokens": 50
}
}
```
------
#### [ Streaming Response ]
```
data: {"type": "message_start", "message": {"id": "msg_123", "type": "message", "role": "assistant"}}
data: {"type": "content_block_start", "index": 0, "content_block": {"type": "tool_use", "id": "toolu_456", "name": "data_analyzer", "input": {}}}
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "input_json_delta", "partial_json": "{\"data\": \"sample"}}
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "input_json_delta", "partial_json": " data\"}"}}
data: {"type": "content_block_stop", "index": 0}
data: {"type": "message_delta", "delta": {"stop_reason": "tool_use"}}
data: {"type": "message_stop"}
{
"type": "message_delta",
"delta": {
"stop_reason": "end_turn",
"stop_sequence": null,
},
"usage": {
"output_tokens": 1024
},
"context_management": {
"applied_edits": [...],
}
}
```
------
**Note**
Bedrock ne prend actuellement pas en charge la gestion du `clear_tool_uses_20250919` contexte sur l' CountTokens API.
## Outil de mémoire (version bêta)
**Avertissement**
Memory Tool est mis à disposition en tant que « service bêta » tel que défini dans les conditions AWS de service.
Claude Sonnet 4.5 inclut un nouvel outil de mémoire qui permet aux clients de gérer la mémoire d’une conversation à l’autre. Grâce à cette fonctionnalité, les clients peuvent autoriser Claude à récupérer des informations en dehors de la fenêtre contextuelle en donnant accès à un répertoire local. Cela sera disponible en tant que fonctionnalité bêta. Pour utiliser cette fonctionnalité, vous devez utiliser l’en-tête bêta `context-management-2025-06-27`.
Définition d’outil :
```
{
"type": "memory_20250818",
"name": "memory"
}
```
Exemple de demande :
```
{
"max_tokens": 2048,
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": ["context-management-2025-06-27"],
"tools": [{
"type": "memory_20250818",
"name": "memory"
}],
"messages": [
{
"role": "user",
"content": [{"type": "text", "text": "Remember that my favorite color is blue and I work at Amazon?"}]
}
]
}
```
Exemple de réponse :
```
{
"id": "msg_vrtx_014mQ5ficCRB6PEa5k5sKqHd",
"type": "message",
"role": "assistant",
"model": "claude-sonnet-4-20250514",
"content": [
{
"type": "text",
"text": "I'll start by checking your memory directory and then record this important information about you."
},
{
"type": "tool_use",
"id": "toolu_vrtx_01EU1UrCDigyPMRntr3VYvUB",
"name": "memory",
"input": {
"command": "view",
"path": "/memories"
}
}
],
"stop_reason": "tool_use",
"stop_sequence": null,
"usage": {
"input_tokens": 1403,
"cache_creation_input_tokens": 0,
"cache_read_input_tokens": 0,
"output_tokens": 87
},
"context_management": {
"applied_edits": []
}
}
```
## Considérations relatives aux coûts liés à l’utilisation d’outil
Les demandes d’utilisation d’outil sont facturées en fonction des facteurs suivants :
1. Nombre total de jetons d’entrée envoyés au modèle (y compris dans le paramètre des outils).
1. Le nombre de jetons de sortie générés.
Le prix des outils est le même que celui de toutes les autres requêtes API Claude, mais ils incluent des jetons supplémentaires par demande. Les jetons supplémentaires liés à l’utilisation de l’outil proviennent des éléments suivants :
+ Le paramètre `tools` dans les requêtes API. Par exemple, les noms, les descriptions et les schémas des outils.
+ Tous les blocs de contenu `tool_use` dans les requêtes et réponses API.
+ Tous les blocs de contenu `tool_result` dans les requêtes API.
Lorsque vous utilisez des outils, les modèles Anthropic incluent automatiquement une invite système spéciale qui permet de les utiliser. Le nombre de jetons d’utilisation d’outils requis pour chaque modèle est indiqué dans le tableau suivant. Ce tableau exclut les jetons supplémentaires décrits précédemment. Notez que ce tableau suppose qu’au moins un outil est fourni. Si aucun outil n’est fourni, le choix d’aucun outil n’utilise aucun jeton d’invite système supplémentaire.
| Modèle | Choix d’outil | Nombre de jetons d’invite système d’utilisation d’outil |
| --- | --- | --- |
| Claude Opus4,5 Claude Opus4,1 Claude Opus 4 Claude Sonnet 4.5 Claude Haiku 4.5 Claude Sonnet 4 Claude 3.7 Sonnet Claude 3.5 Sonnet v2 | auto ou none | 346 |
| Claude Opus4,5 Claude Opus4,1 Claude Opus 4 Claude Sonnet 4.5 Claude Haiku 4.5 Claude Sonnet 4 Claude 3.7 Sonnet Claude 3.5 Sonnet v2 | any ou tool | 313 |
| Claude 3.5 Sonnet | auto ou none | 294 |
| Claude 3.5 Sonnet | any ou tool | 261 |
| Claude 3 Opus | auto ou none | 530 |
| Claude 3 Opus | any ou tool | 281 |
| Claude 3 Sonnet | auto ou none | 159 |
| Claude 3 Sonnet | any ou tool | 235 |
| Claude 3 Haiku | auto ou none | 264 |
| Claude 3 Haiku | any ou tool | 340 |
## Outil de recherche d'outils (version bêta)
L'outil de recherche d'outils Claude permet de travailler avec des centaines, voire des milliers d'outils sans charger toutes leurs définitions dans la fenêtre contextuelle initiale. Au lieu de déclarer tous les outils immédiatement, vous pouvez les marquer avec`defer_loading: true`, rechercher et Claude charger uniquement les outils dont ils ont besoin par le biais du mécanisme de recherche d'outils.
Pour accéder à cette fonctionnalité, vous devez utiliser l'en-tête bêta`tool-search-tool-2025-10-19`. Notez que cette fonctionnalité n'est actuellement disponible que via le [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)et [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) APIs.
Définition d’outil :
```
{
"type": "tool_search_tool_regex",
"name": "tool_search_tool_regex"
}
```
Exemple de requête :
```
{
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": [
"tool-search-tool-2025-10-19"
],
"max_tokens": 4096,
"tools": [{
"type": "tool_search_tool_regex",
"name": "tool_search_tool_regex"
},
{
"name": "get_weather",
"description": "Get current weather for a location",
"input_schema": {
"type": "object",
"properties": {
"location": {
"type": "string"
},
"unit": {
"type": "string",
"enum": ["celsius", "fahrenheit"]
}
},
"required": ["location"]
},
"defer_loading": true
},
{
"name": "search_files",
"description": "Search through files in the workspace",
"input_schema": {
"type": "object",
"properties": {
"query": {
"type": "string"
},
"file_types": {
"type": "array",
"items": {
"type": "string"
}
}
},
"required": ["query"]
},
"defer_loading": true
}
],
"messages": [{
"role": "user",
"content": "What's the weather in Seattle?"
}]
}
```
Exemple de réponse
```
{
"role": "assistant",
"content": [{
"type": "text",
"text": "I'll search for the appropriate tools to help with this task."
},
{
"type": "server_tool_use",
"id": "srvtoolu_01ABC123",
"name": "tool_search_tool_regex",
"input": {
"pattern": "weather"
}
},
{
"type": "tool_search_tool_result",
"tool_use_id": "srvtoolu_01ABC123",
"content": {
"type": "tool_search_tool_search_result",
"tool_references": [{
"type": "tool_reference",
"tool_name": "get_weather"
}]
}
},
{
"type": "text",
"text": "Now I can check the weather."
},
{
"type": "tool_use",
"id": "toolu_01XYZ789",
"name": "get_weather",
"input": {
"location": "Seattle",
"unit": "fahrenheit"
}
}
],
"stop_reason": "tool_use"
}
```
Exemple de streaming
```
# Event 1: content_block_start(with complete server_tool_use block) {
"type": "content_block_start",
"index": 0,
"content_block": {
"type": "server_tool_use",
"id": "srvtoolu_01ABC123",
"name": "tool_search_tool_regex"
}
}
# Event 2: content_block_delta(input JSON streamed) {
"type": "content_block_delta",
"index": 0,
"delta": {
"type": "input_json_delta",
"partial_json": "{\"regex\": \".*weather.*\"}"
}
}
# Event 3: content_block_stop(tool_use complete) {
"type": "content_block_stop",
"index": 0
}
# Event 4: content_block_start(COMPLETE result in single chunk) {
"type": "content_block_start",
"index": 1,
"content_block": {
"type": "tool_search_tool_result",
"tool_use_id": "srvtoolu_01ABC123",
"content": {
"type": "tool_search_tool_search_result",
"tool_references": [{
"type": "tool_reference",
"tool_name": "get_weather"
}]
}
}
}
# Event 5: content_block_stop(result complete) {
"type": "content_block_stop",
"index": 1
}
```
**Outils de recherche d'outils personnalisés**
Vous pouvez implémenter des outils de recherche d'outils personnalisés (par exemple, en utilisant des intégrations) en définissant un outil qui renvoie des blocs. `tool_reference` L'outil personnalisé doit l'être `defer_loading: false` alors que les autres outils devraient l'avoir`defer_loading: true`. Lorsque vous définissez votre propre outil de recherche d'outils, celui-ci doit renvoyer un résultat contenant des blocs de `tool_reference` contenu pointant vers les outils que vous Claude souhaitez utiliser.
Format de réponse aux résultats attendu de l'outil de recherche d'outils défini par le client :
```
{
"type": "tool_result",
"tool_use_id": "toolu_01ABC123",
"content": [{
"type": "tool_reference",
"tool_name": "get_weather"
},
{
"type": "tool_reference",
"tool_name": "weather_forecast"
}
]
}
```
Le `tool_name` doit correspondre à un outil défini dans la demande avec`defer_loading: true`. Claude aura alors accès aux schémas complets de ces outils.
**Outils de recherche personnalisés - Exemple détaillé**
Vous pouvez implémenter des outils de recherche d'outils personnalisés (par exemple, en utilisant des intégrations ou une recherche sémantique) en définissant un outil qui renvoie des blocs. `tool_reference` Cela permet des mécanismes sophistiqués de découverte d'outils allant au-delà de la correspondance des regex.
Exemple de demande avec TST personnalisé :
```
{
"model": "claude-sonnet-4-5-20250929",
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": ["tool-search-tool-2025-10-19"],
"max_tokens": 4096,
"tools": [{
"name": "semantic_tool_search",
"description": "Search for available tools using semantic similarity. Returns the most relevant tools for the given query.",
"input_schema": {
"type": "object",
"properties": {
"query": {
"type": "string",
"description": "Natural language description of what kind of tool is needed"
},
"top_k": {
"type": "integer",
"description": "Number of tools to return (default: 5)"
}
},
"required": ["query"]
},
"defer_loading": false
},
{
"name": "get_weather",
"description": "Get current weather for a location",
"input_schema": {
"type": "object",
"properties": {
"location": {
"type": "string"
},
"unit": {
"type": "string",
"enum": ["celsius", "fahrenheit"]
}
},
"required": ["location"]
},
"defer_loading": true
},
{
"name": "search_flights",
"description": "Search for available flights between locations",
"input_schema": {
"type": "object",
"properties": {
"origin": {
"type": "string"
},
"destination": {
"type": "string"
},
"date": {
"type": "string"
}
},
"required": ["origin", "destination", "date"]
},
"defer_loading": true
}
],
"messages": [{
"role": "user",
"content": "What's the weather forecast in Seattle for the next 3 days?"
}]
}
```
Claudede la réponse (appel au TST personnalisé) :
```
{
"role": "assistant",
"content": [{
"type": "text",
"text": "I'll search for the appropriate tools to help with weather information."
},
{
"type": "tool_use",
"id": "toolu_01ABC123",
"name": "semantic_tool_search",
"input": {
"query": "weather forecast multiple days",
"top_k": 3
}
}
],
"stop_reason": "tool_use"
}
```
**Résultat de l'outil fourni par le client**
Après avoir effectué une recherche sémantique dans la bibliothèque d'outils, le client renvoie les références d'outils correspondantes :
```
{
"role": "user",
"content": [{
"type": "tool_search_tool_result",
"tool_use_id": "toolu_01ABC123",
"content": {
"type": "tool_search_tool_search_result",
"tool_references": [{
"type": "tool_reference",
"tool_name": "get_weather"
}]
}
}]
}
```
Claudesuivi (à l'aide de l'outil découvert)
```
{
"role": "assistant",
"content": [{
"type": "text",
"text": "I found the forecast tool. Let me get the weather forecast for Seattle."
},
{
"type": "tool_use",
"id": "toolu_01DEF456",
"name": "get_weather",
"input": {
"location": "Seattle, WA"
}
}
],
"stop_reason": "tool_use"
}
```
**Gestion des erreurs**
+ Le réglage `defer_loading: true` de tous les outils (y compris l'outil de recherche d'outils) générera une erreur 400.
+ La transmission d'un `tool_reference` sans définition d'outil correspondante générera une erreur 400
## Exemples d'utilisation d'outils (version bêta)
Claude Opus4.5 prend en charge les exemples fournis par les utilisateurs dans les définitions d'outils afin d'améliorer les performances Claude d'utilisation des outils. Vous pouvez fournir des exemples sous forme d'appels de fonction complets, formatés exactement comme le seraient les sorties LLM réelles, sans qu'il soit nécessaire de les traduire dans un autre format. Pour utiliser cette fonctionnalité, vous devez transmettre l'en-tête bêta`tool-examples-2025-10-29`.
Exemple de définition d'outil :
```
{
"name": "get_weather",
"description": "Get the current weather in a given location",
"input_schema": {
"type": "object",
"properties": {
"location": {
"type": "string",
"description": "The city and state, e.g. San Francisco, CA"
},
"unit": {
"type": "string",
"enum": ["celsius", "fahrenheit"],
"description": "Temperature unit"
}
},
"required": ["location"]
},
"input_examples": [{
"location": "San Francisco, CA",
"unit": "fahrenheit"
},
{
"location": "Tokyo, Japan",
"unit": "celsius"
},
{
"location": "New York, NY"
}
]
}
```
**Règles de validation**
+ Conformité du schéma : chaque exemple `input_examples` doit être valide conformément à celui de l'`input_schema`outil.
+ Les champs obligatoires doivent être présents dans au moins un exemple.
+ Les types de champs doivent correspondre au schéma.
+ Les valeurs d'énumération doivent provenir de l'ensemble autorisé.
+ Si la validation échoue, renvoyez une erreur 400 avec des détails sur l'exemple d'échec de la validation.
+ Exigences relatives au tableau : `input_examples` doit être un tableau (peut être vide).
+ Un tableau vide `[]` est valide et équivaut à omettre le champ.
+ Un seul exemple doit toujours être encapsulé dans un tableau : `[{...}]`
+ Limite de longueur : commencez par une limite de 20 exemples par définition d'outil.
Exemples d'erreurs :
```
// Invalid: Example doesn't match schema (missing required field)
{
"type": "invalid_request_error",
"message": "Tool 'get_weather' input_examples[0] is invalid: Missing required property 'location'"
}
// Invalid: Example has wrong type for field
{
"type": "invalid_request_error",
"message": "Tool 'search_products' input_examples[1] is invalid: Property 'filters.price_range.min' must be a number, got string"
}
// Invalid: input_examples on server-side tool
{
"type": "invalid_request_error",
"message": "input_examples is not supported for server-side tool"
}
```
# Réflexion étendue
La pensée étendue permet d'Claudeaméliorer les capacités de raisonnement pour les tâches complexes, tout en fournissant différents niveaux de transparence dans son processus de step-by-step réflexion avant qu'il ne donne sa réponse finale. Chaque fois que vous activez le mode de réflexion de Claude, vous devez définir un budget pour le nombre maximum de jetons que Claude peut utiliser pour son processus de raisonnement interne.
Les modèles suivants sont pris en charge :
| Modèle | ID du modèle |
| --- | --- |
| Claude Opus4,5 | `anthropic.claude-opus-4-5-20251101-v1:0` |
| Claude Opus 4 | `anthropic.claude-opus-4-20250514-v1:0` |
| Claude Sonnet 4 | `anthropic.claude-sonnet-4-20250514-v1:0` |
| Claude Sonnet 4.5 | `anthropic.claude-sonnet-4-5-20250929-v1:0` |
| Claude Haiku 4.5 | `anthropic.claude-haiku-4-5-20251001-v1:0` |
| Claude 3.7 Sonnet | `anthropic.claude-3-7-sonnet-20250219-v1:0` |
| Claude Sonnet 4.5 | `anthropic.claude-opus-4-5-20251101-v1:0` |
**Note**
Le comportement de l’API diffère entre les modèles Claude 3.7 et Claude 4. Pour de plus amples informations, veuillez consulter [Différences de raisonnement entre les versions du modèle](claude-messages-thinking-differences.md).
**Topics**
+ [Bonnes pratiques et considérations pour une réflexion étendue](#claude-messages-extended-thinking-bps)
+ [Fonctionnement de la réflexion étendue](#claude-messages-how-extended-thinking-works)
+ [Utilisation de la réflexion étendue](#claude-messages-use-extended-thinking)
+ [Réflexion approfondie avec utilisation d’outils](#claude-messages-extended-thinking-tool-use)
+ [Thinking Block Clearing (version bêta)](#claude-messages-thinking-block-clearing)
+ [Réflexion étendue avec mise en cache des invites](#claude-messages-extended-thinking-prompt-caching)
+ [Présentation du comportement de mise en cache des blocs de réflexion](#claude-messages-extended-thinking-caching-behavior)
+ [Nombre maximal de jetons et taille de fenêtre contextuelle avec une réflexion étendue](#claude-messages-extended-thinking-max-tokens)
+ [Considérations relatives au coût des jetons de réflexion étendue](#claude-messages-extended-thinking-cost)
## Bonnes pratiques et considérations pour une réflexion étendue
Directives d’utilisation
+ **Sélection des tâches** : utilisez la réflexion approfondie pour les tâches particulièrement complexes qui tirent parti du step-by-step raisonnement, comme les mathématiques, le codage et l'analyse.
+ **Gestion du contexte** : il n’est pas nécessaire de supprimer vous-même les blocs de réflexion précédents. L’API Anthropic ignore automatiquement les blocs de réflexion des tours précédents et ils ne sont pas inclus dans le calcul de l’utilisation du contexte.
+ **Ingénierie de requête** : consultez les [conseils de définition d’invites étendues d’Anthropic](https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering/extended-thinking-tips) si vous souhaitez optimiser les capacités de réflexion de Claude.
Considérations sur les performances
+ **Temps de réponse** : préparez-vous à des temps de réponse potentiellement plus longs en raison du traitement supplémentaire requis pour le processus de raisonnement. Tenez compte du fait que la génération de blocs de réflexion peut augmenter le temps de réponse global.
+ **Exigences de diffusion** : la diffusion est requise lorsque `max_tokens` est supérieure à 21 333. Lorsque d’une diffusion, préparez-vous à gérer à la fois les blocs de contenu `thinking` et `text` dès leur arrivée.
Compatibilité des fonctionnalités
+ La réflexion n’est pas compatible avec les modifications `temperature`, `top_p` et `top_k`, ni avec l’[utilisation forcée d’outils](https://docs.anthropic.com/en/docs/agents-and-tools/tool-use/implement-tool-use#forcing-tool-use).
+ Vous ne pouvez pas préremplir les réponses lorsque la réflexion est activée.
+ Les modifications apportées au budget de réflexion invalident les préfixes d’invite mis en cache qui incluent des messages. Cependant, les invites du système mises en cache et les définitions d’outils continueront de fonctionner lorsque les paramètres de réflexion changent.
Utilisation des budgets de réflexion
+ **Optimisations budgétaires** : le budget minimum est de 1 024 jetons. Anthropic suggère de commencer par le minimum et d’augmenter progressivement le budget de réflexion afin de trouver la plage optimale pour votre cas d’utilisation. Un plus grand nombre de jetons peut permettre un raisonnement plus complet et nuancé, mais les rendements peuvent également diminuer en fonction de la tâche. Le budget de réflexion est un objectif plutôt qu’une limite stricte. L’utilisation réelle des jetons peut varier en fonction de la tâche.
+ **Paramètres minimaux et optimaux** : le budget minimum est de 1 024 jetons. Nous vous suggérons de commencer par le minimum et d’augmenter progressivement le budget de réflexion afin de trouver la gamme optimale pour les performances les plus adaptées à Claude pour votre cas d’utilisation. Un nombre de jetons plus élevé peut permettre d’atteindre un raisonnement plus complet et nuancé, mais les rendements peuvent également diminuer en fonction de la tâche. Le budget de réflexion est un objectif plutôt qu’une limite stricte : l’utilisation réelle des jetons peut varier en fonction de la tâche.
+ **Expérimentation** : le modèle peut fonctionner différemment selon les paramètres du budget de réflexion maximal. L’augmentation du budget de réflexion maximal peut permettre au modèle de réfléchir mieux ou plus sérieusement, au prix d’une latence accrue. Pour les tâches critiques, pensez à tester différents paramètres budgétaires afin de trouver l’équilibre optimal entre qualité et performance.
+ **Budgets importants** : pour les budgets supérieurs à 32 000, nous vous recommandons d’utiliser le traitement par lots afin d’éviter les problèmes de réseau. Les demandes qui poussent le modèle à penser au-dessus de 32 000 jetons entraînent des demandes de longue durée qui peuvent entraîner des délais d’expiration du système et des limites de connexions ouvertes. Veuillez noter que les limites de `max_tokens` varient selon les modèles Claude. Pour de plus amples informations, veuillez consulter [Nombre maximal de jetons et taille de fenêtre contextuelle avec une réflexion étendue](#claude-messages-extended-thinking-max-tokens).
+ **Suivi de l’utilisation des jetons** : surveillez l’utilisation des jetons en pensant à l’optimisation des coûts et des performances.
## Fonctionnement de la réflexion étendue
Lorsque la réflexion étendue est activée, Claude crée des blocs de contenu `thinking` dans lesquels elle produit son raisonnement interne. Claude intègre les informations issues de ce raisonnement avant d’élaborer une réponse finale. La réponse de l’API inclura des blocs de contenu `thinking`, suivis de blocs de contenu `text`.
Voici un exemple du format de réponse par défaut :
```
{
"content": [
{
"type": "thinking",
"thinking": "Let me analyze this step by step...",
"signature": "WaUjzkypQ2mUEVM36O2TxuC06KN8xyfbJwyem2dw3URve/op91XWHOEBLLqIOMfFG/UvLEczmEsUjavL...."
},
{
"type": "text",
"text": "Based on my analysis..."
}
]
}
```
Pour plus d’informations sur le format de réponse de la réflexion étendue, consultez l’API Messages [Demande et réponse](model-parameters-anthropic-claude-messages-request-response.md) d’Anthropic.
## Utilisation de la réflexion étendue
Pour activer la réflexion étendue, ajoutez un objet `thinking`, le paramètre `thinking` étant défini sur activé et `budget_tokens` défini sur un budget symbolique spécifié pour la réflexion étendue.
Le paramètre `budget_tokens` détermine le nombre maximum de jetons que Claude est autorisé à utiliser pour son processus de raisonnement interne. Dans les 4 modèles de Claude, cette limite s’applique aux jetons de réflexion complets, et non au résultat résumé. Des budgets plus importants peuvent améliorer la qualité des réponses en permettant une analyse plus approfondie des problèmes complexes, mais Claude risque de ne pas utiliser la totalité du budget alloué, en particulier pour les plages supérieures à 32 000.
La valeur de `budget_tokens` doit être définie sur une valeur inférieure à `max_tokens`. Toutefois, lorsque vous utilisez [Réflexion entrelacée (bêta)](#claude-messages-extended-thinking-tool-use-interleaved) avec des outils, vous pouvez dépasser cette limite, car la limite de jetons devient l’ensemble de votre fenêtre de contexte (200 000 jetons).
### Réflexion résumée
Lorsque la réflexion étendue est activée, l’API Messages pour les 4 modèles Claude renvoie un résumé du processus de réflexion complet de Claude. La réflexion résumée permet de tirer pleinement parti des avantages de la réflexion étendue en termes d’intelligence, tout en empêchant toute utilisation abusive.
Voici quelques considérations importantes pour une réflexion résumée :
+ Les jetons de réflexion complets générés par la demande initiale vous sont facturés, et non les jetons récapitulatifs.
+ Le nombre de jetons de sortie facturés ne correspondra pas au nombre de jetons que vous voyez dans la réponse.
+ L’invite fournie au modèle de résumé est sujette à modification.
+ Les premières lignes de réflexion sont plus verbeuses, fournissant un raisonnement détaillé particulièrement utile à des fins d’ingénierie de requête.
**Note**
Claude 3.7 Sonnet renvoie toujours le résultat de la réflexion dans son intégralité.
Pour accéder à l’ensemble des résultats de réflexion relatifs au 4 modèles Claude, contactez l’équipe chargée de votre compte.
### Diffusion de réflexion
Vous pouvez diffuser des réponses de réflexion étendue à l’aide d’événements envoyés par le serveur (SSE). Lorsque la diffusion est activée pour une réflexion étendue, vous recevez du contenu de réflexion via des événements `thinking_delta`. Il n’est pas garanti que les événements diffusés en continu reviendront à un rythme constant. Il peut y avoir des délais entre les événements de diffusion. Pour plus de documentation sur la diffusion via l’API Messages, consultez [Diffusion de messages](https://docs.anthropic.com/en/docs/build-with-claude/streaming).
Voici comment gérer le streaming en pensant en utilisant **InvokeModelWithResponseStream**:
```
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 10000,
"thinking": {
"type": "enabled",
"budget_tokens": 4000
},
"messages": [
{
"role": "user",
"content": "What is 27 * 453?"
}
]
}
```
Réponse :
```
event: message_start
data: {"type": "message_start", "message": {"id": "msg_01...", "type": "message", "role": "assistant", "content": [], "model": "claude-3-7-sonnet-20250219", "stop_reason": null, "stop_sequence": null}}
event: content_block_start
data: {"type": "content_block_start", "index": 0, "content_block": {"type": "thinking", "thinking": ""}}
event: content_block_delta
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "thinking_delta", "thinking": "Let me solve this step by step:\n\n1. First break down 27 * 453"}}
event: content_block_delta
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "thinking_delta", "thinking": "\n2. 453 = 400 + 50 + 3"}}
// Additional thinking deltas...
event: content_block_delta
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "signature_delta", "signature": "EqQBCgIYAhIM1gbcDa9GJwZA2b3hGgxBdjrkzLoky3dl1pkiMOYds..."}}
event: content_block_stop
data: {"type": "content_block_stop", "index": 0}
event: content_block_start
data: {"type": "content_block_start", "index": 1, "content_block": {"type": "text", "text": ""}}
event: content_block_delta
data: {"type": "content_block_delta", "index": 1, "delta": {"type": "text_delta", "text": "27 * 453 = 12,231"}}
// Additional text deltas...
event: content_block_stop
data: {"type": "content_block_stop", "index": 1}
event: message_delta
data: {"type": "message_delta", "delta": {"stop_reason": "end_turn", "stop_sequence": null}}
event: message_stop
data: {"type": "message_stop"}
```
**À propos du comportement de diffusion avec réflexion**
Lorsque vous utilisez le streaming avec la fonction de réflexion activée, vous remarquerez peut-être que le texte arrive parfois en gros morceaux, alternant avec une token-by-token diffusion plus petite. Il s’agit d’un comportement attendu, en particulier pour ce qui est du contenu de réflexion. Le système de diffusion doit traiter le contenu par lots pour des performances optimales, ce qui peut entraîner ce schéma de diffusion.
## Réflexion approfondie avec utilisation d’outils
La réflexion approfondie peut être utilisée avec [Utilisation d’outil](model-parameters-anthropic-claude-messages-tool-use.md), ce qui permet à Claude de raisonner grâce à la sélection d’outils et au traitement des résultats. Lorsque vous utilisez la réflexion étendue en combinaison avec l’utilisation d’outils, tenez compte des limitations suivantes :
+ **Limitation du choix d’outils** : l’utilisation d’outils avec la fonctionnalité de réflexion ne prend en charge que `tool_choice: any`. Elle ne prend pas en charge la fourniture d’un outil spécifique, `auto`, ou de toute autre valeur.
+ **Préservation des blocs de réflexion** : lors de l’utilisation de l’outil, vous devez renvoyer les blocs de réflexion à l’API pour le dernier message de l’assistant. Incluez de nouveau le bloc complet non modifié dans l’API pour maintenir la continuité du raisonnement.
Voici comment fonctionne la gestion des fenêtres contextuelles avec les outils :
```
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 10000,
"thinking": {
"type": "enabled",
"budget_tokens": 4000
},
"tools": [
{
"name": "get_weather",
"description": "Get current weather for a location",
"input_schema": {
"type": "object",
"properties": {
"location": {
"type": "string"
}
},
"required": [
"location"
]
}
}
],
"messages": [
{
"role": "user",
"content": "What's the weather in Paris?"
}
]
}
```
La première réponse est la suivante :
```
{
"content": [
{
"type": "thinking",
"thinking": "The user wants to know the current weather in Paris. I have access to a function `get_weather`...",
"signature": "BDaL4VrbR2Oj0hO4XpJxT28J5TILnCrrUXoKiiNBZW9P+nr8XSj1zuZzAl4egiCCpQNvfyUuFFJP5CncdYZEQPPmLxYsNrcs...."
},
{
"type": "text",
"text": "I can help you get the current weather information for Paris. Let me check that for you"
},
{
"type": "tool_use",
"id": "toolu_01CswdEQBMshySk6Y9DFKrfq",
"name": "get_weather",
"input": {
"location": "Paris"
}
}
]
}
```
La poursuite de la conversation sur l’utilisation de l’outil générera une autre réponse. Notez que `thinking_block` est transmis ainsi que `tool_use_block`. Si la transmission n’a pas lieu, une erreur se produit.
```
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 10000,
"thinking": {
"type": "enabled",
"budget_tokens": 4000
},
"tools": [
{
"name": "get_weather",
"description": "Get current weather for a location",
"input_schema": {
"type": "object",
"properties": {
"location": {
"type": "string"
}
},
"required": [
"location"
]
}
}
],
"messages": [
{
"role": "user",
"content": "What's the weather in Paris?"
},
{
"role": "assistant",
"content": [
{
"type": "thinking",
"thinking": "The user wants to know the current weather in Paris. I have access to a function `get_weather`…",
"signature": "BDaL4VrbR2Oj0hO4XpJxT28J5TILnCrrUXoKiiNBZW9P+nr8XSj1zuZzAl4egiCCpQNvfyUuFFJP5CncdYZEQPPmLxY",
},
{
"type": "tool_use",
"id": "toolu_01CswdEQBMshySk6Y9DFKrfq",
"name": "get_weather",
"input": {
"location": "Paris"
}
}
]
},
{
"role": "user",
"content": [
{
"type": "tool_result",
"tool_use_id": "toolu_01CswdEQBMshySk6Y9DFKrfq",
"content": "Current temperature: 88°F"
}
]
}
]
}
```
La réponse de l’API ne comprendra désormais que du texte
```
{
"content": [
{
"type": "text",
"text": "Currently in Paris, the temperature is 88°F (31°C)"
}
]
}
```
### Préservation des blocs de réflexion
Lors de l’utilisation de l’outil, vous devez transmettre les blocs de réflexion à l’API, et vous devez inclure le bloc complet non modifié à l’API. Cela est essentiel pour maintenir le flux de raisonnement et l’intégrité des conversations du modèle.
**Astuce**
Bien que vous puissiez omettre les blocs `thinking` des rotations de rôles `assistant` précédentes, nous vous suggérons de toujours renvoyer tous les blocs de réflexion à l’API pour toute conversation à plusieurs tours. L’API effectuera les opérations suivantes :
Filtrer automatiquement les blocs de réflexion fournis
Utiliser les blocs de réflexion pertinents nécessaires pour préserver le raisonnement du modèle
Ne facturer que les jetons d’entrée pour les blocs présentés à Claude
Lorsque Claude invoque des outils, il suspend la construction d’une réponse dans l’attente d’informations externes. Une fois les résultats de l’outil renvoyés, Claude continuera à construire cette réponse existante. Cela nécessite de préserver les blocs de réflexion lors de l’utilisation de l’outil, pour les raisons suivantes :
+ **Continuité du raisonnement** : les blocs Claude de réflexion capturent step-by-step le raisonnement qui a conduit aux demandes d'outils. Lorsque vous publiez les résultats d’un outil, inclure la réflexion d’origine permet à Claude de poursuivre son raisonnement là où il s’est arrêté.
+ **Maintenance du contexte** : bien que les résultats des outils apparaissent sous forme de messages utilisateur dans la structure de l’API, ils font partie d’un flux de raisonnement continu. La préservation des blocs de réflexion permet de maintenir ce flux conceptuel entre plusieurs appels d’API.
**Important**
Lorsque vous fournissez des blocs de réflexion, la séquence complète des blocs de réflexion consécutifs doit correspondre aux résultats générés par le modèle lors de la demande initiale ; vous ne pouvez pas réorganiser ou modifier la séquence de ces blocs.
### Réflexion entrelacée (bêta)
**Avertissement**
Interleaved Thinking est mis à votre disposition sous la forme d'un « service bêta » tel que défini dans les conditions de service. AWS Il est soumis à votre accord AWS et aux conditions de AWS service, ainsi qu'au modèle EULA applicable.
Les 4 modèles Claude prennent en charge la réflexion entrelacée, une fonctionnalité qui permet à Claude de réfléchir entre les appels d’outils et d’exécuter un raisonnement plus sophistiqué après avoir reçu les résultats de l’outil. Cela permet des interactions agentiques plus complexes où Claude peut effectuer les opérations suivantes :
+ Raisonner sur les résultats d’un appel d’outil avant de décider de la marche à suivre
+ Enchaîner plusieurs appels d’outils avec des étapes de raisonnement entre les deux
+ Prendre des décisions plus nuancées en fonction de résultats intermédiaires
Pour activer la réflexion entrelacée, ajoutez l’en-tête bêta `interleaved-thinking-2025-05-14` à votre demande d’API.
**Note**
Avec la réflexion entrelacée, le paramètre `budget_tokens` peut dépasser le paramètre `max_tokens`, car il représente le budget total pour tous les blocs de réflexion en un tour d’assistant.
## Thinking Block Clearing (version bêta)
**Avertissement**
Thinking Block Clearing est disponible sous la forme d'un « service bêta » tel que défini dans les conditions AWS de service.
**Note**
Cette fonctionnalité est actuellement prise en charge sur Claude Sonnet 4/4.5, Claude Haiku 4.5 et Claude Opus 4/4.1/4.5.
Thinking Block Clearing est une fonctionnalité du modèle Anthropic Claude (en version bêta). Grâce à cette fonctionnalité, Claude peut automatiquement effacer les anciens blocages de pensée des tours précédents. Pour utiliser la suppression des blocs Thinking, vous devez les ajouter `context-management-2025-06-27` à la liste des en-têtes bêta sur le paramètre de requête anthropic\$1beta. Vous devrez également spécifier l'utilisation des options de configuration suivantes `clear_thinking_20251015` et choisir l'une des options de configuration suivantes.
Voici les contrôles disponibles pour la stratégie de gestion du contexte `clear_thinking_20251015`. Elles sont toutes facultatives ou comportent des valeurs par défaut :
| **Option de configuration** | **Description** |
| --- | --- |
| `keep` par défaut : 1 tour de réflexion | Définit le nombre de tours d'assistant récents avec des blocs de réflexion à préserver. Utilisez `{"type": "thinking_turns", "value": N}` où N doit être > 0 pour conserver les N derniers tours ou `{"type": "all"}` pour conserver tous les blocs de réflexion. |
------
#### [ Request ]
```
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 10000,
"anthropic_beta": [
"context-management-2025-06-27"
],
"thinking": {
"type": "enabled",
"budget_tokens": 4000
},
"tools": [
{
"name": "get_weather",
"description": "Get current weather for a location",
"input_schema": {
"type": "object",
"properties": {
"location": {
"type": "string"
}
},
"required": [
"location"
]
}
}
],
"messages": [
{
"role": "user",
"content": "What's the weather in Paris?"
},
{
"role": "assistant",
"content": [
{
"type": "thinking",
"thinking": "The user is asking for the weather in Paris. I have access to a get_weather function that takes a location as a parameter. I have all the information I need to make this call - the location is \"Paris\".\n\nLet me call the get_weather function with \"Paris\" as the location.",
"signature": "ErgDCkgIChABGAIqQC/Ccv8GC+5VfcMEiq78XmpU2Ef2cT+96pHKMedKcRNuPz1x0kFlo5HBpW0r1NcQFVQUPuj6PDmP7jdHY7GsrUwSDKNBMogjaM7wYkwfPhoMswjlmfF09JLjZfFlIjB03NkghGOxLbr3VCQHIY0lMaV9UBvt7ZwTpJKzlz+mulBysfvAmDfcnvdJ/6CZre4qnQJsTZaiXdEgASwPIc5jOExBguerrtYSWVC/oPjSi7KZM8PfhP/SPXupyLi8hwYxeqomqkeG7AQhD+3487ecerZJcpJSOSsf0I1OaMpmQEE/b7ehnvTV/A4nLhxIjP4msyIBW+dVwHNFRFlpJLBHUJvN99b4run6YmqBSf4y9TyNMfOr+FtfxedGE0HfJMBd4FHXmUFyW5y91jAHMWqwNxDgacaKkFCAMaqce5rm0ShOxXn1uwDUAS3jeRP26Pynihq8fw5DQwlqOpo7vvXtqb5jjiCmqfOe6un5xeIdhhbzWddhEk1Vmtg7I817pM4MZjVaeQN02drPs8QgDxihnP6ZooGhd6FCBP2X3Ymdlj5zMlbVHxmSkA4wcNtg4IAYAQ=="
},
{
"type": "tool_use",
"id": "toolu_bdrk_01U7emCvL5v5z5GT7PDr2vzc",
"name": "get_weather",
"input": {
"location": "Paris"
}
}
]
},
{
"role": "user",
"content": [
{
"type": "tool_result",
"tool_use_id": "toolu_bdrk_01U7emCvL5v5z5GT7PDr2vzc",
"content": "Current temperature: 88°F"
}
]
}
],
"context_management": {
"edits": [
{
"type": "clear_thinking_20251015",
"keep": {
"type": "thinking_turns",
"value": 1
}
}
]
}
}
```
------
#### [ Response ]
```
{
"model": "claude-haiku-4-5-20251001",
"id": "msg_bdrk_01KyTbyFbdG2kzPwWMJY1kum",
"type": "message",
"role": "assistant",
"content": [
{
"type": "text",
"text": "The current weather in Paris is **88°F** (approximately 31°C). It's quite warm! If you need more detailed information like humidity, wind conditions, or a forecast, please let me know."
}
],
"stop_reason": "end_turn",
"stop_sequence": null,
"usage": {
"input_tokens": 736,
"cache_creation_input_tokens": 0,
"cache_read_input_tokens": 0,
"cache_creation": {
"ephemeral_5m_input_tokens": 0,
"ephemeral_1h_input_tokens": 0
},
"output_tokens": 47
},
"context_management": {
"applied_edits": [...]
}
}
```
------
## Réflexion étendue avec mise en cache des invites
La [mise en cache des invites](https://docs.aws.amazon.com/bedrock/latest/userguide/prompt-caching.html) avec la fonctionnalité de réflexion comporte plusieurs considérations importantes :
**Suppression du contexte des blocs de réflexion**
+ Les blocs de réflexion des tours précédents sont supprimés du contexte, ce qui peut affecter les points d’arrêt du cache.
+ Lorsque vous poursuivez des conversations utilisant des outils, les blocs de réflexion sont mis en cache et sont considérés comme des jetons d’entrée lorsqu’ils sont lus depuis le cache. Cela crée un compromis dans lequel les blocs de réflexion ne consomment pas visuellement de l’espace dans la fenêtre contextuelle, mais ils seront tout de même pris en compte dans l’utilisation de votre jeton d’entrée une fois mis en cache.
+ Si la réflexion se désactive, les demandes échoueront si vous transmettez le contenu de réflexion au cours du tour d’utilisation actuel de l’outil. Dans d’autres contextes, le contenu de réflexion transmis à l’API est simplement ignoré.
**Modèles d’invalidation du cache**
+ Les modifications apportées aux paramètres de réflexion (telles que l’activation, la désactivation ou la modification de l’allocation budgétaire) invalident les points d’arrêt du cache de messages.
+ [Réflexion entrelacée (bêta)](#claude-messages-extended-thinking-tool-use-interleaved) amplifie l’invalidation du cache, car des blocages de réflexion peuvent survenir entre plusieurs appels d’outils.
+ Les invites et les outils du système restent en cache même si vous pensez à modifier les paramètres ou à supprimer des blocs.
**Note**
Bien que les blocs de réflexion soient supprimés pour les calculs fastidieux et contextuels, ils doivent être préservés lors de la poursuite des conversations utilisant des outils, en particulier dans le cas de la réflexion entrelacée.
## Présentation du comportement de mise en cache des blocs de réflexion
Lorsque la réflexion étendue est associée à l’utilisation d’outils, les blocs de réflexion présentent un comportement de mise en cache spécifique qui affecte le comptage des jetons. La séquence suivante montre comment cela fonctionne.
1. La mise en cache ne se produit que lorsque vous effectuez une demande ultérieure incluant les résultats de l’outil.
1. Lorsque la demande suivante est faite, l’historique des conversations précédentes (y compris les blocs de réflexion) peut être mis en cache.
1. Ces blocs de réflexion mis en cache sont considérés comme des jetons d’entrée dans vos statistiques d’utilisation lorsqu’ils sont lus depuis le cache.
1. Lorsqu'un bloc non-tool-result utilisateur est inclus, tous les blocs de réflexion précédents sont ignorés et retirés de leur contexte.
Voici un exemple de flux détaillé :
Demande 1 :
```
User: "What's the weather in Paris?"
```
Réponse 1 :
```
[thinking_block 1] + [tool_use block 1]
```
Demande 2 :
```
User: "What's the weather in Paris?",
Assistant: [thinking_block_1] + [tool_use block 1],
User: [tool_result_1, cache=True]
```
Réponse 2 :
```
[thinking_block 2] + [text block 2]
```
La demande 2 écrit un cache du contenu de la demande (et non de la réponse). Le cache inclut le message utilisateur d’origine, le premier bloc de réflexion, le bloc d’utilisation de l’outil et le résultat de l’outil.
Demande 3 :
```
User: ["What's the weather in Paris?"],
Assistant: [thinking_block_1] + [tool_use block 1],
User: [tool_result_1, cache=True],
Assistant: [thinking_block_2] + [text block 2],
User: [Text response, cache=True]
```
Comme un bloc non-tool-result utilisateur a été inclus, tous les blocs de réflexion précédents sont ignorés. Cette demande sera traitée de la même manière que la demande suivante :
Demande 3 Alternative :
```
User: ["What's the weather in Paris?"]
Assistant: [tool_use block 1]
User: [tool_result_1, cache=True]
Assistant: [text block 2]
User: [Text response, cache=True]
```
Ce comportement est constant, qu’il s’agisse d’une réflexion régulière ou d’une réflexion entrelacée.
## Nombre maximal de jetons et taille de fenêtre contextuelle avec une réflexion étendue
Dans les anciens modèles Claude (antérieurs à Claude 3.7 Sonnet), si la somme des jetons d’invite et des max\$1tokens dépassait la fenêtre contextuelle du modèle, le système ajustait automatiquement max\$1tokens pour qu’il s’adapte à la limite de contexte. Cela signifiait que vous pouviez définir une valeur max\$1tokens élevée et que le système la réduirait silencieusement selon les besoins. Les modèles Claude 3.7 et 4 `max_tokens` (qui incluent votre budget de réflexion lorsque la réflexion est activée) sont imposés en tant que limite stricte. Le système renvoie désormais une erreur de validation si jetons d’invite \$1 max\$1tokens dépasse la taille de la fenêtre contextuelle.
### La fenêtre contextuelle avec réflexion étendue
Lors du calcul de l’utilisation d’une fenêtre de contexte avec la fonction de réflexion activée, il convient de prendre en compte certaines considérations :
+ Les blocs de réflexion des tours précédents sont supprimés et ne sont pas pris en compte dans votre fenêtre contextuelle.
+ La réflexion sur le tour actuel compte dans le calcul `max_tokens` de votre limite pour ce tour.
La fenêtre contextuelle effective est calculée comme suit : fenêtre de contexte = (jetons d’entrée actuels - jetons de réflexion précédents) \$1 (jetons de réflexion \$1 jetons de réflexion chiffrés \$1 jetons de sortie de texte).
### Gestion des jetons avec la réflexion étendue et à l’utilisation d’outils
Lorsque la réflexion étendue est associée à l’utilisation d’outils, les blocs de réflexion doivent être explicitement préservés et renvoyés avec les résultats de l’outil. Le calcul efficace de la fenêtre contextuelle pour une réflexion étendue avec l’utilisation d’outils devient le suivant :
`context window = (current input tokens + previous thinking tokens + tool use tokens) + (thinking tokens + encrypted thinking tokens + text output tokens)`
### Gestion des jetons avec la réflexion étendue
Compte tenu de la fenêtre contextuelle `max_tokens` et du comportement des modèles Extended Thinking Claude 3.7 et 4, vous devrez peut-être effectuer l’une des actions suivantes :
+ Surveiller et gérer plus activement l’utilisation de vos jetons.
+ Ajuster les valeurs `max_tokens` en fonction de l’évolution de la longueur de votre invite.
+ Sachez que les blocs de pensée précédents ne s’accumulent pas dans votre fenêtre contextuelle. Cette modification a été apportée pour offrir un comportement plus prévisible et transparent, d’autant plus que les limites maximales de jetons ont considérablement augmenté.
## Considérations relatives au coût des jetons de réflexion étendue
Le processus de réflexion entraîne des frais pour les éléments suivants :
+ Jetons utilisés pendant la réflexion (jetons de sortie)
+ Blocs de réflexion du dernier tour de l’assistant inclus dans les demandes suivantes (jetons d’entrée)
+ Jetons de sortie de texte standard
**Astuce**
Lorsque la réflexion étendue est activée, une invite spécialisée du système à 28 ou 29 jetons est automatiquement incluse pour prendre en charge cette fonctionnalité.
Le paramètre `budget_tokens` détermine le nombre maximum de jetons que Claude est autorisé à utiliser pour son processus de raisonnement interne. Des budgets plus importants peuvent améliorer la qualité des réponses en permettant une analyse plus approfondie des problèmes complexes, mais Claude risque de ne pas utiliser la totalité du budget alloué, en particulier pour les plages supérieures à 32 000.
Avec la réflexion entrelacée, le paramètre `budget_tokens` peut dépasser le paramètre `max_tokens`, car il représente le budget total pour tous les blocs de réflexion en un tour d’assistant.
Lorsque vous utilisez la réflexion résumée, gardez à l’esprit les informations suivantes :
+ **Jetons d’entrée** : jetons figurant dans votre demande initiale
+ **Jetons de sortie (facturés)** : les jetons de réflexion originaux Claude générés en interne
+ **Jetons de sortie (visibles)** : les jetons de réflexion résumés que vous voyez dans la réponse
+ **Aucuns frais** : jetons utilisés pour générer le résumé
+ Le champ `summary_status` peut indiquer si les limites du jeton ont une incidence sur le résumé
+ Le nombre de jetons de sortie facturés ne correspondra pas au nombre de jetons que vous voyez dans la réponse. Vous êtes facturé pour l’ensemble du processus de réflexion, et non pour le résumé que vous voyez.
# Pensée adaptative
La pensée adaptative est la méthode recommandée pour utiliser [Réflexion étendue](claude-messages-extended-thinking.md) la version Claude Opus 4.6. Au lieu de définir manuellement un budget symbolique, la pensée adaptative permet de décider Claude dynamiquement quand et dans quelle mesure réfléchir en fonction de la complexité de chaque demande. La pensée adaptative entraîne de manière fiable de meilleures performances que la pensée étendue avec une approche fixe`budget_tokens`, et nous vous recommandons de passer à la pensée adaptative pour obtenir les réponses les plus intelligentes de la Claude Opus version 4.6. Aucun en-tête bêta n'est requis.
Les modèles suivants sont pris en charge :
| Modèle | ID du modèle |
| --- | --- |
| Claude Opus4.6 | `anthropic.claude-opus-4-6-v1` |
| Claude Sonnet 4.6 | `anthropic.claude-sonnet-4-6` |
**Note**
`thinking.type: "enabled"`et `budget_tokens` sont obsolètes dans la version Claude Opus 4.6 et seront supprimés dans une future version du modèle. À utiliser plutôt `thinking.type: "adaptive"` avec le paramètre effort.
Les anciens modèles (Claude Opus4.5Claude Sonnet 4.5, etc.) ne prennent pas en charge la pensée adaptative et nécessitent `thinking.type: "enabled"` avec`budget_tokens`.
## Comment fonctionne la pensée adaptative
En mode adaptatif, Claude évalue la complexité de chaque demande et décide s'il convient de réfléchir et dans quelle mesure. Au niveau d'effort par défaut (`high`), je Claude penserai presque toujours. À un niveau d'effort moindre, vous Claude pouvez éviter de penser à des problèmes plus simples.
La pensée adaptative le permet également automatiquement[Réflexion entrelacée (bêta)](claude-messages-extended-thinking.md#claude-messages-extended-thinking-tool-use-interleaved). Cela Claude permet de réfléchir entre les appels d'outils, ce qui le rend particulièrement efficace pour les flux de travail agentiques.
Définissez `thinking.type` ce paramètre `"adaptive"` dans votre demande d'API :
------
#### [ CLI ]
```
aws bedrock-runtime invoke-model \
--model-id "us.anthropic.claude-opus-4-6-v1" \
--body '{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 16000,
"thinking": {
"type": "adaptive"
},
"messages": [
{
"role": "user",
"content": "Three players A, B, C play a game. Each has a jar with 100 balls numbered 1-100. Simultaneously, each draws one ball. A beats B if As number > Bs number (mod 100, treating 100 as 0 for comparison). Similarly for B vs C and C vs A. The overall winner is determined by majority of pairwise wins (ties broken randomly). Is there a mixed strategy Nash equilibrium where each player draws uniformly? If not, characterize the equilibrium."
}
]
}' \
--cli-binary-format raw-in-base64-out \
output.json && cat output.json | jq '.content[] | {type, thinking: .thinking[0:200], text}'
```
------
#### [ Python ]
```
import boto3
import json
bedrock_runtime = boto3.client(
service_name='bedrock-runtime',
region_name='us-east-2'
)
response = bedrock_runtime.invoke_model(
modelId="us.anthropic.claude-opus-4-6-v1",
body=json.dumps({
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 16000,
"thinking": {
"type": "adaptive"
},
"messages": [{
"role": "user",
"content": "Explain why the sum of two even numbers is always even."
}]
})
)
response_body = json.loads(response["body"].read())
for block in response_body["content"]:
if block["type"] == "thinking":
print(f"\nThinking: {block['thinking']}")
elif block["type"] == "text":
print(f"\nResponse: {block['text']}")
```
------
#### [ TypeScript ]
```
import { BedrockRuntimeClient, InvokeModelCommand } from "@aws-sdk/client-bedrock-runtime";
async function main() {
const client = new BedrockRuntimeClient({});
const command = new InvokeModelCommand({
modelId: "us.anthropic.claude-opus-4-6-v1",
body: JSON.stringify({
anthropic_version: "bedrock-2023-05-31",
max_tokens: 16000,
thinking: {
type: "adaptive"
},
messages: [{
role: "user",
content: "Explain why the sum of two even numbers is always even."
}]
})
});
const response = await client.send(command);
const responseBody = JSON.parse(new TextDecoder().decode(response.body));
for (const block of responseBody.content) {
if (block.type === "thinking") {
console.log(`\nThinking: ${block.thinking}`);
} else if (block.type === "text") {
console.log(`\nResponse: ${block.text}`);
}
}
}
main().catch(console.error);
```
------
## Pensée adaptative avec le paramètre d'effort
Vous pouvez associer la pensée adaptative au paramètre d'effort pour déterminer l'efficacité de la Claude réflexion. Le niveau d'effort sert de guide souple pour Claude la répartition de la réflexion :
| Niveau d'effort | Comportement de réflexion |
| --- | --- |
| max | Claudepense toujours sans aucune contrainte quant à la profondeur de réflexion. Claude Opus4.6 uniquement — les demandes utilisées max sur d'autres modèles renverront une erreur. |
| high (par défaut) | Claudepense toujours. Fournit un raisonnement approfondi sur des tâches complexes. |
| medium | Claudeutilise une pensée modérée. Peut éviter de réfléchir pour des requêtes très simples. |
| low | Claudeminimise la réflexion. Évite de penser à des tâches simples où la rapidité compte le plus. |
## Mise en cache des invites
Les requêtes consécutives utilisant `adaptive` Thinking préservent les points d'arrêt rapides du cache. Cependant, le basculement entre les modes`enabled`/`adaptive`et/`disabled`thinking permet de briser les points d'arrêt du cache pour les messages. Les instructions système et les définitions d'outils restent en cache indépendamment des changements de mode.
## Régler le comportement de réflexion
Si vous Claude réfléchissez plus ou moins souvent que vous ne le souhaiteriez, vous pouvez ajouter des instructions à l'invite de votre système :
```
Extended thinking adds latency and should only be used when it
will meaningfully improve answer quality — typically for problems
that require multi-step reasoning. When in doubt, respond directly.
```
**Avertissement**
ClaudeRéfléchir moins souvent peut réduire la qualité des tâches pour lesquelles le raisonnement est bénéfique. Mesurez l'impact sur vos charges de travail spécifiques avant de déployer un réglage de la production basé sur des instructions. Envisagez d'abord de tester avec des niveaux d'effort moindres.
# Chiffrement des raisonnements
Le contenu complet des raisonnements est crypté et renvoyé dans le champ de signature. Ce champ est utilisé pour vérifier que les blocs de raisonnement ont été générés par Claude lorsqu’ils sont renvoyés à l’API. Lors du streaming des réponses, la signature est ajoutée via un `signature_delta` à l’intérieur d’un événement `content_block_delta` juste avant l’événement `content_block_stop`.
**Note**
Il n’est strictement nécessaire de renvoyer des blocs de raisonnement que lors de l’utilisation d’outils de raisonnement étendu. Sinon, vous pouvez omettre les blocs de raisonnement des tours précédents, ou laisser l’API les supprimer pour vous si vous les renvoyez.
Si vous renvoyez des blocs de raisonnement, nous vous recommandons de tous les transmettre tel que vous les avez reçu pour des raisons de cohérence et afin d’éviter d’éventuels problèmes.
## Expurgation des raisonnements dans Claude 3.7 Sonnet
**Note**
Les informations suivantes s’appliquent spécifiquement à Claude 3.7 Sonnet. Les modèles Claude 4 gèrent les raisonnements différemment et ne produisent pas de blocs de raisonnement expurgés.
Dans Claude 3.7 Sonnet, les conditions suivantes s’appliquent :
+ Occasionnellement, le raisonnement interne de Claude sera signalé par nos systèmes de sécurité. Lorsque cela se produit, nous chiffrons une partie ou la totalité du bloc de raisonnement et nous vous le renvoyons sous forme de bloc redacted\$1thinking (raisonnement expurgé). Les blocs redacted\$1thinking sont déchiffrés lorsqu’ils sont renvoyés à l’API, ce qui permet à Claude de poursuivre sa réponse sans perdre de contexte.
+ Les blocs `thinking` et `redacted_thinking` sont renvoyés avant les blocs de texte dans la réponse.
Lorsque vous créez des applications destinées aux clients qui font appel au raisonnement étendu avec Claude 3.7 Sonnet, tenez compte des points suivants :
+ Sachez que les blocs de raisonnement expurgés contiennent du contenu chiffré qui n’est pas lisible par l’homme.
+ Envisagez de fournir une explication simple telle que : « Certains raisonnements internes de Claude ont été automatiquement chiffrés pour des raisons de sécurité. Cela n’affecte pas la qualité des réponses. »
+ Si vous présentez des blocs de raisonnement aux utilisateurs, vous pouvez filtrer les blocs expurgés tout en préservant les blocs de raisonnement normaux.
+ Sachez que l’utilisation de fonctionnalités de raisonnement étendu peut parfois entraîner le chiffrement de certains raisonnements.
+ Mettez en œuvre une gestion des erreurs appropriée pour gérer de façon fluide les raisonnements expurgés sans endommager votre interface utilisateur.
Voici un exemple illustrant à la fois des blocs de raisonnement normaux et des blocs de raisonnement expurgés :
```
{
"content": [
{
"type": "thinking",
"thinking": "Let me analyze this step by step...",
"signature":"WaUjzkypQ2mUEVM36O2TxuC06KN8xyfbJwyem2dw3URve/op91XWHOEBLLqIOMfFG/UvLEczmEsUjavL...." },
{
"type": "redacted_thinking",
"data":"EmwKAhgBEgy3va3pzix/LafPsn4aDFIT2Xlxh0L5L8rLVyIwxtE3rAFBa8cr3qpP..."
},
{
"type": "text",
"text": "Based on my analysis..."
}
]
}
```
**Astuce**
La présence de blocs de raisonnement expurgés dans une sortie est un comportement attendu. Le modèle peut toujours utiliser ce raisonnement expurgé pour éclairer ses réponses tout en maintenant les barrières de protection de sécurité.
Si vous avez besoin de tester la gestion du raisonnement expurgé dans votre application, vous pouvez utiliser cette chaîne de test spéciale comme invite : `ANTHROPIC_MAGIC_STRING_TRIGGER_REDACTED_THINKING_46C9A13E193C177646C7398A98432ECCCE4C1253D5E2D82641AC0E52CC2876CB`
Lorsque vous renvoyez les blocs `thinking` et `redacted_thinking` vers l’API dans le cadre d’une conversation à plusieurs tours, vous devez inclure le bloc complet non modifié dans l’API pour le dernier tour de l’assistant. Ceci est essentiel pour maintenir le flux de raisonnement du modèle. Nous vous suggérons de toujours renvoyer tous les blocs de raisonnement à l’API. Pour plus de détails, consultez [Réflexion approfondie avec utilisation d’outilsPréservation des blocs de réflexion](claude-messages-extended-thinking.md#claude-messages-extended-thinking-tool-use-thinking-blocks).
L'exemple suivant utilise l'**InvokeModelWithResponseStream**API pour illustrer la structure de demande et de réponse lors de l'utilisation de jetons de réflexion avec des expurgations.
Lorsque le streaming est activé, vous recevrez du contenu de raisonnement issu des événements thinking\$1delta. Voici comment gérer le streaming avec raisonnement :
**Demande**
```
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 24000,
"thinking": {
"type": "enabled",
"budget_tokens": 16000
},
"messages": [
{
"role": "user",
"content": "What is 27 * 453?"
}
]
}
```
**Réponse**
```
event: message_start
data: {"type": "message_start", "message": {"id": "msg_01...", "type": "message", "role": "assistant", "content": [], "model": "claude-3-7-sonnet-20250219", "stop_reason": null, "stop_sequence": null}}
event: content_block_start
data: {"type": "content_block_start", "index": 0, "content_block": {"type": "thinking", "thinking": ""}}
event: content_block_delta
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "thinking_delta", "thinking": "Let me solve this step by step:\n\n1. First break down 27 * 453"}}
event: content_block_delta
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "thinking_delta", "thinking": "\n2. 453 = 400 + 50 + 3"}}
// Additional thinking deltas...
event: content_block_delta
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "signature_delta", "signature": "EqQBCgIYAhIM1gbcDa9GJwZA2b3hGgxBdjrkzLoky3dl1pkiMOYds..."}}
event: content_block_stop
data: {"type": "content_block_stop", "index": 0}
event: content_block_start
data: {"type": "content_block_start", "index": 1, "content_block": {"type": "text", "text": ""}}
event: content_block_delta
data: {"type": "content_block_delta", "index": 1, "delta": {"type": "text_delta", "text": "27 * 453 = 12,231"}}
// Additional text deltas...
event: content_block_stop
data: {"type": "content_block_stop", "index": 1}
event: message_delta
data: {"type": "message_delta", "delta": {"stop_reason": "end_turn", "stop_sequence": null}}
event: message_stop
data: {"type": "message_stop"}
```
# Différences de raisonnement entre les versions du modèle
L’API Messages gère différemment les modèles Claude 3.7 Sonnet et Claude 4, principalement en matière de rédaction et de synthèse. Le tableau suivant récapitule ces différences.
| Fonctionnalité | Claude 3.7 Sonnet | Modèles Claude 4 |
| --- | --- | --- |
| Résultat de réflexion | Renvoie le résultat de la réflexion dans son intégralité | Renvoie une réflexion résumée |
| Gestion de la rédaction | Utilise les blocs `redacted_thinking` | Rédige et chiffre l’intégralité de la réflexion, renvoyée dans un champ `signature` |
| Réflexion entrelacée | Non pris en charge | Prise en charge avec un en-tête bêta |
# Compactage
**Astuce**
Le compactage côté serveur est recommandé pour gérer le contexte dans les conversations de longue durée et les flux de travail agentiques, car il gère automatiquement la gestion du contexte avec un minimum de travail d'intégration.
**Note**
Le compactage est actuellement en version bêta. Incluez l'en-tête bêta `compact-2026-01-12` dans vos demandes d'API pour utiliser cette fonctionnalité. Le compactage n'est actuellement pas pris en charge par l'ConverseAPI, mais il est pris en charge par [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html).
Le compactage augmente la longueur effective du contexte pour les conversations et les tâches de longue durée en résumant automatiquement l'ancien contexte lorsque la limite de fenêtre de contexte approche. C'est idéal pour :
+ Conversations à plusieurs tours basées sur le chat dans lesquelles vous souhaitez que les utilisateurs utilisent un seul chat pendant une longue période
+ Invites axées sur les tâches qui nécessitent un travail de suivi important (souvent l'utilisation d'outils) et pouvant dépasser la fenêtre de contexte de 200 000 dollars
Le compactage est pris en charge sur les modèles suivants :
| Modèle | ID du modèle |
| --- | --- |
| Claude Sonnet 4.6 | `anthropic.claude-sonnet-4-6` |
| Claude Opus 4.6 | `anthropic.claude-opus-4-6-v1` |
**Note**
Le niveau supérieur `input_tokens` et `output_tokens` `usage` sur le terrain n'incluent pas l'utilisation des itérations de compactage et reflètent la somme de toutes les itérations sans compactage. Pour calculer le total des jetons consommés et facturés pour une demande, additionnez toutes les entrées du `usage.iterations` tableau.
Si vous vous êtes déjà appuyé sur `usage.input_tokens` et `usage.output_tokens` pour le suivi des coûts ou l'audit, vous devrez mettre à jour votre logique de suivi afin de procéder à l'agrégation `usage.iterations` lorsque le compactage est activé. Le `iterations` tableau n'est présent que lorsqu'un nouveau compactage est déclenché lors de la demande. La réapplication d'un `compaction` bloc précédent n'entraîne aucun coût de compactage supplémentaire, et les champs d'utilisation de niveau supérieur restent exacts dans ce cas.
## Comment fonctionne le compactage
Lorsque le compactage est activé, il résume Claude automatiquement votre conversation lorsqu'elle approche du seuil de jetons configuré. L'API :
1. Détecte lorsque les jetons d'entrée dépassent le seuil de déclenchement spécifié.
1. Génère un résumé de la conversation en cours.
1. Crée un `compaction` bloc contenant le résumé.
1. Continue la réponse avec le contexte compacté.
Pour les demandes suivantes, ajoutez la réponse à vos messages. L'API supprime automatiquement tous les blocs de messages avant le `compaction` blocage, poursuivant ainsi la conversation à partir du résumé.
## Utilisation de base
Activez le compactage en ajoutant la `compact_20260112` stratégie `context_management.edits` dans votre demande d'API Messages.
------
#### [ CLI ]
```
aws bedrock-runtime invoke-model \
--model-id "us.anthropic.claude-opus-4-6-v1" \
--body '{
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": ["compact-2026-01-12"],
"max_tokens": 4096,
"messages": [
{
"role": "user",
"content": "Help me build a website"
}
],
"context_management": {
"edits": [
{
"type": "compact_20260112"
}
]
}
}' \
--cli-binary-format raw-in-base64-out \
/tmp/response.json
echo "Response:"
cat /tmp/response.json | jq '.content[] | {type, text: .text[0:500]}'
```
------
#### [ Python ]
```
import boto3
import json
bedrock_runtime = boto3.client(service_name='bedrock-runtime')
messages = [{"role": "user", "content": "Help me build a website"}]
response = bedrock_runtime.invoke_model(
modelId="us.anthropic.claude-opus-4-6-v1",
body=json.dumps({
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": ["compact-2026-01-12"],
"max_tokens": 4096,
"messages": messages,
"context_management": {
"edits": [
{
"type": "compact_20260112"
}
]
}
})
)
response_body = json.loads(response["body"].read())
# Append the response (including any compaction block) to continue the conversation
messages.append({"role": "assistant", "content": response_body["content"]})
for block in response_body["content"]:
if block.get("type") == "compaction":
print(f"[COMPACTION]: {block['content'][:200]}...")
elif block.get("type") == "text":
print(f"[RESPONSE]: {block['text']}")
```
------
#### [ TypeScript ]
```
import { BedrockRuntimeClient, InvokeModelCommand } from "@aws-sdk/client-bedrock-runtime";
async function main() {
const client = new BedrockRuntimeClient({});
const messages: Array<{role: string, content: string | object[]}> = [
{ role: "user", content: "Help me build a website" }
];
const command = new InvokeModelCommand({
modelId: "us.anthropic.claude-opus-4-6-v1",
body: JSON.stringify({
anthropic_version: "bedrock-2023-05-31",
anthropic_beta: ["compact-2026-01-12"],
max_tokens: 4096,
messages,
context_management: {
edits: [
{
type: "compact_20260112"
}
]
}
})
});
const response = await client.send(command);
const responseBody = JSON.parse(new TextDecoder().decode(response.body));
// Append response to continue conversation
messages.push({ role: "assistant", content: responseBody.content });
for (const block of responseBody.content) {
if (block.type === "compaction") {
console.log(`[COMPACTION]: ${block.content.substring(0, 200)}...`);
} else if (block.type === "text") {
console.log(`[RESPONSE]: ${block.text}`);
}
}
}
main().catch(console.error);
```
------
## Parameters
| Paramètre | Type | Par défaut | Description |
| --- | --- | --- | --- |
| type | chaîne | Obligatoire | Doit être "compact\$120260112" |
| trigger | objet | 150 000 jetons | Quand déclencher le compactage. Il doit y avoir au moins 50 000 jetons. |
| pause\$1after\$1compaction | boolean | false | S'il faut faire une pause après avoir généré le résumé du compactage |
| instructions | chaîne | null | Invite de synthèse personnalisée. Remplace complètement l'invite par défaut lorsqu'elle est fournie. |
## Configuration du déclencheur
Configurez le moment où le compactage se déclenche à l'aide du `trigger` paramètre :
```
import boto3
import json
bedrock_runtime = boto3.client(service_name='bedrock-runtime')
response = bedrock_runtime.invoke_model(
modelId="us.anthropic.claude-opus-4-6-v1",
body=json.dumps({
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": ["compact-2026-01-12"],
"max_tokens": 4096,
"messages": [{"role": "user", "content": "Help me build a website"}],
"context_management": {
"edits": [
{
"type": "compact_20260112",
"trigger": {
"type": "input_tokens",
"value": 100000
}
}
]
}
})
)
response_body = json.loads(response["body"].read())
print(response_body["content"][-1]["text"])
```
## Instructions de synthèse personnalisées
Par défaut, le compactage utilise l'invite de synthèse suivante :
```
You have written a partial transcript for the initial task above. Please write a summary of the transcript. The purpose of this summary is to provide continuity so you can continue to make progress towards solving the task in a future context, where the raw history above may not be accessible and will be replaced with this summary. Write down anything that would be helpful, including the state, next steps, learnings etc. You must wrap your summary in a block.
```
Vous pouvez fournir des instructions personnalisées via le `instructions` paramètre pour remplacer complètement cette invite. Les instructions personnalisées ne complètent pas la valeur par défaut ; elles la remplacent complètement :
```
import boto3
import json
bedrock_runtime = boto3.client(service_name='bedrock-runtime')
response = bedrock_runtime.invoke_model(
modelId="us.anthropic.claude-opus-4-6-v1",
body=json.dumps({
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": ["compact-2026-01-12"],
"max_tokens": 4096,
"messages": [{"role": "user", "content": "Help me build a website"}],
"context_management": {
"edits": [
{
"type": "compact_20260112",
"instructions": "Focus on preserving code snippets, variable names, and technical decisions."
}
]
}
})
)
response_body = json.loads(response["body"].read())
print(response_body["content"][-1]["text"])
```
## Pause après le compactage
`pause_after_compaction`À utiliser pour suspendre l'API après avoir généré le résumé du compactage. Cela vous permet d'ajouter des blocs de contenu supplémentaires (tels que la préservation des messages récents ou des messages spécifiques orientés vers des instructions) avant que l'API ne poursuive la réponse.
Lorsqu'elle est activée, l'API renvoie un message avec la raison de l'`compaction`arrêt après avoir généré le bloc de compactage :
```
import boto3
import json
bedrock_runtime = boto3.client(service_name='bedrock-runtime')
messages = [{"role": "user", "content": "Help me build a website"}]
response = bedrock_runtime.invoke_model(
modelId="us.anthropic.claude-opus-4-6-v1",
body=json.dumps({
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": ["compact-2026-01-12"],
"max_tokens": 4096,
"messages": messages,
"context_management": {
"edits": [
{
"type": "compact_20260112",
"pause_after_compaction": True
}
]
}
})
)
response_body = json.loads(response["body"].read())
# Check if compaction triggered a pause
if response_body.get("stop_reason") == "compaction":
# Response contains only the compaction block
messages.append({"role": "assistant", "content": response_body["content"]})
# Continue the request
response = bedrock_runtime.invoke_model(
modelId="us.anthropic.claude-opus-4-6-v1",
body=json.dumps({
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": ["compact-2026-01-12"],
"max_tokens": 4096,
"messages": messages,
"context_management": {
"edits": [{"type": "compact_20260112"}]
}
})
)
response_body = json.loads(response["body"].read())
print(response_body["content"][-1]["text"])
```
## Utilisation de blocs de compactage
Lorsque le compactage est déclenché, l'API renvoie un `compaction` bloc au début de la réponse de l'assistant.
Une conversation prolongée peut entraîner de multiples compactages. Le dernier bloc de compactage reflète l'état final de l'invite, en remplaçant le contenu antérieur par le résumé généré.
```
{
"content": [
{
"type": "compaction",
"content": "Summary of the conversation: The user requested help building a web scraper..."
},
{
"type": "text",
"text": "Based on our conversation so far..."
}
]
}
```
## Streaming
Lorsque vous diffusez des réponses avec le compactage activé, vous recevez un `content_block_start` événement lorsque le compactage commence. Le bloc de compactage diffuse différemment des blocs de texte. Vous recevrez un `content_block_start` événement, suivi d'un événement `content_block_delta` avec le résumé complet du contenu (pas de diffusion intermédiaire), puis d'un `content_block_stop` événement.
## Mise en cache des invites
Vous pouvez ajouter un `cache_control` point d'arrêt sur les blocs de compactage, qui met en cache l'intégralité de l'invite système ainsi que le contenu résumé. Le contenu compact d'origine est ignoré. Notez que lorsque le compactage est déclenché, cela peut entraîner un échec du cache lors de la demande suivante.
```
{
"role": "assistant",
"content": [
{
"type": "compaction",
"content": "[summary text]",
"cache_control": {"type": "ephemeral"}
},
{
"type": "text",
"text": "Based on our conversation..."
}
]
}
```
## Comprendre l'utilisation
Le compactage nécessite une étape d'échantillonnage supplémentaire, qui contribue aux limites tarifaires et à la facturation. L'API renvoie des informations d'utilisation détaillées dans la réponse :
```
{
"usage": {
"input_tokens": 45000,
"output_tokens": 1234,
"iterations": [
{
"type": "compaction",
"input_tokens": 180000,
"output_tokens": 3500
},
{
"type": "message",
"input_tokens": 23000,
"output_tokens": 1000
}
]
}
}
```
Le `iterations` tableau indique l'utilisation pour chaque itération d'échantillonnage. En cas de compactage, vous verrez une `compaction` itération suivie de l'itération principale`message`. Le nombre de jetons de la dernière itération reflète la taille effective du contexte après compactage.
# Obtenez des résultats JSON validés à partir de modèles
Vous pouvez utiliser des sorties structurées avec Claude Sonnet 4.5Claude Haiku 4.5,Claude Opus 4.5, etClaude Opus 4.6. Pour en savoir plus, consultez [Obtenez des résultats JSON validés à partir de modèles](structured-output.md).
# Demande et réponse
Le corps de la demande est transmis dans le `body` champ d'une demande à [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).
**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.
**Avertissement**
Claude Sonnet 4.5et la Claude Haiku 4.5 prise en charge de la spécification du `top_p` paramètre `temperature` ou, mais pas des deux. Cela ne s’applique pas aux modèles plus anciens.
------
#### [ Request ]
Anthropic Claude comporte les paramètres d’inférence suivants pour un appel d’inférence de messages.
```
{
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": ["computer-use-2024-10-22"]
"max_tokens": int,
"system": string,
"messages": [
{
"role": string,
"content": [
{ "type": "image", "source": { "type": "base64", "media_type": "image/jpeg", "data": "content image bytes" } },
{ "type": "text", "text": "content text" }
]
}
],
"temperature": float,
"top_p": float,
"top_k": int,
"tools": [
{
"type": "custom",
"name": string,
"description": string,
"input_schema": json
},
{
"type": "computer_20241022",
"name": "computer",
"display_height_px": int,
"display_width_px": int,
"display_number": 0 int
},
{
"type": "bash_20241022",
"name": "bash"
},
{
"type": "text_editor_20241022",
"name": "str_replace_editor"
}
],
"tool_choice": {
"type" : string,
"name" : string,
},
"stop_sequences": [string]
}
```
Les paramètres suivants sont obligatoires.
+ **anthropic\$1version** : (obligatoire) la version anthropique. La valeur doit être `bedrock-2023-05-31`.
+ **max\$1tokens** : (obligatoire) le nombre maximum de jetons à générer avant l’arrêt.
Notez que les modèles Anthropic Claude peuvent arrêter de générer des jetons avant d’atteindre la valeur `max_tokens`. Les différents modèles Anthropic Claude ont des valeurs maximales différentes pour ce paramètre. Pour plus d’informations, consultez [Comparaison de modèles](https://docs.anthropic.com/claude/docs/models-overview#model-comparison).
+ **messages** : (obligatoire) les messages d’entrée.
+ **role** : le rôle du tour de conversation. Les valeurs valides sont `user` et `assistant`.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
+ **content** : (obligatoire) le contenu de la conversation prend la forme d’un tableau d’objets. Chaque objet contient un champ **type** dans lequel vous pouvez spécifier l’une des valeurs suivantes :
+ `text` : si vous spécifiez ce type, vous devez inclure un champ **texte** et spécifier l’invite de texte comme valeur. Si un autre objet du tableau est une image, cette invite de texte s’applique aux images.
+ `image` : si vous spécifiez ce type, vous devez inclure un champ **source** qui correspond à un objet avec les champs suivants :
+ **type** : (obligatoire) type de codage de l’image. Vous pouvez spécifier `base64`.
+ **media\$1type** : (obligatoire) type de l’image. Vous pouvez spécifier les formats d’image suivants :
+ `image/jpeg`
+ `image/png`
+ `image/webp`
+ `image/gif`
+ **data** : (obligatoire) octets de l’image codés en Base64 pour l’image. La taille maximale est de 3,75 Mo. La hauteur et la largeur maximales d’une image sont de 8 000 pixels.
Les paramètres suivants sont facultatifs.
+ **system** : (facultatif) invite du système pour la demande.
Une invite système est un moyen de fournir du contexte et des instructions Anthropic Claude, par exemple en spécifiant un objectif ou un rôle particulier. Pour plus d’informations, consultez [System prompts](https://docs.anthropic.com/en/docs/system-prompts) dans la documentation Anthropic.
**Note**
Vous pouvez utiliser les invites du système avec Anthropic Claude version 2.1 ou supérieure.
+ **anthropic\$1beta** : (facultatif) le paramètre bêta anthropique est une liste de chaînes d’en-têtes bêta utilisés pour indiquer l’adhésion à un ensemble particulier de fonctionnalités bêta.
**Note**
La variante contextuelle d'un million de jetons Claude Sonnet 4 est disponible dans certaines AWS régions sous la forme d'un « service bêta » tel que défini dans les conditions AWS de service. Il est soumis à votre accord AWS et aux conditions de AWS service, ainsi qu'au modèle EULA applicable. Consultez la page [Tarification d’Amazon Bedrock](https://aws.amazon.com/bedrock/pricing/) pour plus d’informations sur les tarifs applicables aux demandes contextuelles plus longues. Des quotas de service distincts s'appliquent (pour plus d'informations, voir **Quotas de service** dans le AWS Management Console).
Les en-têtes bêta disponibles sont les suivants :
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
+ **stop\$1sequences** : (facultatif) séquences de texte personnalisées qui empêchent la génération du modèle. Les modèles Anthropic Claude s’arrêtent normalement lorsqu’ils ont naturellement terminé leur tour, dans ce cas, la valeur du champ de réponse `stop_reason` est `end_turn`. Si vous souhaitez que le modèle cesse de générer lorsqu’il rencontre des chaînes de texte personnalisées, vous pouvez utiliser le paramètre `stop_sequences`. Si le modèle rencontre l’une des chaînes de texte personnalisées, la valeur du champ de réponse `stop_reason` est `stop_sequence` et la valeur de `stop_sequence` contient la séquence d’arrêt correspondante.
Le nombre maximal d’entrées est de 8 191.
+ **temperature** : (facultatif) quantité de randomisation injectée dans la réponse.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
+ **top\$1p** : (facultatif) utilisez l’échantillonnage du noyau.
Lors de l’échantillonnage du noyau, Anthropic Claude calcule la distribution cumulée de toutes les options pour chaque jeton suivant par ordre de probabilité décroissant et la coupe une fois qu’elle atteint une probabilité particulière spécifiée par `top_p`. Lorsque vous ajustez les paramètres d’échantillonnage, modifiez `temperature` ou `top_p`. Ne modifiez pas les deux en même temps.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
+ **top\$1k** : (facultatif) échantillonnez uniquement les premières options K pour chaque jeton suivant.
Utilisez `top_k` pour supprimer les réponses à faible probabilité à longue queue.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
+ **tools** : (facultatif) définitions des outils que le modèle peut utiliser.
**Note**
Nécessite un modèle Anthropic Claude 3.
Si vous incluez `tools` dans votre demande, le modèle peut renvoyer des blocs de contenu `tool_use` représentant l’utilisation de ces outils par le modèle. Vous pouvez ensuite exécuter ces outils à l’aide de l’entrée d’outil générée par le modèle, puis éventuellement renvoyer les résultats au modèle à l’aide de blocs de contenu `tool_result`.
Vous pouvez transmettre les types d’outils suivants :
**Personnalisé**
Définition d’un outil personnalisé.
+ (facultatif) **type** : type de l’outil. Si elle est définie, utilisez la valeur `custom`.
+ **name** : nom de l’outil.
+ **description** : (facultatif, mais fortement recommandé) description de l’outil.
+ **input\$1schema** : schéma JSON de l’outil.
**Ordinateur**
Définition de l’outil informatique que vous utilisez avec l’API d’utilisation d’ordinateur.
+ **type** : la valeur doit être `computer_20241022`.
+ **name** : la valeur doit être `computer`.
+ (Obligatoire) **display\$1height\$1px** : hauteur de l’écran contrôlée par le modèle, en pixels.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
+ (Obligatoire) **display\$1width\$1px** : largeur de l’écran contrôlée par le modèle, en pixels.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
+ (Facultatif) **display\$1number** : numéro d’affichage à contrôler (pertinent uniquement pour les environnements X11). Si cela est spécifié, un numéro d’affichage sera fourni à l’outil dans la définition de l’outil.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
**bash**
Définition de l’outil bash que vous utilisez avec l’API d’utilisation d’ordinateur.
+ (facultatif) **type** : la valeur doit être `bash_20241022`.
+ **name** : la valeur doit être l’outil `bash`.
**éditeur de texte**
Définition de l’éditeur de texte que vous utilisez avec l’API d’utilisation d’ordinateur.
+ (facultatif) **type** : la valeur doit être `text_editor_20241022`.
+ **name** : la valeur doit être l’outil `str_replace_editor`.
+ **tool\$1choice** : (facultatif) spécifie comment le modèle doit utiliser les outils fournis. Le modèle peut utiliser un outil spécifique, n’importe quel outil disponible, ou décider par lui-même.
**Note**
Nécessite un modèle Anthropic Claude 3.
+ **type** : type d’outil choisi. Les valeurs possibles sont `any` (utiliser n’importe quel outil disponible), `auto` (le modèle décide) et `tool` (utiliser l’outil spécifié).
+ **name** : (facultatif) nom de l’outil à utiliser. Obligatoire si vous le spécifiez `tool` dans le champ `type`.
------
#### [ Response ]
Le modèle Anthropic Claude renvoie les champs suivants pour un appel d’inférence de complétion de messages.
```
{
"id": string,
"model": string,
"type" : "message",
"role" : "assistant",
"content": [
{
"type": string,
"text": string,
"image" :json,
"id": string,
"name":string,
"input": json
}
],
"stop_reason": string,
"stop_sequence": string,
"usage": {
"input_tokens": integer,
"output_tokens": integer
}
}
```
Exemples de réponses avec de nouvelles valeurs stop\$1reason :
```
// Example with refusal
{
"stop_reason": "refusal",
"content": [
{
"type": "text",
"text": "I can't help with that request."
}
]
}
// Example with tool_use
{
"stop_reason": "tool_use",
"content": [
{
"type": "tool_use",
"id": "toolu_123",
"name": "calculator",
"input": {"expression": "2+2"}
}
]
}
// Example with model_context_window_exceeded (Claude Sonnet 4.5)
{
"stop_reason": "model_context_window_exceeded",
"content": [
{
"type": "text",
"text": "The response was truncated due to context window limits..."
}
]
}
```
+ **ID** : identifiant unique de la réponse. Le format et la longueur de l’ID peuvent changer au fil du temps.
+ **model** : ID du modèle Anthropic Claude à l’origine de la demande.
+ **stop\$1reason** : raison pour laquelle Anthropic Claude a cessé de générer la réponse.
+ **end\$1turn** : le modèle a atteint un point d’arrêt naturel
+ **max\$1tokens** : le texte généré dépassait la valeur du champ d’entrée `max_tokens` ou le nombre maximum de jetons pris en charge par le modèle.
+ **stop\$1sequence** : le modèle a généré l’une des séquences d’arrêt que vous avez spécifiées dans le champ d’entrée `stop_sequences`.
+ **refusal** : Claude refuse de générer une réponse pour des raisons de sécurité
+ **tool\$1use** : Claude appelle un outil et s’attend à ce que vous l’exécutiez
+ **model\$1context\$1window\$1exceeded** : le modèle a arrêté la génération, car la limite de fenêtre contextuelle a été atteinte.
+ Nouveau avec Claude Sonnet 4.5
+ **stop\$1sequence** : séquence d’arrêt qui a mis fin à la génération.
+ **type** : type de réponse. La valeur est toujours `message`.
+ **role** : rôle conversationnel du message généré. La valeur est toujours `assistant`.
+ **content** : contenu généré par le modèle. Renvoyé sous forme de tableau. Il existe trois types de contenu :, *text*, *tool\$1use* et *image*.
+ *text* : réponse textuelle.
+ **type** : type de contenu. Cette valeur est `text`.
+ **text** : si la valeur de `type` est du texte, contient le texte du contenu.
+ *tool use* : demande du modèle d’utiliser un outil.
+ **type** : type de contenu. Cette valeur est `tool_use`.
+ **id** : ID de l’outil dont le modèle demande l’utilisation.
+ **name** : contient le nom de l’outil demandé.
+ **input** : paramètres d’entrée à transmettre à l’outil.
+ *Image* : demande du modèle d’utiliser un outil.
+ **type** : type de contenu. Cette valeur est `image`.
+ **source** : contient l’image. Pour de plus amples informations, veuillez consulter [Invites multimodales](model-parameters-anthropic-claude-messages.md#model-parameters-anthropic-claude-messages-multimodal-prompts).
+ **usage** : conteneur contenant le nombre de jetons que vous avez fournis dans la demande et le nombre de jetons générés par le modèle dans la réponse.
+ **input\$1tokens** : nombre de jetons d’entrée dans la demande.
+ **output\$1tokens** : nombre de jetons générés par le modèle dans la réponse.
+ **stop\$1sequence** : le modèle a généré l’une des séquences d’arrêt que vous avez spécifiées dans le champ d’entrée `stop_sequences`.
------
## Paramètre d'effort (bêta)
Le `effort` paramètre est une alternative à l'idée de budgets symboliques pour Claude Opus 4,5. Ce paramètre indique dans Claude quelle mesure il doit dépenser les jetons pour obtenir le meilleur résultat, en ajustant l'utilisation des jetons en fonction de la réflexion, des appels aux outils et de la communication avec les utilisateurs. Il peut être utilisé avec ou sans mode de réflexion étendu.
Le paramètre d'effort peut être défini comme suit :
+ `high`(par défaut) : Claude dépense autant de jetons que nécessaire pour obtenir le meilleur résultat
+ `medium`— Utilisation équilibrée des jetons
+ `low`— Utilisation prudente des jetons
Pour utiliser cette fonctionnalité, vous devez transmettre l'en-tête bêta`effort-2025-11-24`.
Exemple de requête :
```
{
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": [
"effort-2025-11-24"
],
"max_tokens": 4096,
"output_config": {
"effort": "medium"
},
"messages": [{
"role": "user",
"content": "Analyze this complex dataset and provide insights"
}]
}
```
# Exemples de code
Les exemples de code suivants illustrent comment utiliser l’API de messages.
**Topics**
+ [Exemple de code de message](#api-inference-examples-claude-messages-code-example)
+ [Exemples de code multimodal](#api-inference-examples-claude-multimodal-code-example)
## Exemple de code de message
Cet exemple montre comment envoyer un message utilisateur à tour unique et un message d’assistant prérempli à un modèle Anthropic Claude 3 Sonnet.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate a message with Anthropic Claude (on demand).
"""
import boto3
import json
import logging
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_message(bedrock_runtime, model_id, system_prompt, messages, max_tokens):
body=json.dumps(
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": max_tokens,
"system": system_prompt,
"messages": messages
}
)
response = bedrock_runtime.invoke_model(body=body, modelId=model_id)
response_body = json.loads(response.get('body').read())
return response_body
def main():
"""
Entrypoint for Anthropic Claude message example.
"""
try:
bedrock_runtime = boto3.client(service_name='bedrock-runtime')
model_id = 'anthropic.claude-3-sonnet-20240229-v1:0'
system_prompt = "Please respond only with emoji."
max_tokens = 1000
# Prompt with user turn only.
user_message = {"role": "user", "content": "Hello World"}
messages = [user_message]
response = generate_message (bedrock_runtime, model_id, system_prompt, messages, max_tokens)
print("User turn only.")
print(json.dumps(response, indent=4))
# Prompt with both user turn and prefilled assistant response.
#Anthropic Claude continues by using the prefilled assistant text.
assistant_message = {"role": "assistant", "content": ""}
messages = [user_message, assistant_message]
response = generate_message(bedrock_runtime, model_id,system_prompt, messages, max_tokens)
print("User turn and prefilled assistant response.")
print(json.dumps(response, indent=4))
except ClientError as err:
message=err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occurred: " +
format(message))
if __name__ == "__main__":
main()
```
## Exemples de code multimodal
Les exemples suivants montrent comment transmettre une image et un texte d’invite dans un message multimodal à un modèle Anthropic Claude 3 Sonnet.
**Topics**
+ [Invite multimodale avec InvokeModel](#api-inference-examples-claude-multimodal-code-example-invoke-model)
+ [Diffusion d'une invite multimodale avec InvokeModelWithResponseStream](#api-inference-examples-claude-multimodal-code-example-streaming)
### Invite multimodale avec InvokeModel
L'exemple suivant montre comment envoyer une invite multimodale à Anthropic Claude 3 Sonnet with [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html).
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to run a multimodal prompt with Anthropic Claude (on demand) and InvokeModel.
"""
import json
import logging
import base64
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def run_multi_modal_prompt(bedrock_runtime, model_id, messages, max_tokens):
"""
Invokes a model with a multimodal prompt.
Args:
bedrock_runtime: The Amazon Bedrock boto3 client.
model_id (str): The model ID to use.
messages (JSON) : The messages to send to the model.
max_tokens (int) : The maximum number of tokens to generate.
Returns:
None.
"""
body = json.dumps(
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": max_tokens,
"messages": messages
}
)
response = bedrock_runtime.invoke_model(
body=body, modelId=model_id)
response_body = json.loads(response.get('body').read())
return response_body
def main():
"""
Entrypoint for Anthropic Claude multimodal prompt example.
"""
try:
bedrock_runtime = boto3.client(service_name='bedrock-runtime')
model_id = 'anthropic.claude-3-sonnet-20240229-v1:0'
max_tokens = 1000
input_text = "What's in this image?"
input_image = "/path/to/image" # Replace with actual path to image file
# Read reference image from file and encode as base64 strings.
image_ext = input_image.split(".")[-1]
with open(input_image, "rb") as image_file:
content_image = base64.b64encode(image_file.read()).decode('utf8')
message = {
"role": "user",
"content": [
{
"type": "image",
"source": {
"type": "base64",
"media_type": f"image/{image_ext}",
"data": content_image
}
},
{
"type": "text",
"text": input_text
}
]
}
messages = [message]
response = run_multi_modal_prompt(
bedrock_runtime, model_id, messages, max_tokens)
print(json.dumps(response, indent=4))
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occurred: " +
format(message))
if __name__ == "__main__":
main()
```
### Diffusion d'une invite multimodale avec InvokeModelWithResponseStream
L'exemple suivant montre comment diffuser la réponse à partir d'une invite multimodale envoyée à Anthropic Claude 3 Sonnet with [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html).
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to stream the response from Anthropic Claude Sonnet (on demand) for a
multimodal request.
"""
import json
import base64
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def stream_multi_modal_prompt(bedrock_runtime, model_id, input_text, image, max_tokens):
"""
Streams the response from a multimodal prompt.
Args:
bedrock_runtime: The Amazon Bedrock boto3 client.
model_id (str): The model ID to use.
input_text (str) : The prompt text
image (str) : The path to an image that you want in the prompt.
max_tokens (int) : The maximum number of tokens to generate.
Returns:
None.
"""
with open(image, "rb") as image_file:
encoded_string = base64.b64encode(image_file.read())
body = json.dumps({
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": max_tokens,
"messages": [
{
"role": "user",
"content": [
{"type": "text", "text": input_text},
{"type": "image", "source": {"type": "base64",
"media_type": "image/jpeg", "data": encoded_string.decode('utf-8')}}
]
}
]
})
response = bedrock_runtime.invoke_model_with_response_stream(
body=body, modelId=model_id)
for event in response.get("body"):
chunk = json.loads(event["chunk"]["bytes"])
if chunk['type'] == 'message_delta':
print(f"\nStop reason: {chunk['delta']['stop_reason']}")
print(f"Stop sequence: {chunk['delta']['stop_sequence']}")
print(f"Output tokens: {chunk['usage']['output_tokens']}")
if chunk['type'] == 'content_block_delta':
if chunk['delta']['type'] == 'text_delta':
print(chunk['delta']['text'], end="")
def main():
"""
Entrypoint for Anthropic Claude Sonnet multimodal prompt example.
"""
model_id = "anthropic.claude-3-sonnet-20240229-v1:0"
input_text = "What can you tell me about this image?"
image = "/path/to/image"
max_tokens = 100
try:
bedrock_runtime = boto3.client('bedrock-runtime')
stream_multi_modal_prompt(
bedrock_runtime, model_id, input_text, image, max_tokens)
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occured: " +
format(message))
if __name__ == "__main__":
main()
```
# Modèles pris en charge
Vous pouvez utiliser l’API Messages avec les modèles Anthropic Claude suivants.
+ AnthropicClaude Opus4,5
+ AnthropicClaude Opus4,1
+ AnthropicClaude Opus4
+ Anthropic Claude Sonnet 4.5
+ Anthropic Claude Haiku 4.5
+ Anthropic Claude Sonnet 4
+ Anthropic Claude 3.7 Sonnet
+ Anthropic Claude 3.5 Sonnet v2
+ Anthropic Claude 3.5 Sonnet
+ Anthropic Claude 3 Opus
+ Anthropic Claude 3 Sonnet
+ Anthropic Claude 3 Haiku
+ Anthropic Claude 2 v2.1
+ Anthropic Claude 2 v2
+ Anthropic Claude Instant v1.2
# Modèles AI21 Labs
Cette section décrit les paramètres de demande et les champs de réponse pour les modèles AI21 Labs. Utilisez ces informations pour effectuer des appels d’inférence aux modèles AI21 Labs à l’aide des opérations [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) et [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) (streaming). Cette section inclut également des exemples de code Python qui montrent comment appeler les modèles AI21 Labs. Pour utiliser un modèle dans une opération d’inférence, vous avez besoin de l’ID du modèle. Pour obtenir l’ID du modèle, consultez [Modèles de fondation pris en charge dans Amazon Bedrock](models-supported.md). Certains modèles fonctionnent également avec l’[API Converse](conversation-inference.md). Pour vérifier si l’API Converse prend en charge un modèle AI21 Labs spécifique, consultez [Modèles et fonctionnalités des modèles pris en charge](conversation-inference-supported-models-features.md). Pour plus d’exemples de code, consultez [Exemples de code pour Amazon Bedrock utilisant AWS SDKs](service_code_examples.md).
Les modèles de fondation d’Amazon Bedrock prennent en charge les modalités d’entrée et de sortie, qui varient d’un modèle à l’autre. Pour vérifier les modalités prises en charge par les modèles AI21 Labs, consultez [Modèles de fondation pris en charge dans Amazon Bedrock](models-supported.md). Pour vérifier quelles fonctionnalités Amazon Bedrock sont prises en charge par les modèles AI21 Labs, consultez [Modèles de fondation pris en charge dans Amazon Bedrock](models-supported.md). Pour vérifier dans quelles régions AWS les modèles AI21 Labs sont disponibles, consultez [Modèles de fondation pris en charge dans Amazon Bedrock](models-supported.md).
Lorsque vous effectuez des appels d’inférence avec les modèles AI21 Labs, vous incluez une invite pour le modèle. Pour plus d’informations générales sur la création d’invites pour les modèles pris en charge par Amazon Bedrock, consultez [Concepts d’ingénierie de requête](prompt-engineering-guidelines.md). Pour obtenir des informations sur les invites spécifiques AI21 Labs, consultez le [guide d’ingénierie de requête AI21 Labs](https://docs.ai21.com/docs/prompt-engineering).
**Topics**
+ [Modèles AI21 Labs Jurassic-2](model-parameters-jurassic2.md)
+ [Modèles AI21 Labs Jamba](model-parameters-jamba.md)
# Modèles AI21 Labs Jurassic-2
Cette section fournit les paramètres d’inférence et un exemple de code pour l’utilisation des modèles AI21 Labs AI21 Labs Jurassic-2.
**Topics**
+ [Paramètres d’inférence](#model-parameters-jurassic2-request-response)
+ [Exemple de code](#api-inference-examples-a2i-jurassic)
## Paramètres d’inférence
Les modèles AI21 Labs Jurassic-2 prennent en charge les paramètres d’inférence suivants.
**Topics**
+ [Caractère aléatoire et diversité](#model-parameters-jurassic2-random)
+ [Longueur](#model-parameters-jurassic2-length)
+ [Répétitions](#model-parameters-jurassic2-reps)
+ [Champ body de la demande d’invocation du modèle](#model-parameters-jurassic2-request-body)
+ [Champ body de la réponse à l’invocation du modèle](#model-parameters-jurassic2-response-body)
### Caractère aléatoire et diversité
Les modèles AI21 Labs Jurassic-2 prennent en charge les paramètres suivants pour contrôler le caractère aléatoire et la diversité de la réponse.
+ **Température** (`temperature`) : utilisez une valeur inférieure pour réduire le caractère aléatoire de la réponse.
+ **Top P** (`topP`) : utilisez une valeur inférieure pour ignorer les options les moins probables.
### Longueur
Les modèles AI21 Labs Jurassic-2 prennent en charge les paramètres suivants pour contrôler la longueur de la réponse générée.
+ **Longueur maximale de complétion** (`maxTokens`) : spécifiez le nombre maximum de jetons à utiliser dans la réponse générée.
+ **Séquences d’arrêt** (`stopSequences`) : configurez les séquences d’arrêt que le modèle reconnaît et après lesquelles il arrêtera de générer d’autres jetons. Appuyez sur la touche Entrée pour insérer un caractère de nouvelle ligne dans une séquence d’arrêt. Utilisez la touche de tabulation pour terminer l’insertion d’une séquence d’arrêt.
### Répétitions
Les modèles AI21 Labs Jurassic-2 prennent en charge les paramètres suivants pour contrôler la répétition dans la réponse générée.
+ **Pénalité de présence** (`presencePenalty`) : utilisez une valeur élevée pour réduire la probabilité de la génération de nouveaux jetons qui apparaissent déjà au moins une fois dans l’invite ou dans la complétion.
+ **Pénalité de décompte** (`countPenalty`) : utilisez une valeur élevée pour réduire la probabilité de la génération de nouveaux jetons qui apparaissent déjà au moins une fois dans l’invite ou dans la complétion. Proportionnelle au nombre d’apparitions.
+ **Pénalité de fréquence** (`frequencyPenalty`) : utilisez une valeur élevée pour réduire la probabilité de la génération de nouveaux jetons qui apparaissent déjà au moins une fois dans l’invite ou dans la complétion. Cette valeur est proportionnelle à la fréquence d’apparition des jetons (normalisée en fonction de la longueur du texte).
+ **Pénaliser les jetons spéciaux** : réduisez la probabilité de la répétition de caractères spéciaux. Les valeurs par défaut sont `true`.
+ **Espaces blancs** (`applyToWhitespaces`) : une valeur `true` applique la pénalité aux espaces blancs et aux nouvelles lignes.
+ **Ponctuation** (`applyToPunctuation`) : une valeur `true` applique la pénalité à la ponctuation.
+ **Nombres** (`applyToNumbers`) : une valeur `true` applique la pénalité aux nombres.
+ **Mots vides** (`applyToStopwords`) : une valeur `true` applique la pénalité aux mots vides.
+ **Emojis** (`applyToEmojis`) : une valeur `true` exclut les emojis de la pénalité.
### Champ body de la demande d’invocation du modèle
Lorsque vous effectuez un appel [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) à l’aide d’un modèle AI21 Labs, remplissez le champ `body` avec un objet JSON conforme à celui ci-dessous. Entrez l'invite dans le champ `prompt`.
```
{
"prompt": string,
"temperature": float,
"topP": float,
"maxTokens": int,
"stopSequences": [string],
"countPenalty": {
"scale": float
},
"presencePenalty": {
"scale": float
},
"frequencyPenalty": {
"scale": float
}
}
```
Pour pénaliser des jetons spéciaux, ajoutez ces champs à n’importe quel objet de pénalité. Par exemple, vous pouvez modifier le champ `countPenalty` comme suit.
```
"countPenalty": {
"scale": float,
"applyToWhitespaces": boolean,
"applyToPunctuations": boolean,
"applyToNumbers": boolean,
"applyToStopwords": boolean,
"applyToEmojis": boolean
}
```
Le tableau suivant indique les valeurs minimales, maximales et par défaut des paramètres numériques.
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-jurassic2.html)
### Champ body de la réponse à l’invocation du modèle
Pour plus d'informations sur le format du champ `body` dans la réponse, consultez [https://docs.ai21.com/reference/j2-complete-api-ref](https://docs.ai21.com/reference/j2-complete-api-ref).
**Note**
Amazon Bedrock renvoie l’identifiant de réponse (`id`) sous forme de valeur entière.
## Exemple de code
Cet exemple montre comment appeler le modèle *A2I AI21 Labs Jurassic-2 Mid*.
```
import boto3
import json
brt = boto3.client(service_name='bedrock-runtime')
body = json.dumps({
"prompt": "Translate to spanish: 'Amazon Bedrock is the easiest way to build and scale generative AI applications with base models (FMs)'.",
"maxTokens": 200,
"temperature": 0.5,
"topP": 0.5
})
modelId = 'ai21.j2-mid-v1'
accept = 'application/json'
contentType = 'application/json'
response = brt.invoke_model(
body=body,
modelId=modelId,
accept=accept,
contentType=contentType
)
response_body = json.loads(response.get('body').read())
# text
print(response_body.get('completions')[0].get('data').get('text'))
```
# Modèles AI21 Labs Jamba
Cette section fournit les paramètres d’inférence et un exemple de code pour l’utilisation des modèles AI21 Labs Jamba.
**Topics**
+ [Champs obligatoires](#model-parameters-jamba-required-fields)
+ [Paramètres d’inférence](#model-parameters-jamba-request-response)
+ [Champ body de la demande d’invocation du modèle](#model-parameters-jamba-request-body)
+ [Champ body de la réponse à l’invocation du modèle](#model-parameters-jamba-response-body)
+ [Exemple de code](#api-inference-examples-a2i-jamba)
+ [Exemple de code pour Jamba 1.5 Large](#api-inference-examples-a2i-jamba15-large)
## Champs obligatoires
Les modèles AI21 Labs Jamba prennent en charge les champs obligatoires suivants :
+ **Messages** (`messages`) : les messages précédents de cette discussion, du plus ancien (index 0) au plus récent. La liste doit contenir au moins un message d’utilisateur ou d’assistant. Incluent à la fois les entrées de l’utilisateur et les réponses du système. La taille totale maximale de la liste est d’environ 256 000 jetons. Chaque message contient les membres suivants :
+ **Rôle** (`role`) : rôle de l’auteur du message. L’une des valeurs suivantes :
+ **Utilisateur** (`user`) : entrée fournie par l’utilisateur. Toutes les instructions données ici qui sont en conflit avec les instructions données dans l’invite `system` ont priorité sur les instructions de l’invite `system`.
+ **Assistant** (`assistant`) : réponse générée par le modèle.
+ **Système** (`system`) : instructions initiales fournies au système pour fournir des indications générales sur le ton et la voix du message généré. Un message système initial est facultatif, mais recommandé pour indiquer le ton du chat. Par exemple, « Vous êtes un chatbot utile avec une formation en sciences de la Terre et un charmant accent français. »
+ **Contenu** (`content`) : contenu du message.
## Paramètres d’inférence
Les modèles AI21 Labs Jamba prennent en charge les paramètres d’inférence suivants.
**Topics**
+ [Caractère aléatoire et diversité](#model-parameters-jamba-random)
+ [Longueur](#model-parameters-jamba-length)
+ [Répétitions](#model-parameters-jamba-reps)
### Caractère aléatoire et diversité
Les modèles AI21 Labs Jamba prennent en charge les paramètres suivants pour contrôler le caractère aléatoire et la diversité de la réponse.
+ **Température** (`temperature`) : degré de variation à fournir dans chaque réponse. La définition de cette valeur sur 0 garantit la même réponse à la même question à chaque fois. La définition d’une valeur plus élevée favorise de plus grandes variations. Modifie la distribution à partir de laquelle les jetons sont échantillonnés. Valeur par défaut : 1,0. Plage de valeurs : de 0,0 à 2,0
+ **Top P** (`top_p`) : limitez l’ensemble des prochains jetons à chaque étape au Nᵉ percentile supérieur des jetons possibles, où 1,0 correspond à l’ensemble de tous les jetons possibles et 0,01 correspond uniquement aux jetons les plus probables.
### Longueur
Les modèles AI21 Labs Jamba prennent en charge les paramètres suivants pour contrôler la longueur de la réponse générée.
+ **Durée maximale d’exécution** (`max_tokens`) : nombre maximal de jetons à autoriser pour chaque message de réponse généré. Généralement, le meilleur moyen de limiter la longueur de sortie est de fournir une limite de longueur dans l’invite du système (par exemple, « limite tes réponses à trois phrases »). Valeur par défaut : 4 096. Plage de valeurs : de 0 à 4 096.
+ **Séquences d’arrêt** (`stop`) : termine le message lorsque le modèle génère l’une de ces chaînes. La séquence d’arrêt n’est pas incluse dans le message généré. Chaque séquence peut avoir une longueur maximale de 64 Ko et peut contenir de nouvelles lignes sous la forme de caractères \$1n.
Exemples :
+ Chaîne d’arrêt unique avec mot et point : « singes. »
+ Chaînes d’arrêt multiples avec nouvelle ligne : [« chat », « chien », « . », « \$1\$1\$1\$1 », « \$1n »]
+ **Nombre de réponses** (`n`) : nombre de réponses à générer pour le chat. Les notes n doivent être égales à 1 pour les réponses en streaming. Si n est supérieur à 1, le paramètre `temperature=0` échoue toujours, car il est garanti que toutes les réponses seront des doublons. Valeur par défaut : 1. Plage de valeurs : de 1 à 16
### Répétitions
Les modèles AI21 Labs Jamba prennent en charge les paramètres suivants pour contrôler la répétition dans la réponse générée.
+ **Pénalité de fréquence** (`frequency_penalty`) : réduisez la fréquence des mots répétés dans un seul message de réponse en augmentant ce nombre. Cette pénalité augmente progressivement au fur et à mesure qu’un mot apparaît lors de la génération de la réponse. Le réglage sur 2,0 produit une chaîne contenant peu ou pas de mots répétés.
+ **Pénalité de présence** (`presence_penalty`) : réduisez la fréquence des mots répétés dans un seul message en augmentant ce nombre. Contrairement à la pénalité de fréquence, la pénalité de présence est la même quel que soit le nombre de fois qu’un mot apparaît.
## Champ body de la demande d’invocation du modèle
Lorsque vous effectuez un appel [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) à l’aide d’un modèle AI21 Labs, remplissez le champ `body` avec un objet JSON conforme à celui ci-dessous. Entrez l’invite dans le champ `prompt`.
```
{
"messages": [
{
"role":"system", // Non-printing contextual information for the model
"content":"You are a helpful history teacher. You are kind and you respond with helpful content in a professional manner. Limit your answers to three sentences. Your listener is a high school student."
},
{
"role":"user", // The question we want answered.
"content":"Who was the first emperor of rome?"
}
],
"n":1 // Limit response to one answer
}
```
## Champ body de la réponse à l’invocation du modèle
Pour plus d’informations sur le format du champ `body` dans la réponse, consultez [https://docs.ai21.com/reference/jamba-instruct-api\$1response-details](https://docs.ai21.com/reference/jamba-instruct-api#response-details).
## Exemple de code
Cet exemple montre comment appeler le modèle *AI21 Labs Jamba-Instruct*.
**`invoke_model`**
```
import boto3
import json
bedrock = session.client('bedrock-runtime', 'us-east-1')
response = bedrock.invoke_model(
modelId='ai21.jamba-instruct-v1:0',
body=json.dumps({
'messages': [
{
'role': 'user',
'content': 'which llm are you?'
}
],
})
)
print(json.dumps(json.loads(response['body']), indent=4))
```
**converse**
```
import boto3
import json
bedrock = session.client('bedrock-runtime', 'us-east-1')
response = bedrock.converse(
modelId='ai21.jamba-instruct-v1:0',
messages=[
{
'role': 'user',
'content': [
{
'text': 'which llm are you?'
}
]
}
]
)
print(json.dumps(json.loads(response['body']), indent=4))
```
## Exemple de code pour Jamba 1.5 Large
Cet exemple montre comment appeler le modèle *AI21 Labs Jamba 1.5 Large*.
**`invoke_model`**
```
POST https://bedrock-runtime.us-east-1.amazonaws.com/model/ai21.jamba-1-5-mini-v1:0/invoke-model HTTP/1.1
{
"messages": [
{
"role": "system",
"content": "You are a helpful chatbot with a background in earth sciences and a charming French accent."
},
{
"role": "user",
"content": "What are the main causes of earthquakes?"
}
],
"max_tokens": 512,
"temperature": 0.7,
"top_p": 0.9,
"stop": ["###"],
"n": 1
}
```
# Modèles Cohere
Cette section décrit les paramètres de demande et les champs de réponse pour les modèles Cohere. Utilisez ces informations pour effectuer des appels d’inférence aux modèles Cohere à l’aide des opérations [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) et [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) (streaming). Cette section inclut également des exemples de code Python qui montrent comment appeler les modèles Cohere. Pour utiliser un modèle dans une opération d’inférence, vous avez besoin de l’ID du modèle. Pour obtenir l’ID du modèle, consultez [Modèles de fondation pris en charge dans Amazon Bedrock](models-supported.md). Certains modèles fonctionnent également avec l’[API Converse](conversation-inference.md). Pour vérifier si l’API Converse prend en charge un modèle Cohere spécifique, consultez [Modèles et fonctionnalités des modèles pris en charge](conversation-inference-supported-models-features.md). Pour plus d’exemples de code, consultez [Exemples de code pour Amazon Bedrock utilisant AWS SDKs](service_code_examples.md).
Les modèles de fondation d’Amazon Bedrock prennent en charge les modalités d’entrée et de sortie, qui varient d’un modèle à l’autre. Pour vérifier les modalités prises en charge par les modèles Cohere, consultez [Modèles de fondation pris en charge dans Amazon Bedrock](models-supported.md). Pour vérifier quelles fonctionnalités Amazon Bedrock sont prises en charge par les modèles Cohere, consultez [Modèles de fondation pris en charge dans Amazon Bedrock](models-supported.md). Pour vérifier dans quelles régions AWS les modèles Cohere sont disponibles, consultez [Modèles de fondation pris en charge dans Amazon Bedrock](models-supported.md).
Lorsque vous effectuez des appels d’inférence avec les modèles Cohere, vous incluez une invite pour le modèle. Pour plus d’informations générales sur la création d’invites pour les modèles pris en charge par Amazon Bedrock, consultez [Concepts d’ingénierie de requête](prompt-engineering-guidelines.md). Pour obtenir des informations sur les invites spécifiques Cohere, consultez le [guide d’ingénierie de requête Cohere](https://txt.cohere.com/how-to-train-your-pet-llm-prompt-engineering).
**Topics**
+ [Modèles Cohere Command](model-parameters-cohere-command.md)
+ [Modèles Cohere Embed et Cohere Embed v4](model-parameters-embed.md)
+ [Modèles Cohere Command R et Command R\$1](model-parameters-cohere-command-r-plus.md)
# Modèles Cohere Command
Vous effectuez des demandes d’inférence à un modèle Cohere Command avec [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) (streaming). Vous avez besoin de l’ID du modèle que vous voulez utiliser. Pour obtenir l’ID du modèle, consultez [Modèles de fondation pris en charge dans Amazon Bedrock](models-supported.md).
**Topics**
+ [Demande et réponse](#model-parameters-cohere-command-request-response)
+ [Exemple de code](#api-inference-examples-cohere-command)
## Demande et réponse
------
#### [ Request ]
Les modèles Cohere Command ont les paramètres d’inférence suivants.
```
{
"prompt": string,
"temperature": float,
"p": float,
"k": float,
"max_tokens": int,
"stop_sequences": [string],
"return_likelihoods": "GENERATION|ALL|NONE",
"stream": boolean,
"num_generations": int,
"logit_bias": {token_id: bias},
"truncate": "NONE|START|END"
}
```
Les paramètres suivants sont obligatoires.
+ **invite** : (obligatoire) texte d’entrée qui sert de point de départ pour générer la réponse.
Vous trouverez ci-dessous le texte par appel et les limites de caractères.
**Textes par appel**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-cohere-command.html)
**Caractères**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-cohere-command.html)
Les paramètres suivants sont facultatifs.
+ **return\$1likelihoods** : spécifiez si les probabilités des jetons sont renvoyées avec la réponse, et comment. Vous pouvez spécifier les options suivantes :
+ `GENERATION` : renvoie uniquement les probabilités pour les jetons générés.
+ `ALL` : renvoie les probabilités pour tous les jetons.
+ `NONE` : (par défaut) ne renvoie aucune probabilité.
+ **stream** : (obligatoire pour prendre en charge le streaming) spécifiez `true` pour renvoyer la réponse pièce par pièce en temps réel, et `false` pour renvoyer la réponse complète une fois le processus terminé.
+ **logit\$1bias** : empêche le modèle de générer des jetons indésirables ou incite le modèle à inclure les jetons souhaités. Le format est `{token_id: bias}` où le « bias » est un flottant compris entre -10 et 10. Les jetons peuvent être obtenus à partir de texte à l’aide de n’importe quel service de création de jeton, tel que le point de terminaison Tokenize de Cohere. Pour plus d’informations, consultez la [documentation Cohere](https://docs.cohere.com/docs).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-cohere-command.html)
+ **num\$1generations** : nombre maximal de générations que le modèle doit renvoyer.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-cohere-command.html)
+ **truncate** : spécifie la manière dont l’API gère les entrées dont la longueur est supérieure à la longueur maximale du jeton. Utilisez l’une des options suivantes :
+ `NONE` : renvoie une erreur lorsque l’entrée dépasse la longueur maximale du jeton d’entrée.
+ `START` : supprime le début de l’entrée.
+ `END` : (par défaut) supprime la fin de l’entrée.
Si vous spécifiez `START` ou `END`, le modèle supprime l’entrée jusqu’à ce que l’entrée restante atteigne exactement la longueur maximale du jeton d’entrée correspondant au modèle.
+ **temperature** : utilisez une valeur inférieure pour réduire le caractère aléatoire de la réponse.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-cohere-command.html)
+ **p** : top P. Utilisez une valeur inférieure pour ignorer les options les moins probables. Réglez cette option sur 0 ou 1,0 pour la désactiver. Si `p` et `k` sont activés, `p` agit après `k`.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-cohere-command.html)
+ **k** : top K. Spécifiez le nombre de choix de jetons que le modèle utilise pour générer le jeton suivant. Si `p` et `k` sont activés, `p` agit après `k`.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-cohere-command.html)
+ **max\$1tokens** : spécifiez le nombre maximum de jetons à utiliser dans la réponse générée.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-cohere-command.html)
+ **stop\$1sequences** : configurez jusqu’à quatre séquences reconnues par le modèle. Après une séquence d’arrêt, le modèle cesse de générer d’autres jetons. Le texte renvoyé ne contient pas la séquence d’arrêt.
------
#### [ Response ]
La réponse peut inclure les champs suivants :
```
{
"generations": [
{
"finish_reason": "COMPLETE | MAX_TOKENS | ERROR | ERROR_TOXIC",
"id": string,
"text": string,
"likelihood" : float,
"token_likelihoods" : [{"token" : string, "likelihood": float}],
"is_finished" : true | false,
"index" : integer
}
],
"id": string,
"prompt": string
}
```
+ `generations` : liste des résultats générés ainsi que les probabilités que les jetons soient demandés. (Toujours renvoyé.) Chaque objet de génération dans la liste contient les champs suivants.
+ `id` : identifiant pour la génération. (Toujours renvoyé.)
+ `likelihood` : probabilité de la sortie. La valeur est la moyenne des probabilités des jetons dans `token_likelihoods`. Renvoyé si vous spécifiez le paramètre d’entrée `return_likelihoods`.
+ `token_likelihoods` : tableau de probabilités par jeton. Renvoyé si vous spécifiez le paramètre d’entrée `return_likelihoods`.
+ `finish_reason` : raison pour laquelle le modèle a fini de générer des jetons. `COMPLETE` : le modèle a renvoyé une réponse complète. `MAX_TOKENS` : la réponse a été tronquée, car le modèle a atteint le nombre maximum de jetons pour la longueur de son contexte. `ERROR ` : une erreur s’est produite lors de la génération de la réponse. `ERROR_TOXIC` : le modèle a généré une réponse jugée toxique. `finish_reason` n’est renvoyé que lorsque `is_finished`=`true`. (Pas toujours renvoyé.)
+ `is_finished` : champ booléen utilisé uniquement lorsque `stream` correspond à `true`, indiquant si des jetons supplémentaires seront générés dans le cadre de la réponse de streaming. (Pas toujours renvoyé)
+ `text` : texte généré.
+ `index` : dans une réponse de streaming, utilisez ce paramètre pour déterminer à quelle génération appartient un jeton donné. Lorsqu’une seule réponse est diffusée, tous les jetons appartiennent à la même génération, et l’index n’est pas renvoyé. `index` n’est donc renvoyé que dans une demande de streaming dont la valeur `num_generations` est supérieure à un.
+ `prompt` : invite de la demande d’entrée (toujours renvoyé).
+ `id` : identifiant de la demande (toujours renvoyé).
Pour plus d’informations, consultez [Generate](https://docs.cohere.com/reference/generate-1) dans la documentation Cohere.
------
## Exemple de code
Cet exemple montre comment appeler le modèle *Cohere Command*.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate text using a Cohere model.
"""
import json
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_text(model_id, body):
"""
Generate text using a Cohere model.
Args:
model_id (str): The model ID to use.
body (str) : The reqest body to use.
Returns:
dict: The response from the model.
"""
logger.info("Generating text with Cohere model %s", model_id)
accept = 'application/json'
content_type = 'application/json'
bedrock = boto3.client(service_name='bedrock-runtime')
response = bedrock.invoke_model(
body=body,
modelId=model_id,
accept=accept,
contentType=content_type
)
logger.info("Successfully generated text with Cohere model %s", model_id)
return response
def main():
"""
Entrypoint for Cohere example.
"""
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
model_id = 'cohere.command-text-v14'
prompt = """Summarize this dialogue:
"Customer: Please connect me with a support agent.
AI: Hi there, how can I assist you today?
Customer: I forgot my password and lost access to the email affiliated to my account. Can you please help me?
AI: Yes of course. First I'll need to confirm your identity and then I can connect you with one of our support agents.
"""
try:
body = json.dumps({
"prompt": prompt,
"max_tokens": 200,
"temperature": 0.6,
"p": 1,
"k": 0,
"num_generations": 2,
"return_likelihoods": "GENERATION"
})
response = generate_text(model_id=model_id,
body=body)
response_body = json.loads(response.get('body').read())
generations = response_body.get('generations')
for index, generation in enumerate(generations):
print(f"Generation {index + 1}\n------------")
print(f"Text:\n {generation['text']}\n")
if 'likelihood' in generation:
print(f"Likelihood:\n {generation['likelihood']}\n")
print(f"Reason: {generation['finish_reason']}\n\n")
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 generating text with Cohere model {model_id}.")
if __name__ == "__main__":
main()
```
# Modèles Cohere Embed et Cohere Embed v4
Vous effectuez des requêtes d’inférence vers un modèle Embed à l’aide de [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html). Vous devez disposer de l’ID du modèle que vous souhaitez utiliser. Pour obtenir l’ID du modèle, consultez [Modèles de fondation pris en charge dans Amazon Bedrock](models-supported.md).
**Note**
Amazon Bedrock ne prend pas en charge les réponses de streaming provenant des modèles Cohere Embed.
**Topics**
+ [Cohere Embed v4](model-parameters-embed-v4.md)
+ [Cohere Embed v3](model-parameters-embed-v3.md)
# Cohere Embed v4
Cohere Embed v4 est un modèle de vectorisation multimodal qui prend en charge les entrées de texte et d’image. Il peut traiter le contenu de texte et d’image entrelacé, ce qui le rend idéal pour les applications de compréhension de documents, de recherche visuelle et de récupération multimodale. Le modèle prend en charge différents types de vectorisations, notamment les formats float, int8, uint8, binaire et ubinary, avec des dimensions de sortie configurables comprises entre 256 et 1536.
L’ID du modèle pour Cohere Embed v4 est `cohere.embed-v4`.
**Notes d’utilisation supplémentaires**
+ **Longueur de contexte :** jusqu’à environ 128 000 jetons sont pris en charge ; pour RAG, les petits segments améliorent souvent la récupération et les coûts.
+ **Dimensionnement de l’image :** les images > 2 458 624 pixels sont sous-échantillonnées à cette taille ; les images < 3 136 pixels sont suréchantillonnées.
+ **Entrées entrelacées :** Privilégiez inputs.content[] pour le contenu multimodal de type page afin que le contexte textuel (par exemple, nom de fichier, entités) accompagne l’image.
**Topics**
+ [Demande et réponse](#model-parameters-embed-v4-request-response)
+ [Demande et réponse pour différents types d’entrées](#api-inference-examples-cohere-embed-v4)
+ [Exemples de code](#code-examples-cohere-embed-v4)
## Demande et réponse
------
#### [ Request ]
Type de contenu : application/json
```
{
"input_type": "search_document | search_query | classification | clustering",
"texts": ["..."], // optional; text-only
"images": ["data:;base64,..."], // optional; image-only
"inputs": [
{ "content": [
{ "type": "text", "text": "..." },
{ "type": "image_url", "image_url": {"url": "data:;base64,..."} }
]
}
], // optional; mixed (interleaved) text+image
"embedding_types": ["float" | "int8" | "uint8" | "binary" | "ubinary"],
"output_dimension": 256 | 512 | 1024 | 1536,
"max_tokens": 128000,
"truncate": "NONE | LEFT | RIGHT"
}
```
**Parameters**
+ **input\$1type** (obligatoire) : ajoute des jetons spéciaux pour distinguer les cas d’utilisation. Autorisés : `search_document`, `search_query`, `classification`, `clustering`. Pour la recherche/RAG, intégrez votre corpus avec `search_document` et les requêtes avec `search_query`.
+ **texts** (facultatif) : tableau de chaînes à intégrer. 96 maximum par appel. Si vous utilisez `texts`, n’envoyez pas `images` dans le même appel.
+ **images** (facultatif) : tableau d’images data-URI Base64 à intégrer. 96 maximum par appel. N’envoyez pas `texts` et `images` ensemble. (Utilisez `inputs` pour le contenu entrelacé.)
+ **entrées** (facultatif ; mixed/fused modalité) — Une liste où chaque élément possède une liste de contenu de parties. Chaque partie est `{ "type": "text", "text": ... }` ou `{ "type": "image_url", "image_url": {"url": "data:;base64,..."} }`. Envoyez du contenu entrelacé semblable à une page ici (par exemple, image de page PDF avec sous-titre/métadonnées). 96 articles maximum.
+ **embedding\$1types** (facultatif) : un ou plusieurs des éléments suivants : `float`, `int8`, `uint8`, `binary`, `ubinary`. En cas d’omission, renvoie des vectorisations flottantes.
+ **output\$1dimension** (facultatif) : sélectionnez la longueur du vecteur. Valeurs autorisées : `256`, `512`, `1024`, `1536` (par défaut `1536` si non spécifié).
+ **max\$1tokens** (facultatif) : budget de troncature par objet d’entrée. Le modèle prend en charge jusqu’à environ 128 000 jetons ; un peu plus petit pour RAG, le cas échéant.
+ **truncate** (facultatif) : comment gérer les entrées trop longues : `LEFT` supprime les jetons depuis le début ; `RIGHT` supprime les jetons depuis la fin ; `NONE` renvoie une erreur si l’entrée dépasse la limite.
**Limites et tailles**
+ Articles par demande : jusqu’à 96 images. Le type de fichier image d’origine doit être au format png, jpeg, webp ou gif et sa taille peut atteindre 5 Mo.
+ Limite de taille des demandes : environ 20 Mo de données utiles totales.
+ Nombre maximum de jetons d’entrée : 128 000 jetons maximum Les fichiers image sont convertis en jetons, et le nombre total de jetons doit être inférieur à 128 000.
+ Images : maximum 2 458 624 pixels avant sous-échantillonnage ; les images inférieures à 3 136 pixels sont suréchantillonnées. Fournissez des images en tant que `data:;base64,....`
+ Comptabilisation des jetons (par élément `inputs`) : jetons provenant d’une entrée d’image ≈ (pixels de l’image ÷ 784) x 4 Jetons provenant d’une entrée de texte et d’image entrelacés = (pixels de l’image ÷ 784) x 4 \$1 (jetons de texte)
**Conseil :** Convertissez chaque page en image et envoyez-la `inputs` avec les métadonnées de la page (par exemple, nom\$1fichier, entités) dans les parties de texte adjacentes. PDFs
------
#### [ Response ]
Type de contenu : application/json
Si vous avez demandé un seul type de vectorisation (par exemple, uniquement `float`) :
```
{
"id": "string",
"embeddings": [[ /* length = output_dimension */ ]],
"response_type": "embeddings_floats",
"texts": ["..."], // present if text was provided
"inputs": [ { "content": [ ... ] } ] // present if 'inputs' was used
}
```
Si vous avez demandé plusieurs types de vectorisations (par exemple, `["float","int8"]`) :
```
{
"id": "string",
"embeddings": {
"float": [[ ... ]],
"int8": [[ ... ]]
},
"response_type": "embeddings_by_type",
"texts": ["..."], // when text used
"inputs": [ { "content": [ ... ] } ] // when 'inputs' used
}
```
+ Le nombre de vecteurs renvoyés correspond à la longueur de votre tableau `texts` ou au nombre d’éléments `inputs`.
+ La longueur de chaque vecteur est égale à `output_dimension` (par défaut `1536`).
------
## Demande et réponse pour différents types d’entrées
**A) Page entrelacée (image \$1 légende) avec des vecteurs int8 compacts**
**Demande**
```
{
"input_type": "search_document",
"inputs": [
{
"content": [
{ "type": "text", "text": "Quarterly ARR growth chart; outlier in Q3." },
{ "type": "image_url", "image_url": {"url": "data:image/png;base64,{{BASE64_PAGE_IMG}}"} }
]
}
],
"embedding_types": ["int8"],
"output_dimension": 512,
"truncate": "RIGHT",
"max_tokens": 128000
}
```
**Réponse (tronquée)**
```
{
"id": "836a33cc-61ec-4e65-afaf-c4628171a315",
"embeddings": { "int8": [[ 7, -3, ... ]] },
"response_type": "embeddings_by_type",
"inputs": [
{ "content": [
{ "type": "text", "text": "Quarterly ARR growth chart; outlier in Q3." },
{ "type": "image_url", "image_url": {"url": "data:image/png;base64,{{...}}"} }
] }
]
}
```
**B) Indexation de corpus en texte uniquement (float par défaut, 1536-dim)**
**Demande**
```
{
"input_type": "search_document",
"texts": [
"RAG system design patterns for insurance claims",
"Actuarial loss triangles and reserving primer"
]
}
```
**Réponse (exemple)**
```
{
"response_type": "embeddings_floats",
"embeddings": [
[0.0135, -0.0272, ...], // length 1536
[0.0047, 0.0189, ...]
]
}
```
## Exemples de code
------
#### [ Text input ]
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate embeddings using the Cohere Embed v4 model.
"""
import json
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_text_embeddings(model_id, body, region_name):
"""
Generate text embedding by using the Cohere Embed model.
Args:
model_id (str): The model ID to use.
body (str) : The reqest body to use.
region_name (str): The AWS region to invoke the model on
Returns:
dict: The response from the model.
"""
logger.info("Generating text embeddings with the Cohere Embed model %s", model_id)
accept = '*/*'
content_type = 'application/json'
bedrock = boto3.client(service_name='bedrock-runtime', region_name=region_name)
response = bedrock.invoke_model(
body=body,
modelId=model_id,
accept=accept,
contentType=content_type
)
logger.info("Successfully generated embeddings with Cohere model %s", model_id)
return response
def main():
"""
Entrypoint for Cohere Embed example.
"""
logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
region_name = 'us-east-1'
model_id = 'cohere.embed-v4:0'
text1 = "hello world"
text2 = "this is a test"
input_type = "search_document"
embedding_types = ["float"]
try:
body = json.dumps({
"texts": [
text1,
text2],
"input_type": input_type,
"embedding_types": embedding_types
})
response = generate_text_embeddings(model_id=model_id, body=body, region_name=region_name)
response_body = json.loads(response.get('body').read())
print(f"ID: {response_body.get('id')}")
print(f"Response type: {response_body.get('response_type')}")
print("Embeddings")
embeddings = response_body.get('embeddings')
for i, embedding_type in enumerate(embeddings):
print(f"\t{embedding_type} Embeddings:")
print(f"\t{embeddings[embedding_type]}")
print("Texts")
for i, text in enumerate(response_body.get('texts')):
print(f"\tText {i}: {text}")
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 generating text embeddings with Cohere model {model_id}.")
if __name__ == "__main__":
main()
```
------
#### [ Mixed modalities ]
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate image embeddings using the Cohere Embed v4 model.
"""
import json
import logging
import boto3
import base64
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def get_base64_image_uri(image_file_path: str, image_mime_type: str):
with open(image_file_path, "rb") as image_file:
image_bytes = image_file.read()
base64_image = base64.b64encode(image_bytes).decode("utf-8")
return f"data:{image_mime_type};base64,{base64_image}"
def generate_embeddings(model_id, body, region_name):
"""
Generate image embedding by using the Cohere Embed model.
Args:
model_id (str): The model ID to use.
body (str) : The reqest body to use.
region_name (str): The AWS region to invoke the model on
Returns:
dict: The response from the model.
"""
logger.info("Generating image embeddings with the Cohere Embed model %s", model_id)
accept = '*/*'
content_type = 'application/json'
bedrock = boto3.client(service_name='bedrock-runtime', region_name=region_name)
response = bedrock.invoke_model(
body=body,
modelId=model_id,
accept=accept,
contentType=content_type
)
logger.info("Successfully generated embeddings with Cohere model %s", model_id)
return response
def main():
"""
Entrypoint for Cohere Embed example.
"""
logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
region_name = 'us-east-1'
image_file_path = "image.jpg"
image_mime_type = "image/jpg"
text = "hello world"
model_id = 'cohere.embed-v4:0'
input_type = "search_document"
image_base64_uri = get_base64_image_uri(image_file_path, image_mime_type)
embedding_types = ["int8","float"]
try:
body = json.dumps({
"inputs": [
{
"content": [
{ "type": "text", "text": text },
{ "type": "image_url", "image_url": {"url": "data:image/png;base64,{{image_base64_uri}}"} }
]
}
],
"input_type": input_type,
"embedding_types": embedding_types
})
response = generate_embeddings(model_id=model_id, body=body, region_name=region_name)
response_body = json.loads(response.get('body').read())
print(f"ID: {response_body.get('id')}")
print(f"Response type: {response_body.get('response_type')}")
print("Embeddings")
embeddings = response_body.get('embeddings')
for i, embedding_type in enumerate(embeddings):
print(f"\t{embedding_type} Embeddings:")
print(f"\t{embeddings[embedding_type]}")
print("inputs")
for i, input in enumerate(response_body.get('inputs')):
print(f"\tinput {i}: {input}")
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 generating embeddings with Cohere model {model_id}.")
if __name__ == "__main__":
main()
```
------
# Cohere Embed v3
**Topics**
+ [Demande et réponse](#model-parameters-embed-v3-request-response)
+ [Exemple de code](#api-inference-examples-cohere-embed-v3)
## Demande et réponse
------
#### [ Request ]
Les modèles Cohere Embed ont les paramètres d’inférence suivants.
```
{
"input_type": "search_document|search_query|classification|clustering|image",
"texts":[string],
"images":[image_base64_image_uri]
"truncate": "NONE|START|END",
"embedding_types": embedding_types
}
```
Les paramètres suivants sont obligatoires.
+ **texts** : tableau de chaînes que le modèle doit intégrer. Pour des performances optimales, nous recommandons de réduire la longueur de chaque texte à moins de 512 jetons. Un jeton contient environ quatre caractères.
Vous trouverez ci-dessous le texte par appel et les limites de caractères.
**Textes par appel**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-embed-v3.html)
**Caractères**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-embed-v3.html)
+ **input\$1type** : ajoute des jetons spéciaux pour différencier chaque type des autres. Vous ne devez pas mélanger différents types, sauf à des fins de recherche et de récupération. Dans ce cas, intégrez votre corpus avec le type `search_document` et les requêtes intégrées avec le type `search_query`.
+ `search_document` : dans les cas d’utilisation de la recherche, utilisez `search_document` lorsque vous codez des documents que vous stockez dans une base de données vectorielles pour les intégrations.
+ `search_query` : utilisez `search_query` lorsque vous interrogez la base de données vectorielles pour trouver les documents pertinents.
+ `classification` : utilisez `classification` lorsque vous optez pour des intégrations comme entrée dans un classificateur de texte.
+ `clustering` : utilisez `clustering` pour regrouper les intégrations.
+ `images` : il s’agit d’un tableau d’images.
+ Un tableau d’URI de données d’image que le modèle doit intégrer. Le nombre maximum d’images par appel est de 1 (c’est-à-dire que le modèle ne prend en charge qu’une seule entrée d’image).
+ L’image doit être un URI de données valide. L’image doit être au format jpeg ou png et sa taille maximale doit être de 5 Mo.
+ Une seule des « images » ou un seul des « textes » doit être fourni(e).
Les paramètres suivants sont facultatifs :
+ **truncate** : spécifie la manière dont l’API gère les entrées dont la longueur est supérieure à la longueur maximale du jeton. Utilisez l'une des options suivantes :
+ `NONE` : (par défaut) renvoie une erreur lorsque l’entrée dépasse la longueur maximale du jeton d’entrée.
+ `START` : supprime le début de l’entrée.
+ `END` : supprime la fin de l’entrée.
Si vous spécifiez `START` ou `END`, le modèle supprime l'entrée jusqu'à ce que l'entrée restante atteigne exactement la longueur maximale du jeton d'entrée correspondant au modèle.
+ **embedding\$1types** : spécifie les types de vectorisations que vous souhaitez renvoyer. Facultatif et la valeur par défaut est `None`, ce qui renvoie le type de réponse `Embed Floats`. Peut être de l’un ou plusieurs des types suivants :
+ `float` : utilisez cette valeur pour renvoyer les vectorisations flottantes par défaut.
+ `int8` : utilisez cette valeur pour renvoyer des vectorisations int8 signées.
+ `uint8` : utilisez cette valeur pour renvoyer des vectorisations int8 non signées.
+ `binary` : utilisez cette valeur pour renvoyer des vectorisations binaires signées.
+ `ubinary` : utilisez cette valeur pour renvoyer des vectorisations binaires non signées.
Pour plus d’informations, consultez [https://docs.cohere.com/reference/embed](https://docs.cohere.com/reference/embed) dans la documentation Cohere.
------
#### [ Response ]
Voici la réponse `body` d’un appel `InvokeModel` :
```
{
"embeddings": [
[ array of 1024 floats. ]
],
"id": string,
"response_type" : "embeddings_floats,
"texts": [string],
"images": [image_description]
}
```
La réponse `body` inclut les champs suivants :
+ **id** : identifiant de la réponse.
+ **response\$1type** : type de réponse. Cette valeur est toujours `embeddings_floats`.
+ **embeddings** : tableau d’intégrations dans lequel chaque intégration est un tableau de flottants avec 1 024 éléments. La longueur du tableau `embeddings` est la même que celle du tableau `texts` d’origine.
+ **texts** : tableau contenant les entrées de texte pour lesquelles les intégrations ont été renvoyées.
+ **images** : tableau d’une description pour chaque entrée d’image.
Une `image_description`image\$1description est de la forme suivante :
```
{
"width": long,
"height": long,
"format": string,
"bit_depth": long
}
```
Si l’image a été utilisée comme entrée, le champ de réponse `“texts”` sera un tableau vide. L’inverse n’est pas vrai (c’est-à-dire que lorsque des textes sont utilisés, `“images”` ne figurera pas dans la réponse)
Pour plus d'informations, consultez [https://docs.cohere.com/reference/embed](https://docs.cohere.com/reference/embed).
------
## Exemple de code
Cet exemple montre comment appeler le modèle *Cohere Embed English*.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate text embeddings using the Cohere Embed English model.
"""
import json
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_text_embeddings(model_id, body, region_name):
"""
Generate text embedding by using the Cohere Embed model.
Args:
model_id (str): The model ID to use.
body (str) : The reqest body to use.
region_name (str): The AWS region to invoke the model on
Returns:
dict: The response from the model.
"""
logger.info("Generating text embeddings with the Cohere Embed model %s", model_id)
accept = '*/*'
content_type = 'application/json'
bedrock = boto3.client(service_name='bedrock-runtime', region_name=region_name)
response = bedrock.invoke_model(
body=body,
modelId=model_id,
accept=accept,
contentType=content_type
)
logger.info("Successfully generated embeddings with Cohere model %s", model_id)
return response
def main():
"""
Entrypoint for Cohere Embed example.
"""
logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
region_name = 'us-east-1'
model_id = 'cohere.embed-english-v3'
text1 = "hello world"
text2 = "this is a test"
input_type = "search_document"
embedding_types = ["int8", "float"]
try:
body = json.dumps({
"texts": [
text1,
text2],
"input_type": input_type,
"embedding_types": embedding_types
})
response = generate_text_embeddings(model_id=model_id, body=body, region_name=region_name)
response_body = json.loads(response.get('body').read())
print(f"ID: {response_body.get('id')}")
print(f"Response type: {response_body.get('response_type')}")
print("Embeddings")
embeddings = response_body.get('embeddings')
for i, embedding_type in enumerate(embeddings):
print(f"\t{embedding_type} Embeddings:")
print(f"\t{embeddings[embedding_type]}")
print("Texts")
for i, text in enumerate(response_body.get('texts')):
print(f"\tText {i}: {text}")
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 generating text embeddings with Cohere model {model_id}.")
if __name__ == "__main__":
main()
```
**Entrée d’image**
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate image embeddings using the Cohere Embed English model.
"""
import json
import logging
import boto3
import base64
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def get_base64_image_uri(image_file_path: str, image_mime_type: str):
with open(image_file_path, "rb") as image_file:
image_bytes = image_file.read()
base64_image = base64.b64encode(image_bytes).decode("utf-8")
return f"data:{image_mime_type};base64,{base64_image}"
def generate_image_embeddings(model_id, body, region_name):
"""
Generate image embedding by using the Cohere Embed model.
Args:
model_id (str): The model ID to use.
body (str) : The reqest body to use.
region_name (str): The AWS region to invoke the model on
Returns:
dict: The response from the model.
"""
logger.info("Generating image embeddings with the Cohere Embed model %s", model_id)
accept = '*/*'
content_type = 'application/json'
bedrock = boto3.client(service_name='bedrock-runtime', region_name=region_name)
response = bedrock.invoke_model(
body=body,
modelId=model_id,
accept=accept,
contentType=content_type
)
logger.info("Successfully generated embeddings with Cohere model %s", model_id)
return response
def main():
"""
Entrypoint for Cohere Embed example.
"""
logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
region_name = 'us-east-1'
image_file_path = "image.jpg"
image_mime_type = "image/jpg"
model_id = 'cohere.embed-english-v3'
input_type = "image"
images = [get_base64_image_uri(image_file_path, image_mime_type)]
embedding_types = ["int8", "float"]
try:
body = json.dumps({
"images": images,
"input_type": input_type,
"embedding_types": embedding_types
})
response = generate_image_embeddings(model_id=model_id, body=body, region_name=region_name)
response_body = json.loads(response.get('body').read())
print(f"ID: {response_body.get('id')}")
print(f"Response type: {response_body.get('response_type')}")
print("Embeddings")
embeddings = response_body.get('embeddings')
for i, embedding_type in enumerate(embeddings):
print(f"\t{embedding_type} Embeddings:")
print(f"\t{embeddings[embedding_type]}")
print("Texts")
for i, text in enumerate(response_body.get('texts')):
print(f"\tText {i}: {text}")
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 generating text embeddings with Cohere model {model_id}.")
if __name__ == "__main__":
main()
```
# Modèles Cohere Command R et Command R\$1
Vous effectuez des demandes d’inférence aux modèles Cohere Command R et Cohere Command R\$1 avec [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) (streaming). Vous avez besoin de l’ID du modèle que vous voulez utiliser. Pour obtenir l’ID du modèle, consultez [Modèles de fondation pris en charge dans Amazon Bedrock](models-supported.md).
**Astuce**
Pour les applications conversationnelles, nous vous recommandons d’utiliser l’API Converse. L’API Converse fournit un ensemble unifié de paramètres qui fonctionnent sur tous les modèles prenant en charge les messages. Pour plus d’informations, consultez [Mener une conversation avec les opérations d’API Converse](conversation-inference.md).
**Topics**
+ [Demande et réponse](#model-parameters-cohere-command-request-response)
+ [Exemple de code](#api-inference-examples-cohere-command-r)
## Demande et réponse
------
#### [ Request ]
Les modèles Cohere Command ont les paramètres d’inférence suivants.
```
{
"message": string,
"chat_history": [
{
"role":"USER or CHATBOT",
"message": string
}
],
"documents": [
{"title": string, "snippet": string},
],
"search_queries_only" : boolean,
"preamble" : string,
"max_tokens": int,
"temperature": float,
"p": float,
"k": float,
"prompt_truncation" : string,
"frequency_penalty" : float,
"presence_penalty" : float,
"seed" : int,
"return_prompt" : boolean,
"tools" : [
{
"name": string,
"description": string,
"parameter_definitions": {
"parameter name": {
"description": string,
"type": string,
"required": boolean
}
}
}
],
"tool_results" : [
{
"call": {
"name": string,
"parameters": {
"parameter name": string
}
},
"outputs": [
{
"text": string
}
]
}
],
"stop_sequences": [string],
"raw_prompting" : boolean
}
```
Les paramètres suivants sont obligatoires.
+ **message** : (obligatoire) saisie de texte auquel le modèle doit répondre.
Les paramètres suivants sont facultatifs.
+ **chat\$1history** : liste des messages précédents échangés entre l’utilisateur et le modèle, destinée à donner au modèle le contexte conversationnel pour répondre au message de l’utilisateur.
Les champs suivants sont obligatoires.
+ `role` : rôle du message. Les valeurs valides sont les jetons `USER` ou `CHATBOT`.
+ `message` : contenu du texte du message.
L’exemple suivant est un exemple JSON pour le champ `chat_history`.
```
"chat_history": [
{"role": "USER", "message": "Who discovered gravity?"},
{"role": "CHATBOT", "message": "The man who is widely credited with discovering gravity is Sir Isaac Newton"}
]
```
+ **documents** : liste de textes que le modèle peut citer pour générer une réponse plus précise. Chaque document est un dictionnaire chaîne-chaîne. La génération qui en résulte inclut des citations qui font référence à certains de ces documents. Nous vous recommandons de limiter le nombre total de mots des chaînes du dictionnaire à moins de 300 mots. Un champ `_excludes` (tableau de chaînes) peut être fourni en option pour empêcher l’affichage de certaines paires clé-valeur dans le modèle. Pour plus d’informations, consultez [Guide du mode document](https://docs.cohere.com/docs/retrieval-augmented-generation-rag#document-mode) dans la documentation Cohere.
L’exemple suivant est un exemple JSON pour le champ `documents`.
```
"documents": [
{"title": "Tall penguins", "snippet": "Emperor penguins are the tallest."},
{"title": "Penguin habitats", "snippet": "Emperor penguins only live in Antarctica."}
]
```
+ **search\$1queries\$1only** : la valeur par défaut est `false`. Lorsqu’elle est définie sur `true`, la réponse ne contiendra qu’une liste de requêtes de recherche générées, mais aucune recherche n’aura lieu et aucune réponse du modèle au `message` de l’utilisateur sera générée.
+ **preamble** : remplace le préambule par défaut pour la génération de requêtes de recherche. N’a aucun effet sur les générations d’utilisation des outils.
+ **max\$1tokens** : le nombre maximum de jetons que le modèle doit générer dans le cadre de la réponse. Notez que la définition d’une valeur faible peut entraîner des générations incomplètes. La définition de `max_tokens` peut entraîner des générations incomplètes ou inexistantes lorsqu’il est utilisé avec les champs `tools` ou `documents`.
+ **temperature** : utilisez une valeur inférieure pour réduire le caractère aléatoire de la réponse. Le caractère aléatoire peut être encore maximisé en augmentant la valeur du paramètre `p`.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-cohere-command-r-plus.html)
+ **p** : top P. Utilisez une valeur inférieure pour ignorer les options les moins probables.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-cohere-command-r-plus.html)
+ **k** : top K. Spécifiez le nombre de choix de jetons que le modèle utilise pour générer le jeton suivant.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-cohere-command-r-plus.html)
+ **prompt\$1truncation** : la valeur par défaut est `OFF`. Détermine la manière dont l’invite est construite. Lorsque `prompt_truncation` est défini sur `AUTO_PRESERVE_ORDER`, certains éléments de `chat_history` et `documents` seront supprimés pour construire une invite correspondant à la limite de longueur du contexte du modèle. Au cours de ce processus, l’ordre des documents et l’historique du chat seront préservés. Si `prompt_truncation` est défini sur `OFF`, aucun élément ne sera supprimé.
+ **frequency\$1penalty** : utilisé pour réduire la répétitivité des jetons générés. Plus la valeur est élevée, plus une pénalité est appliquée aux jetons précédemment présents, proportionnelle au nombre de fois qu’ils sont déjà apparus dans l’invite ou la génération précédente.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-cohere-command-r-plus.html)
+ **presence\$1penalty** : utilisé pour réduire la répétitivité des jetons générés. Similaire à `frequency_penalty`, sauf que cette pénalité est appliquée de la même manière à tous les jetons déjà apparus, quelle que soit leur fréquence exacte.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-cohere-command-r-plus.html)
+ **seed** : si ce paramètre est spécifié, le système dorsal fera de son mieux pour échantillonner les jetons de manière déterministe, de telle sorte que les demandes répétées avec la même valeur de départ et les mêmes paramètres devraient renvoyer le même résultat. Cependant, le déterminisme ne peut être totalement garanti.
+ **return\$1prompt** : spécifiez `true` pour renvoyer l’invite complète envoyée au modèle. La valeur par défaut est `false`. Dans la réponse, l’invite dans le champ `prompt`.
+ **tools** : liste des outils (fonctions) disponibles que le modèle peut suggérer d’invoquer avant de produire une réponse textuelle. Une fois `tools` transmis (sans `tool_results`), le champ `text` dans la réponse sera `""` et le champ `tool_calls` dans la réponse sera rempli avec une liste des appels d’outils à effectuer. Si aucun appel n’est nécessaire, le tableau `tool_calls` sera vide.
Pour plus d’informations, consultez [Utilisation d’outil](https://docs.cohere.com/docs/tool-use) dans la documentation Cohere.
**Astuce**
Nous vous recommandons d’utiliser l’API Converse pour intégrer l’utilisation des outils dans votre application. Pour plus d’informations, consultez [Utilisation d’un outil pour compléter une réponse au modèle Amazon Bedrock](tool-use.md).
L’exemple suivant est un exemple JSON pour le champ `tools`.
```
[
{
"name": "top_song",
"description": "Get the most popular song played on a radio station.",
"parameter_definitions": {
"sign": {
"description": "The call sign for the radio station for which you want the most popular song. Example calls signs are WZPZ and WKRP.",
"type": "str",
"required": true
}
}
}
]
```
Pour plus d’informations, consultez [Utilisation d’outil en une seule étape (appel de fonction)](https://docs.cohere.com/docs/tool-use) dans la documentation Cohere.
+ **tools\$1results** : liste des résultats obtenus en invoquant les outils recommandés par le modèle lors du tour de chat précédent. Les résultats sont utilisés pour produire une réponse textuelle et sont référencés dans les citations. Lors de l’utilisation de `tool_results`, `tools` doit également être transmis. Chaque `tool_result` contient des informations sur la manière dont il a été invoqué, ainsi qu’une liste de sorties sous forme de dictionnaires. La logique de citation affinée unique de Cohere exige que la sortie soit une liste. Si la sortie n’est qu’un seul élément, tel que `{"status": 200}`, vous devez tout de même l’envelopper dans une liste.
Pour plus d’informations, consultez [Utilisation d’outil](https://docs.cohere.com/docs/tool-use) dans la documentation Cohere.
L’exemple suivant est un exemple JSON pour le champ `tools_results`.
```
[
{
"call": {
"name": "top_song",
"parameters": {
"sign": "WZPZ"
}
},
"outputs": [
{
"song": "Elemental Hotel"
}
]
}
]
```
+ **stop\$1sequences** : liste de séquences d’arrêt. Une fois qu’une séquence d’arrêt est détectée, le modèle cesse de générer d’autres jetons.
+ **raw\$1prompting** : spécifiez `true`, pour envoyer le `message` de l’utilisateur au modèle sans aucun prétraitement. Sinon, spécifiez false.
------
#### [ Response ]
La réponse peut inclure les champs suivants :
```
{
"response_id": string,
"text": string,
"generation_id": string,
"citations": [
{
"start": int,
"end": int,
"text": "string",
"document_ids": [
"string"
]
}
],
"finish_reason": string,
"tool_calls": [
{
"name": string,
"parameters": {
"parameter name": string
}
}
],
{
"meta": {
"api_version": {
"version": string
},
"billed_units": {
"input_tokens": int,
"output_tokens": int
}
}
}
```
+ **response\$1id** : identifiant unique pour achever la conversation
+ **text** : réponse du modèle à la saisie d’un message de chat.
+ **generation\$1id** : identifiant unique pour achever la conversation, utilisé avec le point de terminaison des commentaires sur la plateforme de Cohere.
+ **citations** : tableau de citations en ligne et de métadonnées associées pour la réponse générée. Contient les champs suivants :
+ **start** : index auquel la citation commence, à partir de 0.
+ **end** : index après lequel la citation se termine, à partir de 0.
+ **text** : texte auquel se rapporte la citation.
+ **document\$1ids** : tableau d’identifiants d’ID de document correspondant aux documents cités pour le texte.
+ **prompt** : invite complète envoyée au modèle. Spécifiez le champ `return_prompt` pour renvoyer ce champ.
+ **finish\$1reason** : raison pour laquelle le modèle a cessé de générer une sortie. Il peut s’agir de l’une des valeurs suivantes :
+ **complete** : l’achèvement a atteint la fin du jeton de génération, assurez-vous que c’est la raison de finition pour obtenir les meilleures performances.
+ **error\$1toxic** : la génération n’a pas pu être terminée en raison de nos filtres de contenu.
+ **error\$1limit** : la génération n’a pas pu être terminée, car la limite de contexte du modèle a été atteinte.
+ **error** : la génération n’a pas pu être terminée en raison d’une erreur.
+ **user\$1cancel** : la génération n’a pas pu être terminée, car elle a été arrêtée par l’utilisateur.
+ **max\$1tokens** : la génération n’a pas pu être terminée, car l’utilisateur a spécifié une limite `max_tokens` dans la demande et cette limite a été atteinte. Il est possible que les performances ne soient pas optimales.
+ **tool\$1calls** : liste des outils appropriés pour les appels. Renvoyé uniquement si vous spécifiez le champ d’entrée `tools`.
Pour plus d’informations, consultez [Utilisation d’outil](https://docs.cohere.com/docs/tool-use) dans la documentation Cohere.
**Astuce**
Nous vous recommandons d’utiliser l’API Converse pour intégrer l’utilisation des outils dans votre application. Pour plus d’informations, consultez [Utilisation d’un outil pour compléter une réponse au modèle Amazon Bedrock](tool-use.md).
L’exemple suivant est un exemple JSON pour le champ `tool_calls`.
```
[
{
"name": "top_song",
"parameters": {
"sign": "WZPZ"
}
}
]
```
+ **meta** : données d’utilisation de l’API (n’existent que pour le streaming).
+ `api_version` : version de l’API. La version se trouve dans le champ `version`.
+ `billed_units` : unités facturées. Les valeurs possibles sont :
+ `input_tokens` : nombre de jetons d’entrée facturés.
+ `output_tokens` : nombre de jetons de sortie facturés.
------
## Exemple de code
Cet exemple montre comment appeler le modèle *Cohere Command R*.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to use the Cohere Command R model.
"""
import json
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_text(model_id, body):
"""
Generate text using a Cohere Command R model.
Args:
model_id (str): The model ID to use.
body (str) : The reqest body to use.
Returns:
dict: The response from the model.
"""
logger.info("Generating text with Cohere model %s", model_id)
bedrock = boto3.client(service_name='bedrock-runtime')
response = bedrock.invoke_model(
body=body,
modelId=model_id
)
logger.info(
"Successfully generated text with Cohere Command R model %s", model_id)
return response
def main():
"""
Entrypoint for Cohere example.
"""
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
model_id = 'cohere.command-r-v1:0'
chat_history = [
{"role": "USER", "message": "What is an interesting new role in AI if I don't have an ML background?"},
{"role": "CHATBOT", "message": "You could explore being a prompt engineer!"}
]
message = "What are some skills I should have?"
try:
body = json.dumps({
"message": message,
"chat_history": chat_history,
"max_tokens": 2000,
"temperature": 0.6,
"p": 0.5,
"k": 250
})
response = generate_text(model_id=model_id,
body=body)
response_body = json.loads(response.get('body').read())
response_chat_history = response_body.get('chat_history')
print('Chat history\n------------')
for response_message in response_chat_history:
if 'message' in response_message:
print(f"Role: {response_message['role']}")
print(f"Message: {response_message['message']}\n")
print("Generated text\n--------------")
print(f"Stop reason: {response_body['finish_reason']}")
print(f"Response text: \n{response_body['text']}")
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 generating text with Cohere model {model_id}.")
if __name__ == "__main__":
main()
```
# Modèles DeepSeek
DeepSeek[les modèles R1 et V3.1 sont des text-to-text modèles disponibles pour l'inférence via l'API Invoke ([InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html), [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)) et l'API Converse (Converse et). [ConverseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ConverseStream.html)](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html)
Lorsque vous effectuez des appels d’inférence avec des modèles DeepSeek, incluez une invite pour ce modèle. Pour obtenir des informations générales sur la création d’invites pour les modèles DeepSeek pris en charge par Amazon Bedrock, consultez le [Guide d’invites DeepSeek](https://api-docs.deepseek.com/guides/reasoning_model.html).
**Note**
Vous ne pouvez pas supprimer les demandes d'accès pour les modèles Amazon Titan, Amazon Nova, DeepSeek -R1, Mistral AI, Meta Llama 3 Instruct et Meta Llama 4. Vous pouvez empêcher les utilisateurs d’effectuer des appels d’inférence vers ces modèles en utilisant une politique IAM et en spécifiant l’ID du modèle. Pour plus d’informations, consultez [Refus de l’accès à des fins d’inférence de modèles de fondation](https://docs.aws.amazon.com/bedrock/latest/userguide/security_iam_id-based-policy-examples.html#security_iam_id-based-policy-examples-deny-inference .html).
Pour une qualité de réponse optimaleDeepSeek-R1, limitez le `max_tokens` paramètre à 8 192 jetons ou moins. Bien que l'API accepte jusqu'à 32 768 jetons, la qualité de réponse se dégrade considérablement au-dessus de 8 192 jetons. Cela correspond aux capacités de raisonnement du modèle telles que décrites dans le guide de [raisonnement par inférence](https://docs.aws.amazon.com/bedrock/latest/userguide/inference-reasoning.html).
Cette section décrit les paramètres de demande et les champs de réponse pour les modèles DeepSeek. Utilisez ces informations pour effectuer des appels d'inférence aux DeepSeek modèles avec l'[InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)opération. Cette section inclut également des exemples de code Python qui montrent comment appeler des modèles DeepSeek.
Pour utiliser un modèle dans une opération d’inférence, vous avez besoin de l’ID du modèle. Comme ce modèle est invoqué par inférence interrégionale, vous devez utiliser l’ID de l’[ID du profil d’inférence](https://docs.aws.amazon.com/bedrock/latest/userguide/inference-profiles-support.html) comme ID du modèle. Par exemple, pour les USA, vous utilisez `us.deepseek.r1-v1:0`.
+ Nom du modèle : DeepSeek-R1
+ Modèle de texte
Pour plus d'informations sur l'utilisation des DeepSeek modèles avec APIs, consultez la section [DeepSeekModèles](https://deepseek.com/).
**Demande et réponse DeepSeek**
**Corps de la demande**
DeepSeek comporte les paramètres d’inférence suivants pour un appel d’inférence de complétion de texte.
```
{
"prompt": string,
"temperature": float,
"top_p": float,
"max_tokens": int,
"stop": string array
}
```
**Champs :**
+ **prompt** : (chaîne) entrée de texte requise pour l’invite.
+ **temperature** : (valeur flottante) valeur numérique inférieure ou égale à 1.
+ **top\$1p** : (valeur flottante) valeur numérique inférieure ou égale à 1.
+ **max\$1tokens** — (int) Jetons utilisés, d'un minimum de 1 à un maximum de 8 192 jetons pour une qualité optimale. Bien que l'API accepte jusqu'à 32 768 jetons, la qualité de réponse se dégrade considérablement au-dessus de 8 192 jetons.
+ **stop** : (tableau de chaînes) maximum de 10 éléments.
**Organisme de réponse**
DeepSeek comporte les paramètres de réponse inférence suivants pour un appel d’inférence de complétion de texte. Cet exemple est une complétion de texte à partir de DeepSeek et ne renvoie aucun bloc de raisonnement relatif au contenu.
```
{
"choices": [
{
"text": string,
"stop_reason": string
}
]
}
```
**Champs :**
+ **stop\$1reason** : (chaîne) raison pour laquelle la réponse a cessé de générer du texte. Valeur de `stop` ou `length`.
+ **stop** : (chaîne) le modèle a fini de générer le texte pour l’invite d’entrée.
+ **length** : (chaîne) la longueur des jetons pour le texte généré dépasse la valeur de `max_tokens` dans l’appel `InvokeModel` (`InvokeModelWithResponseStream`, si vous diffusez une sortie). La réponse est tronquée à `max_tokens`. Augmentez la valeur de `max_tokens` et renouvelez votre demande.
**Exemple de code**
Cet exemple montre comment appeler le modèle DeepSeek-R1.
```
# Use the API to send a text message to DeepSeek-R1.
import boto3
import json
from botocore.exceptions import ClientError
# Create a Bedrock Runtime client in the Région AWS of your choice.
client = boto3.client("bedrock-runtime", region_name="us-west-2")
# Set the cross Region inference profile ID for DeepSeek-R1
model_id = "us.deepseek.r1-v1:0"
# Define the prompt for the model.
prompt = "Describe the purpose of a 'hello world' program in one line."
# Embed the prompt in DeepSeek-R1's instruction format.
formatted_prompt = f"""
<｜begin▁of▁sentence｜><｜User｜>{prompt}<｜Assistant｜>\n
"""
body = json.dumps({
"prompt": formatted_prompt,
"max_tokens": 512,
"temperature": 0.5,
"top_p": 0.9,
})
try:
# Invoke the model with the request.
response = client.invoke_model(modelId=model_id, body=body)
# Read the response body.
model_response = json.loads(response["body"].read())
# Extract choices.
choices = model_response["choices"]
# Print choices.
for index, choice in enumerate(choices):
print(f"Choice {index + 1}\n----------")
print(f"Text:\n{choice['text']}\n")
print(f"Stop reason: {choice['stop_reason']}\n")
except (ClientError, Exception) as e:
print(f"ERROR: Can't invoke '{model_id}'. Reason: {e}")
exit(1)
```
**Converse**
Corps de la demande : utilisez cet exemple de corps de la demande pour appeler l’API ConverseAPI.
```
{
"modelId": string, # us.deepseek.r1-v1:0
"system": [
{
"text": string
}
],
"messages": [
{
"role": string,
"content": [
{
"text": string
}
]
}
],
"inferenceConfig": {
"temperature": float,
"topP": float,
"maxTokens": int,
"stopSequences": string array
},
"guardrailConfig": {
"guardrailIdentifier":"string",
"guardrailVersion": "string",
"trace": "string"
}
}
```
**Champs :**
+ **system** : (facultatif) invite du système pour la demande.
+ **messages** : (obligatoire) les messages d’entrée.
+ **role** : le rôle du tour de conversation. Les valeurs valides sont `user` et `assistant`.
+ **content** : (obligatoire) le contenu de la conversation prend la forme d’un tableau d’objets. Chaque objet contient un champ type dans lequel vous pouvez spécifier l’une des valeurs suivantes :
+ **text** : (obligatoire) si vous spécifiez ce type, vous devez inclure un champ texte et spécifier l’invite de texte comme valeur.
+ **inferenceConfig**
+ **temperature** : (facultatif) valeurs : minimum = 0. maximum = 1.
+ **topP** : (facultatif) valeurs : minimum = 0. Maximum = 1.
+ **maxTokens** : (facultatif) nombre maximum de jetons à générer avant l’arrêt. Valeurs : minimum = 0. Maximum = 32 768.
+ **stopSequences** : (facultatif) séquences de texte personnalisées qui empêchent le modèle de générer une sortie. Maximum = 10 éléments.
Corps de la réponse : utilisez cet exemple de corps de la demande pour appeler l’API Converse.
```
{
"message": {
"role" : "assistant",
"content": [
{
"text": string
},
{
"reasoningContent": {
"reasoningText": string
}
}
],
},
"stopReason": string,
"usage": {
"inputTokens": int,
"outputTokens": int,
"totalTokens": int
}
"metrics": {
"latencyMs": int
}
}
```
**Champs :**
+ **message** : réponse renvoyée par le modèle.
+ **role** : rôle conversationnel du message généré. La valeur est toujours `assistant`.
+ **content** : contenu généré par le modèle, qui est renvoyé sous forme de tableau. Il existe deux types contenus :
+ **text** : contenu textuel de la réponse.
+ **reasoningContent** : (facultatif) contenu du raisonnement issu de la réponse du modèle.
+ **reasoningText** : texte de raisonnement issu de la réponse du modèle.
+ **stopReason** : raison pour laquelle le modèle a cessé de générer la réponse.
+ **end\$1turn** : tour auquel le modèle a atteint un point d’arrêt.
+ **max\$1tokens** : le texte généré dépassait la valeur du champ d’entrée `maxTokens` ou le nombre maximum de jetons pris en charge par le modèle.
Exemple de code - Voici un exemple de DeepSeek création d'un appel à la ConverseAPI.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to use the Converse API with DeepSeek-R1 (on demand).
"""
import logging
import boto3
from botocore.client import Config
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
max_tokens = 4096
# Base inference parameters to use.
inference_config = {
"temperature": temperature,
"maxTokens": max_tokens,
}
# Send the message.
response = bedrock_client.converse(
modelId=model_id,
messages=messages,
system=system_prompts,
inferenceConfig=inference_config,
)
# 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 DeepSeek-R1 example.
"""
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
model_id = "us.deepseek.r1-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:
# Configure timeout for long responses if needed
custom_config = Config(connect_timeout=840, read_timeout=840)
bedrock_client = boto3.client(service_name='bedrock-runtime', config=custom_config)
# 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']
# Remove reasoning content from the response
output_contents = []
for content in output_message["content"]:
if content.get("reasoningContent"):
continue
else:
output_contents.append(content)
output_message["content"] = output_contents
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']:
if content.get("text"):
print(f"Text: {content['text']}")
if content.get("reasoningContent"):
reasoning_content = content['reasoningContent']
reasoning_text = reasoning_content.get('reasoningText', {})
print()
print(f"Reasoning Text: {reasoning_text.get('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()
```
# Modèles Luma AI
Cette section décrit les paramètres de demande et les champs de réponse pour les modèles d’IA Luma. Utilisez ces informations pour effectuer des appels d'inférence vers les modèles Luma AI avec l'[StartAsyncInvoke](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_StartAsyncInvoke.html)opération. Cette section inclut également des exemples de code Python qui montrent comment appeler des modèles d’IA Luma. Pour utiliser un modèle dans une opération d’inférence, vous avez besoin de l’ID du modèle.
+ ID du modèle : luma.ray-v 2:0
+ Nom du modèle : Luma Ray 2
+ Modèle texte vers vidéo
Les modèles Luma AI traitent les demandes du modèle de manière asynchrone en utilisant l'asynchrone APIs , y compris, et. [StartAsyncInvoke[GetAsyncInvoke[ListAsyncInvokes](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ListAsyncInvokes.html)](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_GetAsyncInvoke.html)](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_StartAsyncInvoke.html)
Le modèle d’IA Luma traite les invites en suivant les étapes suivantes.
+ L'utilisateur invite le modèle à l'aide [StartAsyncInvoke](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_StartAsyncInvoke.html)de.
+ Attendez que le InvokeJob soit terminé. Vous pouvez utiliser `GetAsyncInvoke` ou `ListAsyncInvokes` pour vérifier l’état d’achèvement de la tâche.
+ La sortie du modèle sera placée dans le compartiment Amazon S3 de sortie spécifié.
Pour plus d'informations sur l'utilisation des modèles Luma AI avec le APIs, voir [Génération de vidéos](https://docs.lumalabs.ai/docs/video-generation).
Appel d’inférence Luma AI.
```
POST /async-invoke HTTP/1.1
Content-type: application/json
{
"modelId": "luma.ray-v2:0",
"modelInput": {
"prompt": "your input text here",
"aspect_ratio": "16:9",
"loop": false,
"duration": "5s",
"resolution": "720p"
},
"outputDataConfig": {
"s3OutputDataConfig": {
"s3Uri": "s3://your-bucket-name"
}
}
}
```
**Champs**
+ **prompt** : (chaîne) contenu nécessaire à la sortie vidéo (1 <= longueur <= 5 000 caractères).
+ **aspect\$1ratio** : (enum) rapport hauteur/largeur de la vidéo de sortie (« 1:1 », « 16:9 », « 9:16 », « 4:3 », « 3:4, « 21:9 », « 9:21 »).
+ **loop** : (booléen) indique s’’il faut mettre en boucle la vidéo de sortie.
+ **duration** : (enum) durée de la sortie vidéo (« 5s », « 9s »).
+ **résolution** : (enum) résolution de la vidéo de sortie (« 540p », « 720p »).
Le MP4 fichier sera stocké dans le compartiment Amazon S3 tel que configuré dans la réponse.
## Text-to-Video Génération
Générez des vidéos à partir d’invites textuelles à l’aide du modèle Luma Ray 2. Le modèle prend en charge diverses options de personnalisation, notamment le rapport hauteur/largeur, la durée, la résolution et le bouclage.
** Text-to-VideoDemande de base**
```
{
"modelId": "luma.ray-v2:0",
"modelInput": {
"prompt": "an old lady laughing underwater, wearing a scuba diving suit"
},
"outputDataConfig": {
"s3OutputDataConfig": {
"s3Uri": "s3://your-bucket-name"
}
}
}
```
**Avancé Text-to-Video avec options**
```
{
"modelId": "luma.ray-v2:0",
"modelInput": {
"prompt": "an old lady laughing underwater, wearing a scuba diving suit",
"aspect_ratio": "16:9",
"loop": true,
"duration": "5s",
"resolution": "720p"
},
"outputDataConfig": {
"s3OutputDataConfig": {
"s3Uri": "s3://your-bucket-name"
}
}
}
```
** Text-to-VideoExemple supplémentaire**
Exemple avec paramètres de résolution et de durée.
```
{
"modelId": "luma.ray-v2:0",
"modelInput": {
"prompt": "a car",
"resolution": "720p",
"duration": "5s"
},
"outputDataConfig": {
"s3OutputDataConfig": {
"s3Uri": "s3://your-bucket-name"
}
}
}
```
## Image-to-Video Génération
Transformez des images statiques en vidéos dynamiques en fournissant des séquences clés. Vous pouvez spécifier des séquences de début, des séquences de fin ou les deux pour contrôler le processus de génération vidéo.
**Basic Image-to-Video avec cadre de départ**
```
{
"modelId": "luma.ray-v2:0",
"modelInput": {
"prompt": "A tiger walking in snow",
"keyframes": {
"frame0": {
"type": "image",
"source": {
"type": "base64",
"media_type": "image/jpeg",
"data": "iVBORw0KGgoAAAANSUhEUgAAAAgAAAAIAQMAAAD+wSzIAAAABlBMVEX///+/v7+jQ3"
}
}
}
},
"outputDataConfig": {
"s3OutputDataConfig": {
"s3Uri": "s3://your-bucket-name"
}
}
}
```
**Image-to-Video avec cadres de début et de fin**
```
{
"modelId": "luma.ray-v2:0",
"modelInput": {
"prompt": "A tiger walking in snow",
"keyframes": {
"frame0": {
"type": "image",
"source": {
"type": "base64",
"media_type": "image/jpeg",
"data": "iVBORw0KGgoAAAANSUhEUgAAAAgAAAAIAQMAAAD+wSzIAAAABlBMVEX///+/v7+jQ3"
}
},
"frame1": {
"type": "image",
"source": {
"type": "base64",
"media_type": "image/jpeg",
"data": "iVBORw0KGgoAAAANSUhEUgAAAAgAAAAIAQMAAAD+wSzIAAAABlBMVEX///+/v7+jQ3"
}
}
},
"loop": false,
"aspect_ratio": "16:9"
},
"outputDataConfig": {
"s3OutputDataConfig": {
"s3Uri": "s3://your-bucket-name"
}
}
}
```
**Paramètres supplémentaires pour Image-to-Video**
+ **keyframes** — (object) Définit les images-clés de début (frame0) de and/or fin (frame1)
+ **frame0** : image de séquence clé de départ
+ **frame1** : image de séquence clé de fin
+ **type** : doit être « image »
+ **source** : source de l’image
## Résolution des problèmes
Problèmes courants et solutions liés à l’utilisation des modèles d’IA Luma :
+ **État de tâche « Échec »** : vérifiez que votre compartiment S3 dispose des autorisations d’écriture appropriées et qu’il existe dans la même région que votre service Bedrock.
+ **Erreurs d'accès à l'URL** de l'image : assurez-vous que l'image URLs est accessible au public et utilisez le protocole HTTPS. Les images doivent être aux formats pris en charge (PNG ou JPEG).
+ **Erreurs de paramètres non valides** : vérifiez que les valeurs du rapport hauteur/largeur correspondent aux options prises en charge (« 1:1 », « 16:9 », « 9:16 », « 4:3 », « 3:4 », « 21:9 », « 9:21 ») et que la durée est de « 5s » ou « 9s ».
+ **Problèmes de délai d’attente** : utilisez `GetAsyncInvoke` pour vérifier le statut de la tâche plutôt que d’attendre de manière synchrone. La génération d’une vidéo peut prendre plusieurs minutes.
+ **Erreurs de longueur d’invite** : maintenez les invites entre 1 et 5 000 caractères. Les invites plus longues seront rejetées.
## Notes de performance
Considérations importantes concernant les performances et les limites du modèle d’IA Luma :
+ **Temps de traitement** : la génération de vidéos prend généralement de 2 à 5 minutes pour les vidéos de 5 secondes et de 4 à 8 minutes pour les vidéos de 9 secondes, selon la complexité.
+ **Exigences relatives à l’image** : les images d’entrée doivent être de haute qualité avec une résolution minimale de 512 x 512 pixels. La taille d’image maximale prise en charge est de 4 096 x 4 096 pixels.
+ **Taille de la vidéo de sortie** : les vidéos générées varient de 5 à 50 Mo en fonction de la durée, de la résolution et de la complexité du contenu.
+ **Limites de débit :** les appels d’API asynchrones sont soumis à des quotas de service. Surveillez votre utilisation et les augmentations de quotas de demande si nécessaire.
+ **Stockage S3** : garantissez une capacité de stockage S3 suffisante pour les vidéos de sortie et considérez les politiques de cycle de vie pour optimiser les coûts.
## Documents associés
Pour des informations supplémentaires et des services connexes :
+ **Configuration Amazon S3** : [création de compartiments S3](https://docs.aws.amazon.com/s3/latest/userguide/creating-buckets-s3.html) et de [stratégies de compartiment](https://docs.aws.amazon.com/s3/latest/userguide/bucket-policies.html) pour le stockage des sorties.
+ **Opérations d'API asynchrones** - [StartAsyncInvoke[GetAsyncInvoke](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_GetAsyncInvoke.html)](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_StartAsyncInvoke.html), et référence [ListAsyncInvokes](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ListAsyncInvokes.html)d'API.
+ **Quotas de service** : [Quotas pour Amazon Bedrock](quotas.md) pour les limites de service Bedrock et les demandes d’augmentation de quotas.
+ **Meilleures pratiques en matière de traitement vidéo** : [Soumission d’invites et génération de réponses à l’aide de l’inférence de modèle](inference.md) pour des conseils généraux sur l’inférence de modèle.
+ **Documentation IA Luma** [Documentation sur la génération vidéo Luma Labs](https://docs.lumalabs.ai/docs/video-generation) pour plus de détails sur les capacités détaillées et les fonctionnalités avancées des modèles.
# Modèles Meta Llama
Cette section décrit les paramètres de demande et les champs de réponse pour les modèles Meta Llama. Utilisez ces informations pour effectuer des appels d’inférence aux modèles Meta Llama à l’aide des opérations [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) et [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) (streaming). Cette section inclut également des exemples de code Python qui montrent comment appeler les modèles Meta Llama. Pour utiliser un modèle dans une opération d’inférence, vous avez besoin de l’ID du modèle. Pour obtenir l’ID du modèle, consultez [Modèles de fondation pris en charge dans Amazon Bedrock](models-supported.md). Certains modèles fonctionnent également avec l’[API Converse](conversation-inference.md). Pour vérifier si l’API Converse prend en charge un modèle Meta Llama spécifique, consultez [Modèles et fonctionnalités des modèles pris en charge](conversation-inference-supported-models-features.md). Pour plus d’exemples de code, consultez [Exemples de code pour Amazon Bedrock utilisant AWS SDKs](service_code_examples.md).
Les modèles de fondation d’Amazon Bedrock prennent en charge les modalités d’entrée et de sortie, qui varient d’un modèle à l’autre. Pour vérifier les modalités prises en charge par les modèles Meta Llama, consultez [Modèles de fondation pris en charge dans Amazon Bedrock](models-supported.md). Pour vérifier quelles fonctionnalités Amazon Bedrock sont prises en charge par les modèles Meta Llama, consultez [Modèles de fondation pris en charge dans Amazon Bedrock](models-supported.md). Pour vérifier dans quelles régions AWS les modèles Meta Llama sont disponibles, consultez [Modèles de fondation pris en charge dans Amazon Bedrock](models-supported.md).
Lorsque vous effectuez des appels d’inférence avec les modèles Meta Llama, vous incluez une invite pour le modèle. Pour plus d’informations générales sur la création d’invites pour les modèles pris en charge par Amazon Bedrock, consultez [Concepts d’ingénierie de requête](prompt-engineering-guidelines.md). Pour obtenir des informations sur les invites spécifiques à Meta Llama, consultez le [guide d’ingénierie de requête MetaLlama](https://ai.meta.com/llama/get-started/#prompting).
**Note**
Les modèles Llama 3.2 Instruct et Llama 3.3 Instruct utilisent le géorepérage. Cela signifie que ces modèles ne peuvent pas être utilisés en dehors des régions AWS disponibles pour les modèles répertoriés dans le tableau des régions.
Cette section fournit des informations sur l’utilisation des modèles suivants de Meta.
+ Llama 3 Instruct
+ Llama 3.1 Instruct
+ Llama 3.2 Instruct
+ Llama 3.3 Instruct
+ Llama 4 Instruct
**Topics**
+ [Demande et réponse](#model-parameters-meta-request-response)
+ [Exemple de code](#api-inference-examples-meta-llama)
## Demande et réponse
Le corps de la demande est transmis dans le champ `body` d’une demande adressée à [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).
**Note**
Vous ne pouvez pas utiliser les opérations [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) ou [ConverseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ConverseStream.html) (streaming) avec Llama 4 Instruct.
------
#### [ Request ]
Les modèles Llama 3 Instruct, Llama 3.1 Instruct, Llama 3.2 Instruct et Llama 4 Instruct possèdent les paramètres d’inférence suivants :
```
{
"prompt": string,
"temperature": float,
"top_p": float,
"max_gen_len": int
}
```
REMARQUE : Llama 3.2 et les modèles ultérieurs ajoutent `images` à la structure de requête, qui est une liste de chaînes. Exemple : `images: Optional[List[str]]`
Les paramètres suivants sont obligatoires :
+ **prompt** : (obligatoire) invite que vous souhaitez transmettre au modèle. Pour des résultats optimaux, formatez la conversation à l’aide du modèle suivant.
```
<|begin_of_text|><|start_header_id|>user<|end_header_id|>
What can you help me with?<|eot_id|><|start_header_id|>assistant<|end_header_id|>
```
**Exemple de modèle avec invite système**
Voici un exemple d’invite qui inclut une invite système.
```
<|begin_of_text|><|start_header_id|>system<|end_header_id|>
You are a helpful AI assistant for travel tips and recommendations<|eot_id|><|start_header_id|>user<|end_header_id|>
What can you help me with?<|eot_id|><|start_header_id|>assistant<|end_header_id|>
```
**Exemple de conversation complexe**
Voici un exemple d’invite d’une conversation complexe.
```
<|begin_of_text|><|start_header_id|>user<|end_header_id|>
What is the capital of France?<|eot_id|><|start_header_id|>assistant<|end_header_id|>
The capital of France is Paris!<|eot_id|><|start_header_id|>user<|end_header_id|>
What is the weather like in Paris?<|eot_id|><|start_header_id|>assistant<|end_header_id|>
```
**Exemple de modèle avec invite système**
Pour plus d’informations, consultez [Meta Llama 3](https://llama.meta.com/docs/model-cards-and-prompt-formats/meta-llama-3).
Les paramètres suivants sont facultatifs :
+ **temperature** : utilisez une valeur inférieure pour réduire le caractère aléatoire de la réponse.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-meta.html)
+ **top\$1p** : utilisez une valeur inférieure pour ignorer les options les moins probables. Réglez cette option sur 0 ou 1,0 pour la désactiver.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-meta.html)
+ **max\$1gen\$1len** : spécifiez le nombre maximum de jetons à utiliser dans la réponse générée. Le modèle tronque la réponse une fois que le texte généré dépasse `max_gen_len`.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-meta.html)
------
#### [ Response ]
Les modèles Llama 3 Instruct renvoient les champs suivants pour un appel d’inférence de complétion de texte.
```
{
"generation": "\n\n",
"prompt_token_count": int,
"generation_token_count": int,
"stop_reason" : string
}
```
Vous trouverez plus d'informations sur chaque champ ci-dessous.
+ **generation** : texte généré.
+ **prompt\$1token\$1count** : nombre de jetons figurant dans l’invite.
+ **generation\$1token\$1count** : nombre de jetons dans le texte généré.
+ **stop\$1reason** : raison pour laquelle la réponse a cessé de générer du texte. Les valeurs possibles sont :
+ **arrêt** : le modèle a fini de générer le texte pour l’invite d’entrée.
+ **longueur** : la longueur des jetons pour le texte généré dépasse la valeur de `max_gen_len` dans l’appel `InvokeModel` (`InvokeModelWithResponseStream`, si vous diffusez une sortie). La réponse est tronquée en fonction du nombre de jetons défini dans `max_gen_len`. Envisagez d’augmenter la valeur de `max_gen_len` et de réessayer.
------
## Exemple de code
Cet exemple montre comment appeler le modèle *Llama 3 Instruct*.
```
# Use the native inference API to send a text message to Meta Llama 3.
import boto3
import json
from botocore.exceptions import ClientError
# Create a Bedrock Runtime client in the Région AWS of your choice.
client = boto3.client("bedrock-runtime", region_name="us-west-2")
# Set the model ID, e.g., Llama 3 70b Instruct.
model_id = "meta.llama3-70b-instruct-v1:0"
# Define the prompt for the model.
prompt = "Describe the purpose of a 'hello world' program in one line."
# Embed the prompt in Llama 3's instruction format.
formatted_prompt = f"""
<|begin_of_text|><|start_header_id|>user<|end_header_id|>
{prompt}
<|eot_id|>
<|start_header_id|>assistant<|end_header_id|>
"""
# Format the request payload using the model's native structure.
native_request = {
"prompt": formatted_prompt,
"max_gen_len": 512,
"temperature": 0.5,
}
# Convert the native request to JSON.
request = json.dumps(native_request)
try:
# Invoke the model with the request.
response = client.invoke_model(modelId=model_id, body=request)
except (ClientError, Exception) as e:
print(f"ERROR: Can't invoke '{model_id}'. Reason: {e}")
exit(1)
# Decode the response body.
model_response = json.loads(response["body"].read())
# Extract and print the response text.
response_text = model_response["generation"]
print(response_text)
```
Cet exemple montre comment contrôler la durée de la génération à l’aide des modèles Llama 3 Instruct. Pour obtenir des réponses ou des résumés détaillés, ajustez `max\$1gen\$1len` et incluez des instructions spécifiques dans votre invite.
# Modèles Mistral AI
Cette section décrit les paramètres de demande et les champs de réponse pour les modèles Mistral AI. Utilisez ces informations pour effectuer des appels d’inférence aux modèles Mistral AI à l’aide des opérations [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) et [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) (streaming). Cette section inclut également des exemples de code Python qui montrent comment appeler les modèles Mistral AI. Pour utiliser un modèle dans une opération d’inférence, vous avez besoin de l’ID du modèle. Pour obtenir l’ID du modèle, consultez [Modèles de fondation pris en charge dans Amazon Bedrock](models-supported.md). Certains modèles fonctionnent également avec l’[API Converse](conversation-inference.md). Pour vérifier si l’API Converse prend en charge un modèle Mistral AI spécifique, consultez [Modèles et fonctionnalités des modèles pris en charge](conversation-inference-supported-models-features.md). Pour plus d’exemples de code, consultez [Exemples de code pour Amazon Bedrock utilisant AWS SDKs](service_code_examples.md).
Les modèles de fondation d’Amazon Bedrock prennent en charge les modalités d’entrée et de sortie, qui varient d’un modèle à l’autre. Pour vérifier les modalités prises en charge par les modèles Mistral AI, consultez [Modèles de fondation pris en charge dans Amazon Bedrock](models-supported.md). Pour vérifier quelles fonctionnalités Amazon Bedrock sont prises en charge par les modèles Mistral AI, consultez [Modèles de fondation pris en charge dans Amazon Bedrock](models-supported.md). Pour vérifier dans quelles régions AWS les modèles Mistral AI sont disponibles, consultez [Modèles de fondation pris en charge dans Amazon Bedrock](models-supported.md).
Lorsque vous effectuez des appels d’inférence avec les modèles Mistral AI, vous incluez une invite pour le modèle. Pour plus d’informations générales sur la création d’invites pour les modèles pris en charge par Amazon Bedrock, consultez [Concepts d’ingénierie de requête](prompt-engineering-guidelines.md). Pour obtenir des informations sur les invites spécifiques Mistral AI, consultez le [guide d’ingénierie de requête Mistral AI](https://docs.mistral.ai/guides/prompting_capabilities/).
**Topics**
+ [Complétion de texte Mistral AI](model-parameters-mistral-text-completion.md)
+ [Achèvement de discussion Mistral AI](model-parameters-mistral-chat-completion.md)
+ [Paramètres et inférence de Mistral AI Large (24.07)](model-parameters-mistral-large-2407.md)
+ [Paramètres et inférence Pixtral Large (25.02)](model-parameters-mistral-pixtral-large.md)
# Complétion de texte Mistral AI
L’API de complétion de texte Mistral AI vous permet de générer du texte à l’aide d’un modèle Mistral AI.
Vous effectuez des demandes d’inférence aux modèles Mistral AI avec [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) (streaming).
Les modèles Mistral AI sont disponibles sous la [licence Apache 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt). Pour plus d’informations sur l’utilisation des modèles Mistral AI, consultez la [documentation Mistral AI](https://docs.mistral.ai/).
**Topics**
+ [Modèles pris en charge](#mistral--text-completion-supported-models)
+ [Demande et réponse](#model-parameters-mistral-text-completion-request-response)
+ [Exemple de code](#api-inference-examples-mistral-text-completion)
## Modèles pris en charge
Vous pouvez utiliser les modèles Mistral AI suivants.
+ Mistral 7B Instruct
+ Mixtral 8X7B Instruct
+ Mistral Large
+ Mistral Small
Vous avez besoin de l’ID du modèle que vous voulez utiliser. Pour obtenir l’ID du modèle, consultez [Modèles de fondation pris en charge dans Amazon Bedrock](models-supported.md).
## Demande et réponse
------
#### [ Request ]
Les modèles Mistral AI ont les paramètres d’inférence suivants.
```
{
"prompt": string,
"max_tokens" : int,
"stop" : [string],
"temperature": float,
"top_p": float,
"top_k": int
}
```
Les paramètres suivants sont obligatoires.
+ **prompt** : (obligatoire) invite que vous souhaitez transmettre au modèle, comme illustré dans l’exemple suivant.
```
[INST] What is your favourite condiment? [/INST]
```
L’exemple suivant montre comment mettre en forme une invite complexe.
```
[INST] What is your favourite condiment? [/INST]
Well, I'm quite partial to a good squeeze of fresh lemon juice.
It adds just the right amount of zesty flavour to whatever I'm cooking up in the kitchen!
[INST] Do you have mayonnaise recipes? [/INST]
```
Le texte du rôle d’utilisateur se trouve à l’intérieur des jetons `[INST]...[/INST]`, le texte situé en dehors est le rôle d’assistant. Le début et la fin d’une chaîne sont représentés par les jetons `` (début de chaîne) et `` (fin de chaîne). Pour plus d’informations sur l’envoi d’une invite de discussion dans le format correct, consultez [Modèle de discussion](https://docs.mistral.ai/models/#chat-template) dans la documentation Mistral AI.
Les paramètres suivants sont facultatifs.
+ **max\$1tokens** : spécifiez le nombre maximum de jetons à utiliser dans la réponse générée. Le modèle tronque la réponse une fois que le texte généré dépasse `max_tokens`.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-mistral-text-completion.html)
+ **stop** : liste de séquences d’arrêt qui, si elles sont générées par le modèle, empêchent le modèle de générer d’autres sorties.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-mistral-text-completion.html)
+ **temperature** : contrôle le caractère aléatoire des prédictions faites par le modèle. Pour plus d’informations, consultez [Génération de réponse d’influence à l’aide de paramètres d’inférence](inference-parameters.md).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-mistral-text-completion.html)
+ **top\$1p** : contrôle la diversité du texte généré par le modèle en définissant le pourcentage de candidats les plus probables que le modèle prend en compte pour le jeton suivant. Pour plus d’informations, consultez [Génération de réponse d’influence à l’aide de paramètres d’inférence](inference-parameters.md).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-mistral-text-completion.html)
+ **top\$1k** : contrôle le nombre de candidats les plus probables que le modèle prend en compte pour le jeton suivant. Pour plus d’informations, consultez [Génération de réponse d’influence à l’aide de paramètres d’inférence](inference-parameters.md).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-mistral-text-completion.html)
------
#### [ Response ]
Voici la réponse `body` d’un appel `InvokeModel` :
```
{
"outputs": [
{
"text": string,
"stop_reason": string
}
]
}
```
La réponse `body` inclut les champs suivants :
+ **outputs** : liste des sorties du modèle. Chaque sortie contient les champs suivants.
+ **text** : le texte généré par le modèle.
+ **stop\$1reason** : raison pour laquelle la réponse a cessé de générer du texte. Les valeurs possibles sont :
+ **arrêt** : le modèle a fini de générer le texte pour l’invite d’entrée. Le modèle s’arrête parce qu’il n’a plus de contenu à générer ou s’il génère l’une des séquences d’arrêt que vous définissez dans le paramètre de demande `stop`.
+ **longueur** : la longueur des jetons pour le texte généré dépasse la valeur de `max_tokens` dans l’appel `InvokeModel` (`InvokeModelWithResponseStream`, si vous diffusez une sortie). La réponse est tronquée en fonction du nombre de jetons défini dans `max_tokens`.
------
## Exemple de code
Cet exemple montre comment appeler le modèle Mistral 7B Instruct.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate text using a Mistral AI model.
"""
import json
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_text(model_id, body):
"""
Generate text using a Mistral AI model.
Args:
model_id (str): The model ID to use.
body (str) : The request body to use.
Returns:
JSON: The response from the model.
"""
logger.info("Generating text with Mistral AI model %s", model_id)
bedrock = boto3.client(service_name='bedrock-runtime')
response = bedrock.invoke_model(
body=body,
modelId=model_id
)
logger.info("Successfully generated text with Mistral AI model %s", model_id)
return response
def main():
"""
Entrypoint for Mistral AI example.
"""
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
try:
model_id = 'mistral.mistral-7b-instruct-v0:2'
prompt = """[INST] In Bash, how do I list all text files in the current directory
(excluding subdirectories) that have been modified in the last month? [/INST]"""
body = json.dumps({
"prompt": prompt,
"max_tokens": 400,
"temperature": 0.7,
"top_p": 0.7,
"top_k": 50
})
response = generate_text(model_id=model_id,
body=body)
response_body = json.loads(response.get('body').read())
outputs = response_body.get('outputs')
for index, output in enumerate(outputs):
print(f"Output {index + 1}\n----------")
print(f"Text:\n{output['text']}\n")
print(f"Stop reason: {output['stop_reason']}\n")
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 generating text with Mistral AI model {model_id}.")
if __name__ == "__main__":
main()
```
# Achèvement de discussion Mistral AI
L’API Mistral AI Chat completion vous permet de créer des applications conversationnelles.
**Astuce**
Vous pouvez utiliser l’API d’achèvement de conversation Mistral AI avec les opérations d’inférence de base ([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)). Toutefois, nous vous recommandons d’utiliser l’API Converse pour mettre en œuvre des messages dans votre application. L’API Converse fournit un ensemble unifié de paramètres qui fonctionnent sur tous les modèles prenant en charge les messages. Pour plus d’informations, consultez [Mener une conversation avec les opérations d’API Converse](conversation-inference.md).
Les modèles Mistral AI sont disponibles sous la [licence Apache 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt). Pour plus d’informations sur l’utilisation des modèles Mistral AI, consultez la [documentation Mistral AI](https://docs.mistral.ai/).
**Topics**
+ [Modèles pris en charge](#mistral-supported-models-chat-completion)
+ [Demande et réponse](#model-parameters-mistral-chat-completion-request-response)
## Modèles pris en charge
Vous pouvez utiliser les modèles Mistral AI suivants.
+ Mistral Large
Vous avez besoin de l’ID du modèle que vous voulez utiliser. Pour obtenir l’ID du modèle, consultez [Modèles de fondation pris en charge dans Amazon Bedrock](models-supported.md).
## Demande et réponse
------
#### [ Request ]
Les modèles Mistral AI ont les paramètres d’inférence suivants.
```
{
"messages": [
{
"role": "system"|"user"|"assistant",
"content": str
},
{
"role": "assistant",
"content": "",
"tool_calls": [
{
"id": str,
"function": {
"name": str,
"arguments": str
}
}
]
},
{
"role": "tool",
"tool_call_id": str,
"content": str
}
],
"tools": [
{
"type": "function",
"function": {
"name": str,
"description": str,
"parameters": dict
}
}
],
"tool_choice": "auto"|"any"|"none",
"max_tokens": int,
"top_p": float,
"temperature": float
}
```
Les paramètres suivants sont obligatoires.
+ **messages** : (obligatoire) les messages que vous souhaitez transmettre au modèle.
+ **role** : rôle du message. Les valeurs valides sont :
+ **system** : définit le comportement et le contexte du modèle dans la conversation.
+ **user** : message à envoyer au modèle.
+ **assistant** : réponse du modèle.
+ **content** : contenu du message.
```
[
{
"role": "user",
"content": "What is the most popular song on WZPZ?"
}
]
```
Pour transmettre le résultat d’un outil, utilisez le format JSON avec les champs suivants.
+ **role** : rôle du message. La valeur doit être `tool`.
+ **tool\$1call\$1id** : ID de la demande d’outil. Vous obtenez l’ID dans les champs de réponse `tool_calls` de la demande précédente.
+ **content** : résultat de l’outil.
L’exemple suivant illustre le résultat d’un outil qui obtient les chansons les plus populaires d’une station de radio.
```
{
"role": "tool",
"tool_call_id": "v6RMMiRlT7ygYkT4uULjtg",
"content": "{\"song\": \"Elemental Hotel\", \"artist\": \"8 Storey Hike\"}"
}
```
Les paramètres suivants sont facultatifs.
+ **outils** : définitions des outils que le modèle peut utiliser.
Si vous l’incluez `tools` dans votre demande, le modèle peut renvoyer un champ `tool_calls` dans le message qui représente l’utilisation de ces outils par le modèle. Vous pouvez ensuite exécuter ces outils à l’aide de l’entrée d’outil générée par le modèle, puis éventuellement renvoyer les résultats au modèle à l’aide de blocs de contenu `tool_result`.
L’exemple suivant concerne un outil qui obtient les chansons les plus populaires d’une station de radio.
```
[
{
"type": "function",
"function": {
"name": "top_song",
"description": "Get the most popular song played on a radio station.",
"parameters": {
"type": "object",
"properties": {
"sign": {
"type": "string",
"description": "The call sign for the radio station for which you want the most popular song. Example calls signs are WZPZ and WKRP."
}
},
"required": [
"sign"
]
}
}
}
]
```
+ **tool\$1choice** : spécifie comment les fonctions sont appelées. S’il est défini sur `none`, le modèle n’appellera pas de fonction et générera un message à la place. S’il est défini sur `auto`, le modèle peut choisir de générer un message ou d’appeler une fonction. S’il est défini sur `any`, le modèle est forcé d’appeler une fonction.
+ **max\$1tokens** : spécifiez le nombre maximum de jetons à utiliser dans la réponse générée. Le modèle tronque la réponse une fois que le texte généré dépasse `max_tokens`.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-mistral-chat-completion.html)
+ **temperature** : contrôle le caractère aléatoire des prédictions faites par le modèle. Pour plus d’informations, consultez [Génération de réponse d’influence à l’aide de paramètres d’inférence](inference-parameters.md).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-mistral-chat-completion.html)
+ **top\$1p** : contrôle la diversité du texte généré par le modèle en définissant le pourcentage de candidats les plus probables que le modèle prend en compte pour le jeton suivant. Pour plus d’informations, consultez [Génération de réponse d’influence à l’aide de paramètres d’inférence](inference-parameters.md).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-mistral-chat-completion.html)
------
#### [ Response ]
Voici la réponse `body` d’un appel `InvokeModel` :
```
{
"choices": [
{
"index": 0,
"message": {
"role": "assistant",
"content": str,
"tool_calls": [...]
},
"stop_reason": "stop"|"length"|"tool_calls"
}
]
}
```
La réponse `body` inclut les champs suivants :
+ **choices** : sortie du modèle.
+ **index** : index du message.
+ **message** : message du modèle.
+ **role** : rôle du message.
+ **content** : contenu du message.
+ **tool\$1calls** : si la valeur de `stop_reason` est `tool_calls`, ce champ contient une liste des demandes d’outils que le modèle souhaite que vous exécutiez.
+ **id** : ID de la demande d’outil.
+ **function** : fonction demandée par le modèle.
+ **name** : nom de la fonction.
+ **arguments** : arguments à transmettre à l’outil
Voici un exemple de demande pour un outil qui permet d’obtenir la meilleure chanson d’une station de radio.
```
[
{
"id": "v6RMMiRlT7ygYkT4uULjtg",
"function": {
"name": "top_song",
"arguments": "{\"sign\": \"WZPZ\"}"
}
}
]
```
+ **stop\$1reason** : raison pour laquelle la réponse a cessé de générer du texte. Les valeurs possibles sont :
+ **arrêt** : le modèle a fini de générer le texte pour l’invite d’entrée. Le modèle s’arrête parce qu’il n’a plus de contenu à générer ou s’il génère l’une des séquences d’arrêt que vous définissez dans le paramètre de demande `stop`.
+ **length** : la longueur des jetons pour le texte généré dépasse la valeur de `max_tokens`. La réponse est tronquée en fonction du nombre de jetons défini dans `max_tokens`.
+ **tool\$1calls** : le modèle vous demande d’exécuter un outil.
------
# Paramètres et inférence de Mistral AI Large (24.07)
L’API d’achèvement de conversation Mistral AI vous permet de créer des applications conversationnelles. Vous pouvez également utiliser l’API Converse Amazon Bedrock avec ce modèle. Vous pouvez utiliser des outils pour effectuer des appels de fonction.
**Astuce**
Vous pouvez utiliser l’API d’achèvement de conversation Mistral AI avec les opérations d’inférence de base ([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)). Toutefois, nous vous recommandons d’utiliser l’API Converse pour mettre en œuvre des messages dans votre application. L’API Converse fournit un ensemble unifié de paramètres qui fonctionnent sur tous les modèles prenant en charge les messages. Pour plus d’informations, consultez [Mener une conversation avec les opérations d’API Converse](conversation-inference.md).
Les modèles Mistral AI sont disponibles sous la [licence Apache 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt). Pour plus d’informations sur l’utilisation des modèles Mistral AI, consultez la [documentation Mistral AI](https://docs.mistral.ai/).
**Topics**
+ [Modèles pris en charge](#mistral-supported-models-chat-completion)
+ [Exemples de demandes et de réponses](#model-parameters-mistral-large-2407-request-response)
## Modèles pris en charge
Vous pouvez utiliser les modèles Mistral AI suivants avec les exemples de code présentés sur cette page.
+ Mistral Large 2 (24.07)
Vous avez besoin de l’ID du modèle que vous voulez utiliser. Pour obtenir l’ID du modèle, consultez [Modèles de fondation pris en charge dans Amazon Bedrock](models-supported.md).
## Exemples de demandes et de réponses
------
#### [ Request ]
Exemple de modèle d’invocation Mistral AI Large (24.07).
```
import boto3
import json
bedrock = session.client('bedrock-runtime', 'us-west-2')
response = bedrock.invoke_model(
modelId='mistral.mistral-large-2407-v1:0',
body=json.dumps({
'messages': [
{
'role': 'user',
'content': 'which llm are you?'
}
],
})
)
print(json.dumps(json.loads(response['body']), indent=4))
```
------
#### [ Converse ]
Exemple converse Mistral AI Large (24.07).
```
import boto3
import json
bedrock = session.client('bedrock-runtime', 'us-west-2')
response = bedrock.converse(
modelId='mistral.mistral-large-2407-v1:0',
messages=[
{
'role': 'user',
'content': [
{
'text': 'which llm are you?'
}
]
}
]
)
print(json.dumps(json.loads(response['body']), indent=4))
```
------
#### [ invoke\$1model\$1with\$1response\$1stream ]
Exemple invoke\$1model\$1with\$1response\$1stream Mistral AI Large (24.07).
```
import boto3
import json
bedrock = session.client('bedrock-runtime', 'us-west-2')
response = bedrock.invoke_model_with_response_stream(
"body": json.dumps({
"messages": [{"role": "user", "content": "What is the best French cheese?"}],
}),
"modelId":"mistral.mistral-large-2407-v1:0"
)
stream = response.get('body')
if stream:
for event in stream:
chunk=event.get('chunk')
if chunk:
chunk_obj=json.loads(chunk.get('bytes').decode())
print(chunk_obj)
```
------
#### [ converse\$1stream ]
Exemple converse\$1stream Mistral AI Large (24.07).
```
import boto3
import json
bedrock = session.client('bedrock-runtime', 'us-west-2')
mistral_params = {
"messages": [{
"role": "user","content": [{"text": "What is the best French cheese? "}]
}],
"modelId":"mistral.mistral-large-2407-v1:0",
}
response = bedrock.converse_stream(**mistral_params)
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")
```
------
#### [ JSON Output ]
Exemple de sortie JSON Mistral AI Large (24.07).
```
import boto3
import json
bedrock = session.client('bedrock-runtime', 'us-west-2')
mistral_params = {
"body": json.dumps({
"messages": [{"role": "user", "content": "What is the best French meal? Return the name and the ingredients in short JSON object."}]
}),
"modelId":"mistral.mistral-large-2407-v1:0",
}
response = bedrock.invoke_model(**mistral_params)
body = response.get('body').read().decode('utf-8')
print(json.loads(body))
```
------
#### [ Tooling ]
Exemple d’outils Mistral AI Large (24.07).
```
data = {
'transaction_id': ['T1001', 'T1002', 'T1003', 'T1004', 'T1005'],
'customer_id': ['C001', 'C002', 'C003', 'C002', 'C001'],
'payment_amount': [125.50, 89.99, 120.00, 54.30, 210.20],
'payment_date': ['2021-10-05', '2021-10-06', '2021-10-07', '2021-10-05', '2021-10-08'],
'payment_status': ['Paid', 'Unpaid', 'Paid', 'Paid', 'Pending']
}
# Create DataFrame
df = pd.DataFrame(data)
def retrieve_payment_status(df: data, transaction_id: str) -> str:
if transaction_id in df.transaction_id.values:
return json.dumps({'status': df[df.transaction_id == transaction_id].payment_status.item()})
return json.dumps({'error': 'transaction id not found.'})
def retrieve_payment_date(df: data, transaction_id: str) -> str:
if transaction_id in df.transaction_id.values:
return json.dumps({'date': df[df.transaction_id == transaction_id].payment_date.item()})
return json.dumps({'error': 'transaction id not found.'})
tools = [
{
"type": "function",
"function": {
"name": "retrieve_payment_status",
"description": "Get payment status of a transaction",
"parameters": {
"type": "object",
"properties": {
"transaction_id": {
"type": "string",
"description": "The transaction id.",
}
},
"required": ["transaction_id"],
},
},
},
{
"type": "function",
"function": {
"name": "retrieve_payment_date",
"description": "Get payment date of a transaction",
"parameters": {
"type": "object",
"properties": {
"transaction_id": {
"type": "string",
"description": "The transaction id.",
}
},
"required": ["transaction_id"],
},
},
}
]
names_to_functions = {
'retrieve_payment_status': functools.partial(retrieve_payment_status, df=df),
'retrieve_payment_date': functools.partial(retrieve_payment_date, df=df)
}
test_tool_input = "What's the status of my transaction T1001?"
message = [{"role": "user", "content": test_tool_input}]
def invoke_bedrock_mistral_tool():
mistral_params = {
"body": json.dumps({
"messages": message,
"tools": tools
}),
"modelId":"mistral.mistral-large-2407-v1:0",
}
response = bedrock.invoke_model(**mistral_params)
body = response.get('body').read().decode('utf-8')
body = json.loads(body)
choices = body.get("choices")
message.append(choices[0].get("message"))
tool_call = choices[0].get("message").get("tool_calls")[0]
function_name = tool_call.get("function").get("name")
function_params = json.loads(tool_call.get("function").get("arguments"))
print("\nfunction_name: ", function_name, "\nfunction_params: ", function_params)
function_result = names_to_functions[function_name](**function_params)
message.append({"role": "tool", "content": function_result, "tool_call_id":tool_call.get("id")})
new_mistral_params = {
"body": json.dumps({
"messages": message,
"tools": tools
}),
"modelId":"mistral.mistral-large-2407-v1:0",
}
response = bedrock.invoke_model(**new_mistral_params)
body = response.get('body').read().decode('utf-8')
body = json.loads(body)
print(body)
invoke_bedrock_mistral_tool()
```
------
# Paramètres et inférence Pixtral Large (25.02)
Pixtral Large 25.02 est un modèle multimodal à paramètres 124 B qui associe la compréhension de state-of-the-art l'image à de puissantes capacités de traitement de texte. AWS est le premier fournisseur de cloud à proposer Pixtral Large (25.02) en tant que modèle sans serveur entièrement géré. Ce modèle fournit des performances de pointe lors des tâches d’analyse de documents, d’interprétation de graphiques et de compréhension naturelle des images, tout en conservant les fonctionnalités de texte avancées de Mistral Large 2.
Avec une fenêtre contextuelle de 128 000 pixels, Pixtral Large 25.02 atteint des best-in-class performances sur des tests clés tels que DocVQA MathVista et. VQAv2 Le modèle offre un support multilingue complet dans de nombreuses langues et est entraîné sur plus de 80 langages de programmation. Les principales fonctionnalités incluent le raisonnement mathématique avancé, l’appel de fonctions natives, la sortie JSON et une solide adhésion au contexte pour les applications RAG.
L’API d’achèvement de conversation Mistral AI vous permet de créer des applications conversationnelles. Vous pouvez également utiliser l’API Converse Amazon Bedrock avec ce modèle. Vous pouvez utiliser des outils pour effectuer des appels de fonction.
**Astuce**
Vous pouvez utiliser l'API de fin de Mistral AI chat avec les opérations d'inférence de base ([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)). Toutefois, nous vous recommandons d’utiliser l’API Converse pour mettre en œuvre des messages dans votre application. L’API Converse fournit un ensemble unifié de paramètres qui fonctionnent sur tous les modèles prenant en charge les messages. Pour plus d’informations, consultez [Mener une conversation avec les opérations d’API Converse](conversation-inference.md).
Le modèle Mistral AI Pixtral Large est disponible sous la [licence Mistral Research](https://mistral.ai/licenses/MRL-0.1.md). Pour plus d’informations sur l’utilisation des modèles Mistral AI, consultez la [documentation Mistral AI](https://docs.mistral.ai/).
**Topics**
+ [Modèles pris en charge](#mistral-supported-models-chat-completion)
+ [Exemples de demandes et de réponses](#model-parameters-pixtral-large-2502-request-response)
## Modèles pris en charge
Vous pouvez utiliser les modèles Mistral AI suivants avec les exemples de code présentés sur cette page.
+ Pixtral Large (25.02)
Vous avez besoin de l’ID du modèle que vous voulez utiliser. Pour obtenir l’ID du modèle, consultez [Modèles de fondation pris en charge dans Amazon Bedrock](models-supported.md).
## Exemples de demandes et de réponses
------
#### [ Request ]
Exemple de modèle d’invocation Pixtral Large (25.02).
```
import boto3
import json
import base64
input_image = "image.png"
with open(input_image, "rb") as f:
image = f.read()
image_bytes = base64.b64encode(image).decode("utf-8")
bedrock = boto3.client(
service_name='bedrock-runtime',
region_name="us-east-1")
request_body = {
"messages" : [
{
"role" : "user",
"content" : [
{
"text": "Describe this picture:",
"type": "text"
},
{
"type" : "image_url",
"image_url" : {
"url" : f"data:image/png;base64,{image_bytes}"
}
}
]
}
],
"max_tokens" : 10
}
response = bedrock.invoke_model(
modelId='us.mistral.pixtral-large-2502-v1:0',
body=json.dumps(request_body)
)
print(json.dumps(json.loads(response.get('body').read()), indent=4))
```
------
#### [ Converse ]
Exemple Converse Pixtral Large (25.02).
```
import boto3
import json
import base64
input_image = "image.png"
with open(input_image, "rb") as f:
image_bytes = f.read()
bedrock = boto3.client(
service_name='bedrock-runtime',
region_name="us-east-1")
messages =[
{
"role" : "user",
"content" : [
{
"text": "Describe this picture:"
},
{
"image": {
"format": "png",
"source": {
"bytes": image_bytes
}
}
}
]
}
]
response = bedrock.converse(
modelId='mistral.pixtral-large-2502-v1:0',
messages=messages
)
print(json.dumps(response.get('output'), indent=4))
```
------
#### [ invoke\$1model\$1with\$1response\$1stream ]
Exemple invoke\$1model\$1with\$1response\$1stream Pixtral Large (25.02).
```
import boto3
import json
import base64
input_image = "image.png"
with open(input_image, "rb") as f:
image = f.read()
image_bytes = base64.b64encode(image).decode("utf-8")
bedrock = boto3.client(
service_name='bedrock-runtime',
region_name="us-east-1")
request_body = {
"messages" : [
{
"role" : "user",
"content" : [
{
"text": "Describe this picture:",
"type": "text"
},
{
"type" : "image_url",
"image_url" : {
"url" : f"data:image/png;base64,{image_bytes}"
}
}
]
}
],
"max_tokens" : 10
}
response = bedrock.invoke_model_with_response_stream(
modelId='us.mistral.pixtral-large-2502-v1:0',
body=json.dumps(request_body)
)
stream = response.get('body')
if stream:
for event in stream:
chunk=event.get('chunk')
if chunk:
chunk_obj=json.loads(chunk.get('bytes').decode())
print(chunk_obj)
```
------
#### [ converse\$1stream ]
Exemple converse\$1stream Pixtral Large (25.02).
```
import boto3
import json
import base64
input_image = "image.png"
with open(input_image, "rb") as f:
image_bytes = f.read()
bedrock = boto3.client(
service_name='bedrock-runtime',
region_name="us-east-1")
messages =[
{
"role" : "user",
"content" : [
{
"text": "Describe this picture:"
},
{
"image": {
"format": "png",
"source": {
"bytes": image_bytes
}
}
}
]
}
]
response = bedrock.converse_stream(
modelId='mistral.pixtral-large-2502-v1:0',
messages=messages
)
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")
```
------
#### [ JSON Output ]
Exemple de sortie JSON Pixtral Large (25.02).
```
import boto3
import json
bedrock = session.client('bedrock-runtime', 'us-west-2')
mistral_params = {
"body": json.dumps({
"messages": [{"role": "user", "content": "What is the best French meal? Return the name and the ingredients in short JSON object."}]
}),
"modelId":"us.mistral.pixtral-large-2502-v1:0",
}
response = bedrock.invoke_model(**mistral_params)
body = response.get('body').read().decode('utf-8')
print(json.loads(body))
```
------
#### [ Tooling ]
Exemple d’outils Pixtral Large (25.02).
```
data = {
'transaction_id': ['T1001', 'T1002', 'T1003', 'T1004', 'T1005'],
'customer_id': ['C001', 'C002', 'C003', 'C002', 'C001'],
'payment_amount': [125.50, 89.99, 120.00, 54.30, 210.20],
'payment_date': ['2021-10-05', '2021-10-06', '2021-10-07', '2021-10-05', '2021-10-08'],
'payment_status': ['Paid', 'Unpaid', 'Paid', 'Paid', 'Pending']
}
# Create DataFrame
df = pd.DataFrame(data)
def retrieve_payment_status(df: data, transaction_id: str) -> str:
if transaction_id in df.transaction_id.values:
return json.dumps({'status': df[df.transaction_id == transaction_id].payment_status.item()})
return json.dumps({'error': 'transaction id not found.'})
def retrieve_payment_date(df: data, transaction_id: str) -> str:
if transaction_id in df.transaction_id.values:
return json.dumps({'date': df[df.transaction_id == transaction_id].payment_date.item()})
return json.dumps({'error': 'transaction id not found.'})
tools = [
{
"type": "function",
"function": {
"name": "retrieve_payment_status",
"description": "Get payment status of a transaction",
"parameters": {
"type": "object",
"properties": {
"transaction_id": {
"type": "string",
"description": "The transaction id.",
}
},
"required": ["transaction_id"],
},
},
},
{
"type": "function",
"function": {
"name": "retrieve_payment_date",
"description": "Get payment date of a transaction",
"parameters": {
"type": "object",
"properties": {
"transaction_id": {
"type": "string",
"description": "The transaction id.",
}
},
"required": ["transaction_id"],
},
},
}
]
names_to_functions = {
'retrieve_payment_status': functools.partial(retrieve_payment_status, df=df),
'retrieve_payment_date': functools.partial(retrieve_payment_date, df=df)
}
test_tool_input = "What's the status of my transaction T1001?"
message = [{"role": "user", "content": test_tool_input}]
def invoke_bedrock_mistral_tool():
mistral_params = {
"body": json.dumps({
"messages": message,
"tools": tools
}),
"modelId":"us.mistral.pixtral-large-2502-v1:0",
}
response = bedrock.invoke_model(**mistral_params)
body = response.get('body').read().decode('utf-8')
body = json.loads(body)
choices = body.get("choices")
message.append(choices[0].get("message"))
tool_call = choices[0].get("message").get("tool_calls")[0]
function_name = tool_call.get("function").get("name")
function_params = json.loads(tool_call.get("function").get("arguments"))
print("\nfunction_name: ", function_name, "\nfunction_params: ", function_params)
function_result = names_to_functions[function_name](**function_params)
message.append({"role": "tool", "content": function_result, "tool_call_id":tool_call.get("id")})
new_mistral_params = {
"body": json.dumps({
"messages": message,
"tools": tools
}),
"modelId":"us.mistral.pixtral-large-2502-v1:0",
}
response = bedrock.invoke_model(**new_mistral_params)
body = response.get('body').read().decode('utf-8')
body = json.loads(body)
print(body)
invoke_bedrock_mistral_tool()
```
------
# Modèles OpenAI
OpenAI propose les modèles à pondération ouverte suivants :
+ [https://huggingface.co/openai/gpt-oss-20b](https://huggingface.co/openai/gpt-oss-20b) : modèle plus petit optimisé pour une latence plus faible et des cas d’utilisation locaux ou spécialisés.
+ [https://huggingface.co/openai/gpt-oss-120b](https://huggingface.co/openai/gpt-oss-120b) : modèle plus grand optimisé pour la production et les cas d’utilisation à usage général ou exigeant un raisonnement poussé.
Le tableau suivant résume les informations sur les modèles :
| Informations | gpt-oss-20b | gpt-oss-120b |
| --- | --- | --- |
| Date de publication | 5 août 2025 | 5 août 2025 |
| ID du modèle | openai.gpt-oss-20b-1:0 | openai.gpt-oss-120b-1:0 |
| ID produit | N/A | N/A |
| Modalités d’entrée prises en charge | Texte | Texte |
| Modalités de sortie prises en charge | Texte | Texte |
| Fenêtre contextuelle | 128 000 | 128 000 |
Les modèles OpenAI prennent en charge les fonctionnalités suivantes :
+ [Modèle d’invocation](inference.md) avec les opérations suivantes :
+ [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)
+ [Converse](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html)
+ [API OpenAI Chat completions](inference-chat-completions.md)
+ [Inférence par lots](batch-inference.md) avec [CreateModelInvocationJob](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_CreateModelInvocationJob.html).
+ Application d’une [barrière de protection](guardrails.md) via l’utilisation d’en-têtes dans les opérations d’invocation du modèle.
**Topics**
+ [Corps de la demande OpenAI](#model-parameters-openai-request)
+ [Corps de la réponse OpenAI](#model-parameters-openai-response)
+ [Exemple d’utilisation de modèles OpenAI](#model-parameters-openai-use)
## Corps de la demande OpenAI
Pour plus d’informations sur les paramètres du corps de la demande et leurs descriptions, consultez [Create chat completion](https://platform.openai.com/docs/api-reference/chat/create) dans la documentation OpenAI.
Utilisez les champs du corps de a demande de l’une des façons suivantes :
+ Dans une demande [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)ou dans OpenAI Chat Completions, incluez les champs dans le corps de la demande.
+ Dans une demande [Converse](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html), procédez comme suit :
+ Mappez les `messages` comme suit :
+ Pour chaque message dont le rôle est`developer`, ajoutez le `content` a [SystemContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_SystemContentBlock.html)dans le `system` tableau.
+ Pour chaque message dont le rôle est `user` ou`assistant`, ajoutez le `content` à a [ContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ContentBlock.html)dans le `content` champ et spécifiez le `role` dans le `role` champ d'un [message](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Message.html) dans le `messages` tableau.
+ Mappez les valeurs des champs suivants aux champs correspondants de l’objet `inferenceConfig` :
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-openai.html)
+ Incluez tout autre champ dans l’objet `additionalModelRequestFields`.
**Considérations lors de la construction du corps de la demande**
+ Les modèles OpenAI ne prennent en charge que l’entrée et la sortie de texte.
+ La valeur du champ `model` doit correspondre à celle de l’en-tête. Vous pouvez omettre ce champ pour qu’il soit automatiquement rempli avec la même valeur que l’en-tête.
+ La valeur du champ `stream` doit correspondre à l’opération d’API que vous utilisez. Vous pouvez omettre ce champ pour qu’il soit automatiquement renseigné avec la valeur correcte.
+ Si vous utilisez [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html), la `stream` valeur doit être`false`.
## Corps de la réponse OpenAI
Le corps de réponse pour les modèles OpenAI est conforme à l’objet d’achèvement de discussion renvoyé par OpenAI. Pour plus d’informations sur les champs de réponse, consultez [The chat completion object](https://platform.openai.com/docs/api-reference/chat/object) dans la documentation OpenAI.
**Note**
Si vous utilisez `InvokeModel`, le raisonnement du modèle, entouré de balises ``, précède le contenu textuel de la réponse.
## Exemple d’utilisation de modèles OpenAI
Cette section fournit quelques exemples sur l’utilisation des modèles OpenAI.
### Conditions préalables
Avant d’essayer ces exemples, vérifiez que vous avez rempli les conditions préalables :
+ **Authentification** — Vous pouvez vous authentifier avec vos AWS informations d'identification ou avec une clé d'API Amazon Bedrock.
Configurez vos AWS informations d'identification ou générez une clé d'API Amazon Bedrock pour authentifier votre demande.
+ Pour en savoir plus sur la configuration de vos AWS informations d'identification, consultez la section [Accès par programmation avec informations d'identification AWS de sécurité](https://docs.aws.amazon.com/IAM/latest/UserGuide/security-creds-programmatic-access.html).
+ Pour en savoir plus sur les clés d'API Amazon Bedrock et sur la façon de les générer, consultez la section Clés d'API du chapitre Build.
**Note**
Si vous utilisez l’API OpenAI Chat completions, vous ne pouvez vous authentifier qu’avec une clé d’API Amazon Bedrock.
+ Point de **terminaison** : recherchez le point de terminaison correspondant à la AWS région à utiliser dans les [points de terminaison et les quotas Amazon Bedrock Runtime](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#br-rt). Si vous utilisez un AWS SDK, il se peut que vous deviez uniquement spécifier le code de région et non le point de terminaison complet lors de la configuration du client. Vous devez utiliser un point de terminaison associé à une région prise en charge par le modèle utilisé dans l’exemple.
+ **Accès au modèle** : demande l’accès à un modèle OpenAI. Pour de plus amples informations, veuillez consulter [Gérez l'accès aux modèles à l'aide du SDK et de la CLI](model-access.md#model-access-modify).
+ **(Si l'exemple utilise un SDK) Installez le SDK : après l'**installation, configurez les informations d'identification par défaut et une région par défaut AWS . Si vous ne configurez pas d’informations d’identification par défaut ou de région, vous devrez les spécifier explicitement dans les exemples de code pertinents. Pour plus d'informations sur les fournisseurs d'informations d'identification standardisées, voir [AWS SDKs et Outils fournisseurs d'informations d'identification standardisés](https://docs.aws.amazon.com/sdkref/latest/guide/standardized-credentials.html).
**Note**
Si vous utilisez le kit OpenAI SDK, vous ne pouvez vous authentifier qu’avec une clé d’API Amazon Bedrock et vous devez définir explicitement le point de terminaison Amazon Bedrock.
Développez la section correspondant à l’exemple que vous souhaitez voir :
### OpenAI Create chat completion
Pour voir des exemples d’utilisation de l’API OpenAI Create chat completion, choisissez l’onglet correspondant à votre méthode préférée, puis suivez les étapes :
------
#### [ OpenAI SDK (Python) ]
Le script Python suivant appelle l’API Create chat completion avec le kit SDK OpenAI Python :
```
from openai import OpenAI
client = OpenAI(
base_url="https://bedrock-runtime.us-west-2.amazonaws.com/openai/v1",
api_key="$AWS_BEARER_TOKEN_BEDROCK" # Replace with actual API key
)
completion = client.chat.completions.create(
model="openai.gpt-oss-20b-1:0",
messages=[
{
"role": "developer",
"content": "You are a helpful assistant."
},
{
"role": "user",
"content": "Hello!"
}
]
)
print(completion.choices[0].message)
```
------
#### [ HTTP request using curl ]
Vous pouvez exécuter la commande suivante dans un terminal pour appeler l’API Create chat completion à l’aide de curl :
```
curl -X POST https://bedrock-runtime.us-west-2.amazonaws.com/openai/v1/chat/completions \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $AWS_BEARER_TOKEN_BEDROCK" \
-d '{
"model": "openai.gpt-oss-20b-1:0",
"messages": [
{
"role": "developer",
"content": "You are a helpful assistant."
},
{
"role": "user",
"content": "Hello!"
}
]
}'
```
------
### InvokeModel
Choisissez l’onglet correspondant à votre méthode préférée, puis suivez les étapes :
------
#### [ Python ]
```
import boto3
import json
# Initialize the Bedrock Runtime client
client = boto3.client('bedrock-runtime')
# Model ID
model_id = 'openai.gpt-oss-20b-1:0'
# Create the request body
native_request = {
"model": model_id, # You can omit this field
"messages": [
{
"role": "system",
"content": "You are a helpful assistant."
},
{
"role": "assistant",
"content": "Hello! How can I help you today?"
},
{
"role": "user",
"content": "What is the weather like today?"
}
],
"max_completion_tokens": 150,
"temperature": 0.7,
"top_p": 0.9,
"stream": False # You can omit this field
}
# Make the InvokeModel request
response = client.invoke_model(
modelId=model_id,
body=json.dumps(native_request)
)
# Parse and print the message for each choice in the chat completion
response_body = json.loads(response['body'].read().decode('utf-8'))
for choice in response_body['choices']:
print(choice['message']['content'])
```
------
### Converse
Lorsque vous utilisez l’API [Converse](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html) unifiée, vous devez mapper les champs OpenAI Create chat completion au champ correspondant dans le corps de la demande Converse.
Par exemple, comparez le corps de demande d’achèvement de conversation suivant au corps de demande Converse correspondant :
------
#### [ Create chat completion request body ]
```
{
"model": "openai.gpt-oss-20b-1:0",
"messages": [
{
"role": "developer",
"content": "You are a helpful assistant."
},
{
"role": "assistant",
"content": "Hello! How can I help you today?"
},
{
"role": "user",
"content": "What is the weather like today?"
}
],
"max_completion_tokens": 150,
"temperature": 0.7
}
```
------
#### [ Converse request body ]
```
{
"messages": [
{
"role": "user",
"content": [
{
"text": "Hello! How can I help you today?"
}
]
},
{
"role": "user",
"content": [
{
"text": "What is the weather like today?"
}
]
}
],
"system": [
{
"text": "You are a helpful assistant."
}
],
"inferenceConfig": {
"maxTokens": 150,
"temperature": 0.7
}
}
```
------
Choisissez l’onglet correspondant à votre méthode préférée, puis suivez les étapes :
------
#### [ Python ]
```
# Use the Conversation API to send a text message to Anthropic Claude.
import boto3
from botocore.exceptions import ClientError
# Initialize the Bedrock Runtime client
client = boto3.client("bedrock-runtime")
# Set the model ID
model_id = "openai.gpt-oss-20b-1:0"
# Set up messages and system message
messages = [
{
"role": "assistant",
"content": [
{
"text": "Hello! How can I help you today?"
}
]
},
{
"role": "user",
"content": [
{
"text": "What is the weather like today?"
}
]
}
]
system = [
{
"text": "You are a helpful assistant."
}
]
try:
# Send the message to the model, using a basic inference configuration.
response = client.converse(
modelId=model_id,
messages=messages,
system=system,
inferenceConfig={
"maxTokens": 150,
"temperature": 0.7,
"topP": 0.9
},
)
# Extract and print the response text.
for content_block in response["output"]["message"]["content"]:
print(content_block)
except (ClientError, Exception) as e:
print(f"ERROR: Can't invoke '{model_id}'. Reason: {e}")
exit(1)
```
------
### Rambardes avec InvokeModel
Appliquez une barrière de protection lors de l’exécution de l’invocation du modèle en spécifiant l’ID et la version de la barrière de protection et en indiquant s’il faut activer ou non la trace de la barrière de protection dans l’en-tête d’une demande d’invocation de modèle.
Choisissez l’onglet correspondant à votre méthode préférée, puis suivez les étapes :
------
#### [ Python ]
```
import boto3
from botocore.exceptions import ClientError
import json
# Initiate the Amazon Bedrock Runtime client
bedrock_runtime = boto3.client("bedrock-runtime")
# Model ID
model_id = "openai.gpt-oss-20b-1:0"
# Replace with actual values from your guardrail
guardrail_id = "GR12345"
guardrail_version = "DRAFT"
# Create the request body
native_request = {
"model": model_id, # You can omit this field
"messages": [
{
"role": "system",
"content": "You are a helpful assistant."
},
{
"role": "assistant",
"content": "Hello! How can I help you today?"
},
{
"role": "user",
"content": "What is the weather like today?"
}
],
"max_completion_tokens": 150,
"temperature": 0.7,
"top_p": 0.9,
"stream": False # You can omit this field
}
try:
response = bedrock_runtime.invoke_model(
modelId=model_id,
body=json.dumps(native_request),
guardrailIdentifier=guardrail_id,
guardrailVersion=guardrail_version,
trace='ENABLED',
)
response_body = json.loads(response.get('body').read())
print("Received response from InvokeModel API (Request Id: {})".format(response['ResponseMetadata']['RequestId']))
print(json.dumps(response_body, indent=2))
except ClientError as err:
print("RequestId = " + err.response['ResponseMetadata']['RequestId'])
raise err
```
------
### Barrières de protection avec achèvements de conversation OpenAI
Pour voir des exemples d’utilisation de barrière de protection lors de l’achèvement d’une discussion OpenAI, choisissez l’onglet correspondant à votre méthode préférée, puis suivez les étapes :
------
#### [ OpenAI SDK (Python) ]
```
import openai
from openai import OpenAIError
# Endpoint for Amazon Bedrock Runtime
bedrock_endpoint = "https://bedrock-runtime.us-west-2.amazonaws.com/openai/v1"
# Model ID
model_id = "openai.gpt-oss-20b-1:0"
# Replace with actual values
bedrock_api_key = "$AWS_BEARER_TOKEN_BEDROCK"
guardrail_id = "GR12345"
guardrail_version = "DRAFT"
client = openai.OpenAI(
api_key=bedrock_api_key,
base_url=bedrock_endpoint,
)
try:
response = client.chat.completions.create(
model=model_id,
# Specify guardrail information in the header
extra_headers={
"X-Amzn-Bedrock-GuardrailIdentifier": guardrail_id,
"X-Amzn-Bedrock-GuardrailVersion": guardrail_version,
"X-Amzn-Bedrock-Trace": "ENABLED",
},
# Additional guardrail information can be specified in the body
extra_body={
"amazon-bedrock-guardrailConfig": {
"tagSuffix": "xyz" # Used for input tagging
}
},
messages=[
{
"role": "system",
"content": "You are a helpful assistant."
},
{
"role": "assistant",
"content": "Hello! How can I help you today?"
},
{
"role": "user",
"content": "What is the weather like today?"
}
]
)
request_id = response._request_id
print(f"Request ID: {request_id}")
print(response)
except OpenAIError as e:
print(f"An error occurred: {e}")
if hasattr(e, 'response') and e.response is not None:
request_id = e.response.headers.get("x-request-id")
print(f"Request ID: {request_id}")
```
------
#### [ OpenAI SDK (Java) ]
```
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.core.http.HttpResponseFor;
import com.openai.models.chat.completions.ChatCompletion;
import com.openai.models.chat.completions.ChatCompletionCreateParams;
// Endpoint for Amazon Bedrock Runtime
String bedrockEndpoint = "http://bedrock-runtime.us-west-2.amazonaws.com/openai/v1"
// Model ID
String modelId = "openai.gpt-oss-20b-1:0"
// Replace with actual values
String bedrockApiKey = "$AWS_BEARER_TOKEN_BEDROCK"
String guardrailId = "GR12345"
String guardrailVersion = "DRAFT"
OpenAIClient client = OpenAIOkHttpClient.builder()
.apiKey(bedrockApiKey)
.baseUrl(bedrockEndpoint)
.build()
ChatCompletionCreateParams request = ChatCompletionCreateParams.builder()
.addUserMessage("What is the temperature in Seattle?")
.model(modelId)
// Specify additional headers for the guardrail
.putAdditionalHeader("X-Amzn-Bedrock-GuardrailIdentifier", guardrailId)
.putAdditionalHeader("X-Amzn-Bedrock-GuardrailVersion", guardrailVersion)
// Specify additional body parameters for the guardrail
.putAdditionalBodyProperty(
"amazon-bedrock-guardrailConfig",
JsonValue.from(Map.of("tagSuffix", JsonValue.of("xyz"))) // Allows input tagging
)
.build();
HttpResponseFor rawChatCompletionResponse =
client.chat().completions().withRawResponse().create(request);
final ChatCompletion chatCompletion = rawChatCompletionResponse.parse();
System.out.println(chatCompletion);
```
------
### Inférence par lots
[Inférence par lots](batch-inference.md) vous permet d’exécuter l’inférence de modèle de manière asynchrone à l’aide de plusieurs invites. Pour exécuter l’inférence par lots avec un modèle OpenAI, procédez comme suit :
1. Créez un fichier JSONL et remplissez-le avec au moins le nombre minimum d’objets JSON, séparés chacun par une nouvelle ligne. Chaque objet `modelInput` doit être conforme au format du corps de la demande [OpenAI create chat completion](https://platform.openai.com/docs/api-reference/chat/create). Voici un exemple des deux premières lignes d’un fichier JSONL contenant les corps de requête pour OpenAI.
```
{
"recordId": "RECORD1",
"modelInput": {
"messages": [
{
"role": "system",
"content": "You are a helpful assistant."
},
{
"role": "user",
"content": "Can you generate a question with a factual answer?"
}
],
"max_completion_tokens": 1000
}
}
{
"recordId": "RECORD2",
"modelInput": {
"messages": [
{
"role": "system",
"content": "You are a helpful assistant."
},
{
"role": "user",
"content": "What is the weather like today?"
}
],
"max_completion_tokens": 1000
}
}
...
```
**Note**
Le champ `model` est facultatif, car le service d’inférence par lots l’insérera pour vous en fonction de l’en-tête si vous l’omettez.
Vérifiez que votre fichier JSONL est conforme aux quotas d’inférence par lots, comme indiqué dans [Mise en forme et chargement des données d’inférence par lots](batch-inference-data.md).
1. Chargement du fichier image sur un compartiment Amazon S3.
1. Envoyez une [CreateModelInvocationJob](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_CreateModelInvocationJob.html)demande avec un point de [terminaison du plan de contrôle Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#br-cp) avec le compartiment S3 de l'étape précédente spécifiée dans le `inputDataConfig` champ et le OpenAI modèle spécifié dans le `modelId` champ.
Pour un exemple de end-to-end code, voir[Exemple de code pour l’inférence par lots](batch-inference-example.md). Remplacez par des configurations appropriées pour les modèles OpenAI.
# Modèles Stability AI
Cette section décrit les paramètres de demande et les champs de réponse pour les modèles Stability AI. Utilisez ces informations pour effectuer des appels d'inférence vers les modèles Stability AI avec l'[InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)opération. Cette section inclut également des exemples de code Python qui montrent comment appeler les modèles Stability AI. Pour utiliser un modèle dans une opération d’inférence, vous avez besoin de l’ID du modèle. Pour obtenir l’ID du modèle, consultez [Modèles de fondation pris en charge dans Amazon Bedrock](models-supported.md). Certains modèles fonctionnent également avec l’[API Converse](conversation-inference.md). Pour vérifier si l’API Converse prend en charge un modèle Stability AI spécifique, consultez [Modèles et fonctionnalités des modèles pris en charge](conversation-inference-supported-models-features.md). Pour plus d’exemples de code, consultez [Exemples de code pour Amazon Bedrock utilisant AWS SDKs](service_code_examples.md).
Les modèles de fondation d’Amazon Bedrock prennent en charge les modalités d’entrée et de sortie, qui varient d’un modèle à l’autre. Pour vérifier les modalités prises en charge par les modèles Stability AI, consultez [Modèles de fondation pris en charge dans Amazon Bedrock](models-supported.md). Pour vérifier quelles fonctionnalités Amazon Bedrock sont prises en charge par les modèles Stability AI, consultez [Modèles de fondation pris en charge dans Amazon Bedrock](models-supported.md). Pour vérifier AWS dans quelles régions les modèles Stability AI sont disponibles, consultez[Modèles de fondation pris en charge dans Amazon Bedrock](models-supported.md).
Lorsque vous effectuez des appels d’inférence avec les modèles Stability AI, vous incluez une invite pour le modèle. Pour plus d’informations générales sur la création d’invites pour les modèles pris en charge par Amazon Bedrock, consultez [Concepts d’ingénierie de requête](prompt-engineering-guidelines.md). Pour obtenir des informations sur les invites spécifiques à Stability AI, consultez le [Guide d’ingénierie de requête Stability AI](https://platform.stability.ai/docs/getting-started).
## Services d’imagerie et modèles pris en charge
Amazon Bedrock prend en charge les services d’imagerie et modèles Stability AI suivants.
**Note**
La prise en charge de tous les autres modèles Stability AI est sur le point de devenir obsolète.
| Modèle | Cas d’utilisation | Exemple |
| --- | --- | --- |
| [Stable Image Ultra](model-parameters-diffusion-stable-ultra-text-image-request-response.md) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-stability-diffusion.html) | Une marque de luxe utilise Stable Image Ultra pour créer des visuels époustouflants de sa dernière collection pour les magazines, garantissant ainsi une touche haut de gamme à la hauteur de ses normes élevées. |
| [Stable Diffusion 3.5 Large](model-parameters-diffusion-3-5-large.md) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-stability-diffusion.html) | Une équipe de développement de jeux utilise SD3 .5 Large pour créer des textures environnementales détaillées et des concepts de personnages, accélérant ainsi son pipeline créatif. |
| [Stable Image Core](model-parameters-diffusion-stable-image-core-text-image-request-response.md) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-stability-diffusion.html) | Un détaillant en ligne utilise Stable Image Core pour générer rapidement des images de produits pour les nouveaux arrivants, ce qui lui permet de répertorier les articles plus rapidement et de conserver son catalogue up-to-date. |
| [Services d’imagerie Stability AI](stable-image-services.md) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-stability-diffusion.html) | Une entreprise de médias utilise la recherche et la recoloration, le transfert de style et la suppression de l’arrière-plan pour générer des variations d’images pour une campagne publicitaire. |
**Topics**
+ [Services d’imagerie et modèles pris en charge](#supported-stability-models)
+ [Stable Image Ultra : demande et réponse](model-parameters-diffusion-stable-ultra-text-image-request-response.md)
+ [Stability.ai Stable Diffusion 3.5 Large](model-parameters-diffusion-3-5-large.md)
+ [Demande et réponse de Stable Image Core](model-parameters-diffusion-stable-image-core-text-image-request-response.md)
+ [Services d’imagerie Stability AI](stable-image-services.md)
# Stable Image Ultra : demande et réponse
Le corps de la demande est transmis dans le `body` champ d'une demande à une [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)opération.
**Modèle de champ du corps de la demande d'invocation**
Lorsque vous effectuez un InvokeModel appel à l'aide d'un modèle Stable Image Ultra, remplissez le champ body avec un objet JSON semblable à celui ci-dessous.
+ **prompt** : (chaîne) ce que vous souhaitez voir dans l’image de sortie. Une invite descriptive forte qui définit clairement les éléments, les couleurs et les sujets permettra d’obtenir de meilleurs résultats.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-diffusion-stable-ultra-text-image-request-response.html)
**Champ body des réponses à l’invocation du modèle**
Lorsque vous passez un appel `InvokeModel` à l’aide d’un modèle Stable Image Ultra, la réponse est similaire à la suivante :
```
{
'seeds': [2130420379],
"finish_reasons":[null],
"images":["..."]
}
```
Une réponse dont la raison finale n’est pas `null` ressemblera à ce qui suit :
```
{
"finish_reasons":["Filter reason: prompt"]
}
```
+ **seeds** : (chaîne) liste des amorces permettant de générer des images pour le modèle.
+ **finish\$1reasons** : Enum indiquant si la demande a été filtrée ou non. `null` indiquera que la demande a été acceptée. Valeurs possibles actuelles : `"Filter reason: prompt", "Filter reason: output image", "Filter reason: input image", "Inference error", null`.
+ **images** : liste des images générées au format de chaîne Base64.
Pour plus d'informations, consultez [https://platform.us.stability. ai/docs/api-reference\$1tag/v1génération](https://platform.us.stability.ai/docs/api-reference#tag/v1generation).
------
#### [ Text to image ]
Le modèle Stability.ai Stable Image Ultra possède les paramètres d'inférence suivants pour un appel d' text-to-imageinférence.
+ **prompt** : (chaîne) ce que vous souhaitez voir dans l’image de sortie. Une invite descriptive forte qui définit clairement les éléments, les couleurs et les sujets permettra d’obtenir de meilleurs résultats.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-diffusion-stable-ultra-text-image-request-response.html)
**Champs facultatifs**
+ **aspect\$1ratio** : (chaîne) contrôle les proportions de l’image générée. Ce paramètre n'est valide que pour les text-to-image demandes. Valeur par défaut : 1:1. Enum : 16:9, 1:1, 21:9, 2:3, 3:2, 4:5, 5:4, 9:16, 9:21.
+ **mode** — Réglé sur text-to-image. Par défaut : text-to-image. Énumération : `text-to-image`.
+ **output\$1format** : spécifie le format de l’image de sortie. Formats pris en charge : JPEG, PNG. Dimensions prises en charge : hauteur 640 à 1 536 pixels, largeur 640 à 1 536 pixels.
+ **seed** : (nombre) valeur spécifique utilisée pour indiquer le « caractère aléatoire » de la génération. (Omettez ce paramètre ou transmettez 0 pour utiliser une amorce aléatoire.) Plage de valeurs : de 0 à 4 294 967 295.
+ **negative\$1prompt** : mots clés indiquant ce que vous ne souhaitez pas voir dans l’image de sortie. Maximum : 10 000 caractères.
```
import boto3
import json
import base64
import io
from PIL import Image
bedrock = boto3.client('bedrock-runtime', region_name='us-west-2')
response = bedrock.invoke_model(
modelId='stability.sd3-ultra-v1:1',
body=json.dumps({
'prompt': 'A car made out of vegetables.'
})
)
output_body = json.loads(response["body"].read().decode("utf-8"))
base64_output_image = output_body["images"][0]
image_data = base64.b64decode(base64_output_image)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
```
------
#### [ Image to image ]
Le modèle Stability.ai Stable Image Ultra possède les paramètres d'inférence suivants pour un appel d' image-to-imageinférence.
+ **prompt** : (chaîne) ce que vous souhaitez voir dans l’image de sortie. Une invite descriptive forte qui définit clairement les éléments, les couleurs et les sujets permettra d’obtenir de meilleurs résultats.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-diffusion-stable-ultra-text-image-request-response.html)
**Champs facultatifs**
+ **image** : (chaîne) image Base64 à utiliser comme point de départ pour la génération. Formats pris en charge : JPEG, PNG, WebP.
+ **force** : (nombre) niveau d’influence du paramètre d’image sur l’image générée. Les images dont les valeurs d’intensité sont faibles ressembleront davantage à l’image d’origine. Plage de valeurs : de 0,0 à 1,0. Valeur par défaut : 0,35.
+ **aspect\$1ratio** : (chaîne) contrôle les proportions de l’image générée. Ce paramètre n'est valide que pour les text-to-image demandes. Valeur par défaut : 1:1. Enum : 16:9, 1:1, 21:9, 2:3, 3:2, 4:5, 5:4, 9:16, 9:21.
+ **output\$1format** : spécifie le format de l’image de sortie. Formats pris en charge : JPEG, PNG. Dimensions prises en charge : hauteur 640 à 1 536 pixels, largeur 640 à 1 536 pixels.
+ **seed** : (nombre) valeur spécifique utilisée pour indiquer le « caractère aléatoire » de la génération. (Omettez ce paramètre ou transmettez 0 pour utiliser une amorce aléatoire.) Plage de valeurs : de 0 à 4 294 967 295.
+ **negative\$1prompt** : mots clés indiquant ce que vous ne souhaitez pas voir dans l’image de sortie. Maximum : 10 000 caractères.
```
import boto3
import json
import base64
import io
from PIL import Image
bedrock = boto3.client('bedrock-runtime', region_name='us-west-2')
response = bedrock.invoke_model(
modelId='stability.sd3-ultra-v1:1',
body=json.dumps({
'prompt': 'A car made out of vegetables.'
})
)
output_body = json.loads(response["body"].read().decode("utf-8"))
base64_output_image = output_body["images"][0]
image_data = base64.b64decode(base64_output_image)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
```
------
# Stability.ai Stable Diffusion 3.5 Large
Le modèle Stable Diffusion 3.5 Large utilise 8 milliards de paramètres et prend en charge une résolution de sortie text-to-image et de image-to-image génération de 1 mégapixel.
Le corps de la demande est transmis dans le `body` champ d'une demande à [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html).
**Modèle de champ du corps de la demande d'invocation**
Lorsque vous passez un InvokeModel appel à l'aide d'un modèle Stable Diffusion 3.5 Large, remplissez le champ body avec un objet JSON semblable à celui ci-dessous.
+ **prompt** : (chaîne) description textuelle de l’image de sortie souhaitée. 10 000 caractères maximum.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-diffusion-3-5-large.html)
**Champ body des réponses à l’invocation du modèle**
Lorsque vous passez un appel `InvokeModel` à l’aide d’un modèle Stable Diffusion 3.5 Large, la réponse est similaire à la suivante :
```
{
'seeds': [2130420379],
"finish_reasons":[null],
"images":["..."]
}
```
Une réponse dont la raison finale n’est pas `null` ressemblera à ce qui suit :
```
{
"finish_reasons":["Filter reason: prompt"]
}
```
+ **seeds** : (chaîne) liste des amorces permettant de générer des images pour le modèle.
+ **finish\$1reasons** : Enum indiquant si la demande a été filtrée ou non. `null` indiquera que la demande a été acceptée. Valeurs possibles actuelles : `"Filter reason: prompt", "Filter reason: output image", "Filter reason: input image", "Inference error", null`.
+ **images** : liste des images générées au format de chaîne Base64.
------
#### [ Text to image ]
Le modèle Stability.ai Stable Diffusion 3.5 Large possède les paramètres d'inférence suivants pour un appel d' text-to-imageinférence.
+ **prompt** (string) — Description textuelle de l'image de sortie souhaitée. 10 000 caractères maximum.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-diffusion-3-5-large.html)
**Paramètres facultatifs**
+ **aspect\$1ratio** (string) — Contrôle le rapport hauteur/largeur de l'image générée. Valable uniquement pour text-to-image les demandes. Enum : 16:9, 1:1, 21:9, 2:3, 3:2, 4:5, 5:4, 9:16, 9:21. Valeur par défaut : 1:1.
+ **mode** (string) (GenerationMode) - Par défaut : text-to-image. Enum : image-to-image ou. text-to-image Contrôle s'il s'agit d'une image-to-image génération text-to-image ou, ce qui influe sur les paramètres requis :
+ text-to-image nécessite uniquement le paramètre prompt.
+ image-to-image nécessite les paramètres d'invite, d'image et d'intensité.
+ **seed** (number) — Valeur permettant de contrôler le caractère aléatoire de la génération. Plage de 0 à 4 294 967 294. 0 par défaut (amorce aléatoire).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-diffusion-3-5-large.html)
+ **negative\$1prompt** (string) — Texte décrivant les éléments à exclure de l'image de sortie. 10 000 caractères maximum.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-diffusion-3-5-large.html)
+ **output\$1format (string) — Format** de l'image de sortie. Enum : jpeg, png, webp. Valeur par défaut : png.
```
import boto3
import json
bedrock = boto3.client('bedrock-runtime', region_name='us-west-2')
response = bedrock.invoke_model(
modelId='stability.sd3-5-large-v1:0',
body=json.dumps({
'prompt': 'A car made out of vegetables.'
})
)
```
------
#### [ Image to image ]
Le modèle Stability.ai Stable Diffusion 3.5 Large possède les paramètres d'inférence suivants pour un appel d' image-to-imageinférence.
+ **prompt** (string) — Description textuelle de l'image de sortie souhaitée. 10 000 caractères maximum.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-diffusion-3-5-large.html)
+ **image** (chaîne) — Image d'entrée codée en Base64. Minimum 64 pixels par côté. Formats pris en charge : jpeg, png, webp.
+ **mode** (string) (GenerationMode) - Par défaut : text-to-image. Enum : image-to-image ou. text-to-image Contrôle s'il s'agit d'une image-to-image génération text-to-image ou, ce qui influe sur les paramètres requis :
+ text-to-image nécessite uniquement le paramètre prompt.
+ image-to-image nécessite les paramètres d'invite, d'image et d'intensité.
+ **force** (nombre) — Contrôle l'influence de l'image d'entrée sur la sortie. Plage de valeurs : de 0 à 1. La valeur 0 préserve l’image d’entrée, la valeur 1 ignore l’image d’entrée.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-diffusion-3-5-large.html)
+ **seed** (number) — Valeur permettant de contrôler le caractère aléatoire de la génération. Plage de 0 à 4 294 967 294. 0 par défaut (amorce aléatoire).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-diffusion-3-5-large.html)
+ **negative\$1prompt** (string) — Texte décrivant les éléments à exclure de l'image de sortie. 10 000 caractères maximum.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-diffusion-3-5-large.html)
+ **output\$1format (string) — Format** de l'image de sortie. Enum : jpeg, png, webp. Valeur par défaut : png.
```
import boto3
import base64
import json
# Load and encode image
with open('input_image.jpg', 'rb') as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
bedrock = boto3.client('bedrock-runtime', region_name='us-west-2')
response = bedrock.invoke_model(
modelId='stability.sd3-5-large-v1:0',
body=json.dumps({
'prompt': 'A car made out of vegetables.',
'image': image_base64,
'strength': 0.7
})
)
```
------
# Demande et réponse de Stable Image Core
Le corps de la demande est transmis dans le `body` champ d'une demande à [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html).
**Modèle de champ du corps de la demande d'invocation**
Lorsque vous passez un InvokeModel appel à l'aide d'un modèle Stability AI Stable Diffusion Stable Image Core, remplissez le champ body avec un objet JSON semblable à celui ci-dessous.
```
{
'prompt': 'Create an image of a panda'
}
```
**Champ body des réponses à l’invocation du modèle**
Lorsque vous passez un InvokeModel appel à l'aide d'un modèle Stability AI Stable Diffusion Stable Image Core, la réponse est la suivante :
```
{
'seeds': [2130420379],
'finish_reasons': [null],
'images': ['...']
}
```
+ **seeds** : (chaîne) liste des amorces permettant de générer des images pour le modèle.
+ **finish\$1reasons** : Enum indiquant si la demande a été filtrée ou non. `null` indiquera que la demande a été acceptée. Valeurs possibles actuelles : `"Filter reason: prompt", "Filter reason: output image", "Filter reason: input image", "Inference error", null`.
+ **images** : liste des images générées au format de chaîne Base64.
Pour plus d'informations, consultez [https://platform.us.stability. ai/docs/api-reference\$1tag/v1génération](https://platform.us.stability.ai/docs/api-reference#tag/v1generation).
------
#### [ Text to image ]
Le modèle Stable Image Core comporte les paramètres d’inférence suivants pour un appel d’inférence texte vers image.
**text\$1prompts** (obligatoire) : tableau d’invites de texte à utiliser pour la génération. Chaque élément est un objet JSON qui contient une invite et une pondération pour l’invite.
+ **prompt** : (chaîne) ce que vous souhaitez voir dans l’image de sortie. Une invite descriptive forte qui définit clairement les éléments, les couleurs et les sujets permettra d’obtenir de meilleurs résultats.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-parameters-diffusion-stable-image-core-text-image-request-response.html)
**Champs facultatifs**
+ **aspect\$1ratio** : (chaîne) contrôle les proportions de l’image générée. Ce paramètre n'est valide que pour les text-to-image demandes. Valeur par défaut : 1:1. Enum : 16:9, 1:1, 21:9, 2:3, 3:2, 4:5, 5:4, 9:16, 9:21.
+ **output\$1format** : spécifie le format de l’image de sortie. Formats pris en charge : JPEG, PNG. Dimensions prises en charge : hauteur 640 à 1 536 pixels, largeur 640 à 1 536 pixels.
+ **seed** : (nombre) valeur spécifique utilisée pour indiquer le « caractère aléatoire » de la génération. (Omettez ce paramètre ou transmettez 0 pour utiliser une amorce aléatoire.) Plage de valeurs : de 0 à 4 294 967 295.
+ **negative\$1prompt** : mots clés indiquant ce que vous ne souhaitez pas voir dans l’image de sortie. Maximum : 10 000 caractères.
```
import boto3
import json
import base64
import io
from PIL import Image
bedrock = boto3.client('bedrock-runtime', region_name='us-west-2')
response = bedrock.invoke_model(
modelId='stability.stable-image-core-v1:0',
body=json.dumps({
'prompt': 'A car made out of vegetables.'
})
)
output_body = json.loads(response["body"].read().decode("utf-8"))
base64_output_image = output_body["images"][0]
image_data = base64.b64decode(base64_output_image)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
```
------
# Services d’imagerie Stability AI
Vous pouvez utiliser Stability AI Image Services avec Amazon Bedrock pour accéder à treize outils de retouche d'image spécialisés conçus pour accélérer les flux de travail créatifs professionnels. Grâce aux services d’imagerie Stability AI, vous pouvez générer des images à partir d’une esquisse, restructurer et relooker une image existante ou supprimer et remplacer des objets dans une image.
Cette section décrit comment effectuer des appels d'inférence vers Stability AI Image Services à l'aide du [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html). Cette section fournit également des exemples de code en Python et des exemples d’images avant et après l’utilisation des services d’imagerie Stability AI.
Les services d’imagerie Stability AI sont disponibles dans les catégories suivantes :
+ **Retouche** : services de retouche d’images basés sur l’IA, y compris la peinture à l’aide de masques (remplissage génératif) ou de mots. Comprend des outils pour le placement de produits et la publicité, ainsi que des outils de base tels que la suppression de l’arrière-plan.
+ **Contrôle** : peut prendre des invites, des cartes et d’autres guides. Ces services tirent parti ControlNets de technologies similaires basées sur des modèles de diffusion stable.
**Note**
L'abonnement à n'importe quel service de modification ou de contrôle Stability AI Image Service vous inscrit automatiquement aux treize services d'imagerie Stability AI disponibles.
**Topics**
+ [Demande et réponse](#model-parameters-stable-image-services-request-response)
+ [Haut de gamme](#stable-image-services-upscale)
+ [Retouche](#stable-image-services-edit)
+ [Contrôle](#stable-image-services-control)
## Demande et réponse
Le corps de la demande est transmis dans le `body` champ d'une demande à [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html).
**Modèle de champ du corps de la demande d'invocation**
Lorsque vous passez un InvokeModel appel à l'aide de Stability AI Image Services, remplissez le champ body avec un objet JSON semblable à celui ci-dessous.
```
{
'prompt': 'Create an image of a panda'
}
```
**Champ body des réponses à l’invocation du modèle**
Lorsque vous passez un InvokeModel appel à l'aide de Stability AI Image Services, la réponse est la suivante :
```
{
'seeds': [2130420379],
'finish_reasons': [null],
'images': ['...']
}
```
+ **seeds** : (chaîne) liste des amorces permettant de générer des images pour le modèle.
+ **finish\$1reasons** : Enum indiquant si la demande a été filtrée ou non. `null` indiquera que la demande a été acceptée. Valeurs possibles actuelles : `"Filter reason: prompt", "Filter reason: output image", "Filter reason: input image", "Inference error", null`.
+ **images** : liste des images générées au format de chaîne Base64.
Pour plus d'informations, consultez [https://platform.us.stability. ai/docs/api-reference\$1tag/v1génération](https://platform.us.stability.ai/docs/api-reference#tag/v1generation).
## Haut de gamme
La section suivante décrit les services d'imagerie haut de gamme Stability AI.
### Haut de gamme créatif
Creative Upscale prend des images entre 64 x 64 et 1 mégapixel et les fait passer à une résolution 4K. Ce service permet de redimensionner les images de 20 à 40 fois tout en préservant et souvent en améliorant la qualité. Creative Upscale fonctionne mieux sur les images très dégradées et ne convient pas aux photos de 1 mégapixel ou plus, car il permet de nombreuses réimaginations.
Les paramètres requis pour Creative Upscale sont les suivants :
+ **prompt** : ce que vous souhaitez voir dans l’image de sortie. Une invite descriptive forte qui définit clairement les éléments, les couleurs et les sujets permettra d’obtenir de meilleurs résultats. Contrôlez la pondération d’un mot donné à l’aide du format (mot:pondération), où « mot » est le mot dont vous souhaitez contrôler la pondération et « pondération » est une valeur. Une valeur comprise entre 0 et 1,0 réduit l’accent sur le mot et une valeur comprise entre 1,1 et 2 met l’accent dessus. Par exemple : « Le ciel était d’un (bleu:0,3) et d’un (vert:1,8) vifs » refléterait un ciel bleu et vert, mais davantage vert que bleu. 0 caractères minimum et 10 000 caractères maximum.
+ **image** ‐ (chaîne) L'image Base64 à augmenter. Chaque côté de l’image doit mesurer au moins 64 pixels. Le nombre total de pixels doit être compris entre 4 096 et 1 048 576 pixels. Formats pris en charge : jpeg, png, webp.
Les paramètres suivants sont facultatifs :
+ **créativité** ‐ (nombre) Indique à quel point le modèle doit être créatif lors de la mise à l'échelle d'une image. Des valeurs plus élevées permettront d'ajouter plus de détails à l'image lors de la mise à l'échelle. Plage comprise entre 0,1 et 0,5. Par défaut 0,3
+ **negative\$1prompt** : (chaîne) texte de présentation décrivant ce que vous ne souhaitez pas voir dans l’image de sortie. Il s’agit d’une fonctionnalité avancée. 10 000 caractères maximum.
+ **seed** : (nombre) valeur spécifique utilisée pour indiquer le « caractère aléatoire » de la génération. (Omettez ce paramètre ou transmettez 0 pour utiliser une amorce aléatoire.) Plage de valeurs : de 0 à 4294967294. Valeur par défaut : 0.
+ **output\$1format** : (chaîne) indique le type de contenu de l’image générée. Enum : jpeg, png, webp. Valeur par défaut : png.
+ **style\$1preset** : guide le modèle d’image vers un style particulier. Enum : modèle 3D, film analogique, anime, cinématographique, bande dessinée, art numérique, amélioration, art fantastique, isométrique, dessin au trait, low-poly, composé de modélisation, néon-punk, origami, photographique, pixel art, texture de tuile.
------
#### [ API ]
```
import base64
import json
import requests
import io
import os
from PIL import Image
image = "./content/input.jpg"
region = "us-east-1"
model_id = "us.stability.stable-creative-upscale-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
"Content-Type":"application/json",
"Authorization":f"Bearer {api_key}"
}
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "This dreamlike digital art captures a vibrant, kaleidoscopic Big Ben in London",
"creativity": 0.30
}
response = requests.request("POST", url, json=params, headers=headers)
response.raise_for_status()
model_response = json.loads(response.text)
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
#### [ Python ]
```
import boto3
import base64
import io
import json
from PIL import Image
image = "./content/input.jpg"
region = "us-east-1"
model_id = "us.stability.stable-creative-upscale-v1:0"
bedrock = boto3.client("bedrock-runtime", region_name=region)
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "This dreamlike digital art captures a vibrant, kaleidoscopic Big Ben in London",
"creativity": 0.30
}
request = json.dumps(params)
response = bedrock.invoke_model(modelId=model_id, body=request)
model_response = json.loads(response["body"].read())
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
Le tableau suivant montre les images d'entrée et de sortie d'une opération Creative Upscale à l'aide de l'invite suivante : *Cette œuvre d'art numérique onirique capture un oiseau kaléidoscopique aux couleurs vives dans une* forêt tropicale luxuriante.
| Input | Output |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/images/stable-image-services/input-creative-upscale.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/images/stable-image-services/output-creative-upscale.jpg) |
### Haut de gamme conservateur
Conservative Upscale prend des images entre 64 x 64 et 1 mégapixel et les fait passer à une résolution 4K. Ce service permet de redimensionner les images de 20 à 40 fois tout en préservant tous les aspects. Conservative Upscale minimise les altérations de l'image et ne doit pas être utilisé pour réinventer une image.
Conservative Upscale possède les paramètres requis suivants :
+ **prompt** : ce que vous souhaitez voir dans l’image de sortie. Une invite descriptive forte qui définit clairement les éléments, les couleurs et les sujets permettra d’obtenir de meilleurs résultats. Contrôlez la pondération d’un mot donné à l’aide du format (mot:pondération), où « mot » est le mot dont vous souhaitez contrôler la pondération et « pondération » est une valeur. Une valeur comprise entre 0 et 1,0 réduit l’accent sur le mot et une valeur comprise entre 1,1 et 2 met l’accent dessus. Par exemple : « Le ciel était d’un (bleu:0,3) et d’un (vert:1,8) vifs » refléterait un ciel bleu et vert, mais davantage vert que bleu. 0 caractères minimum et 10 000 caractères maximum.
+ **image** ‐ (chaîne) L'image Base64 à augmenter. Chaque côté de l’image doit mesurer au moins 64 pixels. Le nombre total de pixels ne peut pas dépasser 9 437 184 pixels. Les proportions de l’image doivent être comprises entre 1:2,5 et 2,5:1. Formats pris en charge : jpeg, png, webp.
Les paramètres suivants sont facultatifs :
+ **créativité** ‐ (nombre) Indique à quel point le modèle doit être créatif lors de la mise à l'échelle d'une image. Des valeurs plus élevées permettront d'ajouter plus de détails à l'image lors de la mise à l'échelle. Plage comprise entre 0,1 et 0,5. Par défaut 0,35
+ **negative\$1prompt** : (chaîne) texte de présentation décrivant ce que vous ne souhaitez pas voir dans l’image de sortie. Il s’agit d’une fonctionnalité avancée. 10 000 caractères maximum.
+ **seed** : (nombre) valeur spécifique utilisée pour indiquer le « caractère aléatoire » de la génération. (Omettez ce paramètre ou transmettez 0 pour utiliser une amorce aléatoire.) Plage de valeurs : de 0 à 4294967294. Valeur par défaut : 0.
+ **output\$1format** : (chaîne) indique le type de contenu de l’image générée. Enum : jpeg, png, webp. Valeur par défaut : png.
------
#### [ API ]
```
import base64
import json
import requests
import io
import os
from PIL import Image
image = "./content/input.jpg"
region = "us-east-1"
model_id = "us.stability.stable-conservative-upscale-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
"Content-Type":"application/json",
"Authorization":f"Bearer {api_key}"
}
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "This dreamlike digital art captures a vibrant, kaleidoscopic Big Ben in London",
"creativity": 0.30
}
response = requests.request("POST", url, json=params, headers=headers)
response.raise_for_status()
model_response = json.loads(response.text)
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
#### [ Python ]
```
import boto3
import base64
import io
import json
from PIL import Image
image = "./content/input.jpg"
region = "us-east-1"
model_id = "us.stability.stable-conservative-upscale-v1:0"
bedrock = boto3.client("bedrock-runtime", region_name=region)
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "This dreamlike digital art captures a vibrant, kaleidoscopic Big Ben in London",
"creativity": 0.30
}
request = json.dumps(params)
response = bedrock.invoke_model(modelId=model_id, body=request)
model_response = json.loads(response["body"].read())
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
Le tableau suivant montre les images d'entrée et de sortie d'une opération Conservative Upscale à l'aide de l'invite suivante : *photo d'un poulet géant dans une forêt*.
| Input | Output |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/images/stable-image-services/input-conservative-upscale.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/images/stable-image-services/output-conservative-upscale.jpg) |
### Haut de gamme rapide
Fast Upscale multiplie par 4 la résolution de l'image grâce à l'IA prédictive et générative. Ce service léger et rapide est idéal pour améliorer la qualité des images compressées, ce qui le rend adapté aux publications sur les réseaux sociaux et à d'autres applications.
Fast Upscale possède les paramètres requis suivants :
+ **image** ‐ (chaîne) L'image Base64 à augmenter. La largeur doit être comprise entre 32 et 1 536 pixels. La hauteur doit être comprise entre 32 et 1 536 pixels. Le nombre total de pixels doit être compris entre 1 024 et 1 048 576 pixels. Formats pris en charge : jpeg, png, webp.
+ **output\$1format** : (chaîne) indique le type de contenu de l’image générée. Enum : jpeg, png, webp. Valeur par défaut : png.
------
#### [ API ]
```
import base64
import json
import requests
import io
import os
from PIL import Image
image = "./content/input.jpg"
region = "us-east-1"
model_id = "us.stability.stable-fast-upscale-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
"Content-Type":"application/json",
"Authorization":f"Bearer {api_key}"
}
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64
}
response = requests.request("POST", url, json=params, headers=headers)
response.raise_for_status()
model_response = json.loads(response.text)
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
#### [ Python ]
```
import boto3
import base64
import io
import json
from PIL import Image
image = "./content/input.jpg"
region = "us-east-1"
model_id = "us.stability.stable-fast-upscale-v1:0"
bedrock = boto3.client("bedrock-runtime", region_name=region)
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64
}
request = json.dumps(params)
response = bedrock.invoke_model(modelId=model_id, body=request)
model_response = json.loads(response["body"].read())
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
Le tableau suivant montre les images d'entrée et de sortie d'une opération Fast Upscale.
| Input | Output |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/images/stable-image-services/input-fast-upscale.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/images/stable-image-services/output-fast-upscale.jpg) |
## Retouche
La section suivante décrit les services de retouche d’images Stability AI.
### Inpaint
Inpaint modifie les images de manière intelligente en remplissant (ou en remplaçant) des zones spécifiées avec (ou par) du nouveau contenu basé sur le contenu d’une image de masque.
Voici les paramètres obligatoires d’Inpaint :
+ **prompt** : ce que vous souhaitez voir dans l’image de sortie. Une invite descriptive forte qui définit clairement les éléments, les couleurs et les sujets permettra d’obtenir de meilleurs résultats. Contrôlez la pondération d’un mot donné à l’aide du format (mot:pondération), où « mot » est le mot dont vous souhaitez contrôler la pondération et « pondération » est une valeur. Une valeur comprise entre 0 et 1,0 réduit l’accent sur le mot et une valeur comprise entre 1,1 et 2 met l’accent dessus. Par exemple : « Le ciel était d’un (bleu:0,3) et d’un (vert:1,8) vifs » refléterait un ciel bleu et vert, mais davantage vert que bleu. 0 caractères minimum et 10 000 caractères maximum.
+ **image** : (chaîne) image Base64 à peindre. Chaque côté de l’image doit mesurer au moins 64 pixels. Le nombre total de pixels ne peut pas dépasser 9 437 184 pixels. Les proportions de l’image doivent être comprises entre 1:2,5 et 2,5:1. Formats pris en charge : jpeg, png, webp.
Les paramètres suivants sont facultatifs :
+ **style\$1preset** : (chaîne) guide le modèle d’image vers un style particulier. Enum : modèle 3D, film analogique, anime, cinématographique, bande dessinée, art numérique, amélioration, art fantastique, isométrique, dessin au trait, low-poly, composé de modélisation, néon-punk, origami, photographique, pixel art, texture de tuile.
+ **negative\$1prompt** : (chaîne) texte de présentation décrivant ce que vous ne souhaitez pas voir dans l’image de sortie. Il s’agit d’une fonctionnalité avancée. 10 000 caractères maximum.
+ **seed** : (nombre) valeur spécifique utilisée pour indiquer le « caractère aléatoire » de la génération. (Omettez ce paramètre ou transmettez 0 pour utiliser une amorce aléatoire.) Plage de valeurs : de 0 à 4294967294. Valeur par défaut : 0.
+ **output\$1format** : (chaîne) indique le type de contenu de l’image générée. Enum : jpeg, png, webp. Valeur par défaut : png.
+ **mask** : (chaîne) contrôle l’intensité du processus de peinture par pixel, soit via une deuxième image (transmise dans ce paramètre), soit via le canal alpha du paramètre d’image.
+ **Transmission d’un masque** : l’image transmise à ce paramètre doit être une image en noir et blanc qui représente, à chaque pixel, l’intensité de la peinture en fonction du degré d’obscurité ou de lumière du pixel donné. Les pixels entièrement noirs ne représentent aucune intensité de peinture, tandis que les pixels entièrement blancs représentent une intensité maximale. Si le masque possède une taille différente de celle du paramètre d’image, il est automatiquement redimensionné.
+ **Prise en charge du canal alpha** : si vous ne fournissez pas de masque explicite, celui-ci est dérivé du canal alpha du paramètre d’image. Les pixels transparents sont peints, tandis que les pixels opaques sont préservés. Si une image avec un canal alpha est fournie avec un masque, le masque prévaut.
+ **grow\$1mask** : agrandit les bords du masque vers l’extérieur dans toutes les directions selon le nombre de pixels spécifié. La zone étendue autour du masque est floue, ce qui facilite la transition entre le contenu peint et l’image d’origine. Plage de valeurs : de 0 à 20. Valeur par défaut : 5. Essayez ce paramètre si vous remarquez des raccords ou des bords irréguliers autour du contenu peint. Notez qu'une croissance excessive peut masquer les détails les plus fins du masque et and/or fusionner les régions masquées voisines.
------
#### [ API ]
```
import base64
import json
import requests
import io
import os
from PIL import Image
image = "./content/input.png"
mask = "./content/mask.png"
region = "us-east-1"
model_id = "us.stability.stable-image-inpaint-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
"Content-Type":"application/json",
"Authorization":f"Bearer {api_key}"
}
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
with open(mask, "rb") as mask_file:
mask_base64 = base64.b64encode(mask_file.read()).decode('utf-8')
params = {
"image": image_base64,
"mask": mask_base64,
"prompt": "artificer of time and space"
}
response = requests.request("POST", url, json=params, headers=headers)
response.raise_for_status()
model_response = json.loads(response.text)
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
#### [ Python ]
```
import boto3
import base64
import io
import json
from PIL import Image
image = "./content/input.png"
mask = "./content/mask.png"
region = "us-east-1"
model_id = "us.stability.stable-image-inpaint-v1:0"
bedrock = boto3.client("bedrock-runtime", region_name=region)
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
with open(mask, "rb") as mask_file:
mask_base64 = base64.b64encode(mask_file.read()).decode('utf-8')
params = {
"image": image_base64,
"mask": mask_base64,
"prompt": "artificer of time and space"
}
request = json.dumps(params)
response = bedrock.invoke_model(modelId=model_id, body=request)
model_response = json.loads(response["body"].read())
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
Le tableau suivant indique les images d’entrée et de sortie d’une opération Inpaint :
| Input | Masque | Output |
| --- | --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/images/stable-image-services/input-image-inpaint.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/images/stable-image-services/mask-image-inpaint.png) | ![\[alt text not found\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/images/stable-image-services/output-image-inpaint.jpg) |
### Dépasser la peinture
Outpaint insère du contenu supplémentaire dans une image pour remplir l'espace dans n'importe quelle direction. Comparé à d'autres tentatives automatisées ou manuelles d'extension du contenu d'une image, le service Outpaint minimise les indications indiquant que l'image d'origine a été modifiée.
Outpaint possède les paramètres obligatoires suivants :
+ **image** ‐ (chaîne) L'image Base64 à surpeindre. Chaque côté de l’image doit mesurer au moins 64 pixels. Le nombre total de pixels ne peut pas dépasser 9 437 184 pixels. Les proportions de l’image doivent être comprises entre 1:2,5 et 2,5:1. Formats pris en charge : jpeg, png, webp.
**Note**
Au moins une direction de sortie : (gauche, droite, haut ou bas) doit être fournie avec une valeur différente de zéro. Pour des résultats de qualité optimale, tenez compte de la composition et du contenu de votre image d'origine lorsque vous choisissez les directions de surpeinture.
Les paramètres suivants sont facultatifs :
+ **prompt** : ce que vous souhaitez voir dans l’image de sortie. Une invite descriptive forte qui définit clairement les éléments, les couleurs et les sujets permettra d’obtenir de meilleurs résultats. Contrôlez la pondération d’un mot donné à l’aide du format (mot:pondération), où « mot » est le mot dont vous souhaitez contrôler la pondération et « pondération » est une valeur. Une valeur comprise entre 0 et 1,0 réduit l’accent sur le mot et une valeur comprise entre 1,1 et 2 met l’accent dessus. Par exemple : « Le ciel était d’un (bleu:0,3) et d’un (vert:1,8) vifs » refléterait un ciel bleu et vert, mais davantage vert que bleu. 0 caractères minimum et 10 000 caractères maximum.
+ **style\$1preset** : (chaîne) guide le modèle d’image vers un style particulier. Enum : modèle 3D, film analogique, anime, cinématographique, bande dessinée, art numérique, amélioration, art fantastique, isométrique, dessin au trait, low-poly, composé de modélisation, néon-punk, origami, photographique, pixel art, texture de tuile.
+ **seed** : (nombre) valeur spécifique utilisée pour indiquer le « caractère aléatoire » de la génération. (Omettez ce paramètre ou transmettez 0 pour utiliser une amorce aléatoire.) Plage de valeurs : de 0 à 4294967294. Valeur par défaut : 0.
+ **output\$1format** : (chaîne) indique le type de contenu de l’image générée. Enum : jpeg, png, webp. Valeur par défaut : png.
+ **créativité** ‐ (nombre) Indique à quel point le modèle doit être créatif lorsqu'il surpeint une image. Plus les valeurs sont élevées, plus de contenu créatif sera ajouté à l'image lors de la peinture. Plage comprise entre 0,1 et 1,0. Valeur par défaut : 0,5.
+ **left** ‐ (entier) Nombre de pixels à surpeindre sur le côté gauche de l'image. Au moins une direction de surpeinture doit être fournie avec une valeur différente de zéro. Plage de 0 à 2000. Par défaut 0.
+ **right** ‐ (entier) Nombre de pixels à surpeindre sur le côté droit de l'image. Au moins une direction de surpeinture doit être fournie avec une valeur différente de zéro. Plage de 0 à 2000. Par défaut 0.
+ **up** ‐ (entier) Nombre de pixels à surpeindre en haut de l'image. Au moins une direction de surpeinture doit être fournie avec une valeur différente de zéro. Plage de 0 à 2000. Par défaut 0.
+ **down** ‐ (entier) Nombre de pixels à surpeindre en bas de l'image. Au moins une direction de surpeinture doit être fournie avec une valeur différente de zéro. Plage de 0 à 2000. Par défaut 0.
------
#### [ API ]
```
import base64
import json
import requests
import io
import os
from PIL import Image
image = "./content/input.jpg"
region = "us-east-1"
model_id = "us.stability.stable-outpaint-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
"Content-Type":"application/json",
"Authorization":f"Bearer {api_key}"
}
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"left": 512,
"right": 512,
"up": 200,
"down": 100
}
response = requests.request("POST", url, json=params, headers=headers)
response.raise_for_status()
model_response = json.loads(response.text)
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
#### [ Python ]
```
import boto3
import base64
import io
import json
from PIL import Image
image = "./content/input.png"
region = "us-east-1"
model_id = "us.stability.stable-outpaint-v1:0"
bedrock = boto3.client("bedrock-runtime", region_name=region)
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"left": 512,
"right": 512,
"up": 200,
"down": 100
}
request = json.dumps(params)
response = bedrock.invoke_model(modelId=model_id, body=request)
model_response = json.loads(response["body"].read())
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
Le tableau suivant montre les images d'entrée et de sortie d'une opération Outpaint.
| Input | Output |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/images/stable-image-services/input-image-outpaint.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/images/stable-image-services/output-image-outpaint.jpg) |
### Search and Recolor
Search and Recolor vous permet de modifier la couleur d’un objet spécifique dans une image à l’aide d’une invite. Ce service est une version spécifique de peinture qui ne nécessite pas de masque. Il segmente automatiquement l’objet et le recolore à l’aide des couleurs demandées dans l’invite.
Voici les paramètres obligatoires de Search and Recolor :
+ **prompt** : ce que vous souhaitez voir dans l’image de sortie. Une invite descriptive forte qui définit clairement les éléments, les couleurs et les sujets permettra d’obtenir de meilleurs résultats. Contrôlez la pondération d’un mot donné à l’aide du format (mot:pondération), où « mot » est le mot dont vous souhaitez contrôler la pondération et « pondération » est une valeur. Une valeur comprise entre 0 et 1,0 réduit l’accent sur le mot et une valeur comprise entre 1,1 et 2 met l’accent dessus. Par exemple : « Le ciel était d’un (bleu:0,3) et d’un (vert:1,8) vifs » refléterait un ciel bleu et vert, mais davantage vert que bleu. 0 caractères minimum et 10 000 caractères maximum.
+ **image** : (chaîne) image Base64 à recolorer. Chaque côté de l’image doit mesurer au moins 64 pixels. Le nombre total de pixels ne peut pas dépasser 9 437 184 pixels. Les proportions de l’image doivent être comprises entre 1:2,5 et 2,5:1. Formats pris en charge : jpeg, png, webp.
+ **select\$1prompt** : (chaîne) brève description des éléments à rechercher dans l’image. 10 000 caractères maximum.
Les paramètres suivants sont facultatifs :
+ **style\$1preset** : (chaîne) guide le modèle d’image vers un style particulier. Enum : modèle 3D, film analogique, anime, cinématographique, bande dessinée, art numérique, amélioration, art fantastique, isométrique, dessin au trait, low-poly, composé de modélisation, néon-punk, origami, photographique, pixel art, texture de tuile.
+ **negative\$1prompt** : (chaîne) texte de présentation décrivant ce que vous ne souhaitez pas voir dans l’image de sortie. Il s’agit d’une fonctionnalité avancée. 10 000 caractères maximum.
+ **seed** : (nombre) valeur spécifique utilisée pour indiquer le « caractère aléatoire » de la génération. (Omettez ce paramètre ou transmettez 0 pour utiliser une amorce aléatoire.) Plage de valeurs : de 0 à 4294967294. Valeur par défaut : 0.
+ **output\$1format** : (chaîne) indique le type de contenu de l’image générée. Enum : jpeg, png, webp. Valeur par défaut : png.
+ **grow\$1mask** : agrandit les bords du masque vers l’extérieur dans toutes les directions selon le nombre de pixels spécifié. La zone étendue autour du masque est floue, ce qui facilite la transition entre le contenu peint et l’image d’origine. Plage de valeurs : de 0 à 20. Valeur par défaut : 5. Essayez ce paramètre si vous remarquez des raccords ou des bords irréguliers autour du contenu peint. Notez qu'une croissance excessive peut masquer les détails les plus fins du masque et and/or fusionner les régions masquées voisines.
------
#### [ API ]
```
import base64
import json
import requests
import io
import os
from PIL import Image
image = "./content/input.png"
region = "us-east-1"
model_id = "us.stability.stable-image-search-recolor-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
"Content-Type":"application/json",
"Authorization":f"Bearer {api_key}"
}
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "pink jacket",
"select_prompt": "jacket"
}
response = requests.request("POST", url, json=params, headers=headers)
response.raise_for_status()
model_response = json.loads(response.text)
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
#### [ Python ]
```
import boto3
import base64
import io
import json
from PIL import Image
image = "./content/input.png"
region = "us-east-1"
model_id = "us.stability.stable-image-search-recolor-v1:0"
bedrock = boto3.client("bedrock-runtime", region_name=region)
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "pink jacket",
"select_prompt": "jacket"
}
request = json.dumps(params)
response = bedrock.invoke_model(modelId=model_id, body=request)
model_response = json.loads(response["body"].read())
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
Le tableau suivant montre les images d’entrée et de sortie d’une opération Search and Recolor à l’aide de l’invite suivante : *veste rose*.
| Input | Output |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/images/stable-image-services/input-search-recolor.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/images/stable-image-services/output-search-recolor.jpg) |
### Search and Replace
Search and Replace vous permet d’identifier un objet à remplacer dans un langage simple à l’aide d’une invite de recherche. Le service segmente automatiquement l’objet et le remplace par l’objet demandé dans l’invite sans avoir besoin de masque.
Voici les paramètres obligatoires de Search and Replace :
+ **prompt** : ce que vous souhaitez voir dans l’image de sortie. Une invite descriptive forte qui définit clairement les éléments, les couleurs et les sujets permettra d’obtenir de meilleurs résultats. Contrôlez la pondération d’un mot donné à l’aide du format (mot:pondération), où « mot » est le mot dont vous souhaitez contrôler la pondération et « pondération » est une valeur. Une valeur comprise entre 0 et 1,0 réduit l’accent sur le mot et une valeur comprise entre 1,1 et 2 met l’accent dessus. Par exemple : « Le ciel était d’un (bleu:0,3) et d’un (vert:1,8) vifs » refléterait un ciel bleu et vert, mais davantage vert que bleu. 0 caractères minimum et 10 000 caractères maximum.
+ **image** : (chaîne) image Base64 à recolorer. Chaque côté de l’image doit mesurer au moins 64 pixels. Le nombre total de pixels ne peut pas dépasser 9 437 184 pixels. Les proportions de l’image doivent être comprises entre 1:2,5 et 2,5:1. Formats pris en charge : jpeg, png, webp.
+ **search\$1prompt** : (chaîne) brève description des éléments à peindre dans l’image. 10 000 caractères maximum.
Les paramètres suivants sont facultatifs :
+ **style\$1preset** : (chaîne) guide le modèle d’image vers un style particulier. Enum : modèle 3D, film analogique, anime, cinématographique, bande dessinée, art numérique, amélioration, art fantastique, isométrique, dessin au trait, low-poly, composé de modélisation, néon-punk, origami, photographique, pixel art, texture de tuile.
+ **negative\$1prompt** : (chaîne) texte de présentation décrivant ce que vous ne souhaitez pas voir dans l’image de sortie. Il s’agit d’une fonctionnalité avancée. 10 000 caractères maximum.
+ **seed** : (nombre) valeur spécifique utilisée pour indiquer le « caractère aléatoire » de la génération. (Omettez ce paramètre ou transmettez 0 pour utiliser une amorce aléatoire.) Plage de valeurs : de 0 à 4294967294. Valeur par défaut : 0.
+ **output\$1format** : (chaîne) indique le type de contenu de l’image générée. Enum : jpeg, png, webp. Valeur par défaut : png.
+ **grow\$1mask** : agrandit les bords du masque vers l’extérieur dans toutes les directions selon le nombre de pixels spécifié. La zone étendue autour du masque est floue, ce qui facilite la transition entre le contenu peint et l’image d’origine. Plage de valeurs : de 0 à 20. Valeur par défaut : 5. Essayez ce paramètre si vous remarquez des raccords ou des bords irréguliers autour du contenu peint. Notez qu'une croissance excessive peut masquer les détails les plus fins du masque et and/or fusionner les régions masquées voisines.
------
#### [ API ]
```
import base64
import json
import requests
import io
import os
from PIL import Image
image = "./content/input.png"
region = "us-east-1"
model_id = "us.stability.stable-image-search-replace-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
"Content-Type":"application/json",
"Authorization":f"Bearer {api_key}"
}
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "jacket",
"search_prompt": "sweater",
}
response = requests.request("POST", url, json=params, headers=headers)
response.raise_for_status()
model_response = json.loads(response.text)
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
#### [ Python ]
```
import boto3
import base64
import io
import json
from PIL import Image
image = "./content/input.png"
region = "us-east-1"
model_id = "us.stability.stable-image-search-replace-v1:0"
bedrock = boto3.client("bedrock-runtime", region_name=region)
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "jacket",
"search_prompt": "sweater",
}
request = json.dumps(params)
response = bedrock.invoke_model(modelId=model_id, body=request)
model_response = json.loads(response["body"].read())
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
Le tableau suivant montre les images d’entrée et de sortie d’une opération Search and Replace à l’aide de l’invite suivante : *veste*.
| Input | Output |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/images/stable-image-services/input-search-replace.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/images/stable-image-services/output-search-replace.jpg) |
### Erase
Erase vous permet de supprimer les éléments indésirables à l’aide de masques d’image, tout en préservant intelligemment la cohérence de l’arrière-plan.
Voici les paramètres obligatoires d’Erase :
+ **image** : (chaîne) image Base64 faisant l’objet de l’effacement. Chaque côté de l’image doit mesurer au moins 64 pixels. Le nombre total de pixels ne peut pas dépasser 9 437 184 pixels. Les proportions de l’image doivent être comprises entre 1:2,5 et 2,5:1. Formats pris en charge : jpeg, png, webp.
Les paramètres suivants sont facultatifs :
+ **seed** : (nombre) valeur spécifique utilisée pour indiquer le « caractère aléatoire » de la génération. (Omettez ce paramètre ou transmettez 0 pour utiliser une amorce aléatoire.) Plage de valeurs : de 0 à 4294967294. Valeur par défaut : 0.
+ **output\$1format** : (chaîne) indique le type de contenu de l’image générée. Enum : jpeg, png, webp. Valeur par défaut : png.
+ **mask** : (chaîne) contrôle l’intensité du processus de peinture par pixel, soit via une deuxième image (transmise dans ce paramètre), soit via le canal alpha du paramètre d’image.
+ **Transmission d’un masque** : l’image transmise à ce paramètre doit être une image en noir et blanc qui représente, à chaque pixel, l’intensité de la peinture en fonction du degré d’obscurité ou de lumière du pixel donné. Les pixels entièrement noirs ne représentent aucune intensité de peinture, tandis que les pixels entièrement blancs représentent une intensité maximale. Si le masque possède une taille différente de celle du paramètre d’image, il est automatiquement redimensionné.
+ **Prise en charge du canal alpha** : si vous ne fournissez pas de masque explicite, celui-ci est dérivé du canal alpha du paramètre d’image. Les pixels transparents sont peints, tandis que les pixels opaques sont préservés. Si une image avec un canal alpha est fournie avec un masque, le masque prévaut.
+ **grow\$1mask** : agrandit les bords du masque vers l’extérieur dans toutes les directions selon le nombre de pixels spécifié. La zone étendue autour du masque est floue, ce qui facilite la transition entre le contenu peint et l’image d’origine. Plage de valeurs : de 0 à 20. Valeur par défaut : 5. Essayez ce paramètre si vous remarquez des raccords ou des bords irréguliers autour du contenu peint. Notez qu'une croissance excessive peut masquer les détails les plus fins du masque et and/or fusionner les régions masquées voisines.
**Note**
Pour des résultats d’effacement optimaux, assurez-vous que votre masque définit avec précision les zones à supprimer. Si aucun masque explicite n’est fourni, le service utilise le canal alpha de l’image d’entrée. Le masque prévaut si les deux sont fournis.
------
#### [ API ]
```
import base64
import json
import requests
import io
import os
from PIL import Image
image = "./content/input.png"
mask = "./content/mask.png"
region = "us-east-1"
model_id = "us.stability.stable-image-erase-object-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
"Content-Type":"application/json",
"Authorization":f"Bearer {api_key}"
}
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8'),
with open(mask, "rb") as mask_file:
mask_base64 = base64.b64encode(mask_file.read()).decode('utf-8')
params = {
"image": image_base64,
"mask": mask_base64
}
response = requests.request("POST", url, json=params, headers=headers)
response.raise_for_status()
model_response = json.loads(response.text)
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
#### [ Python ]
```
import boto3
import base64
import io
import json
from PIL import Image
image = "./content/input.png"
mask = "./content/mask.png"
region = "us-east-1"
model_id = "us.stability.stable-image-erase-object-v1:0"
bedrock = boto3.client("bedrock-runtime", region_name=region)
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8'),
with open(mask, "rb") as mask_file:
mask_base64 = base64.b64encode(mask_file.read()).decode('utf-8')
params = {
"image": image_base64,
"mask": mask_base64
}
request = json.dumps(params)
response = bedrock.invoke_model(modelId=model_id, body=request)
model_response = json.loads(response["body"].read())
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
Le tableau suivant indique les images d’entrée et de sortie d’une opération Erase :
| Input | Masque | Output |
| --- | --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/images/stable-image-services/input-erase-object.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/images/stable-image-services/mask-erase-object.png) | ![\[alt text not found\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/images/stable-image-services/output-erase-object.jpg) |
### Remove Background
Remove Background vous permet d’isoler des sujets de l’arrière-plan avec précision.
Voici les paramètres obligatoires de Remove Background :
+ **image** : (chaîne) image Base64 dont vous souhaitez supprimer l’arrière-plan. Chaque côté de l’image doit mesurer au moins 64 pixels. Le nombre total de pixels ne peut pas dépasser 9 437 184 pixels. Les proportions de l’image doivent être comprises entre 1:2,5 et 2,5:1. Formats pris en charge : jpeg, png, webp.
Les paramètres suivants sont facultatifs :
+ **output\$1format** : (chaîne) indique le type de contenu de l’image générée. Enum : jpeg, png, webp. Valeur par défaut : png.
------
#### [ API ]
```
import base64
import json
import requests
import io
import os
from PIL import Image
image = "./content/input.png"
region = "us-east-1"
model_id = "us.stability.stable-image-remove-background-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
"Content-Type":"application/json",
"Authorization":f"Bearer {api_key}"
}
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
}
response = requests.request("POST", url, json=params, headers=headers)
response.raise_for_status()
model_response = json.loads(response.text)
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
#### [ Python ]
```
import boto3
import base64
import io
import json
from PIL import Image
image = "./content/input.png"
region = "us-east-1"
model_id = "us.stability.stable-image-remove-background-v1:0"
bedrock = boto3.client("bedrock-runtime", region_name=region)
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64
}
request = json.dumps(params)
response = bedrock.invoke_model(modelId=model_id, body=request)
model_response = json.loads(response["body"].read())
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
Le tableau suivant présente les images d’entrée et de sortie d’une opération Remove Background :
| Input | Output |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/images/stable-image-services/input-remove-background.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/images/stable-image-services/output-remove-background.jpg) |
## Contrôle
La section suivante décrit les services de contrôle d’images Stability AI.
### Control Sketch
Améliorez vos esquisses dessinées à la main pour obtenir des résultats raffinés avec un contrôle précis. Pour les images autres que des esquisses, Control Sketch permet de manipuler en détail l’aspect final en exploitant les lignes de contour et les arêtes de l’image.
Voici les paramètres obligatoires de Control Sketch :
+ **prompt** : ce que vous souhaitez voir dans l’image de sortie. Une invite descriptive forte qui définit clairement les éléments, les couleurs et les sujets permettra d’obtenir de meilleurs résultats. Contrôlez la pondération d’un mot donné à l’aide du format (mot:pondération), où « mot » est le mot dont vous souhaitez contrôler la pondération et « pondération » est une valeur. Une valeur comprise entre 0 et 1,0 réduit l’accent sur le mot et une valeur comprise entre 1,1 et 2 met l’accent dessus. Par exemple : « Le ciel était d’un (bleu:0,3) et d’un (vert:1,8) vifs » refléterait un ciel bleu et vert, mais davantage vert que bleu. 0 caractères minimum et 10 000 caractères maximum.
+ **image** : (chaîne) image Base64 de l’esquisse. Chaque côté de l’image doit mesurer au moins 64 pixels. Le nombre total de pixels ne peut pas dépasser 9 437 184 pixels. Les proportions de l’image doivent être comprises entre 1:2,5 et 2,5:1. Formats pris en charge : jpeg, png, webp.
Les paramètres suivants sont facultatifs :
+ **control\$1strength** : (nombre) influence ou contrôle de l’image sur la génération. Représenté sous la forme d’une valeur flottante comprise entre 0 et 1, où 0 représente l’influence la plus faible et 1 la plus forte. Valeur par défaut : 0,7.
+ **negative\$1prompt** : (chaîne) texte de présentation décrivant ce que vous ne souhaitez pas voir dans l’image de sortie. Il s’agit d’une fonctionnalité avancée. 10 000 caractères maximum.
+ **seed** : (nombre) valeur spécifique utilisée pour indiquer le « caractère aléatoire » de la génération. (Omettez ce paramètre ou transmettez 0 pour utiliser une amorce aléatoire.) Plage de valeurs : de 0 à 4294967294. Valeur par défaut : 0.
+ **output\$1format** : (chaîne) indique le type de contenu de l’image générée. Enum : jpeg, png, webp. Valeur par défaut : png.
+ **style\$1preset** : guide le modèle d’image vers un style particulier. Enum : modèle 3D, film analogique, anime, cinématographique, bande dessinée, art numérique, amélioration, art fantastique, isométrique, dessin au trait, low-poly, composé de modélisation, néon-punk, origami, photographique, pixel art, texture de tuile.
------
#### [ API ]
```
import base64
import json
import requests
import io
import os
from PIL import Image
image = "./content/input.jpg"
region = "us-east-1"
model_id = "us.stability.stable-image-control-sketch-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
"Content-Type":"application/json",
"Authorization":f"Bearer {api_key}"
}
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "a house with background of mountains and river flowing nearby"
}
response = requests.request("POST", url, json=params, headers=headers)
response.raise_for_status()
model_response = json.loads(response.text)
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
#### [ Python ]
```
import boto3
import base64
import io
import json
from PIL import Image
image = "./content/input.jpg"
region = "us-east-1"
model_id = "us.stability.stable-image-control-sketch-v1:0"
bedrock = boto3.client("bedrock-runtime", region_name=region)
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "a house with background of mountains and river flowing nearby"
}
request = json.dumps(params)
response = bedrock.invoke_model(modelId=model_id, body=request)
model_response = json.loads(response["body"].read())
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
Le tableau suivant montre les images d’entrée et de sortie d’un appel Control Sketch à l’aide de l’invite suivante : *une maison avec en arrière-plan des montagnes et une rivière qui coule à proximité*.
| Input | Output |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/images/stable-image-services/input-control-sketch.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/images/stable-image-services/output-control-sketch.jpg) |
| | |
### Control Structure
Control Structure vous permet de générer des images tout en conservant la structure d’une image d’entrée. Cela est particulièrement utile pour les scénarios avancés de création de contenu tels que la recréation de scènes ou le rendu de personnages à partir de modèles.
Voici les paramètres obligatoires de Control Structure :
+ **prompt** : ce que vous souhaitez voir dans l’image de sortie. Une invite descriptive forte qui définit clairement les éléments, les couleurs et les sujets permettra d’obtenir de meilleurs résultats. Contrôlez la pondération d’un mot donné à l’aide du format (mot:pondération), où « mot » est le mot dont vous souhaitez contrôler la pondération et « pondération » est une valeur. Une valeur comprise entre 0 et 1,0 réduit l’accent sur le mot et une valeur comprise entre 1,1 et 2 met l’accent dessus. Par exemple : « Le ciel était d’un (bleu:0,3) et d’un (vert:1,8) vifs » refléterait un ciel bleu et vert, mais davantage vert que bleu. 0 caractères minimum et 10 000 caractères maximum.
+ **image** : (chaîne) image Base64 de l’esquisse. Chaque côté de l’image doit mesurer au moins 64 pixels. Le nombre total de pixels ne peut pas dépasser 9 437 184 pixels. Les proportions de l’image doivent être comprises entre 1:2,5 et 2,5:1. Formats pris en charge : jpeg, png, webp.
Les paramètres suivants sont facultatifs :
+ **control\$1strength** : (nombre) influence ou contrôle de l’image sur la génération. Représenté sous la forme d’une valeur flottante comprise entre 0 et 1, où 0 représente l’influence la plus faible et 1 la plus forte. Valeur par défaut : 0,7.
+ **negative\$1prompt** : (chaîne) texte de présentation décrivant ce que vous ne souhaitez pas voir dans l’image de sortie. Il s’agit d’une fonctionnalité avancée. 10 000 caractères maximum.
+ **seed** : (nombre) valeur spécifique utilisée pour indiquer le « caractère aléatoire » de la génération. (Omettez ce paramètre ou transmettez 0 pour utiliser une amorce aléatoire.) Plage de valeurs : de 0 à 4294967294. Valeur par défaut : 0.
+ **output\$1format** : (chaîne) indique le type de contenu de l’image générée. Enum : jpeg, png, webp. Valeur par défaut : png.
+ **style\$1preset** : guide le modèle d’image vers un style particulier. Enum : modèle 3D, film analogique, anime, cinématographique, bande dessinée, art numérique, amélioration, art fantastique, isométrique, dessin au trait, low-poly, composé de modélisation, néon-punk, origami, photographique, pixel art, texture de tuile.
------
#### [ API ]
```
import base64
import json
import requests
import io
import os
from PIL import Image
image = "./content/input.jpg"
region = "us-east-1"
model_id = "us.stability.stable-image-control-structure-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
"Content-Type":"application/json",
"Authorization":f"Bearer {api_key}"
}
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "surreal structure with motion generated sparks lighting the scene"
}
response = requests.request("POST", url, json=params, headers=headers)
response.raise_for_status()
model_response = json.loads(response.text)
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
#### [ Python ]
```
import boto3
import base64
import io
import json
from PIL import Image
image = "./content/input.jpg"
region = "us-east-1"
model_id = "us.stability.stable-image-control-structure-v1:0"
bedrock = boto3.client("bedrock-runtime", region_name=region)
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "surreal structure with motion generated sparks lighting the scene"
}
request = json.dumps(params)
response = bedrock.invoke_model(modelId=model_id, body=request)
model_response = json.loads(response["body"].read())
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
Le tableau suivant montre les images d’entrée et de sortie d’une opération Control Structure à l’aide de l’invite suivante : *structure surréaliste avec des étincelles générées par le mouvement qui éclairent la scène*.
| Input | Output |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/images/stable-image-services/input-control-structure.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/images/stable-image-services/output-control-structure.jpg) |
### Style Guide
Style Guide vous permet d’extraire des éléments stylistiques d’une image d’entrée, à l’aide desquels vous guidez ensuite la création d’une image de sortie en fonction de l’invite. Le résultat est une nouvelle image dans le même style que l’image d’entrée.
Voici les paramètres obligatoires de Style Guide :
+ **prompt** : ce que vous souhaitez voir dans l’image de sortie. Une invite descriptive forte qui définit clairement les éléments, les couleurs et les sujets permettra d’obtenir de meilleurs résultats. Contrôlez la pondération d’un mot donné à l’aide du format (mot:pondération), où « mot » est le mot dont vous souhaitez contrôler la pondération et « pondération » est une valeur. Une valeur comprise entre 0 et 1,0 réduit l’accent sur le mot et une valeur comprise entre 1,1 et 2 met l’accent dessus. Par exemple : « Le ciel était d’un (bleu:0,3) et d’un (vert:1,8) vifs » refléterait un ciel bleu et vert, mais davantage vert que bleu. 0 caractères minimum et 10 000 caractères maximum.
+ **image** : (chaîne) image Base64 de l’esquisse. Chaque côté de l’image doit mesurer au moins 64 pixels. Le nombre total de pixels ne peut pas dépasser 9 437 184 pixels. Les proportions de l’image doivent être comprises entre 1:2,5 et 2,5:1. Formats pris en charge : jpeg, png, webp.
Les paramètres suivants sont facultatifs :
+ **aspect\$1ratio** : (chaîne) contrôle les proportions de l’image générée. Ce paramètre n'est valide que pour les text-to-image demandes. Valeur par défaut : 1:1. Enum : 16:9, 1:1, 21:9, 2:3, 3:2, 4:5, 5:4, 9:16, 9:21. Valeur par défaut : 1:1.
+ **negative\$1prompt** : (chaîne) texte de présentation décrivant ce que vous ne souhaitez pas voir dans l’image de sortie. Il s’agit d’une fonctionnalité avancée. 10 000 caractères maximum.
+ **seed** : (nombre) valeur spécifique utilisée pour indiquer le « caractère aléatoire » de la génération. (Omettez ce paramètre ou transmettez 0 pour utiliser une amorce aléatoire.) Plage de valeurs : de 0 à 4294967294. Valeur par défaut : 0.
+ **output\$1format** : (chaîne) indique le type de contenu de l’image générée. Enum : jpeg, png, webp. Valeur par défaut : png.
+ **fidelity** : (nombre) mesure dans laquelle le style de l’image de sortie ressemble à celui de l’image d’entrée. Plage de valeurs : de 0 à 1. Valeur par défaut : 0,5.
+ **style\$1preset** : guide le modèle d’image vers un style particulier. Enum : modèle 3D, film analogique, anime, cinématographique, bande dessinée, art numérique, amélioration, art fantastique, isométrique, dessin au trait, low-poly, composé de modélisation, néon-punk, origami, photographique, pixel art, texture de tuile.
------
#### [ API ]
```
import base64
import json
import requests
import io
import os
from PIL import Image
image = "./content/input.jpg"
region = "us-east-1"
model_id = "us.stability.stable-image-style-guide-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
"Content-Type":"application/json",
"Authorization":f"Bearer {api_key}"
}
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "wide shot of modern metropolis"
}
response = requests.request("POST", url, json=params, headers=headers)
response.raise_for_status()
model_response = json.loads(response.text)
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
#### [ Python ]
```
import boto3
import base64
import io
import json
from PIL import Image
image = "./content/input.jpg"
region = "us-east-1"
model_id = "us.stability.stable-image-style-guide-v1:0"
bedrock = boto3.client("bedrock-runtime", region_name=region)
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
params = {
"image": image_base64,
"prompt": "wide shot of modern metropolis"
}
request = json.dumps(params)
response = bedrock.invoke_model(modelId=model_id, body=request)
model_response = json.loads(response["body"].read())
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
Le tableau suivant montre les images d’entrée et de sortie d’un appel Style Guide à l’aide de l’invite suivante : *plan large d’une métropole moderne*.
| Input | Output |
| --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/images/stable-image-services/input-style-guide.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/images/stable-image-services/output-style-guide.jpg) |
### Style Transfer
Style Transfer vous permet d’appliquer les caractéristiques visuelles des images de style de référence aux images cible. Alors que le service Style Guide extrait des éléments stylistiques d’une image d’entrée qui lui permettent de guider la création d’une image de sortie en fonction de l’invite, Style Transfer transforme spécifiquement le contenu existant tout en préservant la composition d’origine. Cet outil permet de créer du contenu cohérent sur plusieurs ressources.
Voici les paramètres obligatoires de Style Transfer :
+ **init\$1image** : (chaîne) image Base64 contenant le sujet que vous souhaitez redéfinir. Chaque côté de l’image doit mesurer au moins 64 pixels. Le nombre total de pixels ne peut pas dépasser 9 437 184 pixels. Les proportions de l’image doivent être comprises entre 1:2,5 et 2,5:1. Formats pris en charge : jpeg, png, webp.
+ **style\$1image** : (chaîne) image Base64 contenant le sujet que vous souhaitez redéfinir. Chaque côté de l’image doit mesurer au moins 64 pixels. Le nombre total de pixels ne peut pas dépasser 9 437 184 pixels. Les proportions de l’image doivent être comprises entre 1:2,5 et 2,5:1. Formats pris en charge : jpeg, png, webp.
Les paramètres suivants sont facultatifs :
+ **prompt** : (chaîne) ce que vous souhaitez voir dans l’image de sortie. Une invite descriptive forte qui définit clairement les éléments, les couleurs et les sujets permettra d’obtenir de meilleurs résultats. Contrôlez la pondération d’un mot donné à l’aide du format (mot:pondération), où « mot » est le mot dont vous souhaitez contrôler la pondération et « pondération » est une valeur. Une valeur comprise entre 0 et 1,0 réduit l’accent sur le mot et une valeur comprise entre 1,1 et 2 met l’accent dessus. Par exemple : « Le ciel était d’un (bleu:0,3) et d’un (vert:1,8) vifs » refléterait un ciel bleu et vert, mais davantage vert que bleu.
+ **negative\$1prompt** : (chaîne) texte de présentation décrivant ce que vous ne souhaitez pas voir dans l’image de sortie. Il s’agit d’une fonctionnalité avancée. 10 000 caractères maximum.
+ **seed** : (nombre) valeur spécifique utilisée pour indiquer le « caractère aléatoire » de la génération. (Omettez ce paramètre ou transmettez 0 pour utiliser une amorce aléatoire.) Plage de valeurs : de 0 à 4294967294. Valeur par défaut : 0.
+ **output\$1format** : (chaîne) indique le type de contenu de l’image générée. Enum : jpeg, png, webp. Valeur par défaut : png.
+ **composition\$1fidelity** : (nombre) mesure dans laquelle le style de l’image de sortie ressemble à celui de l’image d’entrée. Plage de valeurs : de 0 à 1. Valeur par défaut : 0,9.
+ **style\$1strength** : (nombre) parfois appelé débruitage, ce paramètre contrôle l’influence du paramètre style\$1image sur l’image générée. La valeur 0 produirait une image identique à l’entrée. La valeur 1 serait comme si vous n’aviez transmis aucune image. Plage de valeurs : de 0 à 1. Valeur par défaut : 1.
+ **change\$1strength** : (nombre) mesure dans laquelle l’image d’origine doit changer. Plage de valeurs : de 0,1 à 1. Valeur par défaut : 0,9.
------
#### [ API ]
```
import base64
import json
import requests
import io
import os
from PIL import Image
image = "./content/input.jpg"
style_image = "./content/style.jpg"
region = "us-east-1"
model_id = "us.stability.stable-style-transfer-v1:0"
url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_id}/invoke"
api_key = os.getenv("AWS_BEARER_TOKEN_BEDROCK") # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api-keys.html
headers = {
"Content-Type":"application/json",
"Authorization":f"Bearer {api_key}"
}
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
with open(style_image, "rb") as style_image_file:
style_image_base64 = base64.b64encode(style_image_file.read()).decode('utf-8')
params = {
"init_image": image_base64,
"style_image": style_image_base64,
"prompt": "statue"
}
response = requests.request("POST", url, json=params, headers=headers)
response.raise_for_status()
model_response = json.loads(response.text)
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
#### [ Python ]
```
import boto3
import base64
import io
import json
from PIL import Image
image = "./content/cat_statue_512x512.jpg"
style_image = "./content/glowbot_style.jpg"
region = "us-east-1"
model_id = "us.stability.stable-style-transfer-v1:0"
bedrock = boto3.client("bedrock-runtime", region_name=region)
try:
with open(image, "rb") as image_file:
image_base64 = base64.b64encode(image_file.read()).decode('utf-8')
with open(style_image, "rb") as style_image_file:
style_image_base64 = base64.b64encode(style_image_file.read()).decode('utf-8')
params = {
"init_image": image_base64,
"style_image": style_image_base64,
"prompt": "statue"
}
request = json.dumps(params)
response = bedrock.invoke_model(modelId=model_id, body=request)
model_response = json.loads(response["body"].read())
base64_image_data = model_response["images"][0]
if not base64_image_data:
raise ValueError("No image data found in model response.")
image_data = base64.b64decode(base64_image_data)
image = Image.open(io.BytesIO(image_data))
image.save("image.png")
print("Successfully saved image.")
except Exception as e:
print(e)
```
------
Le tableau suivant indique les images d’entrée et de sortie d’un appel Style Transfer :
| Input | Style | Output |
| --- | --- | --- |
| ![\[alt text not found\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/images/stable-image-services/input-style-transfer.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/images/stable-image-services/style-style-transfer.jpg) | ![\[alt text not found\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/images/stable-image-services/output-style-transfer.jpg) |
# Modèles TwelveLabs
Cette section décrit les paramètres de demande et les champs de réponse pour les modèles TwelveLabs. Utilisez ces informations pour effectuer des appels d’inférence vers les modèles TwelveLabs. Le TwelveLabs Pegasus 1.2 modèle prend en charge [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)les opérations et [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)(streaming). Les TwelveLabs Marengo Embed 3.0 modèles TwelveLabs Marengo Embed 2.7 et les [StartAsyncInvoke](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_StartAsyncInvoke.html)opérations de support. Cette section inclut également des exemples de code qui montrent comment appeler les modèles TwelveLabs. Pour utiliser un modèle dans une opération d’inférence, vous avez besoin de l’ID du modèle. Pour obtenir l’ID du modèle, consultez [Modèles de fondation pris en charge dans Amazon Bedrock](models-supported.md).
TwelveLabs est l’un des principaux fournisseurs de modèles d’IA multimodaux spécialisés dans la compréhension et l’analyse vidéo. Leurs modèles avancés offrent des fonctionnalités sophistiquées de recherche vidéo, d'analyse et de génération de contenu grâce à des technologies de vision par state-of-the-art ordinateur et de traitement du langage naturel.
Amazon Bedrock propose trois TwelveLabs modèles :
+ TwelveLabs Pegasus 1.2fournit une compréhension et une analyse complètes des vidéos.
+ TwelveLabs Marengo Embed 2.7génère des intégrations de haute qualité pour le contenu vidéo, texte, audio et image.
+ TwelveLabs Marengo Embed 3.0est le dernier modèle d'intégration doté de performances et de fonctionnalités améliorées.
Ces modèles vous aident à créer des applications qui traitent, analysent et tirent des informations des données vidéo à grande échelle.
**TwelveLabs Pegasus 1.2**
Modèle multimodal qui offre des capacités complètes de compréhension et d’analyse vidéo, notamment la reconnaissance de contenu, la détection des scènes et la compréhension contextuelle. Ce modèle peut analyser le contenu vidéo et générer des descriptions textuelles, des informations et des réponses aux questions concernant la vidéo.
**TwelveLabs Marengo Embed 2.7**
Modèle de vectorisation multimodal qui génère des représentations vectorielles de haute qualité de contenu vidéo, texte, audio et image pour la recherche de similarités, le clustering et d’autres tâches de machine learning. Ce modèle prend en charge plusieurs modalités d’entrée et fournit des vectorisations spécialisées optimisées pour différents cas d’utilisation.
**TwelveLabs Marengo Embed 3.0**
Un modèle d'intégration multimodal amélioré qui étend les capacités de Marengo 2.7 avec la prise en charge de la modalité de saisie entrelacée de texte et d'image. Ce modèle génère des représentations vectorielles de haute qualité de contenu vidéo, texte, audio, image et texte-image entrelacé pour la recherche de similarités, le clustering et d'autres tâches d'apprentissage automatique.
**Topics**
+ [TwelveLabs Pegasus 1.2](model-parameters-pegasus.md)
+ [TwelveLabs Marengo Embed 2.7](model-parameters-marengo.md)
+ [TwelveLabs Marengo Embed 3.0](model-parameters-marengo-3.md)
# TwelveLabs Pegasus 1.2
Le modèle TwelveLabs Pegasus 1.2 fournit des fonctionnalités complètes de compréhension et d’analyse vidéo. Il peut analyser le contenu vidéo et générer des descriptions textuelles, des informations et des réponses aux questions concernant la vidéo.
Utilisez ces informations pour effectuer des appels d'inférence vers TwelveLabs des modèles avec InvokeModel les opérations InvokeModelWithResponseStream (streaming).
+ Fournisseur — TwelveLabs
+ Catégories : compréhension des vidéos, analyse de contenu
+ ID du modèle : `twelvelabs.pegasus-1-2-v1:0`
+ Modalité d’entrée : vidéo
+ Modalité de sortie : texte
+ Taille maximale de la vidéo : vidéo d’une heure (taille de fichier inférieure à 2 Go)
## Paramètres de demande TwelveLabs Pegasus 1.2
Le tableau suivant décrit les paramètres d’entrée pour le modèle TwelveLabs Pegasus 1.2 :
**Paramètres de demande TwelveLabs Pegasus 1.2**
| Champ | Type | Obligatoire | Description |
| --- | --- | --- | --- |
| inputPrompt | chaîne | Oui | Invite à analyser la vidéo. Max : 2 000 jetons. |
| temperature | double | Non | Température du modèle. Contrôle le caractère aléatoire de la sortie. Par défaut : 0,2, Min : 0, Max : 1. |
| responseFormat | Objet | Non | Permet aux utilisateurs de définir le format de sortie structuré. Prend actuellement en charge uniquement json\$1schema. |
| mediaSource | objet | Oui | Décrit la source multimédia. Il faut fournir soit base64String soit s3Location. |
| mediaSource.base64String | chaîne | Non | Chaîne d’octets codée en Base64 pour la vidéo. Maximum : 25 Mo. |
| mediaSource.s3Location.uri | chaîne | Non | URI S3 à partir duquel la vidéo peut être téléchargée. Max : vidéo d’une heure (taille de fichier inférieure à 2 Go). |
| mediaSource.s3Location.bucketOwner | chaîne | Non | L’ID du compte AWS du propriétaire du compartiment. |
| maxOutputTokens | entier | Non | Nombre maximum de jetons à générer. Max : 4096. |
## TwelveLabs Pegasus 1.2 Champs de réponse
Le tableau suivant décrit les champs de sortie pour le modèle TwelveLabs Pegasus 1.2 :
**TwelveLabs Pegasus 1.2 Champs de réponse**
| Champ | Type | Description |
| --- | --- | --- |
| message | chaîne | Message de sortie contenant l’analyse de la vidéo par le modèle. |
| finishReason | chaîne | Raison d’arrêt qui décrit la raison pour laquelle la sortie s’est terminée. Valeurs valides : stop (l’API a renvoyé les complétions complètes sans atteindre aucune limite), length (la génération a dépassé la limite max\$1tokens). |
## Demande et réponse TwelveLabs Pegasus 1.2
Les exemples suivants montrent comment utiliser le modèle TwelveLabs Pegasus 1.2 avec différentes sources d’entrée.
------
#### [ Request ]
Les exemples suivants montrent les formats de demande pour le modèle TwelveLabs Pegasus 1.2.
**Utilisation d’une vidéo encodée en Base64 :**
```
{
"inputPrompt": "tell me about the video",
"mediaSource": {
"base64String": ""
},
"temperature": 0
}
```
**Utilisation de la vidéo stockée dans S3 :**
```
{
"inputPrompt": "Tell me about this video",
"mediaSource": {
"s3Location": {
"uri": "s3://path-to-video-object-in-s3",
"bucketOwner": "bucket-owner-account-id"
}
},
"temperature": 0
}
```
**Utilisation d’un format de sortie structuré :**
```
{
"inputPrompt": "Analyze this video and provide a structured summary",
"mediaSource": {
"s3Location": {
"uri": "s3://path-to-video-object-in-s3",
"bucketOwner": "bucket-owner-account-id"
}
},
"temperature": 0.2,
"maxOutputTokens": 2048,
"responseFormat": {
"type": "json_schema",
"json_schema": {
"name": "video_analysis",
"schema": {
"type": "object",
"properties": {
"summary": {"type": "string"},
"key_scenes": {"type": "array", "items": {"type": "string"}},
"duration": {"type": "string"}
},
"required": ["summary", "key_scenes"]
}
}
}
}
```
------
#### [ Response ]
Les exemples suivants montrent les formats de réponse pour le modèle TwelveLabs Pegasus 1.2.
**Réponse normale :**
```
{
"message": "This video shows a person walking through a park during sunset. The scene includes trees, a walking path, and golden lighting from the setting sun. The person appears to be enjoying a peaceful evening stroll.",
"finishReason": "stop"
}
```
**Réponse avec sortie structurée :**
```
{
"message": "{\"summary\": \"A peaceful evening walk through a park at sunset\", \"key_scenes\": [\"Person entering the park\", \"Walking along tree-lined path\", \"Sunset lighting through trees\", \"Person sitting on bench\"], \"duration\": \"Approximately 2 minutes\"}",
"finishReason": "stop"
}
```
**Réponse lorsque le nombre maximum de jetons est atteint :**
```
{
"message": "This video contains multiple scenes showing various activities. The first scene shows...",
"finishReason": "length"
}
```
------
# TwelveLabs Marengo Embed 2.7
Le modèle TwelveLabs Marengo Embed 2.7 génère des vectorisations à partir d’entrées vidéo, texte, audio ou image. Ces vectorisation peuvent être utilisées pour la recherche de similarités, le clustering et d’autres tâches de machine learning.
+ Fournisseur — TwelveLabs
+ ID du modèle : twelvelabs.marengo-embed-2-7-v1:0
Le modèle TwelveLabs Marengo Embed 2.7 prend en charge les opérations d’exécution d’Amazon Bedrock décrites dans le tableau suivant.
+ Pour plus d’informations sur les cas d’utilisation, pour les différentes méthodes d’API, consultez [En savoir plus sur les cas d’utilisation des différentes méthodes d’inférence de modèleDifférentes méthodes d'inférence](inference-methods.md).
+ Pour plus d’informations sur les types de modèles, consultez [Fonctionnement de l’inférence dans Amazon BedrockFonctionnement de l’inférence](inference-how.md).
+ Pour obtenir la liste des modèles IDs et voir les modèles et AWS les TwelveLabs Marengo Embed 2.7 régions pris en charge, recherchez le modèle dans le tableau à l'adresse[Modèles de fondation pris en charge dans Amazon Bedrock](models-supported.md).
+ Pour une liste complète des profils d'inférence IDs, voir[Régions et modèles pris en charge pour les profils d'inférence](inference-profiles-support.md). L'ID du profil d'inférence est basé sur la AWS région.
****
| Opération API | Types de nœuds pris en charge | Modalités d’entrée | Modalités de sortie |
| --- | --- | --- | --- |
| InvokeModel | [Profils d’inférence](inference-profiles-support.md) | Texte Image | Intégration |
| StartAsyncInvoke | [Modèles de base](models-supported.md) | Vidéo Audio Image Texte | Vectorisation |
**Note**
Utilisez `InvokeModel` pour générer des vectorisations pour une requête de recherche. Utilisez `StartAsyncInvoke` pour générer des vectorisations pour des actifs à grande échelle.
Les quotas suivants s’appliquent à l’entrée :
****
| Modalité d’entrée | Maximum |
| --- | --- |
| Texte | 77 jetons |
| Image | 5 Mo |
| Vidéo (S3) | 2 Go |
| Audio (S3) | 2 Go |
**Note**
Si vous définissez l’audio ou la vidéo en ligne à l’aide du codage Base64, assurez-vous que les données utiles du corps de la demande ne dépassent pas le quota d’invocation du modèle Amazon Bedrock de 25 Mo.
**Topics**
+ [Paramètres de demande TwelveLabs Marengo Embed 2.7](#model-parameters-marengo-async-request)
+ [Réponse de TwelveLabs Marengo Embed 2.7](#model-parameters-marengo-response)
+ [Exemples de code pour l’TwelveLabs Marengo Embed 2.7](#model-parameters-marengo-examples)
## Paramètres de demande TwelveLabs Marengo Embed 2.7
Lorsque vous faites une demande, le champ dans lequel l’entrée spécifique au modèle est spécifiée dépend du fonctionnement de l’API :
+ [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)— Dans la demande`body`.
+ [StartAsyncInvoke](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_StartAsyncInvoke.html)— Dans le `modelInput` champ du corps de la demande.
Le format de l’entrée du modèle dépend de la modalité d’entrée :
------
#### [ Text ]
```
{
"inputType": "text",
"inputText": "string",
"textTruncate": "string
}
```
------
#### [ Inline image ]
```
{
"inputType": "image",
"mediaSource": {
"base64String": "base64-encoded string"
}
}
```
------
#### [ S3 image ]
```
{
"inputType": "image",
"mediaSource": {
"s3Location": {
"uri": "string",
"bucketOwner": "string"
}
}
}
```
------
#### [ Inline video ]
```
{
"inputType": "video",
"mediaSource": {
"s3Location": {
"base64String": "base64-encoded string"
}
},
"startSec": double,
"lengthSec": double,
"useFixedLengthSec": double,
"embeddingOption": "visual-text" | "visual-image" | "audio"
}
```
------
#### [ S3 video ]
```
{
"inputType": "image",
"mediaSource": {
"s3Location": {
"uri": "string",
"bucketOwner": "string"
}
},
"startSec": double,
"lengthSec": double,
"useFixedLengthSec": double,
"minClipSec": int,
"embeddingOption": ["string"]
}
```
------
#### [ Inline audio ]
```
{
"inputType": "audio",
"mediaSource": {
"base64String": "base64-encoded string"
},
"startSec": double,
"lengthSec": double,
"useFixedLengthSec": double
}
```
------
#### [ S3 audio ]
```
{
"inputType": "audio",
"mediaSource": {
"s3Location": {
"uri": "string",
"bucketOwner": "string"
}
},
"startSec": double,
"lengthSec": double,
"useFixedLengthSec": double
}
```
------
Développez les sections suivantes pour obtenir des détails sur les paramètres d’entrée :
### inputType
Modalité de la vectorisation.
+ **Type** : chaîne
+ **Obligatoire** : oui
+ **Valeurs valides** : `video` \$1 `text` \$1 `audio` \$1 `image`
### inputText
Texte à vectoriser.
+ **Type** : chaîne
+ **Obligatoire :** oui (pour les types d’entrée compatibles)
+ **Types d’entrée compatibles :** texte
### textTruncate
Spécifie la manière dont la plateforme tronque le texte.
+ **Type** : chaîne
+ **Obligatoire** : non
+ **Valeurs valides**:
+ `end` : tronque la fin du texte.
+ `none` : renvoie une erreur si le texte dépasse la limite
+ **Valeur par défaut :** fin
+ **Types d’entrée compatibles :** texte
### mediaSource
Contient des informations concernant la source du média.
+ **Type :** objet
+ **Obligatoire :** oui (si le type est compatible)
+ **Types d’entrées compatibles :** image, vidéo, audio
Le format de l’objet `mediaSource` dans le corps de la demande varie selon que le média est défini comme une chaîne codée en Base64 ou comme un emplacement S3.
+ **Chaîne codée en Base64**
```
{
"mediaSource": {
"base64String": "base64-encoded string"
}
}
```
+ `base64String` : chaîne codée en Base64 pour le média.
+ **Emplacement S3** — Spécifiez l'URI S3 et le propriétaire du compartiment.
```
{
"s3Location": {
"uri": "string",
"bucketOwner": "string"
}
}
```
+ `uri` : URI S3 contenant le média.
+ `bucketOwner`— L'ID de AWS compte du propriétaire du compartiment S3.
### embeddingOption
Spécifie les types de vectorisations à extraire.
+ **Type** : liste
+ **Obligatoire** : non
+ **Valeurs valides pour les membres de la liste :**
+ `visual-text` : vectorisations visuelles optimisées pour la recherche de texte.
+ `visual-image` : vectorisations visuelles optimisées pour la recherche d’images.
+ `audio` : vectorisation de l’audio dans la vidéo.
+ **Valeur par défaut :** ["visual-text", "visual-image", "audio"]
+ **Types d’entrées compatibles :** vidéo, audio
### startSec
Point temporel du clip, en secondes, auquel le traitement doit commencer.
+ **Type** : double
+ **Obligatoire** : non
+ **Valeur minimale** : 0
+ **Valeur par défaut :** 0
+ **Types d’entrées compatibles :** vidéo, audio
### lengthSec
Durée en secondes, à compter du point de départ `startSec`, au terme duquel le traitement doit s’arrêter.
+ **Type** : double
+ **Obligatoire** : non
+ **Valeurs valides :** 0 - durée du média
+ **Valeur par défaut :** durée du média
+ **Types d’entrées compatibles :** vidéo, audio
Exemple :
+ startSec : 5
+ lengthSec : 20
+ Résultat : Le clip est traité de 0:05 à 0:25 (5 secondes \$1 20 secondes).
### useFixedLengthSec
Durée de chaque clip pour lequel le modèle doit générer une vectorisation.
+ **Type** : double
+ **Obligatoire** : non
+ **Paramètres de valeur :** 2 à 10. Il doit être supérieur ou égal à `minClipSec`.
+ **Valeur par défaut :** dépend du type de média :
+ **Vidéo :** divisée dynamiquement par la détection des limites de prise de vue.
+ **Audio :** divisé uniformément avec des segments aussi proches que possible de 10 secondes.
Exemples :
+ Un clip de 50 secondes est divisé en 5 segments de 10 secondes.
+ Un clip de 16 secondes est divisé en 2 segments de 8 secondes.
+ **Types d’entrées compatibles :** vidéo, audio
+ **Remarque :** doit être supérieur ou égal à `minClipSec`.
### minClipSec
Définit une valeur minimale pour chaque clip en secondes.
+ **Type :** int
+ **Obligatoire** : non
+ **Paramètres de valeur :** plage de valeurs : de 1 à 5
+ **Valeur par défaut :** 4
+ **Types d’entrées compatibles :** vidéo
+ **Remarques :** Doit être inférieur ou égal à `useFixedLengthSec`.
## Réponse de TwelveLabs Marengo Embed 2.7
L’emplacement des vectorisations de sortie et des métadonnées associées dépend de la méthode d’invocation :
+ [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)— Dans le corps de réponse.
+ [StartAsyncInvoke](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_StartAsyncInvoke.html)— Dans le compartiment S3 défini dans le`s3OutputDataConfig`, une fois la tâche d'invocation asynchrone terminée.
S’il existe plusieurs vecteurs, le résultat est une liste d’objets, chacun contenant un vecteur et les métadonnées associées.
Le format du vecteur de vectorisation en sortie est le suivant :
```
{
"embedding": ["string"],
"embeddingOption": "visual-text" | "visual-image" | "audio",
"startSec": double,
"endsec": double
}
```
Développez les sections suivantes pour obtenir des détails sur les paramètres de réponse :
### embedding
Vectorisation : représentation vectorielle de l’entrée.
+ **Type** : liste de doubles
### embeddingOption
Type des vectorisations.
+ **Type** : chaîne
+ **Valeurs possibles :**
+ `visual-text` : vectorisations visuelles optimisées pour la recherche de texte.
+ `visual-image` : vectorisations visuelles optimisées pour la recherche d’images.
+ `audio` : vectorisation de l’audio dans la vidéo.
+ **Types d’entrées compatibles :** Vidéo
### startSec
Décalage de départ du clip.
+ **Type** : double
+ **Types d’entrées compatibles :** vidéo, audio
### endSec
Décalage de fin du clip, en secondes.
+ **Type** : double
+ **Types d’entrées compatibles :** vidéo, audio
## Exemples de code pour l’TwelveLabs Marengo Embed 2.7
Cette section explique comment utiliser le modèle TwelveLabs Marengo Embed 2.7 avec différents types d’entrées à l’aide de Python. Les exemples montrent comment définir une entrée spécifique au modèle et exécuter des invocations de modèle.
**Note**
InvokeModel prend uniquement en charge la saisie de texte et d'image. Pour les entrées vidéo et audio, utilisez StartAsyncInvoke.
Composez votre code en procédant comme suit :
**1. Définir une entrée spécifique au modèle**
Définissez l’entrée spécifique au modèle en fonction de votre type d’entrée :
------
#### [ Text ]
```
# Create the model-specific input
model_id = "twelvelabs.marengo-embed-2-7-v1:0"
# Replace the us prefix depending on your region
inference_profile_id = "us.twelvelabs.marengo-embed-2-7-v1:0"
model_input = {
"inputType": "text",
"inputText": "man walking a dog"
}
```
------
#### [ Inline image ]
```
# Create the model-specific input
model_id = "twelvelabs.marengo-embed-2-7-v1:0"
# Replace the us prefix depending on your region
inference_profile_id = "us.twelvelabs.marengo-embed-2-7-v1:0"
model_input = {
"inputType": "image",
"mediaSource": {
"base64String": "example-base64-image"
}
}
```
------
#### [ S3 image ]
```
# Create the model-specific input
model_id = "twelvelabs.marengo-embed-2-7-v1:0"
# Replace the us prefix depending on your region
inference_profile_id = "us.twelvelabs.marengo-embed-2-7-v1:0"
model_input = {
"inputType": "image",
"mediaSource": {
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/my_image.png",
"bucketOwner": "123456789012"
}
}
}
```
------
#### [ Inline video ]
```
# Create the model-specific input
model_id = "twelvelabs.marengo-embed-2-7-v1:0"
# Replace the us prefix depending on your region
inference_profile_id = "us.twelvelabs.marengo-embed-2-7-v1:0"
model_input = {
"inputType": "video",
"mediaSource": {
"base64String": "base_64_encoded_string_of_video"
},
"startSec": 0,
"lengthSec": 13,
"useFixedLengthSec": 5,
"embeddingOption": [
"visual-text",
"audio"
]
}
```
------
#### [ S3 video ]
```
# Create the model-specific input
model_id = "twelvelabs.marengo-embed-2-7-v1:0"
# Replace the us prefix depending on your region
inference_profile_id = "us.twelvelabs.marengo-embed-2-7-v1:0"
model_input = {
"inputType": "video",
"mediaSource": {
"s3Location": {
"uri": "amzn-s3-demo-bucket/my-video.mp4",
"bucketOwner": "123456789012"
}
},
"startSec": 0,
"lengthSec": 13,
"useFixedLengthSec": 5,
"embeddingOption": [
"visual-text",
"audio"
]
}
```
------
#### [ Inline audio ]
```
# Create the model-specific input
model_id = "twelvelabs.marengo-embed-2-7-v1:0"
# Replace the us prefix depending on your region
inference_profile_id = "us.twelvelabs.marengo-embed-2-7-v1:0"
model_input = {
"inputType": "audio",
"mediaSource": {
"base64String": "base_64_encoded_string_of_audio"
},
"startSec": 0,
"lengthSec": 13,
"useFixedLengthSec": 10
}
```
------
#### [ S3 audio ]
```
# Create the model-specific input
model_id = "twelvelabs.marengo-embed-2-7-v1:0"
# Replace the us prefix depending on your region
inference_profile_id = "us.twelvelabs.marengo-embed-2-7-v1:0"
model_input = {
"inputType": "audio",
"mediaSource": {
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/my-audio.wav",
"bucketOwner": "123456789012"
}
},
"startSec": 0,
"lengthSec": 13,
"useFixedLengthSec": 10
}
```
------
**2. Exécuter l’invocation du modèle à l’aide de l’entrée du modèle**
Ajoutez ensuite le fragment de code correspondant à la méthode d’invocation du modèle que vous avez choisie.
------
#### [ InvokeModel ]
```
# Run model invocation with InvokeModel
import boto3
import json
# Initialize the Bedrock Runtime client
client = boto3.client('bedrock-runtime')
# Make the request
response = client.invoke_model(
modelId=inference_profile_id,
body=json.dumps(model_input)
)
# Print the response body
response_body = json.loads(response['body'].read().decode('utf-8'))
print(response_body)
```
------
#### [ StartAsyncInvoke ]
```
# Run model invocation asynchronously
import boto3
import json
# Initalize the Bedrock Runtime client.
client = boto3.client("bedrock-runtime")
try:
# Start the asynchronous job
invocation = client.start_async_invoke(
modelId=model_id,
modelInput=model_input,
outputDataConfig={
"s3OutputDataConfig": {
"s3Uri": "s3://&example-s3-destination-bucket;"
}
}
)
# Print the response JSON
print("Response:")
print(json.dumps(invocation, indent=2, default=str))
except Exception as e:
# Implement error handling here.
message = e.response["Error"]["Message"]
print(f"Error: {message}")
```
------
# TwelveLabs Marengo Embed 3.0
Le TwelveLabs Marengo Embed 3.0 modèle génère des intégrations améliorées à partir d'entrées vidéo, texte, audio ou image. Cette dernière version offre des performances et une précision améliorées pour la recherche de similarités, le clustering et d'autres tâches d'apprentissage automatique.
+ Fournisseur — TwelveLabs
+ ID du modèle : twelvelabs.marengo-embed-3-0-v1:0
Marengo Embed 3.0 apporte plusieurs améliorations clés :
+ **Capacité de traitement vidéo étendue** : traitez jusqu'à 4 heures de contenu vidéo et audio. Les fichiers peuvent atteindre 6 Go, soit le double de la capacité des versions précédentes. Il est donc idéal pour analyser des événements sportifs complets, des vidéos de formation étendues et des productions cinématographiques complètes.
+ **Analyse sportive améliorée** — Le modèle apporte des améliorations significatives. Il permet de mieux comprendre la dynamique du jeu, les mouvements des joueurs et la détection des événements.
+ **Support multilingue mondial** — Capacités linguistiques étendues de 12 à 36 langues. Cela permet aux organisations internationales de créer des systèmes de recherche et de récupération unifiés qui fonctionnent parfaitement dans divers marchés et régions.
+ **Précision de recherche multimodale** : combinez des images et du texte descriptif dans une seule demande d'intégration. Cela combine similarité visuelle et compréhension sémantique pour fournir des résultats de recherche plus précis et contextuellement pertinents.
+ **Dimension d'intégration réduite** : réduction de 1024 à 512, ce qui peut contribuer à réduire les coûts de stockage.
Le modèle TwelveLabs Marengo Embed 3.0 prend en charge les opérations d’exécution d’Amazon Bedrock décrites dans le tableau suivant.
+ Pour plus d’informations sur les cas d’utilisation, pour les différentes méthodes d’API, consultez [En savoir plus sur les cas d’utilisation des différentes méthodes d’inférence de modèleDifférentes méthodes d'inférence](inference-methods.md).
+ Pour plus d’informations sur les types de modèles, consultez [Fonctionnement de l’inférence dans Amazon BedrockFonctionnement de l’inférence](inference-how.md).
+ Pour obtenir la liste des modèles IDs et voir les modèles et AWS les TwelveLabs Marengo Embed 3.0 régions pris en charge, recherchez le modèle dans le tableau à l'adresse[Modèles de fondation pris en charge dans Amazon Bedrock](models-supported.md).
+ Pour une liste complète des profils d'inférence IDs, voir[Régions et modèles pris en charge pour les profils d'inférence](inference-profiles-support.md). L'ID du profil d'inférence est basé sur la AWS région.
****
| Opération API | Types de nœuds pris en charge | Modalités d’entrée | Modalités de sortie |
| --- | --- | --- | --- |
| InvokeModel | USA Est (Virginie du Nord) — [Modèles de base](models-supported.md) et profils [d'inférence](inference-profiles-support.md) Europe (Irlande) [— Profils d'inférence](inference-profiles-support.md) Asie-Pacifique (Séoul) - [Modèles de base](models-supported.md) | Texte Image **Remarque :** Le texte et l'image entrelacés sont également pris en charge. | Vectorisation |
| StartAsyncInvoke | [Modèles de base](models-supported.md) | Vidéo Audio Image Texte **Remarque :** Le texte et l'image entrelacés sont également pris en charge. | Vectorisation |
**Note**
Utilisez `InvokeModel` pour générer des vectorisations pour une requête de recherche. Utilisez `StartAsyncInvoke` pour générer des vectorisations pour des actifs à grande échelle.
Les quotas suivants s’appliquent à l’entrée :
****
| Modalité d’entrée | Maximum |
| --- | --- |
| Texte | 500 jetons |
| Image | 5 Mo par image |
| Vidéo (S3) | 6 Go, durée de 4 heures |
| Audio (S3) | 6 Go, durée de 4 heures |
**Note**
Si vous définissez l’audio ou la vidéo en ligne à l’aide du codage Base64, assurez-vous que les données utiles du corps de la demande ne dépassent pas le quota d’invocation du modèle Amazon Bedrock de 25 Mo.
**Topics**
+ [Paramètres de demande TwelveLabs Marengo Embed 3.0](#model-parameters-marengo-3-async-request)
+ [Réponse de TwelveLabs Marengo Embed 3.0](#model-parameters-marengo-3-response)
+ [Exemples de code pour l’TwelveLabs Marengo Embed 3.0](#model-parameters-marengo-3-examples)
## Paramètres de demande TwelveLabs Marengo Embed 3.0
Lorsque vous faites une demande, le champ dans lequel l’entrée spécifique au modèle est spécifiée dépend du fonctionnement de l’API :
+ [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)— Dans la demande`body`.
+ [StartAsyncInvoke](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_StartAsyncInvoke.html)— Dans le `modelInput` champ du corps de la demande.
Le format de l’entrée du modèle dépend de la modalité d’entrée :
------
#### [ Text ]
```
{
"inputType": "text",
"text": {
"inputText": "string"
}
}
```
------
#### [ Image ]
```
{
"inputType": "image",
"image": {
"mediaSource": {
"base64String": "base64-encoded string", // base64String OR s3Location, exactly one
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/folder/dog.jpg",
"bucketOwner": "123456789012"
}
}
}
}
```
------
#### [ Text & image ]
```
{
"inputType": "text_image",
"text_image": {
"inputText": "man walking a dog",
"mediaSource": {
"base64String": "base64-encoded string", // base64String OR s3Location, exactly one
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/folder/dog.jpg",
"bucketOwner": "123456789012"
}
}
}
}
```
------
#### [ Audio ]
```
{
"inputType": "audio",
"audio": {
"mediaSource": {
"base64String": "base64-encoded string", // base64String OR s3Location, exactly one
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/audio/a.wav",
"bucketOwner": "123456789012"
}
},
"startSec": 0,
"endSec": 6,
"segmentation": {
"method": "fixed",
"fixed": {
"durationSec": 6
}
},
"embeddingOption": [
"audio",
"transcription"
], // optional, default=both
"embeddingScope": [
"clip",
"asset"
] // optional, one or both
}
}
```
------
#### [ Video ]
```
{
"inputType": "video",
"video": {
"mediaSource": {
"base64String": "base64-encoded string", // base64String OR s3Location, exactly one
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/video/clip.mp4",
"bucketOwner": "123456789012"
}
},
"startSec": 0,
"endSec": 6,
"segmentation": {
"method": "dynamic", // dynamic OR fixed, exactly one
"dynamic": {
"minDurationSec": 4
}
"method": "fixed",
"fixed": {
"durationSec": 6
}
},
"embeddingOption": [
"visual",
"audio",
"transcription"
], // optional, default=all
"embeddingScope": [
"clip",
"asset"
] // optional, one or both
},
"inferenceId": "some inference id"
}
```
------
Développez les sections suivantes pour obtenir des détails sur les paramètres d’entrée :
### inputType
Modalité de la vectorisation.
+ **Type** : chaîne
+ **Obligatoire** : oui
+ **Valeurs valides** : `text` \$1 `image` \$1 `text_image` \$1 `audio` \$1 `video`
### inputText
Texte à vectoriser.
+ **Type** : chaîne
+ **Obligatoire :** oui (pour les types d’entrée compatibles)
+ **Types d’entrée compatibles :** texte
### mediaSource
Contient des informations concernant la source du média.
+ **Type :** objet
+ **Obligatoire :** oui (si le type est compatible)
+ **Types d’entrées compatibles :** image, vidéo, audio
Le format de l’objet `mediaSource` dans le corps de la demande varie selon que le média est défini comme une chaîne codée en Base64 ou comme un emplacement S3.
+ **Chaîne codée en Base64**
```
{
"mediaSource": {
"base64String": "base64-encoded string"
}
}
```
+ `base64String` : chaîne codée en Base64 pour le média.
+ **Emplacement S3** — Spécifiez l'URI S3 et le propriétaire du compartiment.
```
{
"s3Location": {
"uri": "string",
"bucketOwner": "string"
}
}
```
+ `uri` : URI S3 contenant le média.
+ `bucketOwner`— L'ID de AWS compte du propriétaire du compartiment S3.
### embeddingOption
Spécifie les types de vectorisations à extraire.
+ **Type** : liste
+ **Obligatoire** : non
+ **Valeurs valides pour les membres de la liste :**
+ `visual`— Intégrations visuelles issues de la vidéo.
+ `audio` : vectorisation de l’audio dans la vidéo.
+ `transcription`— Insertions du texte transcrit.
+ **Valeur par défaut :**
+ Vidéo : ["visuel », « audio », « transcription"]
+ Audio : ["audio », « transcription"]
+ **Types d’entrées compatibles :** vidéo, audio
### Champ d'intégration
Spécifie l'étendue des intégrations à récupérer.
+ **Type** : liste
+ **Obligatoire** : non
+ **Valeurs valides pour les membres de la liste :**
+ `clip`— Renvoie les intégrations pour chaque clip.
+ `asset`— Renvoie les intégrations pour l'ensemble de l'actif.
+ **Types d’entrées compatibles :** vidéo, audio
### startSec
Point temporel du clip, en secondes, auquel le traitement doit commencer.
+ **Type** : double
+ **Obligatoire** : non
+ **Valeur minimale** : 0
+ **Valeur par défaut :** 0
+ **Types d’entrées compatibles :** vidéo, audio
### endSec
Moment en secondes auquel le traitement doit prendre fin.
+ **Type** : double
+ **Obligatoire** : non
+ **Valeur minimale :** StartSec \$1 longueur du segment
+ **Valeur maximale :** Durée du média
+ **Valeur par défaut :** durée du média
+ **Types d’entrées compatibles :** vidéo, audio
### segmentation
Définit la manière dont le média est divisé en segments pour l'intégration de la génération.
+ **Type :** objet
+ **Obligatoire** : non
+ **Types d’entrées compatibles :** vidéo, audio
L'objet de segmentation contient un `method` champ et des paramètres spécifiques à la méthode :
+ `method`— La méthode de segmentation à utiliser. Valeurs valides : `dynamic` \$1 `fixed`
+ `dynamic`— Pour les vidéos, utilise la détection des limites de prise de vue pour diviser le contenu de manière dynamique. Contient :
+ `minDurationSec`— Durée minimale de chaque segment en secondes. Type : entier. Gamme : 1 à 5. Par défaut : 4.
+ `fixed`— Divise le contenu en segments de durée égale. Contient :
+ `durationSec`— Durée de chaque segment en secondes. Type : entier. Gamme : 1 à 10. Par défaut : 6.
**Comportement par défaut :**
+ Vidéo : utilise la segmentation dynamique avec détection des limites de prise de vue.
+ Audio : utilise une segmentation fixe. Le contenu est divisé le plus équitablement possible avec des segments de près de 10 secondes.
### ID d'inférence
Identifiant unique pour la demande d'inférence.
+ **Type** : chaîne
+ **Obligatoire** : non
## Réponse de TwelveLabs Marengo Embed 3.0
L’emplacement des vectorisations de sortie et des métadonnées associées dépend de la méthode d’invocation :
+ InvokeModel — Dans le corps de réponse.
+ StartAsyncInvoke — Dans le compartiment S3 défini dans`s3OutputDataConfig`, une fois la tâche d'invocation asynchrone terminée.
S’il existe plusieurs vecteurs, le résultat est une liste d’objets, chacun contenant un vecteur et les métadonnées associées.
Le format du vecteur de vectorisation en sortie est le suivant :
```
{
"data": {
"embedding": [
0.111, 0.234, ...
],
"embeddingOption": ["visual", "audio", "transcription" (for video input) | "audio", "transcription" (for audio input)],
"embeddingScope": ["asset" | "clip"],
"startSec": 0,
"endSec": 4.2
}
}
```
Les intégrations sont renvoyées sous forme de tableau de flottants.
L'endroit où cette réponse s'affiche dépend de la méthode d'API que vous avez utilisée :
+ InvokeModel — Apparaît dans le corps de la réponse.
+ StartAsyncInvoke — Apparaît à l'emplacement S3 que vous avez spécifié dans la demande. La réponse renvoie un`invocationArn`. Vous pouvez l'utiliser pour obtenir des métadonnées relatives à l'appel asynchrone. Cela inclut le statut et l'emplacement S3 où les résultats sont écrits.
Développez les sections suivantes pour obtenir des détails sur les paramètres de réponse :
### embedding
Vectorisation : représentation vectorielle de l’entrée.
+ **Type** : liste de doubles
### embeddingOption
Type des vectorisations.
+ **Type** : chaîne
+ **Valeurs possibles :**
+ visual — Intégrations visuelles issues de la vidéo.
+ audio — Incorporation de l'audio dans la vidéo.
+ transcription — Incorporation du texte transcrit.
+ **Types d’entrées compatibles :** vidéo, audio
### Champ d'intégration
Spécifie l'étendue des intégrations à récupérer.
+ **Type** : chaîne
Vous pouvez inclure une ou plusieurs des valeurs suivantes :
+ clip : renvoie les intégrations pour chaque clip.
+ actif : renvoie les intégrations pour l'ensemble de l'actif.
### startSec
Décalage de départ du clip.
+ **Type** : double
+ **Types d’entrées compatibles :** vidéo, audio
### endSec
Le décalage final du clip. Non applicable aux intégrations de texte, d'image et de text\$1image.
+ **Type** : double
+ **Types d’entrées compatibles :** vidéo, audio
## Exemples de code pour l’TwelveLabs Marengo Embed 3.0
Cette section explique comment utiliser le modèle TwelveLabs Marengo Embed 3.0 avec différents types d’entrées à l’aide de Python. Les exemples montrent comment définir une entrée spécifique au modèle et exécuter des invocations de modèle.
**Note**
InvokeModel prend en charge le texte, l'image et le texte avec entrée d'image entrelacée. Pour les entrées vidéo et audio, utilisez StartAsyncInvoke.
Composez votre code en procédant comme suit :
**1. Définir une entrée spécifique au modèle**
Définissez l’entrée spécifique au modèle en fonction de votre type d’entrée :
------
#### [ Text ]
```
# Create the model-specific input
model_id = "twelvelabs.marengo-embed-3-0-v1:0"
# Replace the us prefix depending on your region
inference_profile_id = "us.twelvelabs.marengo-embed-3-0-v1:0"
model_input = {
"inputType": "text",
"text": {
"inputText": "man walking a dog"
}
}
```
------
#### [ Image ]
```
# Create the model-specific input
model_id = "twelvelabs.marengo-embed-3-0-v1:0"
# Replace the us prefix depending on your region
inference_profile_id = "us.twelvelabs.marengo-embed-3-0-v1:0"
model_input = {
"inputType": "image",
"image": {
"mediaSource": {
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/my_image.png",
"bucketOwner": "123456789012"
}
}
}
}
```
------
#### [ Text & image ]
```
# Create the model-specific input
model_id = "twelvelabs.marengo-embed-3-0-v1:0"
# Replace the us prefix depending on your region
inference_profile_id = "us.twelvelabs.marengo-embed-3-0-v1:0"
model_input = {
"inputType": "text_image",
"text_image": {
"inputText": "man walking a dog",
"mediaSource": {
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/my_image.jpg",
"bucketOwner": "123456789012"
}
}
}
}
```
------
#### [ Audio ]
```
# Create the model-specific input
model_id = "twelvelabs.marengo-embed-3-0-v1:0"
# Replace the us prefix depending on your region
inference_profile_id = "us.twelvelabs.marengo-embed-3-0-v1:0"
model_input = {
"inputType": "audio",
"audio": {
"mediaSource": {
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/my-audio.wav",
"bucketOwner": "123456789012"
}
},
"startSec": 0,
"endSec": 5,
"segmentation": {
"method": "fixed",
"fixed": {
"durationSec": 5
}
},
"embeddingScope": ["clip", "asset"],
"embeddingOption": ["audio"]
}
}
```
------
#### [ Video ]
```
# Create the model-specific input
model_id = "twelvelabs.marengo-embed-3-0-v1:0"
# Replace the us prefix depending on your region
inference_profile_id = "us.twelvelabs.marengo-embed-3-0-v1:0"
model_input = {
"inputType": "video",
"video": {
"mediaSource": {
"s3Location": {
"uri": "s3://amzn-s3-demo-bucket/my-video.mp4",
"bucketOwner": "123456789012"
}
},
"startSec": 10,
"endSec": 20,
"segmentation": {
"method": "fixed",
"fixed": {
"durationSec": 5
}
},
"embeddingOption": [
"visual",
"audio"
],
"embeddingScope": [
"clip",
"asset"
]
}
}
```
------
**2. Exécuter l’invocation du modèle à l’aide de l’entrée du modèle**
Ajoutez ensuite le fragment de code correspondant à la méthode d’invocation du modèle que vous avez choisie.
------
#### [ InvokeModel ]
```
# Run model invocation with InvokeModel
import boto3
import json
# Initialize the Bedrock Runtime client
client = boto3.client('bedrock-runtime')
# Make the request
response = client.invoke_model(
modelId=inference_profile_id,
body=json.dumps(model_input)
)
# Print the response body
response_body = json.loads(response['body'].read().decode('utf-8'))
print(response_body)
```
------
#### [ StartAsyncInvoke ]
```
# Run model invocation asynchronously
import boto3
import json
# Initalize the Bedrock Runtime client.
client = boto3.client("bedrock-runtime")
try:
# Start the asynchronous job
invocation = client.start_async_invoke(
modelId=model_id,
modelInput=model_input,
outputDataConfig={
"s3OutputDataConfig": {
"s3Uri": "s3://amzn-s3-demo-bucket"
}
}
)
# Print the response JSON
print("Response:")
print(json.dumps(invocation, indent=2, default=str))
except Exception as e:
# Implement error handling here.
message = e.response["Error"]["Message"]
print(f"Error: {message}")
```
------
# Modèles Writer AI Palmyra
Cette section décrit les paramètres de demande et les champs de réponse pour les modèles Writer AI. Utilisez ces informations pour effectuer des appels d’inférence aux modèles Writer AI à l’aide des opérations [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) et [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) (streaming). Cette section inclut également des exemples de code Python qui montrent comment appeler les modèles Writer AI. Pour utiliser un modèle dans une opération d’inférence, vous avez besoin de l’ID du modèle. Pour obtenir l’ID du modèle, consultez [Modèles de fondation pris en charge dans Amazon Bedrock](models-supported.md). Certains modèles fonctionnent également avec l’[API Converse](conversation-inference.md). Pour vérifier si l’API Converse prend en charge un modèle Writer AI spécifique, consultez [Modèles et fonctionnalités des modèles pris en charge](conversation-inference-supported-models-features.md). Pour plus d’exemples de code, consultez [Exemples de code pour Amazon Bedrock utilisant AWS SDKs](service_code_examples.md).
Les modèles de fondation d’Amazon Bedrock prennent en charge les modalités d’entrée et de sortie, qui varient d’un modèle à l’autre. Pour vérifier les modalités prises en charge par les modèles Writer AI, consultez [Modèles de fondation pris en charge dans Amazon Bedrock](models-supported.md). Pour vérifier quelles fonctionnalités Amazon Bedrock sont prises en charge par les modèles Writer AI, consultez [Modèles de fondation pris en charge dans Amazon Bedrock](models-supported.md). Pour vérifier dans quelles régions AWS les modèles Writer AI sont disponibles, consultez [Modèles de fondation pris en charge dans Amazon Bedrock](models-supported.md).
Lorsque vous effectuez des appels d’inférence avec les modèles Writer AI, vous incluez une invite pour le modèle. Pour plus d’informations générales sur la création d’invites pour les modèles pris en charge par Amazon Bedrock, consultez [Concepts d’ingénierie de requête](prompt-engineering-guidelines.md). Pour obtenir des informations sur les invites spécifiques Writer AI, consultez le [guide d’ingénierie de requête Writer AI]().
**Writer Palmyra X4**
Classé en tête du classement Stanford HELM, Writer Palmyra X4 atteint des performances supérieures dans le cadre de tâches complexes et de flux de travail agentiques. Il combine une fenêtre contextuelle de 128 000 jetons à une suite de fonctionnalités destinées aux entreprises, notamment le raisonnement avancé, l’appel d’outils, la délégation LLM, la génération à enrichissement contextuel (RAG) intégrée, la génération de code, les sorties structurées, la multimodalité et le support multilingue. À l’aide d’outils spécifiques à l’entreprise qui étendent la capacité d’action du modèle, Palmyra X4 permet aux développeurs de créer des applications et des agents chargés de mettre à jour le système, d’effectuer des transactions, d’envoyer des e-mails, de déclencher un flux de travail, etc.
**Writer Palmyra X5**
Avec une fenêtre contextuelle d’un million de jetons, Writer Palmyra X5 marque la fin des contraintes contextuelles pour le développement d’applications et d’agents. Le nouveau modèle de Writer atteint des performances supérieures en matière d’inférence contextuelle prolongée grâce à une mémoire et à une puissance de traitement étendues, permettant aux développeurs de créer plus rapidement des flux de travail agentiques plus complexes en plusieurs étapes. À l’instar de Palmyra X4, Palmyra X5 inclut une suite de fonctionnalités adaptées aux entreprises, notamment le raisonnement avancé, l’appel d’outils, la délégation LLM, la génération à enrichissement contextuel (RAG) intégrée, la génération de code, les sorties structurées, la multimodalité et le support multilingue
**Topics**
+ [Writer Palmyra X4](model-parameters-palmyra-x4.md)
+ [Writer Palmyra X5](model-parameters-palmyra-x5.md)
# Writer Palmyra X4
Writer Palmyra X4 est un modèle avec une fenêtre contextuelle pouvant contenir jusqu’à 128 000 jetons. Ce modèle excelle dans le traitement et la compréhension de tâches complexes, ce qui le rend idéal pour l’automatisation des flux de travail, les tâches de codage et l’analyse des données.
+ Prestataire : Writer
+ Catégories : génération de texte, génération de code, mise en forme de texte enrichi
+ Dernière version : v1
+ Date de sortie : 28 avril 2025
+ ID du modèle : `writer.palmyra-x4-v1:0`
+ Modalité : texte
+ Nombre maximum de jetons : entrée : 122 880 jetons, sortie : 8 192 jetons
+ Langue : anglais, espagnol, français, allemand, chinois et plusieurs autres langues
+ Type de déploiement : sans serveur
## Champ body de la demande d’invocation Palmyra X4
Lorsque vous effectuez un appel [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) à l’aide d’un modèle Writer, remplissez le champ `body` avec un objet JSON conforme à celui ci-dessous. Entrez l’invite dans le champ `text` de l’objet `text_prompts`.
```
{
"modelId": "writer.palmyra-x4-v1:0",
"contentType": "application/json",
"accept": "application/json",
"body": "{\"messages\":[{\"role\":\"user\",\"content\":{\"text\":\"Explain quantum computing in simple terms\"}}]}"
}
```
Le tableau suivant indique les valeurs minimales, maximales et par défaut des paramètres numériques.
****
| Paramètre | Type | Par défaut | Gamme/Validation | Description |
| --- | --- | --- | --- | --- |
| messages | array | Obligatoire | 1-∞ articles | Historique des messages de discussion |
| temperature | float | 1.0 | 0,0 ≤ x ≤ 2,0 | Température de prélèvement |
| top\$1p | float | 1.0 | 0,0 < valeur ≤ 1,0 | Seuil d’échantillonnage du noyau |
| max\$1tokens | int | 16 | 1 ≤ x ≤ 8 192 | Nombre maximum de jetons à générer |
| min\$1tokens | int | 0 | 0 ≤ x ≤ max\$1tokens | Nombre minimum de jetons avant l’arrêt |
| stop | array | [] | ≤ 4 entrées | Séquences d’arrêt |
| Seed (Noyau) | int | null | Nombre entier | Random Seed (Nombre aléatoire) |
| presence\$1penalty | float | 0.0 | -2,0 ≤ x ≤ 2,0 | Nouvelle pénalité de présence de jetons |
| frequency\$1penalty | float | 0.0 | -2,0 ≤ x ≤ 2,0 | Pénalité de fréquence de jeton |
## Champ body de la réponse d’invocation Palmyra X4
Le JSON de réponse pour Writer Palmyra X4 utilise le format suivant :
```
{
"id": "chatcmpl-a689a6e150b048ca8814890d3d904d41",
"object": "chat.completion",
"created": 1745854231,
"model": "writer.palmyra-x4-v1:0",
"choices": [
{
"index": 0,
"message": {
"role": "assistant",
"reasoning_content": null,
"content": "Quantum computing harnesses quantum mechanics to process information in extraordinarily powerful ways. Unlike classical bits, which are 0 or 1, quantum bits (qubits) can exist in multiple states simultaneously through superposition. Qubits also entangle, allowing them to be interconnected in such a way that the state of one (whether it's 0 or 1) can depend on the state of another, no matter the distance between them. This combination of superposition and entanglement enables quantum computers to solve complex problems much faster than classical computers, particularly in areas like cryptography, optimization, and simulations of molecular structures. However, quantum computing is still in its early stages, facing challenges in stability and scalability.",
"tool_calls": []
},
"logprobs": null,
"finish_reason": "stop",
"stop_reason": null
}
],
"usage": {
"prompt_tokens": 43,
"total_tokens": 186,
"completion_tokens": 143,
"prompt_tokens_details": null
},
"prompt_logprobs": null
}
```
## Writer Palmyra X4Exemple de code
Exemples de code pour Writer Palmyra X4 :
```
import boto3
import json
from botocore.exceptions import ClientError
client = boto3.client("bedrock-runtime", region_name="us-west-2")
model_id = "writer.palmyra-x4-v1:0"
# Format the request payload using the model's native structure.
native_request = {
"temperature": 1,
"messages": [
{
"role": "user",
"content": "Explain quantum computing in simple terms.",
}
],
}
# Convert the native request to JSON.
request = json.dumps(native_request)
try:
# Invoke the model with the request.
response = client.invoke_model(modelId=model_id, body=request)
except (ClientError, Exception) as e:
print(f"ERROR: Can't invoke '{model_id}'. Reason: {e}")
exit(1)
# Decode the response body.
model_response = json.loads(response["body"].read())
# Extract and print the response text.
response_text = model_response["content"][0]["text"]
print(response_text)
```
# Writer Palmyra X5
Writer Palmyra X5 inclut une suite de fonctionnalités adaptées aux entreprises, notamment le raisonnement avancé, l’appel d’outils, la délégation LLM, la génération à enrichissement contextuel (RAG) intégrée, la génération de code, les sorties structurées, la multimodalité et le support multilingue.
Le modèle Writer Palmyra X5 possède les commandes suivantes :
+ Prestataire : Writer
+ Catégories : génération de texte, génération de code, mise en forme de texte enrichi
+ Dernière version : v1
+ Date de sortie : 28 avril 2025
+ ID du modèle : `writer.palmyra-x5-v1:0`
+ Modalité : texte
+ Nombre maximum de jetons : entrée : 1 040 000 jetons, sortie : 8 192 jetons
+ Langue : anglais, espagnol, français, allemand, chinois et plusieurs autres langues
+ Type de déploiement : sans serveur
## Champ body de la demande d’invocation Palmyra X5
Lorsque vous effectuez un appel [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) à l’aide d’un modèle Writer, remplissez le champ `body` avec un objet JSON conforme à celui ci-dessous. Entrez l’invite dans le champ `text` de l’objet `text_prompts`.
```
{
"modelId": "writer.palmyra-x5-v1:0",
"contentType": "application/json",
"accept": "application/json",
"body": "{\"messages\":[{\"role\":\"user\",\"content\":{\"text\":\"Explain quantum computing in simple terms\"}}]}"
}
```
Le tableau suivant indique les valeurs minimales, maximales et par défaut des paramètres numériques.
****
| Paramètre | Type | Par défaut | Gamme/Validation | Description |
| --- | --- | --- | --- | --- |
| messages | array | Obligatoire | 1-∞ articles | Historique des messages de discussion |
| temperature | float | 1.0 | 0,0 ≤ x ≤ 2,0 | Température de prélèvement |
| top\$1p | float | 1.0 | 0,0 ≤ x ≤ 1,0 | Seuil d’échantillonnage du noyau |
| max\$1tokens | int | 16 | 1 ≤ x ≤ 8 192 | Nombre maximum de jetons à générer |
| min\$1tokens | int | 0 | 0 ≤ x ≤ max\$1tokens | Nombre minimum de jetons avant l’arrêt |
| stop | array | [] | ≤ 4 entrées | Séquences d’arrêt |
| Noyau | int | null | Nombre entier | Nombre aléatoire |
| presence\$1penalty | float | 0.0 | -2,0 ≤ x ≤ 2,0 | Nouvelle pénalité de présence de jetons |
| frequency\$1penalty | float | 0.0 | -2,0 ≤ x ≤ 2,0 | Pénalité de fréquence de jeton |
## Champ body de la réponse d’invocation Palmyra X5
Le JSON de réponse pour Writer Palmyra X5 utilise le format suivant :
```
{
"id": "chatcmpl-a689a6e150b048ca8814890d3d904d41",
"object": "chat.completion",
"created": 1745854231,
"model": "writer.palmyra-x5-v1:0",
"choices": [
{
"index": 0,
"message": {
"role": "assistant",
"reasoning_content": null,
"content": "Quantum computing harnesses quantum mechanics to process information in extraordinarily powerful ways. Unlike classical bits, which are 0 or 1, quantum bits (qubits) can exist in multiple states simultaneously through superposition. Qubits also entangle, allowing them to be interconnected in such a way that the state of one (whether it's 0 or 1) can depend on the state of another, no matter the distance between them. This combination of superposition and entanglement enables quantum computers to solve complex problems much faster than classical computers, particularly in areas like cryptography, optimization, and simulations of molecular structures. However, quantum computing is still in its early stages, facing challenges in stability and scalability.",
"tool_calls": []
},
"logprobs": null,
"finish_reason": "stop",
"stop_reason": null
}
],
"usage": {
"prompt_tokens": 43,
"total_tokens": 186,
"completion_tokens": 143,
"prompt_tokens_details": null
},
"prompt_logprobs": null
}
```
# Cycle de vie des modèles
Amazon Bedrock travaille en permanence pour proposer les dernières versions de modèles de fondation offrant de meilleures capacités, une plus grande précision et une sécurité accrue. Lorsque nous lançons de nouvelles versions de modèles, vous pouvez les tester avec la console ou l’API Amazon Bedrock et migrer vos applications pour bénéficier des dernières versions des modèles.
Un modèle proposé sur Amazon Bedrock peut être dans l'un des états suivants : **Active**, **Legacy** ou ** End-of-Life(EOL**). Vous pouvez consulter l’état des modèles proposés dans la console et dans les tableaux ci-dessous. De plus, lorsque vous passez un [ListFoundationModels](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ListFoundationModels.html)appel [GetFoundationModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_GetFoundationModel.html)ou, l'état du modèle est affiché dans le `modelLifecycle` champ de la réponse. Une fois qu’un modèle est lancé sur Amazon Bedrock, il reste sur Amazon Bedrock pendant au moins 12 mois avant la date EOL.
## Versions actives
**Actif** : le fournisseur de modèles travaille activement sur cette version. Dans la plupart des cas, les fournisseurs de modèles abandonnent un modèle une fois que de nouvelles versions sont disponibles. Pour obtenir la liste des modèles actuellement actifs et des régions prises en charge, consultez la section [Disponibilité régionale](models-region-compatibility.md). Pour les détails spécifiques au modèle, voir [Modèles de cartes](model-cards.md).
## Modèles Legacy et end-of-life (EOL)
**Héritage** — Nous vous informerons lorsqu'un fournisseur de modèles fait passer un modèle à l'état Legacy. **Un modèle restera à l’état Hérité pendant au moins 6 mois avant la date EOL**. Bien que vous puissiez continuer à utiliser un modèle Hérité pendant cette période, vous devez prévoir de passer à un modèle Actif avant la date EOL. Les nouveaux clients ne peuvent pas utiliser les modèles Hérités et les clients existants peuvent perdre l’accès aux modèles Hérités pour cause d’inactivité.
**Pour les modèles dont la date EOL est postérieure au 1er février 2026 : ** après un minimum de 3 mois à l’état Hérité, un modèle entre dans la partie d’accès public étendu de la période de l’état Hérité. Pendant cette période d’accès public étendu, les utilisateurs actifs d’un modèle Hérité peuvent continuer à l’utiliser jusqu’à la date EOL (pendant un minimum de 3 mois), mais vous devez vous attendre à des prix plus élevés, qui seront fixés par le fournisseur du modèle. Lorsque le modèle passe pour la première fois à l'état Legacy, nous vous informerons de la date choisie par le fournisseur pour la transition d'un modèle vers un accès public étendu (qui prendra fin au moins 3 mois à compter de la notification) et des modifications de prix (le cas échéant). Nous vous informerons également avant toute nouvelle modification tarifaire pendant la période d’accès public étendu.
Vous ne pouvez pas créer de [débit alloué](prov-throughput.md) pour les modèles à l’état Hérité.
**EOL** : après la date EOL, un modèle est marqué EOL dans la console et dans le tableau suivant. À la date de fin de validité ou peu après, le modèle ne sera plus disponible dans toutes les AWS régions et les demandes adressées à cette version échoueront, sauf accord privé entre vous et le fournisseur pour un accès continu. Vous devez migrer vers le modèle le plus récent en mettant à jour le code de votre application avant la date EOL. La migration ne s’effectue pas automatiquement.
Le tableau suivant indique les modèles actuellement dans l'état Legacy ou en attente end-of-life (EOL) sur Amazon Bedrock. Ce tableau n'inclut pas les modèles actifs ni les modèles dont la date d'expiration est déjà dépassée.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/model-lifecycle.html)
La date d'accès public étendu indique le moment où un modèle Legacy entre dans la partie d'accès public étendu de la période Legacy. Au cours de cette phase, les prix peuvent augmenter selon les indications du fournisseur du modèle. Le modèle reste disponible jusqu'à sa date d'expiration.
**Modèles personnalisés et comportement du cycle de vie**
Lorsqu'un modèle de base passe à l'état Legacy, les capacités de personnalisation sont limitées. Si vous avez déjà affiné ou personnalisé le modèle avant qu'il ne passe à l'état Legacy, vous pouvez :
+ Créez un nouveau déploiement de modèle personnalisé pour une inférence à la demande.
+ Continuez à utiliser les déploiements à la demande existants ou les points de terminaison à débit provisionné (PT) existants, à condition qu'ils aient été créés avant que le modèle ne passe à l'état Legacy.
Cependant, une fois que le modèle est dans l'état Legacy, vous ne pouvez pas créer de nouvelles tâches de réglage précis sur ce modèle. Vous ne pouvez pas créer de nouveaux points de terminaison à débit provisionné (PT). Les nouveaux clients ne peuvent pas commencer à utiliser l'ancien modèle et les clients existants risquent de perdre l'accès en cas d'inactivité prolongée.
Étant donné que le retrait des modèles Legacy est prévu, les clients sont vivement encouragés à commencer à transférer les charges de travail et les déploiements personnalisés vers un modèle actif dès que l'annonce de l'ancien modèle est faite, et à terminer la migration avant la date End-of-Life (EOL) du modèle.
# Accès aux modèles de fondation Amazon Bedrock
L’accès à tous les modèles de fondation Amazon Bedrock est activé par défaut avec les autorisations AWS Marketplace appropriées. Pour commencer, il vous suffit de sélectionner un modèle dans le catalogue de modèles de la console Amazon Bedrock et de l'ouvrir dans le terrain de jeu ou d'invoquer le modèle à l'aide des opérations de l'API [Converse [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html)ou de l'API. Pour plus d’informations sur les différents modèles pris en charge dans Amazon Bedrock, consultez [Informations sur les modèles de fondation Amazon Bedrock](https://docs.aws.amazon.com//bedrock/latest/userguide/foundation-models-reference.html). Pour plus d’informations sur la tarification des modèles, consultez [Tarification d’Amazon Bedrock](https://aws.amazon.com/bedrock/pricing/).
L’accès à tous les modèles de fondation Amazon Bedrock est activé par défaut avec les autorisations AWS Marketplace appropriées dans toutes les régions AWS commerciales. Pour l'accès par programme à des modèles tiers, voir[Gérez l'accès aux modèles à l'aide du SDK et de la CLI](#model-access-modify).
**Comprendre l'accès automatique aux modèles**
Lorsque vous invoquez un modèle tiers pour la première fois dans votre compte, Amazon Bedrock lance automatiquement le processus d'abonnement en arrière-plan. Pendant cette période de configuration (jusqu'à 15 minutes), vos appels d'API peuvent réussir temporairement pendant la finalisation de l'abonnement. Si aucune condition préalable n'est requise, la tentative d'abonnement échoue et les appels d'API suivants seront `AccessDeniedException` renvoyés. Après avoir accordé les autorisations nécessaires, la fin de l'abonnement peut prendre jusqu'à 2 minutes. Pendant ce temps, les appels d'API peuvent continuer à revenir`AccessDeniedException`. Une fois l'abonnement terminé, toutes les invocations suivantes seront couronnées de succès. Pour éviter complètement cela, vérifiez toutes les conditions préalables avant d'invoquer des modèles en production.
**Conditions préalables pour un accès réussi au modèle :**
**Autorisations AWS Marketplace** : votre rôle IAM doit disposer d'`aws-marketplace:ViewSubscriptions`autorisations `aws-marketplace:Subscribe``aws-marketplace:Unsubscribe`, et. Consultez [Accorder à IAM l’autorisation de demander l’accès aux modèles de fondation Amazon Bedrock à l’aide d’un ID de produit](#model-access-permissions) pour plus de détails.
**Modèles anthropiques** : pour les modèles anthropiques, vous devez remplir le formulaire de première utilisation (FTU) avant d'invoquer le modèle.
**Mode de paiement valide** : votre compte AWS doit disposer d'un mode de paiement valide configuré pour les achats sur AWS Marketplace.
**Note**
Anthropic exige que les nouveaux clients soumettent des détails sur le cas d’utilisation avant d’invoquer un modèle une fois par compte ou une fois sur le compte de gestion de l’organisation. Vous pouvez soumettre les détails sur le cas d’utilisation en sélectionnant un modèle Anthropic dans le catalogue de modèles de la console Amazon Bedrock ou en appelant la commande d’API `PutUseCaseForModelAccess`. L’accès au modèle est accordé immédiatement après que les détails sur le cas d’utilisation ont été soumis avec succès. La soumission du formulaire sur le compte root sera héritée par les autres comptes de la même AWS organisation.
**Note**
Pour les modèles 3P, par invoking/using le modèle, vous acceptez pour la première fois le contrat de licence d'utilisateur final applicable. Pour plus d’informations, consultez [Conditions de service AWS](https://aws.amazon.com/service-terms/) et [Contrats de licence des modèles tiers sans serveur](https://aws.amazon.com/legal/bedrock/third-party-models/).
Les organisations qui doivent examiner et accepter le CLUF avant d’autoriser l’utilisation du modèle doivent :
Bloquer initialement l’accès au modèle à l’aide de politiques de contrôle des services (SCP) ou de politiques IAM
Consulter les termes du CLUF
Activez l'accès aux modèles par le biais de SCP/IAM politiques uniquement si vous acceptez les termes du CLUF
**Topics**
+ [Accorder à IAM l’autorisation de demander l’accès aux modèles de fondation Amazon Bedrock à l’aide d’un ID de produit](#model-access-permissions)
+ [Utilisation des clés de condition de l’ID de produit pour contrôler l’accès](model-access-product-ids.md)
+ [Gérez l'accès aux modèles à l'aide du SDK et de la CLI](#model-access-modify)
+ [Accédez aux modèles Amazon Bedrock Foundation sur AWS GovCloud (États-Unis)](#model-access-govcloud)
+ [Gérez les abonnements aux modèles avec License Manager](managed-entitlements.md)
## Accorder à IAM l’autorisation de demander l’accès aux modèles de fondation Amazon Bedrock à l’aide d’un ID de produit
Vous pouvez gérer les autorisations d’accès aux modèles en créant des politiques IAM personnalisées. Pour modifier l'accès aux modèles de fondation Amazon Bedrock, vous devez d'abord associer une politique IAM basée sur l'identité avec les [AWS Marketplace actions](https://docs.aws.amazon.com/service-authorization/latest/reference/list_awsmarketplace.html#awsmarketplace-actions-as-permissions) suivantes au rôle IAM qui autorise l'accès à Amazon Bedrock.
Lorsque vous invoquez pour la première fois un modèle sans serveur Amazon Bedrock servi depuis AWS Marketplace un compte, Bedrock tente d'activer automatiquement le modèle pour votre compte. Pour que cette activation automatique fonctionne, des AWS Marketplace autorisations sont requises.
Si vous ne pouvez pas assumer d' AWS Marketplace AWS Marketplace autorisation, une personne autorisée doit activer le modèle du compte en une seule étape (manuellement ou automatiquement). Une fois activé, tous les utilisateurs du compte peuvent invoquer le modèle sans avoir besoin d' AWS Marketplace autorisations. Les utilisateurs n'ont pas besoin AWS Marketplace d'autorisations d'abonnement pour invoquer des modèles une fois qu'ils ont été activés. Ces autorisations ne sont requises que lors de la première utilisation d'un modèle dans un compte.
L’accès aux modèles de fondation sans serveur Amazon Bedrock avec un ID de produit est contrôlé par les actions IAM suivantes :
****
| Action IAM | Description | S’applique aux modèles |
| --- | --- | --- |
| aws-marketplace:Subscribe | Permet à une entité IAM de s'abonner à AWS Marketplace des produits, notamment aux modèles de fondation Amazon Bedrock. | Uniquement les modèles sans serveur Amazon Bedrock dotés d’un ID de produit. AWS Marketplace |
| aws-marketplace:Unsubscribe | Permet à une identité IAM de se désabonner de AWS Marketplace produits, y compris les modèles Amazon Bedrock Foundation. | Uniquement les modèles sans serveur Amazon Bedrock dotés d’un ID de produit. AWS Marketplace |
| AWS Marketplace : ViewSubscriptions | Permet à une identité IAM de renvoyer une liste de AWS Marketplace produits, y compris les modèles de fondation Amazon Bedrock. | Uniquement les modèles sans serveur Amazon Bedrock dotés d’un ID de produit. AWS Marketplace |
**Note**
Pour l’action `aws-marketplace:Subscribe` uniquement, vous pouvez utiliser la [clé de condition](https://docs.aws.amazon.com/service-authorization/latest/reference/list_awsmarketplace.html#awsmarketplace-policy-keys) `aws-marketplace:ProductId` pour restreindre l’abonnement à des modèles spécifiques.
**Pour qu’une identité IAM demande l’accès à des modèles dotés d’un ID de produit**
L’identité doit être associée à une politique qui autorise `aws-marketplace:Subscribe`.
**Note**
Si une identité est déjà abonnée à un modèle dans une AWS région, le modèle devient disponible pour que l'identité demande l'accès dans toutes les AWS régions dans lesquelles le modèle est disponible, même s'il `aws-marketplace:Subscribe` est refusé pour les autres régions.
Pour plus d'informations sur la création de la politique, voir [Démarrage rapide](getting-started.md).
Pour l’action `aws-marketplace:Subscribe` uniquement, vous pouvez utiliser la [clé de condition](https://docs.aws.amazon.com/service-authorization/latest/reference/list_awsmarketplace.html#awsmarketplace-policy-keys) `aws-marketplace:ProductId` pour restreindre l’abonnement à des modèles spécifiques.
**Note**
Les modèles des fournisseurs suivants ne sont pas vendus par l'intermédiaire de ces fournisseurs AWS Marketplace et ne disposent pas de clés de produit. Vous ne pouvez donc pas leur attribuer `aws-marketplace` des actions :
Amazon
DeepSeek
Mistral AI
Meta
Qwen
OpenAI
Vous pouvez toutefois empêcher l'utilisation de ces modèles en refusant les actions d'Amazon Bedrock et en spécifiant ces modèles IDs `Resource` sur le terrain. Pour obtenir un exemple, consultez [Empêcher une identité d’utiliser un modèle une fois que l’accès a déjà été accordé](#model-access-prevent-usage).
Sélectionnez une section pour voir des exemples de politique IAM pour un cas d’utilisation spécifique :
**Topics**
+ [Empêcher une identité de demander l’accès à un modèle avec un ID de produit](#model-access-prevent-subscription)
+ [Empêcher une identité d’utiliser un modèle une fois que l’accès a déjà été accordé](#model-access-prevent-usage)
### Empêcher une identité de demander l’accès à un modèle avec un ID de produit
Pour empêcher une entité IAM de demander l’accès à un modèle spécifique doté d’un ID de produit, associez à l’utilisateur une politique IAM qui refuse l’action `aws-marketplace:Subscribe` et étendez le champ `Condition` à l’ID de produit du modèle.
Par exemple, vous pouvez attacher la politique suivante à une identité pour l’empêcher de s’abonner au modèle Anthropic Claude 3.5 Sonnet :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Action": [
"aws-marketplace:Subscribe"
],
"Resource": "*",
"Condition": {
"ForAnyValue:StringEquals": {
"aws-marketplace:ProductId": [
"prod-m5ilt4siql27k"
]
}
}
}
]
}
```
------
**Note**
Le refus à `aws-marketplace:Subscribe` lui seul **ne bloquera pas** l'invocation du premier modèle, car Amazon Bedrock **initie automatiquement** l'abonnement en arrière-plan.
Pour **bloquer l'accès aux modèles dès le départ**, appliquez des **politiques de refus `bedrock:InvokeModel` au** niveau de l'**organisation (SCP) ou du compte (IAM)**.
**Note**
Avec cette politique, l’entité IAM aura accès par défaut à tous les modèles nouvellement ajoutés.
Si l’identité est déjà abonnée au modèle dans au moins une région, cette politique n’empêche pas l’accès dans les autres régions. Au lieu de cela, vous pouvez empêcher son utilisation en consultant l’exemple dans [Empêcher une identité d’utiliser un modèle une fois que l’accès a déjà été accordé](#model-access-prevent-usage).
### Empêcher une identité d’utiliser un modèle une fois que l’accès a déjà été accordé
Si une identité IAM a déjà obtenu l’accès à un modèle, vous pouvez empêcher l’utilisation du modèle en refusant toutes les actions Amazon Bedrock et en limitant le champ `Resource` à l’ARN du modèle de fondation.
Par exemple, vous pouvez associer la politique suivante à une identité pour l'empêcher d'utiliser le Anthropic Claude 3.5 Sonnet modèle dans toutes les AWS régions :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Action": [
"bedrock:*"
],
"Resource": [
"arn:aws:bedrock:*::foundation-model/anthropic.claude-3-5-sonnet-20240620-v1:0"
]
}
]
}
```
------
# Utilisation des clés de condition de l’ID de produit pour contrôler l’accès
La clé de condition `aws-marketplace:ProductId` peut être utilisée pour contrôler la possibilité de s’abonner aux modèles sans serveur Amazon Bedrock dotés d’un ID de produit dans AWS Marketplace. Pour apprendre à utiliser la clé de condition de l’ID de produit, consultez les exemples fournis dans [Accorder à IAM l’autorisation de demander l’accès aux modèles de fondation Amazon Bedrock à l’aide d’un ID de produit](model-access.md#model-access-permissions).
**Note**
Les modèles des fournisseurs suivants ne sont pas vendus par l'intermédiaire de ces fournisseurs AWS Marketplace et ne disposent pas de clés de produit. Vous ne pouvez donc pas leur attribuer `aws-marketplace` des actions :
Amazon
DeepSeek
Mistral AI
Meta
Qwen
OpenAI
Vous pouvez toutefois empêcher l'utilisation de ces modèles en refusant les actions d'Amazon Bedrock et en spécifiant ces modèles IDs `Resource` sur le terrain. Pour obtenir un exemple, consultez [Empêcher une identité d’utiliser un modèle une fois que l’accès a déjà été accordé](model-access.md#model-access-prevent-usage).
Le tableau suivant répertorie les produits IDs pour les modèles de base sans serveur Amazon Bedrock dotés d'un identifiant de produit :
| Modèle | ID produit |
| --- | --- |
| AI21 Labs Jurassic-2 Mid | 1d288c71-65f9-489a-a3e2-9c7f4f6e6a85 |
| AI21 Labs Jurassic-2 Ultra | cc0bdd50-279a-40d8-829c-4009b77a1fcc |
| AI21 Jamba-Instruct | prod-dr2vpvd4k73aq |
| AI21 Labs Jamba 1.5 Large | prod-evcp4w4lurj26 |
| AI21 Labs Jamba 1.5 Mini | prod-ggrzjm65qmjhm |
| Anthropic Claude | c468b48a-84df-43a4-8c46-8870630108a7 |
| Anthropic Claude Instant | b0eb9475-3a2c-43d1-94d3-56756fd43737 |
| Anthropic Claude 3 Sonnet | prod-6dw3qvchef7zy |
| Anthropic Claude 3.5 Sonnet | prod-m5ilt4siql27k |
| Anthropic Claude 3.5 Sonnet v2 | prod-cx7ovbu5wex7g |
| Anthropic Claude 3.7 Sonnet | prod-4dlfvry4v5hbi |
| Anthropic Claude Sonnet 4.5 | prod-mxcfnwvpd6kb4 |
| Anthropic Claude Haiku 4.5 | prod-xdkflymybwmvi |
| Anthropic Claude Sonnet 4 | prod-4pmewlybdftbs |
| AnthropicClaude Sonnet 4.6 | prod-ffvjxvh4ltq64 |
| Anthropic Claude 3 Haiku | prod-ozonys2hmmpeu |
| Anthropic Claude 3.5 Haiku | prod-5oba7y7jpji56 |
| Anthropic Claude 3 Opus | prod-fm3feywmwerog |
| AnthropicClaude Opus4 | prod-azycxvnd5mhqi |
| AnthropicClaude Opus4,1 | prod-w3q2d6rfge4tw |
| AnthropicClaude Opus4,5 | prod-jhuafngbly644 |
| AnthropicClaude Opus 4.6 | prod-5ukwuglpt66 kg |
| Cohere Command | a61c46fe-1747-41aa-9af0-2e0ae8a9ce05 |
| Cohere Command Light | 216b69fd-07d5-4c7b-866b-936456d68311 |
| Cohere Command R | prod-tukx4z3hrewle |
| Cohere Command R\$1 | prod-nb4wqmplze2pm |
| Cohere Embed (version anglaise) | b7568428-a1ab-46d8-bab3-37def50f6f6a |
| Cohere Embed (version multilingue) | 38e55671-c3fe-4a44-9783-3584906e7cad |
| Cohere Rerank 3.5 | prod-2o5bej62oxkbi |
| Cohere Embed v4 | prod-ft3cj5gst3spo |
| Stable Image Core 1.0 | prod-eacdrmv7zfc5e |
| Stable Diffusion 3 Large 1.0 | prod-cqfmszl26sxu4 |
| Stable Image Ultra 1.0 | prod-7boen2z2wnxrg |
| Stability 3.5 Large 1.0 | prodview-ajc3gw4mjy7my |
| TwelveLabs Marengo Embed 2.7 | prod-o6xchhpirymvs |
| TwelveLabs Pegasus 1.2 | prod-635pcy5x5pc2a |
| Writer Palmyra X4 | prod-azehe4da4pzsy |
| Writer Palmyra X5 | prod-23enyy63orhuk |
Vous pouvez utiliser le modèle suivant pour associer une politique IAM qui contrôle les autorisations d’accès des modèles à un rôle :
Pour d’autres exemples de gestion de l’accès aux modèles à l’aide de politiques IAM, consultez [Exemples de politiques basées sur une identité pour Amazon Bedrock](security_iam_id-based-policy-examples.md).
## Gérez l'accès aux modèles à l'aide du SDK et de la CLI
L'accès au modèle peut être géré à l'aide du SDK en plus d'invoquer le modèle. Les étapes ci-dessous peuvent être utilisées pour create/delete modéliser l'accès et vérifier si l'accès existe déjà ou non. Notez que cela ne s'applique qu'aux modèles tiers.
Pour gérer l'accès aux modèles par programmation, procédez comme suit :
+ [Conditions préalables](#model-access-sdk-prerequisites)
+ [Étape 1 : Répertorier les offres de contrats types de fondation](#model-access-sdk-step1)
+ [Étape 2 : [Nécessaire une seule fois pour les modèles Anthropic uniquement] Indiquez un cas d'utilisation pour le premier utilisateur](#model-access-sdk-step2)
+ [Étape 3 : Création d'un accord type de fondation](#model-access-sdk-step3)
+ [Étape 4 : Obtenir la disponibilité du modèle de base](#model-access-sdk-step4)
+ [[Facultatif] Étape 5 : Supprimer le modèle de contrat de fondation](#model-access-sdk-step5)
### Conditions préalables
+ Attachez la [AmazonBedrockFullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonBedrockFullAccess.html)politique à l'IAM user/role utilisé pour le SDK/CLI.
+ Configuration du SDK Bedrock : [configurer le SDK AWS pour](https://docs.aws.amazon.com/bedrock/latest/userguide/sdk-general-information-section.html) Amazon Bedrock
Remarque : Les instructions ci-dessous utilisent python3 pour les exemples
+ Notez le ModelID du modèle pour lequel l'accès doit être géré.
### Étape 1 : Répertorier les offres de contrats types de fondation
Utilisez cette API pour obtenir les offres d'accord pour un modèle particulier. Cela fournira l'OfferToken utilisé pour créer l'accès au modèle lors des prochaines étapes.
Documentation
+ API : [ListFoundationModelAgreementOffers](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_ListFoundationModelAgreementOffers.html)
+ Documentation CLI : [list-foundation-model-agreement-offers](https://docs.aws.amazon.com/cli/latest/reference/bedrock/list-foundation-model-agreement-offers.html)
------
#### [ AWS CLI ]
```
aws bedrock list-foundation-model-agreement-offers --model-id
```
------
#### [ Python ]
```
# Placeholder for modelId
model_id = ""
# Placeholder for offerId
offer_id = ""
try:
# offerType= "ALL" means both public and private offers, if offerType isn't defined, the default would be "PUBLIC"
model_agreement_offers_response = bedrock_client.list_foundation_model_agreement_offers(modelId=model_id,offerType="ALL")
print(model_agreement_offers_response)
except ClientError as e:
print(f"Failed to list foundation model offers for modelId: {model_id} due to the following error: {e}")
```
------
### Étape 2 : [Nécessaire une seule fois pour les modèles Anthropic uniquement] Indiquez un cas d'utilisation pour le premier utilisateur
Utilisé pour mettre le formulaire de cas d'utilisation pour la première fois requis uniquement pour les modèles Anthropic. Il s'agit d'une condition préalable pour accéder aux modèles Anthropic dans le compte. Cette API n'est requise qu'une seule fois par compte ou par organisation AWS dans toutes les régions commerciales, à l'exception des régions optionnelles où ce formulaire doit être rempli à nouveau.
Documentation
+ API : [PutUseCaseForModelAccess](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_PutUseCaseForModelAccess.html)
+ Documentation de la CLI : [put-use-case-for-model-access](https://docs.aws.amazon.com/cli/latest/reference/bedrock/put-use-case-for-model-access.html)
------
#### [ AWS CLI ]
```
aws bedrock put-use-case-for-model-access \
--form-data
```
------
#### [ Python ]
```
# Placeholder for form data, replace the names
COMPANY_NAME = ""
COMPANY_WEBSITE = ""
INTENDED_USERS = "1" #for external users
INDUSTRY_OPTION = ""
OTHER_INDUSTRY_OPTION = ""
USE_CASES = ""
form_data = {
"companyName": COMPANY_NAME,
"companyWebsite": COMPANY_WEBSITE,
"intendedUsers": INTENDED_USERS,
"industryOption": INDUSTRY_OPTION,
"otherIndustryOption": OTHER_INDUSTRY_OPTION,
"useCases": USE_CASES
}
form_data_json = json.dumps(form_data)
model_access_response = bedrock_client.put_use_case_for_model_access(formData=form_data_json)
```
------
Pour la CLI, les données du formulaire sont le code json codé en base64 du formulaire ci-dessous.
```
{
"companyName": COMPANY_NAME,
"companyWebsite": COMPANY_WEBSITE,
"intendedUsers": INTENDED_USERS,
"industryOption": INDUSTRY_OPTION,
"otherIndustryOption": OTHER_INDUSTRY_OPTION,
"useCases": USE_CASES
}
```
+ COMPANY\$1NAME : chaîne d'une longueur maximale de 128
+ COMPANY\$1WEBSITE : chaîne d'une longueur maximale de 128
+ UTILISATEURS VISÉS : 0, 1 ou 2. 0 : interne, 1 : externe, 2 : interne et externe
+ INDUSTRY\$1OPTION : Chaîne d'une longueur maximale de 128
+ OTHER\$1INDUSTRY\$1OPTION : chaîne d'une longueur maximale de 128
+ USE\$1CASES : chaîne d'une longueur maximale de 8192
### Étape 3 : Création d'un accord type de fondation
Utilisé pour créer un accord (accès) pour le modèle de fondation. Utilisez le jeton d'offre et le ModelID ci-dessus.
Documentation
+ API : [CreateFoundationModelAgreement](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_CreateFoundationModelAgreement.html)
+ Documentation de la CLI : [create-foundation-model-agreement](https://docs.aws.amazon.com/cli/latest/reference/bedrock/create-foundation-model-agreement.html)
------
#### [ AWS CLI ]
```
aws bedrock create-foundation-model-agreement \
--model-id \
--offer-token
```
------
#### [ Python ]
```
offer_token= ''
for agreement_offer in model_agreement_offers_response['offers']:
if agreement_offer['offerId'] == offer_id:
offer_token = agreement_offer['offerToken']
print(f"offer token found. Offer token is {offer_token}")
break
if(not offer_token):
print(f"Offer token for modelId: {model_id} is not found")
foundation_model_agreement_reponse = bedrock_client.create_foundation_model_agreement(offerToken= offer_token , modelId= model_id)
```
------
### Étape 4 : Obtenir la disponibilité du modèle de base
Utilisé pour vérifier si le modèle de fondation y a actuellement accès ou non. Utilisez le ModelID ci-dessus.
Documentation
+ API : [GetFoundationModelAvailability](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_GetFoundationModelAvailability.html)
+ Documentation de la CLI : [get-foundation-model-availability](https://docs.aws.amazon.com/cli/latest/reference/bedrock/get-foundation-model-availability.html)
------
#### [ AWS CLI ]
```
aws bedrock get-foundation-model-availability \
--model-id
```
------
#### [ Python ]
```
model_availability_response = bedrock_client.get_foundation_model_availability(modelId=model_id)
```
------
**Réponse attendue**
`agreementAvailability`- `AVAILABLE` si l'accès existe, `NOT_AVAILABLE` c'est qu'il n'existe pas.
```
{
"modelId": "anthropic.claude-sonnet-4-20250514-v1:0",
"agreementAvailability": {
"status": "AVAILABLE"
},
"authorizationStatus": "AUTHORIZED",
"entitlementAvailability": "AVAILABLE",
"regionAvailability": "AVAILABLE"
}
```
### [Facultatif] Étape 5 : Supprimer le modèle de contrat de fondation
Utilisé pour supprimer le modèle d'accord de fondation (accès). Utilisez le ModelID ci-dessus.
**Note**
La suppression de l'accès au modèle ne suffit pas pour bloquer l'accès dans le futur, car l'invocation du modèle créera à nouveau l'accès. Pour vous assurer que l'accès n'est pas créé à nouveau, appliquez des politiques de refus IAM restrictives pour le modèle.
Documentation
+ API : [DeleteFoundationModelAgreement](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_DeleteFoundationModelAgreement.html)
+ Documentation de la CLI : [delete-foundation-model-agreement](https://docs.aws.amazon.com/cli/latest/reference/bedrock/delete-foundation-model-agreement.html)
------
#### [ AWS CLI ]
```
aws bedrock delete-foundation-model-agreement \
--model-id
```
------
#### [ Python ]
```
delete_foundation_model_agreement_reponse = bedrock_client.delete_foundation_model_agreement(modelId= model_id)
```
------
## Accédez aux modèles Amazon Bedrock Foundation sur AWS GovCloud (États-Unis)
Les comptes AWS GovCloud (États-Unis) sont liés sur une one-to-one base aux comptes commerciaux AWS standard. Ce compte commercial associé est utilisé pour la facturation, l'accès aux services, à des fins d'assistance et l'accès à Amazon Bedrock Model Marketplace. Pour plus d'informations sur la relation entre les comptes commerciaux GovCloud et les comptes commerciaux, consultez la section [Liaison de comptes standard sur AWS GovCloud (États-Unis)](https://docs.aws.amazon.com/govcloud-us/latest/UserGuide/getting-started-standard-account-linking.html).
Pour les modèles tiers, l'accès aux modèles doit être activé à la fois dans le compte commercial AWS associé et dans le GovCloud compte AWS. Pour les modèles fournis par Amazon Bedrock, l'accès aux modèles doit uniquement être activé dans le GovCloud compte. Il s'agit d'un processus manuel.
### Activation de l'accès aux modèles pour AWS GovCloud dans un compte commercial AWS associé (uniquement pour les modèles tiers)
L'accès aux modèles peut être activé dans un compte commercial AWS de deux manières :
1. Appelez le modèle requis pour le compte commercial AWS dans `us-east-1` notre `us-west-2` région.
1. Activez par programmation l'accès au modèle à l'aide d'un compte commercial SDK/CLI AWS dans `us-east-1` ou dans une `us-west-2` région. Cela peut être fait en suivant les étapes décrites dans les sections précédentes.
### Activation de l'accès aux modèles pour le GovCloud compte AWS
Dans AWS GovCloud (États-Unis), vous utilisez la page d'**accès aux modèles** de la console Amazon Bedrock de la `us-gov-west-1` région pour activer les modèles de base, comme décrit ci-dessous :
1. Assurez-vous d'être [autorisé à demander l'accès aux modèles](https://docs.aws.amazon.com/bedrock/latest/userguide/model-access.html#model-access-permissions) pour demander l'accès, ou modifier l'accès, aux modèles de fondation Amazon Bedrock. Il est recommandé d'associer la [AmazonBedrockFullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonBedrockFullAccess.html)politique à celle user/role qui est utilisée.
1. Connectez-vous à la console Amazon Bedrock de la `us-gov-west-1` région à [https://console.aws.amazon.com/bedrock/](https://console.aws.amazon.com/bedrock/)l'adresse.
1. Dans le volet de navigation de gauche, sous **Configurations Bedrock**, choisissez **Accès aux modèles**.
1. Sur la page **Accès aux modèles**, choisissez **Modifier l’accès aux modèles**.
1. Sélectionnez les modèles auxquels vous souhaitez que le compte ait accès et désélectionnez les modèles auxquels vous ne souhaitez pas que le compte ait accès. Vous avez les options suivantes :
1. Assurez-vous de consulter le **Contrat de licence de l’utilisateur final (CLUF)** pour connaître les conditions générales d’utilisation d’un modèle avant de demander l’accès à celui-ci.
1. Sélectionnez la case à côté d’un modèle individuel pour le cocher ou le décochez.
1. Sélectionnez la case supérieure pour cocher ou décocher tous les modèles.
1. Sélectionnez le mode de regroupement des modèles, puis cochez ou décochez tous les modèles d’un groupe en sélectionnant la case à côté du groupe. Par exemple, vous pouvez choisir de **regrouper par fournisseur**, puis cocher la case à côté de **Cohere** pour cocher ou décocher tous les modèles Cohere.
1. Choisissez **Suivant**.
1. Si vous ajoutez l'accès aux modèles Anthropic, vous devez décrire les détails de votre cas d'utilisation. Choisissez **Soumettre les détails sur le cas d’utilisation**, remplissez le formulaire, puis sélectionnez **Envoyer le formulaire**. La notification d’accès est accordée ou refusée en fonction de vos réponses lorsque vous remplissez le formulaire pour le fournisseur.
1. Passez en revue les modifications d’accès que vous apportez, puis lisez les **Conditions**.
1. Si vous êtes d’accord avec les conditions, choisissez **Envoyer**. Les modifications peuvent prendre plusieurs minutes pour apparaître dans la console.
1. Si votre demande est acceptée, le **statut d’accès** passe à **Accès accordé** ou **Disponible à la demande**.
# Gérez les abonnements aux modèles avec License Manager
**Note**
Les instructions suivantes s'appliquent uniquement aux modèles sans serveur tiers qui nécessitent des abonnements AWS Marketplace.
Organisations possédant plusieurs comptes AWS doivent souvent fournir un accès au modèle Bedrock tiers sur de nombreux comptes. Sans gestion centralisée, chaque compte doit disposer des autorisations AWS Marketplace et créer ses propres abonnements, ce qui augmente les coûts opérationnels et complique l'application de politiques d'accès cohérentes.
Les droits gérés pour Amazon Bedrock résolvent ce problème en vous permettant de vous abonner une seule fois depuis un compte de gestion et de répartir l'accès aux comptes des membres au sein de votre organisation AWS. Il fonctionne avec les deux types d'abonnements Bedrock :
+ **Activation automatique** — Lorsque Bedrock crée automatiquement un abonnement lors de l'invocation du premier modèle
+ **Offres privées** : prix et conditions personnalisés négociés avec un vendeur via AWS Marketplace
Le flux de distribution utilise AWS License Manager. Lorsque vous vous abonnez à un modèle, une licence est automatiquement créée. Vous créez ensuite des autorisations pour partager cette licence avec d'autres comptes de votre organisation. Les bénéficiaires activent leurs subventions pour commencer à utiliser le modèle. Aucune transaction supplémentaire sur le marché n'est requise.
**Note**
Toutes les licences sont créées dans la région us-east-1, quel que soit l'endroit où vous vous abonnez ou que vous invoquez des modèles.
# Présentation du flux de travail
**Étape 1 - Abonnement** : Abonnez-vous à un modèle sans serveur Bedrock tiers via AWS Marketplace (via une activation automatique ou une offre privée).
**Étape 2 - Création de licence** : une licence est automatiquement générée dans us-east-1, représentant vos droits. Vous pouvez consulter cette licence dans la console License Manager sous Licences accordées.
**Étapes 3 - Création et distribution de subventions** : Créez des subventions pour distribuer la licence. Les subventions peuvent cibler un compte AWS individuel IDs, l'identifiant complet de votre organisation ou des unités organisationnelles spécifiques (OUs).
+ Compte AWS individuel IDs : la subvention apparaît dans la console License Manager du destinataire
+ ID de l'organisation : les subventions sont automatiquement distribuées à tous les comptes des membres
+ Unités organisationnelles (OUs) : subventions distribuées à tous les comptes de l'unité d'organisation
**Étape 4 - Activer** : Les subventions doivent être activées avant que le modèle puisse être utilisé :
+ Subventions individuelles : le bénéficiaire accepte et active sa propre subvention
+ Subventions à l'organisation/à l'unité organisationnelle : le compte de gestion peut activer toutes les subventions en bloc, ou les bénéficiaires les activer individuellement
**Étape 5 - Utiliser le modèle** : une fois activé, les utilisateurs des comptes autorisés peuvent invoquer le modèle à l'aide de la console Amazon Bedrock, de l'AWS CLI ou d'AWS SDKs.
# Concepts clés
## Rôles liés aux comptes
**Concédant ou administrateur** : utilisateur qui crée l'abonnement au modèle tiers sans serveur Bedrock via AWS Marketplace. Cet utilisateur reçoit une licence dans le cadre de cet abonnement et peut ensuite accorder des droits à cette licence à d'autres membres de son organisation AWS. Pour les organisations dont toutes les fonctionnalités sont activées, nous vous recommandons vivement de souscrire aux licences du modèle Bedrock tiers via votre compte de gestion afin de bénéficier de mécanismes de gouvernance supplémentaires, notamment l'acceptation automatique des droits accordés dans les comptes liés et la possibilité de les distribuer sur votre identifiant d'organisation AWS.
**Bénéficiaire ou utilisateur final** : comptes qui reçoivent les droits accordés par le concédant ou l'administrateur. Une fois accordées, les licences peuvent être acceptées et activées par les utilisateurs finaux sans qu'ils aient à s'abonner à nouveau explicitement via AWS Marketplace.
**Administrateur délégué** : compte de membre de votre organisation qui a été désigné pour effectuer des tâches administratives telles que la distribution des droits. Un seul administrateur délégué par organisation AWS est pris en charge. Ce compte peut gérer les licences indépendamment du compte de gestion. Si vous choisissez d'utiliser l'administrateur délégué, vous aurez besoin que l'administrateur délégué s'abonne à l'offre dans un premier temps au cours de l'étape 1.
## États de licence et de concession
Comprendre l'état des licences et des subventions vous permet de suivre le cycle de vie des droits au sein de votre organisation.
### États de licence
**Disponible** : la licence peut être utilisée conformément aux termes du contrat AWS Marketplace.
**Supprimé** : le contrat AWS Marketplace a été annulé ou résilié et le client n'a plus accès à ce modèle de licence.
### États de subvention
**En attente d'acceptation** : la subvention a été créée et le bénéficiaire ou l'utilisateur final ne l'a pas encore acceptée. Cet état s'applique uniquement aux organisations dont toutes les fonctionnalités ne sont pas activées.
**Désactivé** : l'autorisation a été acceptée par l'utilisateur final mais n'a pas été activée pour une utilisation immédiate. Dans cet état, les subventions ne peuvent pas être utilisées pour invoquer des modèles Bedrock tiers.
**Actif** : La subvention a été acceptée et activée avec succès. Les utilisateurs finaux peuvent désormais invoquer le modèle Bedrock tiers.
**Rejeté** : l'utilisateur final a refusé la licence qui lui a été accordée. Il s'agit d'un état terminal pour cette subvention. Le concédant peut créer une nouvelle subvention pour l'utilisateur final sur la même licence.
**Supprimé** : le donateur ou l'administrateur a supprimé la subvention. Il s'agit d'un état terminal pour cette subvention. Le concédant peut créer une nouvelle subvention pour l'utilisateur final sur la même licence.
# Conditions préalables
Avant de pouvoir utiliser les droits gérés pour Amazon Bedrock, vous devez remplir les conditions préalables suivantes.
## Exigences relatives à l'organisation AWS
**Toutes les fonctionnalités activées** : toutes les fonctionnalités doivent être activées dans votre organisation AWS. Managed Entitlements for Bedrock nécessite cette configuration pour fonctionner correctement. Si votre entreprise utilise uniquement la facturation consolidée, vous devez activer toutes les fonctionnalités avant de continuer. Pour activer toutes les fonctionnalités, consultez la section [Activation de toutes les fonctionnalités de votre organisation](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_org_support-all-features.html) dans le guide de l'utilisateur d'AWS Organizations.
Pour vérifier si toutes les fonctionnalités de votre organisation sont activées, accédez à la console AWS Organizations, choisissez Settings dans le volet de navigation et recherchez Feature set sous Organization details. S'il affiche Toutes les fonctionnalités, vous êtes prêt à continuer.
**Accès au compte de gestion** : vous devez avoir accès au compte de gestion de votre organisation (également appelé compte payeur) pour terminer la configuration initiale. Le compte de gestion est nécessaire pour permettre un accès sécurisé et créer des rôles liés à un service.
**Comptes membres associés** : tous les comptes membres qui recevront des licences doivent déjà faire partie de votre organisation AWS. Si vous prévoyez d'ajouter de nouveaux comptes, ils recevront automatiquement toutes les licences accordées à l'identifiant de votre organisation.
## Rôles liés à un service
Les rôles liés à un service (SLRs) sont des rôles IAM prédéfinis directement liés aux services AWS. Pour les droits gérés, vous devez créer à la fois SLRs pour AWS License Manager et AWS Marketplace. Ces rôles incluent toutes les autorisations dont les services ont besoin pour appeler d'autres services AWS en votre nom.
**Pourquoi SLRs sont-ils nécessaires** : pour AWS Marketplace, cette autorisation est requise afin que le service puisse orchestrer avec succès les flux de travail et les distributions de licences sur plusieurs services AWS en votre nom. Pour AWS License Manager, cette autorisation permet au service d'accepter automatiquement les subventions entre les comptes de gestion et les comptes membres d'une all-features-enabled organisation et de suivre l'activité de l'organisation.
Vous allez créer ces rôles liés aux services dans le cadre du processus de configuration décrit dans la section suivante.
# Configuration des droits gérés
Effectuez les étapes de configuration suivantes une seule fois pour votre organisation AWS. Une fois la configuration terminée, vous pouvez vous abonner à des modèles Bedrock tiers et distribuer des licences au sein de votre organisation.
## Étape 1 : Déterminer si vous avez besoin d'un administrateur délégué
Si vous souhaitez gérer les licences directement depuis le compte de gestion, passez à l'étape 2. Pour déléguer la gestion des licences à un compte membre, désignez d'abord un administrateur délégué.
**Pour désigner un administrateur délégué**
1. Connectez-vous à votre compte de gestion.
1. Ouvrez la console AWS License Manager à l'adresse [https://console.aws.amazon.com/license-manager/](https://console.aws.amazon.com/license-manager/).
1. Dans le panneau de navigation, sélectionnez **Settings** (Paramètres).
1. Sous **Administrateur délégué**, entrez l'ID de compte AWS du compte de membre que vous souhaitez désigner.
1. Sélectionnez **Enregistrer les modifications**.
Le compte d'administrateur délégué peut désormais créer des subventions et distribuer des licences indépendamment du compte de gestion. L'administrateur délégué peut distribuer les droits à l'aide d'un compte individuel IDs, d'un identifiant d'organisation ou d'une unité organisationnelle. IDs
Vous pouvez également désigner un administrateur délégué à l'aide de l' RegisterDelegatedAdministrator API.
Une fois désigné, l'administrateur délégué effectue les étapes 2 et 3 à partir de son compte.
## Étape 2 : activer les rôles liés aux services et l'accès sécurisé
Vous devez activer l'accès sécurisé et créer des rôles liés aux services pour AWS License Manager et AWS Marketplace. Effectuez ces étapes depuis votre compte de gestion.
**Pour configurer AWS License Manager**
1. Connectez-vous à votre compte de gestion.
1. Ouvrez la console AWS License Manager à l'adresse [https://console.aws.amazon.com/license-manager/](https://console.aws.amazon.com/license-manager/).
1. Assurez-vous que vous vous trouvez dans la région us-east-1 (Virginie du Nord). Toutes les ressources de licence sont créées et gérées dans cette région.
1. Lorsque vous accédez pour la première fois à la console License Manager, une fenêtre contextuelle apparaît vous demandant de créer un rôle lié à un service. Choisissez **Créer un rôle lié à un service** pour l'accepter.
1. Dans le panneau de navigation, sélectionnez **Settings** (Paramètres).
1. Sous Gestion des comptes, choisissez Lier les comptes d'organisations AWS.
Cela permet l'acceptation des subventions entre comptes et crée une relation d'accès fiable entre AWS Organizations et AWS License Manager.
**Pour configurer AWS Marketplace**
1. Tout en étant connecté à votre compte de gestion, ouvrez la console AWS Marketplace à l'adresse [https://console.aws.amazon.com/marketplace/](https://console.aws.amazon.com/marketplace/).
1. Dans le panneau de navigation, sélectionnez **Settings** (Paramètres).
1. Sous **AWS License Manager Integration**, choisissez **View settings details**.
1. Cochez les deux cases :
+ **Offrez un accès fiable dans l'ensemble de votre organisation**
+ **Rôle lié au service de gestion des licences AWS Marketplace pour ce compte**
1. Choisissez **Créer une intégration**.
Cela crée à la fois le rôle lié au service et la relation d'accès fiable.
**Important**
Lorsque vous sélectionnez **Activer l'accès sécurisé à l'ensemble de votre organisation** depuis le compte de gestion, les rôles liés au service sont automatiquement créés pour tous les comptes membres de votre organisation. Cela garantit que tout compte recevant une subvention pourra l'utiliser.
## Étape 3 : vérifier votre configuration
Après avoir terminé les étapes de configuration, vérifiez que tout est correctement configuré.
**Pour vérifier la configuration d'AWS License Manager**
1. Dans la console AWS License Manager, choisissez **Settings** dans le volet de navigation.
1. Sous **Gestion du compte**, vérifiez que vous voyez le **lien entre les comptes AWS Organizations : Activé**.
1. Sous **Détails de l'organisation**, vous devriez voir votre numéro d'organisation.
**Pour vérifier la configuration d'AWS Marketplace**
1. Dans la console AWS Marketplace, choisissez **Settings** dans le volet de navigation.
1. Sous **AWS License Manager Integration**, vérifiez que vous voyez **Organization integration : Enabled**.
1. Vous devriez également voir l'**état d'accès sécurisé : Activé**.
**Pour vérifier les rôles liés aux services**
1. Ouvrez la console IAM à l’adresse [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Dans le panneau de navigation, choisissez **Rôles**.
1. Dans le champ de recherche, saisissez « AWSService RoleFor AWSLicense Manager » et vérifiez que le rôle existe.
1. Dans le champ de recherche, saisissez « AWSService RoleForMarketplaceLicenseManagement » et vérifiez que le rôle existe.
Si ces rôles ne s'affichent pas, attendez 2 à 3 minutes pour la propagation d'IAM et actualisez la console. Si les rôles n'apparaissent toujours pas, vous devrez peut-être les créer manuellement en accédant à la console IAM, en choisissant **Create role**, en sélectionnant le **service AWS** et en recherchant License Manager ou Marketplace dans la liste des services.
# Abonnement à des modèles Bedrock tiers via une offre privée
Avant de pouvoir distribuer des licences, vous devez d'abord vous abonner à un modèle Bedrock via AWS Marketplace.
**Pour vous abonner à un modèle Bedrock tiers via AWS Marketplace**
1. Cliquez sur le lien de l'offre privée dans les vendeurs pour commencer ou connectez-vous à votre compte de gestion ou au compte de facturation désigné
1. Ouvrez la console AWS Marketplace à l'adresse [https://console.aws.amazon.com/marketplace/](https://console.aws.amazon.com/marketplace/).
1. Accédez aux offres privées pour voir la liste des offres disponibles
1. Consultez le contrat d'abonnement et les détails des prix.
1. Choisissez **S'abonner** pour terminer l'abonnement.
1. Vous verrez un message de confirmation indiquant que votre abonnement est actif.
## Pour vérifier la création de la licence
Après l'abonnement, AWS License Manager crée automatiquement une licence pour votre abonnement.
1. Attendez 1 à 2 minutes pour que la licence soit créée.
1. Ouvrez la console AWS License Manager à l'adresse [https://console.aws.amazon.com/license-manager/](https://console.aws.amazon.com/license-manager/).
1. Assurez-vous que vous vous trouvez dans la région us-east-1.
1. Dans le volet de navigation, sélectionnez **Granted Licenses**.
1. Vous devriez voir une nouvelle licence pour votre abonnement au modèle Bedrock tiers.
1. Le statut de la licence doit s'afficher comme **Disponible**.
**Note**
La licence est toujours créée dans la région us-east-1, quelle que soit la région dans laquelle vous vous êtes abonné. Vérifiez toujours le License Manager dans us-east-1 pour voir vos licences.
Si la licence n'apparaît pas au bout de 5 minutes, vérifiez que votre abonnement est actif en accédant à la console AWS Marketplace, en choisissant Gérer les abonnements et en confirmant que votre abonnement au modèle Bedrock tiers est indiqué comme actif.
# Distribution de licences
Une fois que vous vous êtes abonné à un modèle Bedrock tiers et que vous avez vérifié qu'une licence a été créée, vous pouvez créer des subventions pour distribuer l'accès à d'autres comptes de votre organisation.
## Comprendre les options de distribution des subventions
Vous pouvez distribuer des licences selon trois méthodes :
Octroi de **compte individuel** : créez une subvention pour un ID de compte AWS spécifique. Cette méthode vous permet de contrôler avec précision quels comptes ont accès au modèle. Le compte du bénéficiaire doit accepter et activer la subvention avant d'utiliser le modèle.
**Subventions d'organisation** : créez une subvention unique pour l'intégralité de votre identifiant d'organisation AWS. Cette méthode distribue automatiquement la licence à tous les comptes membres de votre organisation. Les nouveaux comptes qui rejoignent l'organisation reçoivent automatiquement la licence. Pour les organisations dont toutes les fonctionnalités sont activées, les subventions sont automatiquement acceptées et apparaissent comme désactivées, prêtes à être activées.
**Subventions aux unités organisationnelles** : créez une subvention pour une unité organisationnelle (UO) spécifique au sein de votre organisation. Cette méthode distribue la licence à tous les comptes au sein de l'unité d'organisation spécifiée, fournissant ainsi un juste milieu entre le contrôle des comptes individuels et la distribution à l'échelle de l'organisation.
## Créer des subventions
### Console
**Pour créer une subvention pour un compte individuel**
1. Connectez-vous à votre compte de gestion (ou à votre compte d'administrateur délégué).
1. Ouvrez la console AWS License Manager à l'adresse [https://console.aws.amazon.com/license-manager/](https://console.aws.amazon.com/license-manager/).
1. Assurez-vous que vous vous trouvez dans la région us-east-1.
1. Dans le volet de navigation, sélectionnez **Granted Licenses**.
1. Sélectionnez la licence que vous souhaitez partager en cliquant sur le bouton radio situé à côté de la licence.
1. Choisissez **Créer une subvention**.
1. Sous **Détails de la subvention**, entrez un nom descriptif pour la subvention dans **Nom de la subvention**.
1. Sous ID de **compte AWS, ID d'organisation AWS ou ID d'unité organisationnelle AWS, entrez l'ID** de compte AWS à 12 chiffres du compte destinataire.
1. Vérifiez les détails de votre subvention.
1. Choisissez **Créer une subvention**.
La subvention est créée et apparaîtra dans la console License Manager du compte destinataire avec l'état En attente d'acceptation ou Désactivé, selon la configuration de votre organisation.
**Pour créer une subvention pour votre organisation**
1. Suivez les étapes 1 à 6 de la procédure précédente.
1. Sous **Détails de la subvention**, entrez un nom descriptif pour la subvention dans **Nom de la subvention**.
1. Sous ID de **compte AWS, ID d'organisation AWS ou ID d'unité organisationnelle AWS**, entrez votre identifiant d'organisation AWS.
+ Pour trouver l'ID de votre organisation, ouvrez la console AWS Organizations. L'identifiant apparaît dans le volet de navigation et commence par « o- ».
1. Vérifiez les détails de votre subvention.
1. Choisissez **Créer une subvention**.
La subvention est créée et distribuée automatiquement à tous les comptes membres de votre organisation. Pour les organisations dont toutes les fonctionnalités sont activées, les subventions sont automatiquement acceptées et apparaissent dans l'état Désactivé sur chaque compte membre.
**Pour créer une subvention pour une unité organisationnelle**
1. Suivez les étapes 1 à 6 de la procédure de création d'une subvention individuelle.
1. Sous **Détails de la subvention**, entrez un nom descriptif pour la subvention dans **Nom de la subvention**.
1. Sous ID de **compte AWS, ID d'organisation AWS ou ID d'unité organisationnelle AWS, entrez l'ID** de votre unité organisationnelle (UO).
+ Pour trouver votre ID d'unité d'organisation, ouvrez la console AWS Organizations et accédez à votre unité d'organisation. L'identifiant commence par « ou- ».
1. Vérifiez les détails de votre subvention.
1. Choisissez **Créer une subvention**.
La subvention est créée et distribuée automatiquement à tous les comptes membres au sein de l'unité organisationnelle spécifiée.
Remplacez l'ARN de licence, l'ID de compte et l'ID d'organisation par vos valeurs réelles.
### API
Crée une subvention pour distribuer une licence à d'autres comptes, organisations ou unités organisationnelles AWS via [CreateGrantl'API](https://docs.aws.amazon.com/license-manager/latest/APIReference/API_CreateGrant.html)
## Suivi des subventions distribuées
En tant que donateur ou administrateur, vous pouvez suivre toutes les subventions que vous avez créées.
### Console
**Pour consulter vos subventions distribuées**
1. Ouvrez la console AWS License Manager à l'adresse [https://console.aws.amazon.com/license-manager/](https://console.aws.amazon.com/license-manager/).
1. Dans le volet de navigation, sélectionnez **Granted Licenses**.
1. Choisissez la licence pour laquelle vous souhaitez examiner les subventions.
1. Sur la page des détails de la licence, accédez à la section **Subventions**.
1. Vous verrez une liste de toutes les subventions créées pour cette licence, y compris le nom, le destinataire et le statut de la licence.
Pour les subventions à l'échelle de l'organisation, vous pouvez consulter le statut des subventions individuelles au niveau du compte en choisissant le nom de la subvention pour voir la page des détails de la subvention.
### API
Vous pouvez également consulter les subventions distribuées à l'aide de l'[ListDistributedGrants API.](https://docs.aws.amazon.com/license-manager/latest/APIReference/API_ListDistributedGrants.html)
# Acceptation et activation des subventions
Une fois qu'une subvention a été distribuée sur un compte membre, la subvention doit être acceptée et activée avant que le modèle Bedrock tiers puisse être utilisé. Le flux de travail d'acceptation et d'activation varie en fonction de la configuration de votre organisation.
## Pour les entreprises dont toutes les fonctionnalités sont activées
Lorsque vous créez une subvention pour un compte membre dans une organisation dont toutes les fonctionnalités sont activées, la subvention est automatiquement acceptée et apparaît dans l'état Désactivé. Soit le donateur peut activer la subvention pour tous les bénéficiaires, soit chaque bénéficiaire peut activer sa propre subvention.
### Console
**Pour activer les subventions en tant que donateur (activation groupée)**
1. Connectez-vous à votre compte de gestion (ou à votre compte d'administrateur délégué).
1. Ouvrez la console AWS License Manager à l'adresse [https://console.aws.amazon.com/license-manager/](https://console.aws.amazon.com/license-manager/).
1. Dans le volet de navigation, sélectionnez **Granted Licenses**.
1. Choisissez la subvention que vous souhaitez activer. Pour les subventions à l'échelle de l'organisation, sélectionnez la subvention parent.
1. Choisissez **Activer**.
1. Confirmez l'activation.
Cette action active la subvention pour tous les comptes bénéficiaires. **Vous pouvez vérifier le statut des subventions de chaque compte sur la page des détails des subventions en faisant défiler la page jusqu'à la section Subventions.**
**Pour activer les subventions en tant que bénéficiaire**
1. Connectez-vous au compte de membre du destinataire.
1. Ouvrez la console AWS License Manager à l'adresse [https://console.aws.amazon.com/license-manager/](https://console.aws.amazon.com/license-manager/).
1. Assurez-vous que vous vous trouvez dans la région us-east-1.
1. Dans le volet de navigation, sélectionnez **Granted Licenses**.
1. Choisissez la subvention que vous souhaitez activer.
1. Choisissez **Activer**.
1. Confirmez l'activation.
Le statut de la subvention passe à Actif, et les utilisateurs de votre compte peuvent désormais invoquer le modèle Bedrock tiers.
## Pour les organisations avec facturation consolidée uniquement
Si votre organisation utilise la facturation consolidée sans que toutes les fonctionnalités soient activées, les subventions apparaissent dans l'état En attente d'acceptation dans le compte du bénéficiaire. Le bénéficiaire doit d'abord accepter la subvention, puis l'activer.
### Console
**Pour accepter et activer une subvention (organismes de facturation consolidée)**
1. Connectez-vous au compte de membre du destinataire.
1. Ouvrez la console AWS License Manager à l'adresse [https://console.aws.amazon.com/license-manager/](https://console.aws.amazon.com/license-manager/).
1. Assurez-vous que vous vous trouvez dans la région us-east-1.
1. Dans le volet de navigation, sélectionnez **Granted Licenses**.
1. Choisissez la subvention que vous souhaitez accepter.
1. Choisissez **Accepter et activer** pour accepter et activer la subvention en une seule action.
+ Vous pouvez également choisir **Accepter** pour accepter la subvention tout en la maintenant dans l'état Désactivé pour une future activation.
+ Ou choisissez **Refuser** pour refuser la licence (il s'agit d'un état terminal).
Si vous avez choisi **Accepter**, vous devez revenir plus tard et choisir **Activer** pour commencer à utiliser le modèle.
## API
[Vous pouvez activer les subventions par programmation à l'aide de l'CreateGrantVersion API.](https://docs.aws.amazon.com/license-manager/latest/APIReference/API_CreateGrantVersion.html)
# Utilisation de modèles Bedrock tiers avec des licences accordées
Une fois qu'une subvention a été activée sur votre compte, vous pouvez invoquer le modèle Bedrock tiers à l'aide de la console Amazon Bedrock, de l'AWS CLI ou d'AWS. SDKs L'expérience est identique à celle d'invoquer un modèle avec un abonnement direct.
## Pour vérifier que vous disposez d'une licence active
Avant d'essayer d'utiliser un modèle Bedrock tiers, vérifiez que votre subvention est dans un état actif.
1. Ouvrez la console AWS License Manager à l'adresse [https://console.aws.amazon.com/license-manager/](https://console.aws.amazon.com/license-manager/).
1. Assurez-vous que vous vous trouvez dans la région us-east-1.
1. Dans le volet de navigation, sélectionnez **Granted Licenses**.
1. Trouvez la subvention pour le modèle Bedrock tiers que vous souhaitez utiliser.
1. Vérifiez que le statut de la subvention apparaît comme **Actif**.
Si le statut indique Désactivé, vous devez activer la subvention avant d'utiliser le modèle. Si le statut indique En attente d'acceptation, vous devez d'abord accepter la subvention.
## Pour invoquer un modèle Bedrock tiers avec une licence accordée
1. Ouvrez la console Amazon Bedrock dans toutes les régions prises en charge où le modèle est disponible.
1. Dans le volet de navigation, choisissez **Texte** ou **Chat** sous **Playgrounds**, selon le type de modèle.
1. Sélectionnez le modèle pour lequel vous possédez une licence dans la liste déroulante des modèles.
1. Entrez votre invite et choisissez **Exécuter**.
Le modèle d'invocation fonctionne de la même manière que si vous vous étiez inscrit directement. Toute utilisation est facturée sur le compte titulaire de l'abonnement d'origine (généralement le compte de gestion).
[Vous pouvez également appeler des modèles par programmation à l'aide de l'AWS CLI ou d'AWS SDKs avec l'InvokeModel API.](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) La seule exigence est que vous disposiez d'une licence active sur votre compte.
# Gestion des octrois
Après avoir créé des subventions, vous devrez peut-être les modifier, les désactiver ou les supprimer en fonction de l'évolution des besoins de l'organisation.
## Modifier les noms des subventions
### Console
Vous pouvez modifier le nom d'une subvention pour ajouter plus de détails ou améliorer l'organisation.
**Pour modifier le nom d'une subvention**
1. Ouvrez la console AWS License Manager à l'adresse [https://console.aws.amazon.com/license-manager/](https://console.aws.amazon.com/license-manager/).
1. Dans le volet de navigation, sélectionnez **Granted Licenses**.
1. Choisissez la licence qui contient la licence que vous souhaitez modifier.
1. Dans la section **Subventions**, cliquez sur le bouton radio à côté de la subvention.
1. Choisissez **Modifier**.
1. Mettez à jour le champ **Nom de la subvention**.
1. Sélectionnez **Enregistrer les modifications**.
## Désactivation des subventions
Vous souhaiterez peut-être révoquer temporairement l'accès à un modèle Bedrock tiers sans supprimer définitivement la subvention. La désactivation d'une subvention la fait passer à l'état Désactivé.
### Console
**Pour désactiver une subvention**
1. Ouvrez la console AWS License Manager à l'adresse [https://console.aws.amazon.com/license-manager/](https://console.aws.amazon.com/license-manager/).
1. Dans le volet de navigation, sélectionnez **Granted Licenses**.
1. Choisissez la licence qui contient la licence que vous souhaitez désactiver.
1. Dans la section **Subventions**, choisissez le nom de la subvention.
1. Sélectionnez **Désactiver**.
1. Tapez « désactiver » dans le champ de confirmation.
1. Sélectionnez **Désactiver**.
**Important**
La désactivation d'une subvention n'a aucun impact sur les charges de travail actives ni sur les appels de modèles en cours d'exécution. Cependant, les nouvelles demandes d'invocation du modèle seront refusées après la désactivation.
## Supprimer des subventions
Si vous souhaitez révoquer définitivement l'accès à un modèle Bedrock tiers, vous pouvez supprimer la subvention. Cette action est définitive et ne peut pas être annulée.
**Pour supprimer une subvention**
1. Ouvrez la console AWS License Manager à l'adresse [https://console.aws.amazon.com/license-manager/](https://console.aws.amazon.com/license-manager/).
1. Dans le volet de navigation, sélectionnez **Granted Licenses**.
1. Choisissez la licence qui contient la licence que vous souhaitez supprimer.
1. Dans la section **Subventions**, choisissez le nom de la subvention.
1. Sélectionnez **Delete (Supprimer)**.
1. Tapez « supprimer » dans le champ de confirmation.
1. Sélectionnez **Delete (Supprimer)**.
Une fois supprimé, le compte du bénéficiaire ne sera plus en mesure d'activer de nouvelles instances ni d'invoquer le modèle Bedrock tiers à l'aide de cette subvention. Les appels de modèles actifs continueront de s'exécuter jusqu'à leur fin.
**Note**
Si vous supprimez une subvention par erreur, vous pouvez créer une nouvelle subvention pour le même compte. La nouvelle subvention sera indépendante de la subvention supprimée.
## API
Vous pouvez désactiver les autorisations à l'aide de l'[CreateGrantVersion API](https://docs.aws.amazon.com/license-manager/latest/APIReference/API_CreateGrantVersion.html) dont le statut est défini sur DISABLED, et supprimer des autorisations à l'aide de l'[DeleteGrant API](https://docs.aws.amazon.com/license-manager/latest/APIReference/API_DeleteGrant.html).
# Référence d’API
Cette section fournit une documentation API complète pour la gestion programmatique des droits gérés pour Bedrock. Tous APIs interagissent avec AWS License Manager dans la région us-east-1.
## Présentation de l'API
Les AWS License Manager suivants APIs sont utilisés pour les droits gérés :
| Opération API | Objectif | Cas d'utilisation courant |
| --- | --- | --- |
| CreateGrant | Création d'une nouvelle subvention pour distribuer des licences | Distribuez l'accès au modèle Bedrock aux comptes des membres |
| ListDistributedGrants | Répertoriez toutes les subventions que vous avez créées | Suivez les comptes auxquels l'accès a été accordé |
| ListReceivedGrants | Répertoriez toutes les subventions reçues sur votre compte | Afficher les licences disponibles dans un compte membre |
| GetGrant | Obtenez des informations sur une subvention spécifique | Vérifier le statut et la configuration de la subvention |
| CreateGrantVersion | Mettre à jour le statut de la subvention (activer/désactiver) | Activer ou désactiver une subvention |
| AcceptGrant | Accepter une subvention reçue | Le compte membre accepte la licence du compte de gestion |
| RejectGrant | Refuser une subvention reçue | Le compte membre refuse une licence |
| DeleteGrant | Supprimer définitivement une subvention | Révoquer l'accès à un modèle Bedrock |
| ListReceivedLicenses | Répertoriez les licences de votre compte | Afficher toutes les licences du modèle Bedrock disponibles |
| GetLicense | Obtenir des informations sur une licence | Vérifiez l'état de la licence et les métadonnées |
# Résolution des problèmes
Cette section fournit des solutions aux problèmes courants que vous pouvez rencontrer lors de l'utilisation de Managed Entitlements pour Amazon Bedrock.
## La licence n'apparaît pas dans le License Manager après l'abonnement
**Causes possibles et solutions** :
+ **Abonnement non encore traité** : attendez 5 minutes et actualisez la console License Manager. La création des licences peut prendre quelques minutes après l'abonnement.
+ **Vous recherchez dans la mauvaise région** : assurez-vous que vous consultez le License Manager dans la région us-east-1 (Virginie du Nord). Toutes les licences sont créées dans us-east-1, quelle que soit la région d'abonnement.
+ **Échec de l'abonnement** : accédez à la console AWS Marketplace, choisissez **Gérer les abonnements** et vérifiez que l'abonnement apparaît comme actif. S'il n'est pas activé, recommencez le processus d'abonnement.
+ Les **rôles liés aux services ne sont pas configurés** : retournez à la section Configuration des droits gérés et effectuez toutes les étapes préalables. Vérifiez l' SLRs existence dans la console IAM en choisissant **Rôles** et en recherchant les noms de rôles requis.
## La subvention n'apparaît pas dans le compte du bénéficiaire
**Causes possibles et solutions** :
+ La **subvention n'a pas encore été distribuée** : attendez 2 à 3 minutes après avoir créé la subvention. Vérifiez le compte du donateur pour confirmer que la subvention a été créée avec succès.
+ **Le destinataire recherche dans la mauvaise région** : le destinataire doit consulter le License Manager dans la région us-east-1. Toutes les subventions apparaissent uniquement dans us-east-1.
+ **Le compte du destinataire n'a pas de rôles liés à un service** : pour les organisations où toutes les fonctionnalités ne sont pas activées, chaque compte a besoin de rôles liés à un service. Le destinataire doit effectuer les étapes préalables dans son propre compte.
+ **Mauvais identifiant de compte utilisé** : vérifiez que l'identifiant de compte AWS à 12 chiffres correct a été saisi lors de la création de la subvention. Vérifiez qu'il n'y a pas de fautes de frappe dans l'identifiant du compte.
## Impossible d'activer la subvention
**Causes possibles et solutions** :
+ **Licence active existante pour le même modèle** : le compte destinataire possède peut-être déjà une licence active pour ce modèle. Désactivez ou supprimez d'abord la licence existante, puis activez la nouvelle licence.
+ La **subvention n'est pas encore acceptée** : pour les organisations dont toutes les fonctionnalités ne sont pas activées, le bénéficiaire doit d'abord accepter la subvention avant de pouvoir l'activer.
+ **Autorisations IAM insuffisantes** : l'utilisateur a besoin d'une `license-manager:CreateGrantVersion` autorisation. Contactez l'administrateur de votre compte pour lui accorder les autorisations nécessaires.
+ **Subvention dans un état incorrect** : la subvention doit être désactivée ou en attente d'acceptation pour être activée. Vérifiez le statut de l'autorisation dans la console License Manager.
## Impossible d'utiliser le modèle Bedrock après avoir activé la subvention
**Causes possibles et solutions** :
+ La **subvention n'est pas complètement activée** : Vérifiez que le statut de la subvention apparaît comme actif (et non désactivé ou en attente). Essayez de désactiver et de réactiver la subvention.
+ **Permissions Bedrock manquantes** : l'utilisateur a besoin d'une autorisation `bedrock:InvokeModel` IAM. Ajoutez des autorisations Bedrock au rôle ou à la politique IAM de l'utilisateur.
+ **Modèle non disponible dans la région** : Certains modèles Bedrock ne sont disponibles que dans certaines régions. Consultez la console Bedrock pour connaître la disponibilité des modèles dans votre région.
+ **Problème de facturation** : vérifiez que le compte de gestion dispose d'un mode de paiement valide. Vérifiez s'il y a des blocages de compte ou des problèmes de facturation dans la console de facturation.
## Erreurs d'accès refusé lors de la configuration
**Causes possibles et solutions** :
+ **Ne pas utiliser de compte de gestion** : la configuration doit être effectuée à partir du compte de gestion ou du compte payeur. Vérifiez que vous êtes connecté au bon compte en vérifiant l'identifiant du compte dans la console.
+ **Autorisations IAM insuffisantes** : besoins `organizations:EnableAWSServiceAccess` et `iam:CreateServiceLinkedRole` autorisations des utilisateurs. Contactez votre administrateur pour lui accorder les autorisations nécessaires.
+ **Organisation non configurée** : vous devez d'abord créer une organisation AWS. Créez une organisation avant de tenter de configurer les droits gérés.
## Aide supplémentaire
Si le problème persiste après avoir essayé ces solutions :
+ **Consultez le tableau de bord AWS Service Health** : consultez le [https://health.aws.amazon.com/health/statut](https://health.aws.amazon.com/health/status) et recherchez les problèmes récurrents liés aux services License Manager, Marketplace ou Bedrock.
+ **Consultez CloudTrail les journaux AWS** : accédez à CloudTrail la console, recherchez les événements liés à License Manager et Marketplace, et recherchez les messages d'erreur ou les appels d'API ayant échoué.
+ **Contacter AWS Support** : ouvrez un dossier d'assistance auprès d'AWS Support. Incluez votre compte IDs, les noms des modèles Bedrock, les messages d'erreur et les mesures que vous avez prises. Spécifiez que vous utilisez Managed Entitlements pour Bedrock.
# Questions fréquentes (FAQ)
## Installation et configuration
**Q : Mon organisation utilise uniquement la facturation consolidée. Puis-je toujours utiliser les droits gérés ?**
R : Oui, mais avec des limites. Organisations disposant d'une facturation consolidée peuvent utiliser des droits gérés, mais les subventions devront être acceptées manuellement dans le compte de chaque bénéficiaire. Pour une expérience optimale, nous vous recommandons d'activer toutes les fonctionnalités de votre organisation, ce qui permet l'acceptation automatique des subventions et leur distribution à l'échelle de l'organisation.
**Q : Puis-je utiliser un compte membre au lieu du compte de gestion pour gérer les licences ?**
A : Oui. Vous pouvez désigner un compte d'administrateur délégué pour gérer la distribution des licences. Ce compte membre permet de créer et de distribuer des subventions indépendamment du compte de gestion. Toutefois, un seul administrateur délégué est pris en charge par organisation.
**Q : Dois-je configurer des droits gérés dans chaque région AWS ?**
R : Non. Toute la gestion des licences s'effectue dans la région us-east-1 (Virginie du Nord), quel que soit l'endroit où vous utilisez les modèles Bedrock. Une fois la configuration terminée dans us-east-1, vous pouvez invoquer des modèles sous licence dans n'importe quelle région Bedrock prise en charge.
## Offres privées et tarifs
**Q : Comment les droits gérés fonctionnent-ils avec les offres privées d'AWS Marketplace ?**
R : Les droits gérés vous permettent d'accepter des offres privées sur votre compte de gestion, puis de distribuer l'accès à d'autres comptes associés. Lorsque vous créez des subventions, le prix et les conditions de l'offre privée s'appliquent automatiquement à tous les comptes bénéficiaires. Cela garantit une tarification uniforme au sein de votre organisation et élimine la nécessité pour chaque compte d'accepter l'offre individuellement.
**Q : Qui est facturé lorsqu'un compte membre utilise une licence accordée ?**
R : Le compte contenant l'abonnement d'origine (généralement le compte de gestion) est facturé pour toutes les utilisations effectuées sur les comptes accordés. Cette facturation centralisée fournit une visibilité claire sur les coûts totaux de Bedrock au sein de votre organisation.
**Q : Les différents comptes membres peuvent-ils avoir des prix différents pour le même modèle ?**
R : Non. Lorsque vous distribuez des licences par le biais de droits gérés, tous les comptes bénéficiaires appliquent les mêmes conditions tarifaires que celles de l'abonnement initial, y compris les remises relatives aux offres privées.
## Distribution des licences
**Q : Combien de temps faut-il pour que les subventions apparaissent sur les comptes des bénéficiaires ?**
R : Pour l'attribution de comptes individuels, les licences apparaissent généralement dans un délai de 2 à 3 minutes. Pour les subventions accordées à des milliers de comptes à l'échelle de l'organisation, la distribution peut prendre 15 à 30 minutes ou plus. Consultez la console License Manager pour vérifier le statut de l'autorisation.
**Q : Dois-je créer une subvention pour chaque compte auquel un accès est requis ?**
R : Non. Si toutes les fonctionnalités de votre organisation sont activées, créez une attribution unique pour votre ID d'organisation afin de distribuer automatiquement les licences à tous les comptes membres, y compris les comptes qui s'inscriront ultérieurement. Sinon, créez des subventions individuelles ou des subventions aux unités organisationnelles (OUs).
**Q : Que se passe-t-il lorsqu'un nouveau compte rejoint mon organisation ?**
R : Si vous avez attribué une subvention à votre identifiant d'organisation, les nouveaux comptes reçoivent automatiquement la licence et l'accès au modèle. Pour les allocations de compte individuelles, vous devez créer manuellement une subvention pour le nouveau compte.
**Q : Puis-je distribuer des licences à des comptes extérieurs à mon organisation ?**
R : Non. Les droits gérés ne fonctionnent qu'au sein de votre organisation AWS. Vous ne pouvez pas partager de licences avec des comptes qui ne font pas partie de la structure de votre organisation.
**Q : Puis-je accorder l'accès à des unités organisationnelles spécifiques (OUs) plutôt qu'à l'ensemble de mon organisation ?**
A : Oui. Lorsque vous créez une subvention, vous pouvez spécifier un ID d'unité d'organisation pour distribuer les licences uniquement aux comptes de cette unité d'organisation. Cela fournit un juste milieu entre le contrôle des comptes individuels et la distribution à l'échelle de l'organisation.
**Q : J'ai des abonnements existants sur plusieurs comptes membres. Comment migrer vers une gestion centralisée ?**
R : Lorsque les comptes membres disposent de modèles Bedrock actifs et que leur compte payeur leur distribue un abonnement au même modèle, l'échange de subventions prend effet, les droits au premier abonnement sont désactivés et ils ont désormais des droits sur la nouvelle subvention distribuée.
## Gestion des subventions
**Q : Puis-je révoquer temporairement l'accès sans supprimer l'autorisation ?**
A : Oui. Vous pouvez désactiver la subvention pour la faire passer à l'état Disabled. Toutefois, la désactivation d'une subvention ne bloque pas l'accès au modèle : le compte membre peut toujours invoquer le modèle. Ce qui change, c'est la facturation : lorsque la subvention est désactivée, le compte du membre sera facturé aux taux publics au lieu du prix de votre offre privée négociée. Vous pouvez réactiver la subvention ultérieurement pour rétablir les conditions de l'offre privée sans avoir à la recréer.
**Q : Qu'advient-il de l'accès aux modèles si je supprime ou désactive une subvention ?**
R : Le compte membre continuera d'avoir accès au modèle. La suppression ou la désactivation d'une subvention n'interrompt pas la possibilité d'invoquer le modèle. Toutefois, sans subvention active, le compte du membre sera facturé aux taux publics au lieu de toute offre privée négociée.
**Q : Puis-je voir quels comptes utilisent réellement les licences que j'ai distribuées ?**
R : Dans AWS License Manager, vous pouvez voir quels comptes ont des autorisations et leur statut d'activation. Pour obtenir des statistiques d'utilisation détaillées et le suivi des appels d'API, utilisez AWS CloudTrail. Pour les statistiques d'invocation du modèle, utilisez la console Amazon Bedrock ou CloudWatch les statistiques de chaque compte.
**Q : Si je supprime une subvention par erreur, puis-je la restaurer ?**
R : Non. La suppression d'une subvention est définitive et ne peut pas être annulée. Cependant, vous pouvez créer une nouvelle subvention pour le même compte avec la même configuration. L'accès au modèle ne sera pas perturbé : le compte du membre peut continuer à invoquer le modèle pendant l'intervalle. Le principal impact est la facturation : pendant la durée entre la suppression de la subvention et l'activation de la nouvelle subvention, le compte du membre sera facturé aux taux publics plutôt qu'à un prix d'offre privée négocié.
**Q : Qu'advient-il des licences accordées dans les comptes associés lorsque l'abonnement parent expire dans le compte de gestion ?**
R : Les comptes associés continueront d'avoir accès au modèle lorsque l'abonnement parent expirera dans le compte de gestion. Cependant, ils seront facturés aux taux publics plutôt qu'à une offre privée négociée.
## Configurations spéciales
**Q : Comment fonctionnent les droits gérés pour les clients AWS ? GovCloud **
R : GovCloud les clients ont un compte AWS commercial associé à un GovCloud compte. Abonnez-vous aux modèles Bedrock et gérez les licences dans la hiérarchie de l'organisation des comptes commerciaux. Lorsque vous accordez une licence à un compte commercial lié, le GovCloud compte associé reçoit automatiquement les droits et peut invoquer le modèle.
**Q : Puis-je utiliser des droits gérés avec AWS Control Tower ou AWS Service Catalog ?**
A : Oui. Vous pouvez intégrer les droits APIs gérés à votre usine de comptes AWS Control Tower ou à vos portefeuilles Service Catalog afin d'automatiser la distribution des licences lors de la création de nouveaux comptes.
**Q : Plusieurs comptes de gestion peuvent-ils souscrire au même modèle Bedrock ?**
A : Oui. Différents comptes peuvent souscrire au même modèle indépendamment. Chaque abonnement crée sa propre licence distincte qui peut être distribuée à différents ensembles de comptes membres.
## Résolution des problèmes
**Q : Pourquoi ma licence ne s'affiche-t-elle pas dans le License Manager après m'être abonné ?**
R : Les licences peuvent prendre 1 à 2 minutes pour apparaître après l'abonnement. Assurez-vous de consulter le License Manager dans la région us-east-1, car toutes les licences y sont créées, quel que soit l'endroit où vous vous êtes abonné. S'il n'apparaît toujours pas au bout de 5 minutes, vérifiez que votre abonnement est actif dans la console AWS Marketplace.
**Q : Mon compte de bénéficiaire ne peut pas voir la subvention que j'ai créée. Que dois-je vérifier ?**
R : Vérifiez que le destinataire consulte le License Manager dans la région us-east-1. Confirmez que vous avez saisi le bon identifiant de compte à 12 chiffres lors de la création de la subvention. Attendez 2 à 3 minutes pour la distribution des subventions. Pour les organisations dont toutes les fonctionnalités ne sont pas activées, assurez-vous que des rôles liés au service ont été créés sur le compte du destinataire.
**Q : Pourquoi ne puis-je pas activer une subvention sur mon compte ?**
R : Vérifiez que la subvention est désactivée ou en attente d'acceptation. Si vous possédez déjà une licence active pour le même modèle, désactivez-la ou supprimez-la d'abord. Assurez-vous de disposer de l'autorisation `license-manager:CreateGrantVersion` IAM. Pour les organisations de facturation consolidée, confirmez que vous avez accepté la subvention avant de tenter de l'activer.
# Amélioration de la pertinence des réponses aux requêtes grâce à un modèle de reclassement dans Amazon Bedrock
Amazon Bedrock donne accès à des modèles de reclassement que vous pouvez utiliser lors de vos requêtes afin d’améliorer la pertinence des résultats récupérés. Un modèle de reclassement calcule la pertinence des fragments par rapport à une requête et réorganise les résultats en fonction des scores qu’il calcule. En utilisant un modèle de reclassement, vous pouvez renvoyer des réponses mieux adaptées à la requête. Vous pouvez également inclure les résultats dans une invite lorsque vous exécutez l’inférence de modèle afin de générer des réponses plus pertinentes et plus précises. Avec un modèle de reclassement, vous pouvez obtenir moins de résultats, mais plus pertinents. En intégrant ces résultats au modèle de fondation que vous utilisez pour générer une réponse, vous pouvez également réduire les coûts et la latence.
Les modèles de reclassement sont entraînés pour identifier les signaux de pertinence en fonction d’une requête, puis utiliser ces signaux pour classer les documents. De ce fait, les modèles peuvent fournir des résultats plus pertinents et plus précis.
**Note**
Vous ne pouvez utiliser le reclassement que pour les données textuelles.
Pour plus d’informations sur la tarification des modèles de reclassement, consultez [Tarification d’Amazon Bedrock](https://aws.amazon.com/bedrock/pricing/).
Le reclassement nécessite au minimum les informations suivantes :
+ un modèle de reclassement qui prend en compte les requêtes d’un utilisateur et évalue la pertinence des sources de données auxquelles il peut accéder ;
+ la requête de l’utilisateur ;
+ la liste des documents que le reclassement doit réorganiser en fonction de leur pertinence par rapport à la requête.
Vous pouvez utiliser les modèles de reclassement dans Amazon Bedrock de la manière suivante :
+ Appelez l’opération [Reclassement](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_Rerank.html) directement via l’API Amazon Bedrock. L’opération `Rerank` envoie la requête, les documents et toute configuration supplémentaire en tant qu’entrée à un modèle de reclassement. Le modèle reclasse ensuite les documents en fonction de leur pertinence par rapport à la requête et renvoie les documents dans la réponse.
+ Si vous utilisez [Bases de connaissances Amazon Bedrock](knowledge-base.md) pour créer votre application de génération à enrichissement contextuel (RAG), utilisez un modèle de reclassement lorsque vous appelez l’opération [https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_Retrieve.html](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_Retrieve.html) ou [https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_RetrieveAndGenerate.html](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_RetrieveAndGenerate.html) ou lorsque vous interrogez votre base de connaissances dans la AWS Management Console. Les résultats du reclassement remplacent le classement par défaut déterminé par Bases de connaissances Amazon Bedrock.
**Topics**
+ [Régions/modèles pris en charge](rerank-supported.md)
+ [Permissions](rerank-prereq.md)
+ [Utilisation d’un modèle de reclassement](rerank-use.md)
# Régions et modèles pris en charge pour le reclassement dans Amazon Bedrock
La liste suivante fournit des liens vers des informations générales sur la prise en charge des régions et des modèles dans Amazon Bedrock :
+ Pour obtenir la liste des codes de région et des points de terminaison pris en charge dans Amazon Bedrock, consultez [Points de terminaison et quotas Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bedrock_region).
+ Pour obtenir la liste des modèles Amazon Bedrock IDs à utiliser lors de l'appel des opérations de l'API Amazon Bedrock, consultez. [Modèles de fondation pris en charge dans Amazon Bedrock](models-supported.md)
Le tableau suivant indique les modèles de reclassement que vous pouvez utiliser et les régions dans lesquelles ils sont pris en charge :
**Note**
Le modèle Amazon Rerank 1.0 n’est pas pris en charge dans la Région AWS USA Est (Virginie du Nord). Vous ne pouvez utiliser le modèle Cohere Rerank 3.5 que dans cette région.
Le tableau suivant indique la prise en charge des modèles pour le reclassement :
| Fournisseur | Modèle | ID du modèle | Support du modèle à région unique |
| --- | --- | --- | --- |
| Amazon | Rerank 1.0 | amazon.rerank-v1:0 | ap-northeast-1 ca-central-1 eu-central-1 us-west-2 |
| Cohere | Rerank 3.5 | cohere.rerank-v3-5:0 | ap-northeast-1 ca-central-1 eu-central-1 us-east-1 us-west-2 |
Pour plus d’informations sur le reclassement à l’aide de modèles Cohere et de leurs paramètres d’inférence, consultez [Reclassement](https://docs.cohere.com/reference/rerank) sur le site Web de documentation Cohere.
# Autorisations pour le reclassement dans Amazon Bedrock
Les utilisateurs doivent disposer des autorisations suivantes pour pouvoir utiliser le reclassement :
+ Accès aux modèles de reclassement qu’ils prévoient d’utiliser. Pour de plus amples informations, veuillez consulter [Accès aux modèles de fondation Amazon Bedrock](model-access.md).
+ Les autorisations pour leur rôle et, s’ils prévoient d’utiliser le reclassement dans un flux de travail [https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_Retrieve.html](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_Retrieve.html), les autorisations pour le rôle de service Amazon Bedrock Knowledge Bases bénéficiant d’une [relation de confiance](kb-permissions.md#kb-permissions-trust) avec leur rôle.
**Astuce**
Pour configurer rapidement les autorisations requises, vous pouvez procéder comme suit :
Associez la politique [AmazonBedrockFullAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonBedrockFullAccess)AWSgérée au rôle d'utilisateur. Pour plus d’informations sur la façon d’attacher une politique à un rôle IAM, consultez [Ajout et suppression d’autorisations basées sur l’identité IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html).
Utilisez la console Amazon Bedrock pour créer un rôle de service Amazon Bedrock Knowledge Bases lors de la [création d’une base de connaissances](knowledge-base-create.md). Si vous possédez déjà un rôle de service Amazon Bedrock Knowledge Bases créé pour vous par la console, vous pouvez utiliser celle-ci pour le mettre à jour lorsque vous [récupérez des sources](kb-test-retrieve.md) dans la console.
**Important**
Lorsque vous utilisez le reclassement dans un flux de travail `Retrieve` avec un rôle de service Amazon Bedrock Knowledge Bases, notez ce qui suit :
Si vous modifiez manuellement la politique Gestion des identités et des accès AWS (IAM) créée par Amazon Bedrock pour votre rôle de service de base de connaissances, vous risquez de rencontrer des erreurs lorsque vous tentez de mettre à jour les autorisations dans le. AWS Management Console Pour résoudre ce problème, dans la console IAM, supprimez la version de politique que vous avez créée manuellement. Actualisez ensuite la page de reclassement dans la console Amazon Bedrock et réessayez.
Si vous utilisez un rôle personnalisé, Amazon Bedrock ne peut pas mettre à jour le rôle de service de base de connaissances en votre nom. Vérifiez que les autorisations sont correctement configurées pour le rôle de service.
Pour un récapitulatif des cas d’utilisation et des autorisations nécessaires pour ceux-ci, reportez-vous au tableau suivant :
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/rerank-prereq.html)
Pour voir des exemples de politiques d’autorisations que vous pouvez associer à un rôle IAM, développez la section correspondant à votre cas d’utilisation :
## Politique d’autorisations pour l’utilisation indépendante d’un modèle de reclassement
Pour utiliser directement le [reclassement](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_Rerank.html) avec une liste de sources, le rôle utilisateur doit être autorisé à utiliser les actions `bedrock:Rerank` et `bedrock:InvokeModel`. De même, pour empêcher l’utilisation d’un modèle de reclassement, vous devez refuser les autorisations pour les deux actions. Pour autoriser le rôle utilisateur à utiliser un modèle de reclassement de façon indépendante, vous pouvez attacher la politique suivante au rôle :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "RerankSid",
"Effect": "Allow",
"Action": [
"bedrock:Rerank"
],
"Resource": "*"
},
{
"Sid": "InvokeModelSid",
"Effect": "Allow",
"Action": [
"bedrock:InvokeModel"
],
"Resource": [
"arn:aws:bedrock:us-east-1::foundation-model/model-id"
]
}
]
}
```
------
Dans la politique précédente, pour l’action `bedrock:InvokeModel`, vous délimitez les autorisations aux modèles que vous souhaitez permettre au rôle d’utiliser pour le reclassement. Pour autoriser l'accès à tous les modèles, utilisez un caractère générique (*\$1*) dans le `Resource` champ.
## Politiques d’autorisations pour l’utilisation d’un modèle de reclassement dans un flux de travail Retrieve
Pour utiliser le reclassement lors de la récupération de données dans une base de connaissances, vous devez configurer les autorisations suivantes :
**Pour le rôle utilisateur**
Le rôle utilisateur a besoin d’autorisations pour utiliser l’action `bedrock:Retrieve`. Pour permettre au rôle utilisateur de récupérer les données d’une base de connaissances, vous pouvez attacher la politique suivante au rôle :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "RetrieveSid",
"Effect": "Allow",
"Action": [
"bedrock:Retrieve"
],
"Resource": [
"arn:aws:bedrock:us-east-1:123456789012:knowledge-base/KnowledgeBaseId"
]
}
]
}
```
------
Dans la politique précédente, pour l’action `bedrock:Retrieve`, vous définissez les autorisations d’accès aux bases de connaissances à partir desquelles vous souhaitez permettre au rôle de récupérer des informations. Pour autoriser l'accès à toutes les bases de connaissances, vous pouvez utiliser un caractère générique (*\$1*) dans le `Resource` champ.
**Pour le rôle de service**
Le [rôle de service Amazon Bedrock Knowledge Bases](kb-permissions.md) utilisé par l’utilisateur nécessite des autorisations pour utiliser les actions `bedrock:Rerank` et `bedrock:InvokeModel`. Vous pouvez utiliser la console Amazon Bedrock pour configurer automatiquement les autorisations pour votre rôle de service lorsque vous choisissez un modèle de reclassement lors de la [configuration de la récupération de la base de connaissances](kb-test-retrieve.md). Autrement, pour autoriser le rôle de service à reclasser les sources lors de la récupération, vous pouvez attacher la politique suivante :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "RerankSid",
"Effect": "Allow",
"Action": [
"bedrock:Rerank"
],
"Resource": "*"
},
{
"Sid": "InvokeModelSid",
"Effect": "Allow",
"Action": [
"bedrock:InvokeModel"
],
"Resource": "arn:aws:bedrock:us-east-1::foundation-model/RerankModelId"
}
]
}
```
------
Dans la politique précédente, pour l’action `bedrock:InvokeModel`, vous délimitez les autorisations aux modèles que vous souhaitez permettre au rôle d’utiliser pour le reclassement. Pour autoriser l’accès à tous les modèles, vous pouvez utiliser un caractère générique (\$1) dans le champ `Resource`.
## Politique d'autorisations pour l'utilisation d'un modèle de reclassement dans un flux de travail RetrieveAndGenerate
Pour utiliser un modèle de reclassement lors de la récupération des données d’une base de connaissances et de la génération ultérieure de réponses en fonction des résultats récupérés, le rôle utilisateur doit être autorisé à utiliser les actions `bedrock:RetrieveAndGenerate`, `bedrock:Rerank` et `bedrock:InvokeModel`. Pour autoriser le reclassement des sources lors de la récupération et permettre la génération de réponses en fonction des résultats, vous pouvez attacher la politique suivante au rôle d’utilisateur :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "RerankRetrieveAndGenerateSid",
"Effect": "Allow",
"Action": [
"bedrock:Rerank",
"bedrock:RetrieveAndGenerate"
],
"Resource": "*"
},
{
"Sid": "InvokeModelSid",
"Effect": "Allow",
"Action": [
"bedrock:InvokeModel"
],
"Resource": [
"arn:aws:bedrock:us-east-1::foundation-model/RerankModelId}",
"arn:aws:bedrock:us-east-1::foundation-model/GenerationModelId}"
]
}
]
}
```
------
Dans la politique précédente, pour l’opération `bedrock:InvokeModel`, vous délimitez les autorisations aux modèles que vous souhaitez permettre au rôle d’utiliser pour le reclassement, et aux modèles que vous souhaitez permettre au rôle d’utiliser pour générer des réponses. Pour autoriser l'accès à tous les modèles, vous pouvez utiliser un caractère générique (*\$1*) dans le `Resource` champ.
Pour restreindre davantage les autorisations, vous pouvez omettre des actions ou spécifier des ressources et des clés de condition permettant de filtrer les autorisations. Pour plus d’informations sur les actions, les ressources et les clés de condition, consultez les rubriques suivantes dans la *Référence des autorisations de service* :
+ [Actions définies par Amazon Bedrock](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonbedrock.html#amazonbedrock-actions-as-permissions) : découvrez les actions, les types de ressources auxquels vous pouvez les appliquer dans le champ `Resource` et les clés de condition qui vous permettent de filtrer les autorisations dans le champ `Condition`.
+ [Types de ressources définis par Amazon Bedrock](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonbedrock.html#amazonbedrock-resources-for-iam-policies) : découvrez les types de ressources dans Amazon Bedrock.
+ [Clés de condition pour Amazon Bedrock](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonbedrock.html#amazonbedrock-policy-keys) : découvrez les clés de condition dans Amazon Bedrock.
# Utilisation d’un modèle de reclassement dans Amazon Bedrock
Vous pouvez utiliser un modèle de reclassement directement ou lors de la récupération des résultats d’une requête dans la base de connaissances. Choisissez l’onglet correspondant à votre méthode préférée, puis suivez les étapes :
------
#### [ Console ]
Vous ne pouvez pas utiliser un modèle de reclassement directement dans la AWS Management Console, mais vous en utiliser un quand vous interrogez votre base de connaissances en procédant comme suit :
1. Lorsque vous interrogez une base de connaissances, ouvrez le volet **Configurations** en cliquant sur l’icône ![\[Three horizontal sliders with adjustable circular controls for settings or parameters.\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/images/icons/configurations.png).
1. Développez la section **Reclassement.**
1. Choisissez **Sélectionner le modèle** pour sélectionner un modèle.
1. Si votre rôle de service Amazon Bedrock Knowledge Bases ne dispose pas des [autorisations nécessaires pour utiliser le modèle de reclassement](rerank-prereq.md), sélectionnez **Mettre à jour le rôle de service** pour modifier le rôle avec les autorisations appropriées.
1. (Facultatif) Dans la section **Options de reclassement supplémentaires**, modifiez les options de votre choix.
1. Saisissez une invite et cliquez sur **Exécuter**. La réponse est le résultat obtenu après application du modèle de reclassement.
Pour obtenir des instructions plus détaillées sur l’exécution d’une requête dans une base de connaissances, consultez [Interrogation d’une base de connaissances et extraction des données](kb-test-retrieve.md) et [Interrogation d’une base de connaissances et génération de réponses basées sur les données récupérées](kb-test-retrieve-generate.md).
------
#### [ API ]
Pour des instructions sur l’utilisation d’un modèle de reclassement lors d’une requête dans une base de connaissances, consultez [Interrogation d’une base de connaissances et extraction des données](kb-test-retrieve.md) et [Interrogation d’une base de connaissances et génération de réponses basées sur les données récupérées](kb-test-retrieve-generate.md).
Pour utiliser un modèle de reclassement directement avec l’API Amazon Bedrock, envoyez une demande de [reclassement](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_Rerank.html) avec un [point de terminaison d’exécution des agents Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-rt).
Les champs suivants sont obligatoires :
****
| Champ | Description de base |
| --- | --- |
| queries | Tableau d’un objet [RerankQuery](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_RerankQuery.html). Spécifiez TEXT comme type et incluez la requête dans le champ textQuery. |
| sources | Tableau d’objets [RerankSource](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_RerankSource.html) à soumettre au modèle de reclassement. Pour chaque RerankSource, spécifiez INLINE en tant que type et incluez un objet [RerankDocument](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_RerankDocument.html) dans le champ inlineDocumentSource. Voir ci-dessous pour plus de détails sur RerankDocument. |
| rerankingConfiguration | Inclut l’Amazon Resource Name (ARN) du modèle de reclassement à utiliser, le nombre de résultats à renvoyer après le reclassement et, éventuellement, les configurations d’inférence pour le modèle. Vous spécifiez les configurations de modèle supplémentaires sous forme de paires clé-valeur. Pour plus d’informations, consultez [Rerank](https://docs.cohere.com/reference/rerank) sur le site web de la documentation Cohere. |
Les champs suivants sont facultatifs :
****
| Champ | Cas d’utilisation |
| --- | --- |
| nextToken | Jeton renvoyé dans une réponse précédente que vous pouvez inclure pour fournir le prochain lot de résultats. |
Le format de l’objet `RerankSource` que vous incluez dépend du format du document. Pour voir le format des différents types `RerankSource`, cliquez sur l’onglet correspondant au format du document :
------
#### [ String ]
Si le document est une chaîne, spécifiez la valeur du champ `type` de l’objet [RerankDocument](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_RerankDocument.html) sous la forme `TEXT` et incluez le document dans le champ `text`. Par exemple :
```
{
"inlineDocumentSource": {
"textDocument": {
"text": "string"
},
"type": "TEXT"
},
"type": "INLINE"
}
```
------
#### [ JSON object ]
Si le document est un objet JSON, spécifiez la valeur du champ `type` de l’objet [RerankDocument](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_RerankDocument.html) sous la forme `JSON` et incluez le document dans le champ `jsonDocument`. Par exemple :
```
{
"inlineDocumentSource": {
"jsonDocument": JSON value,
"type": "JSON"
},
"type": "INLINE"
}
```
------
La réponse à votre demande `Rerank` renvoie une liste d’objets [RerankResult](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_RerankResult.html) dans le champ `results`. Chaque objet contient les champs suivants :
+ `document` : inclut des informations sur le document que vous avez soumis.
+ `relevanceScore` : score de pertinence pour le document, attribué par le modèle de reclassement.
+ `index` : indique le classement du document par rapport aux autres documents de la liste. Plus le score est bas, plus le classement est élevé.
S’il y a trop de résultats à afficher, la réponse renvoie une valeur dans le champ `nextToken`. Dans ce cas, pour voir le lot de résultats suivant, incluez ce jeton dans une demande ultérieure.
------
# Présentation des modèles Amazon Titan
Les modèles Amazon Titan Foundation (FMs) sont une famille de modèles FMs préentraînés AWS sur de grands ensembles de données, ce qui en fait de puissants modèles polyvalents conçus pour prendre en charge une variété de cas d'utilisation. Utilisez-les tels quels ou personnalisez-les en privé avec vos propres données.
Amazon Titan prend en charge les modèles suivants pour Amazon Bedrock.
+ **Plongement lexical Amazon Titan V2**
+ **Amazon Titan Multimodal Embeddings G1**
+ **Générateur d'images Amazon Titan G1 v2**
**Topics**
+ [Modèles de plongement lexical Amazon Titan](titan-embedding-models.md)
+ [Modèle Amazon Titan Multimodal Embeddings G1](titan-multiemb-models.md)
+ [Générateur d'images Amazon Titan, modèle G1](titan-image-models.md)
# Modèles de plongement lexical Amazon Titan
Les modèles de vectorisations Amazon Titan incluent le plongement lexical Amazon Titan V2 et le modèle de plongement lexical Titan G1.
Les intégrations de texte constituent des représentations vectorielles significatives de texte non structuré telles que des documents, des paragraphes et des phrases. Vous entrez un corps de texte, et la sortie est un vecteur (1 x n). Vous pouvez utiliser les vecteurs d’intégration dans une grande variété d’applications.
Le modèle de plongement lexical Amazon Titan v2 (`amazon.titan-embed-text-v2:0`) peut recevoir jusqu’à 8 192 jetons ou 50 000 caractères et produit un vecteur de 1 024 dimensions. Il est optimisé pour les tâches de récupération de texte, mais peut également être utilisé pour des tâches supplémentaires, telles que la similitude sémantique et la mise en cluster.
Les modèles de vectorisations Amazon Titan génèrent une représentation sémantique significative des documents, des paragraphes et des phrases. Le plongement lexical Amazon Titan prend en entrée un corps de texte et produit un vecteur (1 x n). Le plongement lexical Amazon Titan est proposé via une invocation de point de terminaison optimisée en termes de latence pour une recherche plus rapide (recommandé lors de l’étape de récupération) ainsi que des tâches par lots optimisées en termes de débit pour une indexation plus rapide. Le plongement lexical Amazon Titan v2 prend en charge les documents longs, mais pour les tâches de récupération, il est recommandé de segmenter les documents en segments logiques, tels que des paragraphes ou des sections.
**Note**
Le modèle de plongement lexical Amazon Titan v2 et le modèle de plongement lexical Titan v1 ne prennent pas en charge les paramètres d’inférence tels que `maxTokenCount` ou `topP`.
**Modèle de plongement lexical Amazon Titan V2**
+ **ID du modèle** : `amazon.titan-embed-text-v2:0`
+ **Nombre maximum de jetons de texte d'entrée** : 8 192
+ **Nombre maximal de caractères en entrée** : 50 000
+ **Langues** : anglais (100 langues supplémentaires en version préliminaire)
+ **Taille du vecteur de sortie** : 1 024 (par défaut), 512, 256
+ **Types d’inférence** : débit provisionné, à la demande
+ **Cas d’utilisation pris en charge** : RAG, recherche de documents, reclassement, classification, etc.
**Note**
Le plongement lexical V2 prend en entrée une chaîne non vide contenant jusqu’à 8 192 jetons ou 50 000 caractères. Le ratio de caractères par jeton en anglais est de 4,7 caractères par jeton, en moyenne. Le plongement lexical V1 et le plongement lexical Titan V2 peuvent recevoir jusqu’à 8 192 jetons, mais il est recommandé de segmenter les documents en segments logiques (tels que des paragraphes ou des sections).
Le modèle de plongement lexical Amazon Titan v2 est optimisé pour l’anglais, avec un support multilingue pour les langues suivantes. Les requêtes multilingues (telles que la fourniture d’une base de connaissances en coréen et l’interrogation en allemand) produiront des résultats sous-optimaux.
+ Afrikaans
+ Albanais
+ Amharique
+ Arabe
+ Arménien
+ Assamais
+ Azerbaïdjanais
+ Bachkir
+ Basque
+ Biélorusse
+ Bengali
+ Bosniaque
+ Breton
+ Bulgare
+ Birman
+ Catalan
+ Cebuano
+ Chinois
+ Corse
+ Croate
+ Tchèque
+ Danois
+ Dhivehi
+ Néerlandais
+ Anglais
+ Espéranto
+ Estonian
+ Féroïen
+ Finnois
+ Français
+ Galicien
+ Géorgien
+ Allemand
+ Gujarati
+ Haïtien
+ Haoussa
+ Hébreu
+ Hindi
+ Hongrois
+ Islandais
+ Indonésien
+ Irlandais
+ Italien
+ Japonais
+ Javanais
+ Kannada
+ Kazakh
+ Khmer
+ Kinyarwanda
+ Kirghize
+ Coréen
+ Norvégien
+ Lao
+ Latin
+ Letton
+ Lituanien
+ Luxembourgeois
+ Macédonien
+ Malgache
+ Malais
+ Malayalam
+ Maltais
+ Maori
+ Marathi
+ Grec moderne
+ Mongol
+ Népalais
+ Norvégien
+ Nynorsk norvégien
+ Occitan
+ Oriya
+ Panjabi
+ Persan
+ Polonais
+ Portugais
+ Pushto
+ Roumain
+ Romanche
+ Russe
+ Sanskrit
+ Gaélique écossais
+ Serbe
+ Sindhi
+ Singhalais
+ Slovaque
+ Slovène
+ Somali
+ Espagnol
+ Soundanais
+ Swahili
+ Suédois
+ Tagalog
+ Tadjik
+ Tamoul
+ Tatar
+ Télougou
+ Thaï
+ Tibétain
+ Turc
+ Turkmène
+ Ouïghour
+ Ukrainien
+ Urdu
+ Ouzbek
+ Vietnamien
+ Waray
+ Gallois
+ Frison occidental
+ Xhosa
+ Yiddish
+ Yoruba
+ Zoulou
# Modèle Amazon Titan Multimodal Embeddings G1
Les modèles de fondation Amazon Titan sont pré-entraînés sur de grands jeux de données, ce qui en fait de puissants modèles polyvalents. Utilisez-les tels quels ou personnalisez-les en optimisant les modèles avec vos propres données pour une tâche particulière sans annoter de gros volumes de données.
Il existe trois types de modèles Titan : la vectorisation, la génération de texte et la génération d’images.
Il existe deux modèles Titan Multimodal Embeddings G1. Le modèle de plongement multimodal Amazon Titan G1 traduit les entrées de texte (mots, phrases ou éventuellement de grandes unités de texte) en représentations numériques (appelées vectorisations) qui contiennent le sens sémantique du texte. Bien que ce modèle ne génère pas de texte, il est utile pour les applications telles que la personnalisation et la recherche. En comparant les vectorisations, le modèle produira des réponses plus pertinentes et contextuelles que la correspondance de mots. Le modèle de plongement multimodal G1 est utilisé pour des cas d’utilisation tels que la recherche d’images par texte, par image à des fins de similarité, ou par combinaison de texte et d’image. Il traduit l’image ou le texte d’entrée en une vectorisation qui contient la signification sémantique de l’image et du texte dans le même espace sémantique.
Les modèles Titan Text sont génératifs LLMs pour des tâches telles que la synthèse, la génération de texte, la classification, le QnA ouvert et l'extraction d'informations. Ils sont également formés à de nombreux langages de programmation différents, ainsi qu’à des formats de texte enrichi tels que les tableaux, les fichiers JSON et .csv, entre autres formats.
**Modèle de plongement multimodal Amazon Titan G1**
+ **ID du modèle** : `amazon.titan-embed-image-v1`
+ **Nombre maximum de jetons de texte en entrée** : 256
+ **Langues** : anglais
+ **Taille maximale de l'image en entrée** : 25 Mo
+ **Taille du vecteur de sortie** : 1024 (par défaut), 384, 256
+ **Types d’inférence** : débit provisionné, à la demande
+ **Cas d’utilisation pris en charge** : recherche, recommandations et personnalisation.
Le plongement lexical Amazon Titan V1 prend en entrée une chaîne non vide contenant jusqu’à 8 192 jetons et renvoie une intégration de 1 024 vectorisations dimensionnelles. Le ratio de caractères par jeton en anglais est de 4,7 cars/jeton, en moyenne. Remarque sur les cas d’utilisation RAG : le modèle Titan Text Embeddings V2 peut accueillir jusqu’à 8 192 jetons, mais nous recommandons de segmenter les documents en segments logiques (tels que des paragraphes ou des sections).
## Longueur d’intégration
La définition d’une longueur d’intégration personnalisée est facultative. La longueur d’intégration par défaut est de 1024 caractères, ce qui convient à la plupart des cas d’utilisation. La longueur d’intégration peut être définie sur 256, 384 ou 1024 caractères. Des tailles d’intégration plus importantes créent des réponses plus détaillées, mais augmentent également le temps de calcul. Des longueurs d’intégration plus courtes fournissent moins de détails mais améliorent le temps de réponse.
```
# EmbeddingConfig Shape
{
'outputEmbeddingLength': int // Optional, One of: [256, 384, 1024], default: 1024
}
# Updated API Payload Example
body = json.dumps({
"inputText": "hi",
"inputImage": image_string,
"embeddingConfig": {
"outputEmbeddingLength": 256
}
})
```
## Affinement
+ Les entrées dans le peaufinage Amazon Titan Multimodal Embeddings G1 sont des paires image-texte.
+ Formats d’image : PNG, JPEG
+ Limite de taille de l'image d'entrée : 25 Mo
+ Dimensions de l’image : min : 256 px, max : 4 096 px
+ Nombre maximal de jetons dans la légende : 128
+ Plage de tailles du jeu de données d’entraînement : 1000 à 500 000
+ Plage de tailles du jeu de données de validation : 8 à 50 000
+ Longueur de la légende en caractères : 0 à 2 560
+ Nombre total maximal de pixels par image : 2048\$12048\$13
+ Rapport hauteur/largeur : min : 0,25, max : 4
## Préparation des jeux de données
Pour le jeu de données d’entraînement, créez un fichier `.jsonl` contenant plusieurs lignes JSON. Chaque ligne JSON contient à la fois des attributs `image-ref` et `caption` similaires au [format de fichier manifeste augmenté Sagemaker](https://docs.aws.amazon.com/sagemaker/latest/dg/augmented-manifest.html). Un jeu de données de validation est requis. Le sous-titrage automatique n’est actuellement pas pris en charge.
```
{"image-ref": "s3://bucket-1/folder1/0001.png", "caption": "some text"}
{"image-ref": "s3://bucket-1/folder2/0002.png", "caption": "some text"}
{"image-ref": "s3://bucket-1/folder1/0003.png", "caption": "some text"}
```
Pour les jeux de données d’entraînement et de validation, vous devez créer des fichiers `.jsonl` contenant plusieurs lignes JSON.
Les chemins Amazon S3 doivent se trouver dans les mêmes dossiers dans lesquels vous avez autorisé Amazon Bedrock à accéder aux données en joignant une politique IAM à votre fonction du service Amazon Bedrock. Pour plus d’informations sur l’octroi de politiques IAM pour les données d’entraînement, consultez [Attribution à des tâches personnalisées de l’accès à vos données d’entraînement](https://docs.aws.amazon.com/bedrock/latest/userguide/security_iam_id-based-policy-examples.html#security_iam_id-based-policy-examples-model-customization).
## Hyperparamètres
Ces valeurs peuvent être ajustées pour les hyperparamètres du modèle Multimodal Embeddings. Les valeurs par défaut conviendront à la plupart des cas d’utilisation.
+ Taux d’apprentissage (taux d’apprentissage min/max) : par défaut : 5,00E-05, min : 5,00E-08, max : 1
+ Taille de lot – Taille de lot effective : par défaut : 576, min : 256, max : 9 216
+ Nombre maximal d’époques : par défaut : « auto », min : 1, max : 100
# Générateur d'images Amazon Titan, modèle G1
Amazon Titan Image Generator G1 est un modèle de génération d'images qui permet aux utilisateurs de générer et de modifier des images de manière polyvalente. Les utilisateurs peuvent créer des images qui correspondent à leurs descriptions textuelles en saisissant simplement des invites en langage naturel. En outre, ils peuvent charger et modifier des images existantes, notamment en appliquant des invites textuelles sans avoir besoin de masque, ou en modifiant des parties spécifiques d’une image à l’aide d’un masque d’image. Le modèle prend également en charge l’outpainting, qui repousse les limites d’une image, et l’inpainting, qui comble les zones manquantes. Il offre la possibilité de générer des variations d’une image en fonction d’une invite de texte facultative, ainsi que des options de personnalisation instantanée qui permettent aux utilisateurs de transférer des styles à l’aide d’images de référence, ou de combiner des styles provenant de plusieurs références, le tout sans nécessiter de peaufinage.
Amazon Titan Image Generator G1 v2 ajoute plusieurs fonctionnalités avancées. Il permet aux utilisateurs d’exploiter les images de référence pour guider la génération d’images, où l’image de sortie s’aligne sur la mise en page et la composition de l’image de référence tout en suivant les invites textuelles. Il inclut également une fonctionnalité de suppression automatique de l’arrière-plan, qui permet de supprimer les arrière-plans des images contenant plusieurs objets sans aucune intervention de l’utilisateur. Le modèle permet de contrôler avec précision la palette de couleurs des images générées. Les utilisateurs peuvent ainsi préserver l’identité visuelle d’une marque sans avoir à effectuer de peaufinages supplémentaires. De plus, la fonctionnalité de cohérence du sujet permet aux utilisateurs d’optimiser le modèle avec des images de référence afin de préserver le sujet choisi (animal de compagnie, chaussure ou sac à main, par exemple) dans les images générées. Cette suite complète de fonctionnalités permet aux utilisateurs de libérer leur potentiel créatif et de donner vie à leurs visions imaginatives.
Pour plus d'informations sur les directives d'ingénierie du modèle Amazon Titan Image Generator G1, consultez les [meilleures pratiques d'ingénierie rapide d'Amazon Titan Image Generator](https://d2eo22ngex1n9g.cloudfront.net/Documentation/User+Guides/Titan/Amazon+Titan+Image+Generator+Prompt+Engineering+Guidelines.pdf).
Pour continuer à soutenir les meilleures pratiques en matière d'utilisation responsable de l'IA, les modèles de la Titan Foundation (FMs) sont conçus pour détecter et supprimer le contenu préjudiciable des données, rejeter le contenu inapproprié des entrées utilisateur et filtrer les résultats des modèles contenant du contenu inapproprié (tel que les discours de haine, les blasphèmes et la violence). Le FM du générateur d’images Titan ajoute un filigrane invisible et des métadonnées [C2PA](https://c2pa.org/) à toutes les images générées.
Vous pouvez utiliser la fonctionnalité de détection des filigranes de la console Amazon Bedrock ou appeler l’API de détection des filigranes Amazon Bedrock (version préliminaire) pour vérifier si une image contient un filigrane provenant du générateur d’images Titan. Vous pouvez également utiliser des sites tels que [Content Credentials Verify](https://contentcredentials.org/verify) pour vérifier si une image a été générée par le générateur d’images Titan.
Présentation du **générateur d’images Amazon Titan v2**
+ **ID du modèle** : `amazon.titan-image-generator-v2:0 `
+ **Nombre maximal de caractères en entrée** : 512 caractères
+ **Taille maximale de l'image d'entrée** : 5 Mo (seules certaines résolutions spécifiques sont prises en charge)
+ **Taille maximale de l’image en utilisant l’in/outpainting, la suppression de l’arrière-plan, la conditionnement de l’image, la palette de couleurs** : 1 408 x 1 408 px
+ **Taille maximale de l’image en utilisant la variation d’image** : 4 096 x 4 096 px
+ **Langues** : anglais
+ **Type de sortie** : image
+ **Types d’images pris en charge** : JPEG, JPG, PNG
+ **Types d’inférence** : débit provisionné, à la demande
+ **Cas d’utilisation pris en charge** : génération d’images, retouche d’images, variations d’images, suppression de l’arrière-plan, contenu guidé par la couleur
## Caractéristiques
+ Text-to-image Génération (T2I) — Entrez une invite de texte et générez une nouvelle image en sortie. L’image générée capture les concepts décrits par l’invite de texte.
+ Affinement d’un modèle T2I : importez plusieurs images pour capturer votre propre style et vos personnalisations, puis affinez le modèle T2I de base. Le modèle peaufiné génère des images qui respectent le style et les personnalisations d’un utilisateur spécifique.
+ Options de retouche d’image : incluent l’inpainting, l’outpainting, la génération de variations et la retouche automatique sans masque d’image.
+ Inpainting : utilise une image et un masque de segmentation comme données d’entrée (provenant de l’utilisateur ou estimées par le modèle) et reconstruit la région dans le masque. Utilisez l’inpainting pour supprimer les éléments masqués et les remplacer par des pixels d’arrière-plan.
+ Outpainting : utilise une image et un masque de segmentation comme données d’entrée (provenant de l’utilisateur ou estimées par le modèle) et génère de nouveaux pixels qui étendent la région en toute transparence. Utilisez un outpainting précis pour préserver les pixels de l’image masquée lorsque vous étendez l’image jusqu’aux limites. Utilisez l’outpainting par défaut pour étendre les pixels de l’image masquée jusqu’aux limites de l’image en fonction des paramètres de segmentation.
+ Variation d’image : utilise une à cinq images et une invite facultative comme données d’entrée. Cette fonctionnalité génère une nouvelle image qui préserve le contenu de l’image d’entrée, mais en modifie le style et l’arrière-plan.
+ Conditionnement d’image (v2 uniquement) : utilise une image de référence en entrée pour guider la génération d’images. Le modèle génère une image de sortie qui s’aligne sur la mise en page et la composition de l’image de référence, tout en suivant les invites textuelles.
+ Cohérence du sujet (v2 uniquement) : la cohérence du sujet permet aux utilisateurs d’optimiser le modèle avec des images de référence afin de préserver le sujet choisi (animal de compagnie, chaussure ou sac à main, par exemple) dans les images générées.
+ Contenu guidé par la couleur (v2 uniquement) : vous pouvez fournir une liste de codes couleur hexadécimaux avec une invite. Une plage de 1 à 10 codes hexadécimaux peut être fournie. L’image renvoyée par le Titan Image Generator G1 V2 incorporera la palette de couleurs fournie par l’utilisateur.
+ Suppression de l’arrière-plan (v2 uniquement) : identifie automatiquement plusieurs objets dans l’image d’entrée et supprime l’arrière-plan. L’image de sortie possède un arrière-plan transparent.
+ Provenance du contenu : utilisez des sites tels que [Content Credentials Verify](https://contentcredentials.org/verify) pour vérifier si une image a été générée par le générateur d’images Titan. Cela devrait indiquer que l’image a été générée, sauf si les métadonnées ont été supprimées.
**Note**
Si vous utilisez un modèle peaufiné, vous ne pouvez pas utiliser les fonctionnalité d’inpainting, d’outpainting ou de palette de couleurs de l’API ou du modèle.
## Parameters
Pour plus d'informations sur les paramètres d'inférence du modèle Amazon Titan Image Generator G1, consultez la section Paramètres d'inférence du [modèle Amazon Titan Image Generator G1](model-parameters-titan-image.md).
## Peaufinage
Pour plus d'informations sur le réglage précis du modèle Amazon Titan Image Generator G1, consultez les pages suivantes.
+ [Préparez les données pour affiner vos modèles](model-customization-prepare.md)
+ [Hyperparamètres de personnalisation des modèles de générateur d’images Amazon Titan G1](custom-models-hp.md#cm-hp-titan-image)
**Réglage et tarification du modèle Amazon Titan Image Generator G1**
Le modèle utilise l’exemple de formule suivant pour calculer le prix total par tâche :
Prix total = Étapes \$1 Taille du batch \$1 Prix par image vue
Valeurs minimales (auto) :
+ Nombre minimal d’étapes (auto) : 500
+ Taille de lot minimale : 8
+ Taux d’apprentissage par défaut : 0,00001
+ Prix par image vue : 0,005
**Peaufinage des paramètres des hyperparamètres**
**Étapes** : nombre de fois que le modèle est exposé à chaque lot. Aucun nombre d’étapes n’est défini par défaut. Vous devez sélectionner un nombre compris entre 10 et 40 000 ou une valeur de chaîne « Auto ».
**Réglages des étapes – Auto** : Amazon Bedrock détermine une valeur raisonnable en fonction des informations d’entraînement. Sélectionnez cette option pour donner la priorité aux performances du modèle par rapport aux coûts d’entraînement. Le nombre d’étapes est déterminé automatiquement. Ce nombre sera généralement compris entre 1 000 et 8 000 en fonction de votre jeu de données. Le coût des tâches est influencé par le nombre d’étapes utilisées pour exposer le modèle aux données. Consultez la section des exemples des informations de tarification pour comprendre comment le coût des tâches est calculé. (Consultez le tableau d’exemple ci-dessus pour voir comment le nombre d’étapes est lié au nombre d’images lorsque Auto est sélectionné.)
**Paramètres des étapes – Personnalisé** : vous pouvez indiquer le nombre d’étapes pendant lesquelles Bedrock doit exposer votre modèle personnalisé aux données d’entraînement. La valeur doit être comprise entre 10 et 40 000. Vous pouvez réduire le coût par image produite par le modèle en utilisant une valeur de nombre d’étapes inférieure.
**Taille de lot** : nombre d’exemples traités avant la mise à jour des paramètres du modèle. Cette valeur est comprise entre 8 et 192 et est un multiple de 8.
**Taux d’apprentissage** : taux auquel les paramètres du modèle sont mis à jour après chaque lot de données d’entraînement. Il s’agit d’une valeur flottante comprise entre 0 et 1. Le taux d’apprentissage est défini sur 0,00001 par défaut.
Pour plus d’informations sur la procédure de peaufinage, consultez [Soumission d’une tâche de personnalisation du modèle](https://docs.aws.amazon.com/bedrock/latest/userguide/model-customization-submit.html).
## Output
Le modèle Amazon Titan Image Generator G1 utilise la taille et la qualité de l'image de sortie pour déterminer le prix d'une image. Le modèle comporte deux segments de prix basés sur la taille : un pour 512 x 512 images et un autre pour 1 024 x 1024 images. Le prix dépend de la taille de l’image (hauteur x largeur), inférieure ou égale à 512 x 512 ou supérieure à 512 x 512.
Pour plus d’informations sur la tarification Amazon Bedrock, consultez [Tarification d’Amazon Bedrock](https://aws.amazon.com/bedrock/pricing/).
## Détection de filigranes
**Note**
La détection des filigranes pour la console et l’API Amazon Bedrock est disponible dans la version préliminaire publique et permet de détecter uniquement les filigranes générés par le générateur d’images Titan G1. Cette fonctionnalité n’est actuellement pas disponible dans les régions `us-west-2` et `us-east-1`. La détection de filigrane est une détection très précise du filigrane généré par le générateur d’images Titan G1. Les images modifiées par rapport à l’image d’origine peuvent produire des résultats moins précis.
Ce modèle ajoute un filigrane invisible à toutes les images générées afin de réduire la propagation de la désinformation, de contribuer à la protection des droits d’auteur et de suivre l’utilisation du contenu. La détection de filigrane est disponible pour vous aider à confirmer si une image a été générée par le générateur d’images Titan G1, qui vérifie l’existence de ce filigrane.
**Note**
L’API de détection des filigranes est actuellement disponible en version préliminaire et susceptible d’être modifiée. Nous vous recommandons de créer un nouvel environnement virtuel pour utiliser le kit SDK. La détection des APIs filigranes n'étant pas disponible dans les dernières versions SDKs, nous vous recommandons de désinstaller la dernière version du SDK de l'environnement virtuel avant d'installer la version avec la détection des filigranes. APIs
Vous pouvez télécharger votre image pour détecter si un filigrane provenant du générateur d’images Titan G1 est présent sur l’image. Utilisez la console pour détecter un filigrane provenant de ce modèle en suivant les étapes ci-dessous.
**Pour détecter un filigrane avec le générateur d’images Titan G1 :**
1. Ouvrez la [console Amazon Bedrock](https://console.aws.amazon.com/bedrock).
1. Sélectionnez **Vue d’ensemble** dans le volet de navigation Amazon Bedrock. Cliquez sur l’onglet **Créer et tester**.
1. Dans la section **Garde-fou**, accédez à **Détection de filigranes** et choisissez **Afficher la détection des filigranes**.
1. Sélectionnez **Charger une image** et recherchez un fichier au format JPG ou PNG. La taille de fichier maximale autorisée est 5 Mo.
1. Une fois l’image chargée, une miniature s’affiche avec le nom, la taille du fichier et la date de dernière modification. Cliquez sur X pour supprimer ou remplacer l’image dans la section **Charger**.
1. Sélectionnez **Analyser** pour commencer l’analyse de détection des filigranes.
1. L’image est prévisualisée sous **Résultats** et indique avec la mention **Filigrane détecté** sous l’image et une bannière sur l’image si un filigrane est détecté. Si aucun filigrane n’est détecté, le texte sous l’image indique **Filigrane NON détecté**.
1. Pour charger l’image suivante, cliquez sur X dans la miniature de l’image dans la section **Charger**, puis choisissez une nouvelle image à analyser.
## Directives d’ingénierie de requête
**Invite de masque** : cet algorithme classe les pixels en concepts. L’utilisateur peut fournir une invite de texte qui sera utilisée pour classer les zones de l’image à masquer, en fonction de l’interprétation de l’invite de masque. L’option d’invite permet d’interpréter des invites plus complexes et de coder le masque dans l’algorithme de segmentation.
**Masque d’image** : vous pouvez également utiliser un masque d’image pour définir les valeurs du masque. Le masque d’image peut être combiné à une saisie d’invite de masque afin d’améliorer la précision. Le fichier de masque d’image doit être conforme aux paramètres suivants :
+ Les valeurs de l’image de masque doivent être 0 (noir) ou 255 (blanc). La zone du masque d'image avec la valeur 0 sera régénérée avec l'image provenant de l'image and/or saisie par l'utilisateur.
+ Le champ `maskImage` doit être une chaîne d’image codée en base64.
+ L’image de masque doit avoir les mêmes dimensions que l’image d’entrée (même hauteur et même largeur).
+ Seuls des fichiers PNG ou JPG peuvent être utilisés pour l’image d’entrée et l’image de masque.
+ L’image de masque ne doit utiliser que des valeurs de pixels en noir et blanc.
+ L’image de masque ne peut utiliser que les canaux RVB (le canal alpha n’est pas pris en charge).
Pour plus d’informations sur l’ingénierie de requête du générateur d’images Amazon Titan G1, consultez [Amazon Titan Image Generator Prompt Engineering Best Practices](https://d2eo22ngex1n9g.cloudfront.net/Documentation/User+Guides/Titan/Amazon+Titan+Image+Generator+Prompt+Engineering+Guidelines.pdf).
Pour les directives générales d’ingénierie de requête, consultez [Directives d’ingénierie de requête](https://docs.aws.amazon.com/bedrock/latest/userguide/prompt-engineering-guidelines.html).