

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.

# Surveillance de l’utilisation de vos jetons en comptant les jetons avant l’exécution de l’inférence
<a name="count-tokens"></a>

Lorsque vous exécutez une inférence de modèle, le nombre de jetons que vous envoyez dans l’entrée contribue au coût de la demande et au quota de jetons que vous pouvez utiliser par minute et par jour. L'[CountTokens](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_CountTokens.html)API vous aide à estimer l'utilisation des jetons avant d'envoyer des requêtes aux modèles de base en renvoyant le nombre de jetons qui seraient utilisés si la même entrée était envoyée au modèle dans une demande d'inférence.

**Note**  
L'utilisation de [ CountTokens ](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_CountTokens.html) l'API est gratuite.

**Note**  
Certains modèles Anthropic Claude, y compris ceux qui sont lancés avec l'inférence interrégionale (CRIS) uniquement activée`bedrock-runtime`, ne sont pas compatibles avec. [ CountTokens ](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_CountTokens.html) `bedrock-runtime` Pour ces modèles, comptez les jetons d'entrée en appelant plutôt l'`count_tokens`API d'Anthropic sur le `bedrock-mantle` terminal. Consultez [Comptez les jetons à l'aide du point de terminaison du manteau rocheux](#count-tokens-mantle) l'URL, le corps de la requête et un exemple.

Le comptage des jetons est spécifique au modèle, car les différents modèles utilisent des stratégies de création de jetons différentes. Le nombre de jetons renvoyé par cette opération correspondra au nombre de jetons qui serait facturé si la même entrée était envoyée au modèle pour exécuter l’inférence.

Vous pouvez utiliser l’API `CountTokens` pour effectuer les opérations suivantes :
+ estimer les coûts avant d’envoyer des demandes d’inférence ;
+ optimiser les invites pour les adapter aux limites des jetons ;
+ planifier l’utilisation des jetons dans vos applications.

**Topics**
+ [Modèles et régions pris en charge pour le comptage des jetons](#count-tokens-supported)
+ [Comptez les jetons à l'aide du point de terminaison Bedrock-Runtime](#count-tokens-use)
+ [Exemple : compter les jetons pour une requête Bedrock-Runtime](#count-tokens-example)
+ [Comptez les jetons à l'aide du point de terminaison du manteau rocheux](#count-tokens-mantle)

## Modèles et régions pris en charge pour le comptage des jetons
<a name="count-tokens-supported"></a>

Pour savoir quels modèles prennent en charge le comptage de jetons, consultez la section [ Modèles en un coup d'œil ](model-cards.md) et choisissez le modèle qui vous intéresse.

## Comptez les jetons à l'aide du point de terminaison Bedrock-Runtime
<a name="count-tokens-use"></a>

Pour compter le nombre de jetons d'entrée dans une demande d'inférence, envoyez une [ CountTokens ](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_CountTokens.html) demande avec un point de terminaison d'exécution [ Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#br-rt), spécifiez le modèle dans l'en-tête et l'entrée pour laquelle vous souhaitez compter les jetons dans le `body` champ. La valeur du `body` champ varie selon que vous comptez les jetons d'entrée pour une requête [ InvokeModel ](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) ou pour une [ requête ](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html) Converse :
+ Pour une demande `InvokeModel`, le format de `body` est une chaîne représentant un objet JSON dont le format dépend du modèle que vous spécifiez.
+ Pour une demande `Converse`, le format de `body` est un objet JSON spécifiant les invites `messages` et `system` incluses dans la conversation.

## Exemple : compter les jetons pour une requête Bedrock-Runtime
<a name="count-tokens-example"></a>

Les exemples de cette section vous permettent de compter les jetons pour une demande `InvokeModel` et `Converse` avec Anthropic Claude 3 Haiku.

**Conditions préalables**
+ Vous avez téléchargé AWS SDK pour Python (Boto3) et votre configuration est configurée de telle sorte que vos informations d'identification et votre AWS région par défaut soient automatiquement reconnues.
+ Votre identité IAM est autorisée à effectuer les actions suivantes (pour plus d’informations, consultez [Actions, ressources et clés de condition pour Amazon Bedrock](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonbedrock.html)) :
  + bedrock : CountTokens — Permet l'utilisation de. `CountTokens`
  + socle : InvokeModel — Permet l'utilisation de `InvokeModel` et`Converse`. Doit être limité à{{arn:${Partition}:bedrock:${Region}::foundation-model/anthropic.claude-3-haiku-20240307-v1:0}}, au minimum.

Pour essayer de compter les jetons pour une [ InvokeModel ](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) requête, exécutez le code Python suivant :

```
import boto3
import json

bedrock_runtime = boto3.client("bedrock-runtime")

input_to_count = json.dumps({
    "anthropic_version": "bedrock-2023-05-31",
    "max_tokens": 500,
    "messages": [
        {
            "role": "user",
            "content": "What is the capital of France?"
        }
    ]
})

response = bedrock_runtime.count_tokens(
    modelId="anthropic.claude-3-5-haiku-20241022-v1:0",
    input={
        "invokeModel": {
            "body": input_to_count
        }
    }
)

print(response["inputTokens"])
```

Pour essayer de compter les jetons pour une demande [Converse](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html), exécutez le code Python suivant :

```
import boto3
import json 

bedrock_runtime = boto3.client("bedrock-runtime")

input_to_count = {
    "messages": [
        {
            "role": "user",
            "content": [
                {
                    "text": "What is the capital of France?"
                }
            ]
        },
        {
            "role": "assistant",
            "content": [
                {
                    "text": "The capital of France is Paris."
                }
            ]
        },
        {
            "role": "user",
            "content": [
                {
                    "text": "What is its population?"
                }
            ]
        }
    ],
    "system": [
        {
            "text": "You're an expert in geography."
        }
    ]
}

response = bedrock_runtime.count_tokens(
    modelId="anthropic.claude-3-5-haiku-20241022-v1:0",
    input={
        "converse": input_to_count
    }
)

print(response["inputTokens"])
```

## Comptez les jetons à l'aide du point de terminaison du manteau rocheux
<a name="count-tokens-mantle"></a>

Le `bedrock-mantle` point de terminaison expose l'`count_tokens`API d'Anthropic à. `/anthropic/v1/messages/count_tokens` Utilisez-le pour compter les jetons d'entrée pour les modèles Anthropic Claude qui ne sont pas compatibles avec [ CountTokens ](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_CountTokens.html) ON`bedrock-runtime`, par exemple, lorsque le modèle est proposé uniquement par inférence interrégionale (CRIS) `bedrock-runtime` et qu'il n'a donc aucun Region-specific point final à [ CountTokens ](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_CountTokens.html) cibler. La `/anthropic/v1/messages` voie à suivre est la Claude-specific suivante : modèles non anthropiques en `bedrock-mantle` retour. `The model 'X' does not support the '/anthropic/v1/messages' API`

**Détails de la demande**
+ **URL ** —`POST https://bedrock-mantle.{{region}}.api.aws/anthropic/v1/messages/count_tokens`. Pour connaître les régions prises en charge, consultez [Régions et terminaux pris en charge](bedrock-mantle.md#bedrock-mantle-supported).
+ **Corps de la demande ** : `count_tokens` forme anthropique`model`, y compris les `tools` champs `system` et`messages`, facultatifs. Voir la référence [ des jetons de comptage des messages ](https://docs.anthropic.com/en/api/messages-count-tokens) anthropiques.
+ **Authentification ** : soit une signature SIGv4 avec le nom du service`bedrock-mantle`, soit une clé d'API Amazon Bedrock transmise dans l'`x-api-key`en-tête. Consultez [clés d’API](api-keys.md).
+ **Action IAM ** —`bedrock-mantle:CountTokens`. Cette action utilise le préfixe du `bedrock-mantle` service et apparaît dans la référence d'autorisation du service [ Amazon Bedrock Powered by AWS Mantle](https://docs.aws.amazon.com/service-authorization/latest/reference/list_bedrock-mantle.html), plutôt que dans la référence Amazon Bedrock ()`bedrock`. L'autorisation est limitée à une [ ressource du formulaire Amazon Bedrock ](projects.md) Project. `arn:aws:bedrock-mantle:{{region}}:{{account-id}}:project/{{project-name}}` Le nom du projet par défaut est`default`.
+ **Support du SDK ** — Les AWS SDK n'exposent actuellement aucune méthode ciblant ce point de terminaison. Envoyez la demande au format SigV4-signed HTTP `POST` ou utilisez n'importe quel client HTTP avec une clé d'API Amazon Bedrock. La méthode `bedrock-runtime` client `count_tokens` ne cible pas ce point de terminaison et renvoie une erreur de validation pour les modèles qui ne sont pas pris en charge sur`bedrock-runtime`.
+ **Format d'erreur ** — Les erreurs suivent la forme anthropique :`{"type": "error", "request_id": "...", "error": {"type": "error-type", "message": "error-message"}}`. Cela diffère de l'enveloppe d'erreur AWS JSON standard renvoyée par`bedrock-runtime`.

**Note**  
Le `count_tokens` point de terminaison valide le corps de la demande en utilisant le même schéma que le point de terminaison d'inférence correspondant, de sorte que les champs de demande non pris en charge par le modèle sont rejetés avec HTTP 400. Par exemple, Anthropic Claude Opus 4.7 n'accepte pas `strict: true` `tools[]` les retours`tools.0.custom.strict: Extra inputs are not permitted`. Consultez la fiche du [ modèle ](model-cards.md) pour connaître la surface caractéristique spécifique au modèle.

L'exemple suivant utilise une clé `curl` d'API Amazon Bedrock pour compter les jetons sur le `bedrock-mantle` point de terminaison :

```
curl -X POST https://bedrock-mantle.us-east-1.api.aws/anthropic/v1/messages/count_tokens \
  -H "x-api-key: $BEDROCK_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "anthropic.claude-opus-4-7",
    "messages": [
        {"role": "user", "content": "How many tokens is this prompt?"}
    ]
  }'
```

La réponse contient un `input_tokens` champ dont la valeur est le nombre de jetons pour l'entrée fournie.