Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Inférence à l'aide de l'API Anthropic Messages
L'API Anthropic Messages fournit un accès natif aux modèles Claude en utilisant le format de demande et de réponse Anthropic. Vous pouvez utiliser l'API Messages à la fois sur les points de `bedrock-runtime` terminaison `bedrock-mantle` et sur les points de terminaison, ce qui vous permet de choisir le style d'authentification et d'intégration adapté à votre application.
| **Point de terminaison** | **URL de base** | **Cas d'utilisation** |
| --- | --- | --- |
| bedrock-mantle | https://bedrock-mantle.{region}.api.aws/anthropic/v1/messages | Recommandé pour les nouvelles applications. Supporte l'authentification par clé d'API et. [Espaces de travail () Anthropic-compatible](workspaces.md) |
| bedrock-runtime | https://bedrock-runtime.{region}.amazonaws.com | À utiliser avec les intégrations de AWS SDK existantes et la journalisation des appels. |
## Régions prises en charge
L'API Messages est disponible sur le `bedrock-mantle` terminal dans toutes les régions qui le prennent en charge `bedrock-mantle` (voir[Régions et terminaux pris en charge](bedrock-mantle.md#bedrock-mantle-supported)). En ce qui `bedrock-runtime` concerne le terminal, il est disponible dans toutes les régions où les modèles Claude sont disponibles. Consultez [Disponibilité par région](models-region-compatibility.md) pour plus de détails.
## Conditions préalables
Avant d'utiliser l'API Messages, assurez-vous de disposer des éléments suivants :
+ **Accès aux modèles** — Demandez l'accès aux modèles Claude dans la console Amazon Bedrock. Consultez [Demander l'accès aux modèles](model-access.md).
+ **Authentification** : dépend du point de terminaison :
+ `bedrock-mantle`— Utilisez une clé d'API Amazon Bedrock (voir[clés d’API](api-keys.md)) ou des informations d'identification AWS SigV4.
+ `bedrock-runtime`— Utilisez les informations d'identification AWS SigV4 via le AWS SDK (boto3, etc.).
+ **En-tête de version anthropique** — Toutes les demandes nécessitent une version d'API :
+ `bedrock-mantle`: défini `anthropic-version: 2023-06-01` comme en-tête HTTP.
+ `bedrock-runtime`: défini `"anthropic_version": "bedrock-2023-05-31"` dans le corps de la demande.
## Demande de base
Pour envoyer un message de base à un modèle Claude, choisissez l'onglet correspondant à votre méthode préférée, puis suivez les étapes suivantes :
------
#### [ bedrock-mantle (curl) ]
```
curl -X POST https://bedrock-mantle.us-east-1.api.aws/anthropic/v1/messages \
-H "x-api-key: $BEDROCK_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "Content-Type: application/json" \
-d '{
"model": "anthropic.claude-sonnet-4-6-v1",
"max_tokens": 1024,
"messages": [
{"role": "user", "content": "Explain quantum computing in one sentence."}
]
}'
```
------
#### [ bedrock-runtime (Python) ]
```
import boto3
import json
client = boto3.client("bedrock-runtime", region_name="us-east-1")
response = client.invoke_model(
modelId="anthropic.claude-sonnet-4-6-v1",
body=json.dumps({
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 1024,
"messages": [
{"role": "user", "content": "Explain quantum computing in one sentence."}
]
})
)
result = json.loads(response["body"].read())
print(result["content"][0]["text"])
```
------
#### [ bedrock-runtime (curl) ]
Utilisez la AWS CLI pour appeler le modèle :
```
aws bedrock-runtime invoke-model \
--model-id anthropic.claude-sonnet-4-6-v1 \
--body '{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 1024,
"messages": [
{"role": "user", "content": "Explain quantum computing in one sentence."}
]
}' \
--cli-binary-format raw-in-base64-out \
output.json
```
------
## Diffusez les réponses
Pour recevoir les jetons de réponse de manière incrémentielle au fur et à mesure de leur génération, choisissez l'onglet correspondant à votre méthode préférée, puis suivez les étapes suivantes :
------
#### [ bedrock-mantle (curl) ]
```
curl -X POST https://bedrock-mantle.us-east-1.api.aws/anthropic/v1/messages \
-H "x-api-key: $BEDROCK_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "Content-Type: application/json" \
-d '{
"model": "anthropic.claude-sonnet-4-6-v1",
"max_tokens": 1024,
"stream": true,
"messages": [
{"role": "user", "content": "Write a short poem about cloud computing."}
]
}'
```
------
#### [ bedrock-runtime (Python) ]
```
import boto3
import json
client = boto3.client("bedrock-runtime", region_name="us-east-1")
response = client.invoke_model_with_response_stream(
modelId="anthropic.claude-sonnet-4-6-v1",
body=json.dumps({
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 1024,
"messages": [
{"role": "user", "content": "Write a short poem about cloud computing."}
]
})
)
for event in response["body"]:
chunk = json.loads(event["chunk"]["bytes"])
if chunk["type"] == "content_block_delta":
print(chunk["delta"]["text"], end="")
```
------
## Fonctionnalités prises en charge
L'API Messages prend en charge les fonctionnalités avancées suivantes avec les modèles Claude :
+ **Invites système** — Définissez le comportement du modèle à l'aide d'un `system` paramètre.
+ **Multi-turn conversations** — Passez des `assistant` messages `user` en alternance.
+ **Utilisation de l'outil** : définissez les outils que le modèle peut appeler. Consultez [Utilisation d’un outil pour compléter une réponse au modèle Amazon Bedrock](tool-use.md).
+ **Vision** — Envoyez des images dans le `content` tableau à côté du texte.
+ **Réflexion étendue** — Activez le raisonnement par chaîne de pensée. Consultez [Amélioration des réponses des modèles grâce au raisonnement modélisé](inference-reasoning.md).
+ **Mise en cache rapide : mettez en** cache le contexte fréquemment utilisé pour réduire la latence et les coûts.
Pour le format complet de demande et de réponse de l'API Messages, y compris tous les paramètres et fonctionnalités, voir[Anthropic Claude API Message](model-parameters-anthropic-claude-messages.md).
## Comptez les jetons
Pour compter le nombre de jetons d'entrée qu'une demande consommerait avant de l'envoyer pour inférence, utilisez le `count_tokens` chemin anthropique sur le `bedrock-mantle` point de terminaison. Il s'agit de la seule méthode de comptage de jetons prise en charge pour les modèles Claude qui ne sont pas disponibles `bedrock-runtime` avec un Region-specific point de terminaison, y compris les modèles Claude qui se lancent uniquement avec l'inférence interrégionale (CRIS). Pour plus de détails et un exemple, reportez-vous à la section [Comptez les jetons en utilisant le point de terminaison Bedrock-Mantle](count-tokens.md#count-tokens-mantle).