

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Monitorar o uso de tokens contando os tokens antes de executar a inferência
<a name="count-tokens"></a>

Quando você executa inferência do modelo, o número de tokens enviados na entrada é computado no custo da solicitação e contabilizado na cota de tokens que é possível usar por minuto e por dia. A [CountTokens](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_CountTokens.html)API ajuda você a estimar o uso de tokens antes de enviar solicitações aos modelos básicos, retornando a contagem de tokens que seria usada se a mesma entrada fosse enviada ao modelo em uma solicitação de inferência.

**nota**  
O uso da [CountTokens](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_CountTokens.html)API não gera cobranças.

**nota**  
Alguns modelos do Anthropic Claude, incluindo aqueles que são lançados apenas com a inferência entre regiões (CRIS) ativada, não são compatíveis `bedrock-runtime` com. [CountTokens](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_CountTokens.html)`bedrock-runtime` Para esses modelos, conte os tokens de entrada chamando a `count_tokens` API da Anthropic no `bedrock-mantle` endpoint. Consulte [Conte os tokens usando o ponto final Bedrock-mantle](#count-tokens-mantle) o URL, o corpo da solicitação e um exemplo.

A contagem de tokens é específica do modelo porque modelos diferentes usam estratégias de tokenização diferentes. A contagem de tokens exibida por essa operação corresponderá à contagem de tokens que seria cobrada se a mesma entrada fosse enviada ao modelo para executar a inferência.

É possível usar a API `CountTokens` para fazer o seguinte:
+ Estimar os custos antes de enviar solicitações de inferência.
+ Otimizar os prompts para que se ajustem aos limites de token.
+ Planejar o uso de tokens em sua aplicações.

**Topics**
+ [Modelos e regiões em que é possível usar contagem de tokens](#count-tokens-supported)
+ [Conte tokens usando o endpoint bedrock-runtime](#count-tokens-use)
+ [Exemplo: contar tokens para uma solicitação de tempo de execução fundamental](#count-tokens-example)
+ [Conte os tokens usando o ponto final Bedrock-mantle](#count-tokens-mantle)

## Modelos e regiões em que é possível usar contagem de tokens
<a name="count-tokens-supported"></a>

Para ver quais modelos oferecem suporte à contagem de tokens, visite [rapidamente os modelos](model-cards.md) e escolha o modelo em que você está interessado.

## Conte tokens usando o endpoint bedrock-runtime
<a name="count-tokens-use"></a>

Para contar o número de tokens de entrada em uma solicitação de inferência, envie uma [CountTokens](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_CountTokens.html)solicitação com um [endpoint de tempo de execução do Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#br-rt), especifique o modelo no cabeçalho e a entrada para contar os tokens no campo. `body` O valor do `body` campo depende se você está contando os tokens de entrada para uma solicitação [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)ou para a [Converse](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html):
+ Para uma solicitação `InvokeModel`, o formato de `body` é uma string que representa um objeto JSON cujo formato depende do modelo que você especificar.
+ Para uma solicitação `Converse`, o formato de `body` é um objeto JSON que especifica os prompts `messages` e `system` incluídos na conversa.

## Exemplo: contar tokens para uma solicitação de tempo de execução fundamental
<a name="count-tokens-example"></a>

Os exemplos nesta seção permitem que você conte tokens para uma solicitação `InvokeModel` e `Converse` com o Claude 3 Haiku da Anthropic.

**Pré-requisitos**
+ Você fez o download AWS SDK para Python (Boto3) e sua configuração está configurada para que suas credenciais e sua AWS região padrão sejam reconhecidas automaticamente.
+ Sua identidade do IAM tem permissões para as seguintes ações (para ter mais informações, consulte [Ações, recursos e chaves de condição do Amazon Bedrock](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonbedrock.html)):
  + bedrock: CountTokens — Permite o uso de. `CountTokens`
  + bedrock: InvokeModel — Permite o uso de `InvokeModel` e. `Converse` Deve ter como escopo{{arn:${Partition}:bedrock:${Region}::foundation-model/anthropic.claude-3-haiku-20240307-v1:0}}, no mínimo.

Para experimentar a contagem de tokens para uma [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)solicitação, execute o seguinte código Python:

```
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"])
```

Para experimentar a contagem de tokens para uma solicitação [Converse](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html), execute o seguinte código Python:

```
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"])
```

## Conte os tokens usando o ponto final Bedrock-mantle
<a name="count-tokens-mantle"></a>

O `bedrock-mantle` endpoint expõe a API da Anthropic em. `count_tokens` `/anthropic/v1/messages/count_tokens` Use-o para contar tokens de entrada para modelos Anthropic Claude que não são compatíveis com [CountTokens](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_CountTokens.html)on `bedrock-runtime` — por exemplo, quando o modelo é oferecido somente por meio da inferência entre regiões (CRIS) ativada `bedrock-runtime` e, portanto, não Region-specific tem um endpoint para segmentar. [CountTokens](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_CountTokens.html) O `/anthropic/v1/messages` caminho é Claude-specific: modelos não antrópicos em retorno. `bedrock-mantle` `The model 'X' does not support the '/anthropic/v1/messages' API`

**Detalhes da solicitação**
+ **URL** —`POST https://bedrock-mantle.{{region}}.api.aws/anthropic/v1/messages/count_tokens`. Para saber quais regiões são compatíveis, consulte [Regiões e endpoints compatíveis](bedrock-mantle.md#bedrock-mantle-supported).
+ **Corpo da solicitação** — A `count_tokens` forma antrópica`model`, incluindo`messages`, `system` e `tools` campos opcionais. Veja a [referência de tokens de contagem de mensagens antrópicas](https://docs.anthropic.com/en/api/messages-count-tokens).
+ **Autenticação** — Uma assinatura SigV4 com o nome do `bedrock-mantle` serviço ou uma chave de API Amazon Bedrock passada no cabeçalho. `x-api-key` Consulte [Chaves de API](api-keys.md).
+ **Ação do IAM** —`bedrock-mantle:CountTokens`. A autorização tem como escopo um recurso do Amazon Bedrock [Project](projects.md) do formulário. `arn:aws:bedrock-mantle:{{region}}:{{account-id}}:project/{{project-name}}` O nome padrão do projeto é`default`.
+ **Suporte ao SDK** — No momento, AWS os SDKs não expõem um método que tenha como alvo esse endpoint. Envie a solicitação como SigV4-signed HTTP `POST` ou use qualquer cliente HTTP com uma chave de API do Amazon Bedrock. O método `bedrock-runtime` cliente `count_tokens` não tem como alvo esse endpoint e retorna um erro de validação para modelos que não são suportados. `bedrock-runtime`
+ **Formato do erro** — Os erros seguem a forma antrópica:`{"type": "error", "request_id": "...", "error": {"type": "error-type", "message": "error-message"}}`. Isso difere do envelope de erro AWS JSON padrão retornado por. `bedrock-runtime`

**nota**  
O `count_tokens` endpoint valida o corpo da solicitação usando o mesmo esquema do endpoint de inferência correspondente, portanto, os campos de solicitação que o modelo não suporta são rejeitados com HTTP 400. Por exemplo, o Anthropic Claude Opus 4.7 não aceita `strict: true` trocas e devoluções. `tools[]` `tools.0.custom.strict: Extra inputs are not permitted` Consulte a [placa do modelo](model-cards.md) para ver a superfície de características específicas do modelo.

O exemplo a seguir é usado `curl` com uma chave de API Amazon Bedrock para contar tokens no `bedrock-mantle` endpoint:

```
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?"}
    ]
  }'
```

A resposta contém um `input_tokens` campo cujo valor é a contagem de tokens para a entrada fornecida.