View a markdown version of this page

Inferência usando a API de mensagens antrópicas - Amazon Bedrock
Regiões aceitasPré-requisitosSolicitação básicaTransmita respostasRecursos compatíveisContar tokens

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á.

Inferência usando a API de mensagens antrópicas

A API de mensagens antrópicas fornece acesso nativo aos modelos de Claude usando o formato de solicitação e resposta antrópica. Você pode usar a API de mensagens nos bedrock-mantle terminais bedrock-runtime e nos terminais. Para novos aplicativos, recomendamos o bedrock-runtime endpoint.

Endpoint URL base Caso de uso
bedrock-runtime https://bedrock-runtime.{region}.amazonaws.com/anthropic Recomendado para novas aplicações. Usa integrações de AWS SDK, autenticação IAM e registro de invocação.
bedrock-mantle https://bedrock-mantle.{region}.api.aws/anthropic/v1/messages Oferece suporte à autenticação de chaves da API Amazon Bedrock e. Espaços de trabalho () Anthropic-compatible

Regiões aceitas

A API Messages está disponível no bedrock-runtime endpoint em todas as regiões em que os modelos Claude estão disponíveis. Para mais detalhes, consulte Disponibilidade regional por modelos. No bedrock-mantle endpoint, ele está disponível em todas as regiões que oferecem suporte bedrock-mantle (consulteRegiões e endpoints compatíveis).

Pré-requisitos

Antes de usar a API de mensagens, verifique se você tem o seguinte:

  • Acesso ao modelo — Solicite acesso aos modelos Claude no console Amazon Bedrock. Consulte Solicite acesso aos modelos.

  • Autenticação — Depende do endpoint:

    • bedrock-runtime— Use as credenciais AWS SigV4 por meio do AWS SDK (boto3, etc.), de uma chave de API do Amazon Bedrock (consulteChaves de API) ou de um token portador do Bedrock de curto prazo gerado a partir de credenciais com a biblioteca aws-bedrock-token-generator. AWS https://pypi.org/project/aws-bedrock-token-generator/

    • bedrock-mantle— Use uma chave de API Amazon Bedrock (consulteChaves de API) ou credenciais AWS SigV4.

  • Cabeçalho da versão antrópica — Todas as solicitações exigem uma versão da API:

    • bedrock-runtime: defina "anthropic_version": "bedrock-2023-05-31" no corpo da solicitação ao ligarInvokeModel. O Anthropic SDK adiciona automaticamente o cabeçalho necessário durante o usobase_url=https://bedrock-runtime.{region}.amazonaws.com/anthropic.

    • bedrock-mantle: defina anthropic-version: 2023-06-01 como um cabeçalho HTTP.

Solicitação básica

Para enviar uma mensagem básica para um modelo Claude, escolha a guia do seu método preferido e siga as etapas:

bedrock-runtime (Python, Anthropic SDK)

Use o Anthropic SDK na /anthropic rota do bedrock-runtime endpoint com um token portador Bedrock de curto prazo gerado pelo aws-bedrock-token-generator: https://pypi.org/project/aws-bedrock-token-generator/

from anthropic import Anthropic
from aws_bedrock_token_generator import provide_token

token = provide_token(region="us-east-1")

client = Anthropic(
    base_url="https://bedrock-runtime.us-east-1.amazonaws.com/anthropic",
    api_key=token,
)

response = client.messages.create(
    model="global.anthropic.claude-sonnet-5",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Explain quantum computing in one sentence."}
    ]
)
print(response.content[0].text)
bedrock-runtime (Python, boto3)
import boto3
import json

client = boto3.client("bedrock-runtime", region_name="us-east-1")

response = client.invoke_model(
    modelId="anthropic.claude-sonnet-5",
    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 (AWS CLI)

Use a AWS CLI para invocar o modelo:

aws bedrock-runtime invoke-model \
  --model-id anthropic.claude-sonnet-5 \
  --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
bedrock-runtime (curl)

Você pode ligar bedrock-runtime diretamente com curl assinando a solicitação com AWS SigV4. O exemplo abaixo usa o --aws-sigv4 sinalizador embutido do curl (disponível no curl 7.75.0 e versões posteriores):

curl -X POST \
  "https://bedrock-runtime.us-east-1.amazonaws.com/model/anthropic.claude-sonnet-5/invoke" \
  -H "Content-Type: application/json" \
  --aws-sigv4 "aws:amz:us-east-1:bedrock" \
  --user "$AWS_ACCESS_KEY_ID:$AWS_SECRET_ACCESS_KEY" \
  -d '{
    "anthropic_version": "bedrock-2023-05-31",
    "max_tokens": 1024,
    "messages": [
        {"role": "user", "content": "Explain quantum computing in one sentence."}
    ]
  }'
nota

Se você estiver usando credenciais temporárias do AWS STS (por exemplo, uma função assumida), transmita também o token da sessão adicionando -H "X-Amz-Security-Token: $AWS_SESSION_TOKEN" à solicitação. Para a maioria dos casos de uso, recomendamos os AWS SDKs ou a CLI, que gerenciam a assinatura de solicitações e a atualização de credenciais automaticamente.

bedrock-runtime (curl, API key)

Você também pode ligar bedrock-runtime com uma chave de API do Amazon Bedrock usando a Anthropic-native /anthropic/v1/messages rota, assim como: bedrock-mantle

curl -X POST https://bedrock-runtime.us-east-1.amazonaws.com/anthropic/v1/messages \
  -H "x-api-key: $AWS_BEARER_TOKEN_BEDROCK" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "us.anthropic.claude-sonnet-5",
    "max_tokens": 1024,
    "messages": [
        {"role": "user", "content": "Explain quantum computing in one sentence."}
    ]
  }'
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-5",
    "max_tokens": 1024,
    "messages": [
        {"role": "user", "content": "Explain quantum computing in one sentence."}
    ]
  }'

Transmita respostas

Para receber tokens de resposta de forma incremental à medida que são gerados, escolha a guia do seu método preferido e siga as etapas:

bedrock-runtime (Python, Anthropic SDK)
from anthropic import Anthropic
from aws_bedrock_token_generator import provide_token

token = provide_token(region="us-east-1")

client = Anthropic(
    base_url="https://bedrock-runtime.us-east-1.amazonaws.com/anthropic",
    api_key=token,
)

with client.messages.stream(
    model="global.anthropic.claude-sonnet-5",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Write a short poem about cloud computing."}
    ],
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)
bedrock-runtime (Python, boto3)
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-5",
    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="")
bedrock-runtime (curl, API key)
curl -X POST https://bedrock-runtime.us-east-1.amazonaws.com/anthropic/v1/messages \
  -H "x-api-key: $AWS_BEARER_TOKEN_BEDROCK" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "us.anthropic.claude-sonnet-5",
    "max_tokens": 1024,
    "stream": true,
    "messages": [
        {"role": "user", "content": "Write a short poem about cloud computing."}
    ]
  }'
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-5",
    "max_tokens": 1024,
    "stream": true,
    "messages": [
        {"role": "user", "content": "Write a short poem about cloud computing."}
    ]
  }'

Recursos compatíveis

Além das seções Pensamento estendido, pensamento adaptativo, saídas estruturadas, compactação, crédito alternativo para solicitações recusadas (beta) e mensagens Mid-conversation do sistema acima, a API de mensagens oferece suporte aos seguintes recursos com os modelos Claude:

  • Solicitações do sistema — Defina o comportamento do modelo com um system parâmetro.

  • Multi-turn conversas — Passe assistant mensagens user e mensagens alternadas.

  • Uso da ferramenta — Defina as ferramentas que o modelo pode chamar. Consulte Use uma ferramenta para concluir uma resposta do modelo do Amazon Bedrock.

  • Visão — Envie imagens na content matriz junto com o texto.

  • Cache imediato — Armazene em cache o contexto usado com frequência para reduzir a latência e o custo.

Para ver a referência completa do campo de solicitação e resposta da API de mensagens, consulteSolicitação e reposta.

Contar tokens

Para contar o número de tokens de entrada que uma solicitação consumiria antes de enviá-la para inferência, use o count_tokens caminho antrópico no bedrock-mantle endpoint. Esse é o único caminho de contagem de tokens compatível com modelos Claude que não estão disponíveis bedrock-runtime com um Region-specific endpoint, incluindo modelos Claude que são lançados somente com inferência entre regiões (CRIS). Para obter detalhes e um exemplo, consulte Conte os tokens usando o ponto final do manto rochoso.