A xAI entra no Amazon Bedrock com o Grok 4.3
A AWS anunciou que o Grok 4.3, modelo de Inteligência Artificial (IA) da xAI, está disponível de forma geral no Amazon Bedrock. Com essa chegada, a xAI passa a integrar o catálogo de provedores de modelos da plataforma, ao lado de outras empresas como Anthropic, Meta e Mistral.
O Grok 4.3 foi desenvolvido com foco em cargas de trabalho empresariais que exigem precisão. Segundo a xAI, o modelo foi projetado para trabalhos corporativos onde a acurácia é essencial. Nos próprios benchmarks da empresa no momento do lançamento, o Grok 4.3 ficou em primeiro lugar no benchmark Artificial Analysis Omniscience, com a menor taxa de alucinação entre os modelos de fronteira avaliados. Também liderou o benchmark Artificial Analysis Tau2 Telecom para chamadas de ferramentas em cenários de suporte ao cliente, além dos benchmarks Vals AI Case Law e Corporate Finance para compreensão de documentos.
A xAI posiciona o modelo na fronteira de Pareto entre inteligência e custo, descrevendo uma relação de 2 a 10 vezes mais inteligência por dólar em comparação com outros modelos de fronteira.
O que torna o Grok 4.3 adequado para cargas agênticas
O modelo aceita entrada de texto e imagens, retorna texto e possui uma janela de contexto de 1 milhão de tokens — espaço suficiente para documentos longos e sessões de múltiplos turnos. Ele também suporta chamadas de ferramentas e seguimento de instruções de forma robusta, o que o torna prático para agentes que dependem de chamadas de função para executar ações.
Um diferencial importante é o esforço de raciocínio configurável. A cada requisição, é possível definir o nível de esforço entre quatro opções: none, low, medium e high. Isso permite usar um único modelo para toda a gama de tarefas: chamadas de classificação rodam com esforço none para manter a latência baixa, enquanto análises de contratos ou tarefas jurídicas rodam com esforço high quando a profundidade importa mais do que o tempo de resposta.
Esses atributos se alinham bem com casos de uso como revisão de contratos, análise de acordos de crédito e respostas a perguntas sobre documentos financeiros — cenários em que o modelo precisa raciocinar sobre entradas longas e acionar sistemas de registro externos.
Como o Grok 4.3 é acessado no Amazon Bedrock
O Grok 4.3 roda no Mantle, o mecanismo de inferência de próxima geração do Amazon Bedrock. O acesso ao modelo difere dos modelos que usam a API padrão do Amazon Bedrock Runtime: o Mantle utiliza APIs compatíveis com o padrão OpenAI. É possível invocar o Grok 4.3 com o SDK da OpenAI ou via requisições HTTPS diretas à Chat Completions API ou à Responses API.
A URL do endpoint Mantle segue um padrão específico por região:
Por exemplo, na região us-west-2, a URL base é https://bedrock-mantle.us-west-2.api.aws/openai/v1. Vale observar que a rota da Responses API no endpoint Mantle (/openai/v1/) difere ligeiramente do endpoint Runtime (/v1/responses).
Ao configurar o SDK com o Grok 4.3, é importante saber que os valores padrão divergem da especificação OpenAI padrão em três pontos: temperature padrão é 0.7 (em vez de 1), top_p padrão é 0.95 (em vez de 1) e max_completion_tokens padrão é 131072. Se a aplicação precisar de comportamento diferente, esses valores devem ser definidos explicitamente.
Autenticação e primeira requisição
Há duas formas de autenticar contra o endpoint Mantle. Para produção, a AWS recomenda tokens de curto prazo gerados a partir das credenciais do IAM (Gerenciamento de Identidade e Acesso), pois eles expiram automaticamente e mantêm o acesso vinculado à identidade do IAM. Para exploração inicial, é possível usar uma chave de API de longo prazo do Amazon Bedrock — mas a recomendação é restringir esse tipo de chave a esse propósito, sem incorporá-la em aplicações de produção.
O exemplo abaixo mostra como autenticar com uma chave de API de longo prazo. É possível gerar essa chave pelo console do Amazon Bedrock e, em seguida, instalar o SDK da OpenAI:
pip install openaiCom o cliente apontado para o endpoint Mantle regional e autenticado com a chave de API, o ID do modelo é xai.grok-4.3:
from openai import OpenAI
client = OpenAI(
api_key="<your Amazon Bedrock API key>",
base_url="https://bedrock-mantle.us-west-2.api.aws/openai/v1",
)
response = client.chat.completions.create(
model="xai.grok-4.3",
messages=[
{"role": "user", "content": "In one sentence, what is Amazon Bedrock?"}
],
)
print(response.choices[0].message.content)Para aplicações com requisitos de segurança mais elevados, a AWS recomenda credenciais de curto prazo. É possível gerar um token bearer de curto prazo a partir das credenciais AWS existentes usando o gerador de tokens do Amazon Bedrock. Para isso, instale o pacote:
pip install aws-bedrock-token-generatorE use a função provide_token da biblioteca aws_bedrock_token_generator:
from aws_bedrock_token_generator import provide_token
from openai import OpenAI
client = OpenAI(
api_key=provide_token(region="us-west-2"),
base_url="https://bedrock-mantle.us-west-2.api.aws/openai/v1",
)Raciocínio configurável na prática
O controle do esforço de raciocínio é feito pelo parâmetro reasoning na Responses API. Níveis mais altos tendem a ajudar em problemas de múltiplos passos onde uma resposta rápida estaria errada, ao custo de mais tokens de saída. A Chat Completions API não retorna o rastreamento de raciocínio — para isso, é necessário usar a Responses API.
No padrão stateful (com estado), onde store=True e as chamadas são encadeadas com previous_response_id, o serviço retém o raciocínio de cada turno e o alimenta de volta automaticamente. No padrão stateless (sem estado), com store=False, é possível solicitar o raciocínio com include=["reasoning.encrypted_content"] e passá-lo de volta na próxima requisição.
O exemplo abaixo roda um problema clássico com esforço high:
response = client.responses.create(
model="xai.grok-4.3",
reasoning={"effort": "high"}, # none, low, medium, or high
include=["reasoning.encrypted_content"],
max_output_tokens=4096,
input=(
"A bat and ball cost $1.10. The bat costs $1 more than the ball. "
"How much is the ball? Answer with just the number."
),
)
print(response.output_text)
print(response.usage.output_tokens_details.reasoning_tokens)O modelo trabalha a álgebra em vez de chegar à resposta intuitiva errada de $0,10. Com esforço none, o mesmo campo de tokens de raciocínio reporta 0 — a configuração ideal para chamadas simples e sensíveis a latência.
Um padrão prático: classificação, extração e consultas factuais curtas rodam com none ou low, enquanto etapas de planejamento, matemática e cadeias onde um erro inicial compromete toda a tarefa se beneficiam do esforço high.
Chamadas de ferramentas e saída estruturada
O Grok 4.3 suporta chamadas de ferramentas pela mesma interface compatível com OpenAI. Você descreve as ferramentas disponíveis, o modelo decide quando chamar uma e retorna uma requisição estruturada que o seu código executa e alimenta de volta. O exemplo abaixo oferece uma ferramenta get_weather e faz uma pergunta que deve acioná-la:
tools = [
{
"type": "function",
"function": {
"name": "get_weather",
"description": "Get the current weather for a city",
"parameters": {
"type": "object",
"properties": {"city": {"type": "string"}},
"required": ["city"],
},
},
}
]
response = client.chat.completions.create(
model="xai.grok-4.3",
messages=[{"role": "user", "content": "What's the weather in Sydney? Use the tool."}],
tools=tools,
tool_choice="auto", # let the model decide whether to call a tool
)
tool_call = response.choices[0].message.tool_calls[0]
print(tool_call.function.name, tool_call.function.arguments)
# get_weather {"city":"Sydney"}A partir daqui, você executa a função no seu próprio código, acrescenta uma mensagem com o resultado e chama o modelo novamente para que ele incorpore os dados em uma resposta em linguagem natural. Esse é o bloco de construção para agentes de múltiplos passos com o Grok 4.3.
Para saída estruturada, o Grok 4.3 suporta o formato json_schema com modo estrito, garantindo que a resposta esteja em conformidade com o esquema fornecido:
import json
schema = {
"type": "object",
"properties": {
"name": {"type": "string"},
"capital": {"type": "string"},
"population_millions": {"type": "number"},
},
"required": ["name", "capital", "population_millions"],
"additionalProperties": False,
}
response = client.chat.completions.create(
model="xai.grok-4.3",
messages=[{"role": "user", "content": "Return facts about the country Australia."}],
response_format={
"type": "json_schema",
"json_schema": {"name": "country_facts", "strict": True, "schema": schema},
},
max_completion_tokens=4096,
)
data = json.loads(response.choices[0].message.content)
print(data)
# {'name': 'Australia', 'capital': 'Canberra', 'population_millions': 26.6}Uma observação operacional relevante: em testes, requisições ocasionalmente retornam erro 400 de uma verificação automatizada de segurança de conteúdo, mesmo em entradas inofensivas. Por isso, vale implementar uma lógica de retry curta em chamadas de produção.
Entrada de imagens e conversas com estado
O Grok 4.3 aceita imagens como entrada e retorna texto, cobrindo casos como compreensão de documentos, leitura de gráficos e resposta a perguntas visuais. A imagem é passada como uma parte de conteúdo com uma URL data: contendo bytes codificados em base64, ou uma URL de imagem pública:
import base64
with open("chart.png", "rb") as f:
b64 = base64.b64encode(f.read()).decode()
response = client.chat.completions.create(
model="xai.grok-4.3",
messages=[
{
"role": "user",
"content": [
{"type": "text", "text": "Describe this image in one short sentence."},
{
"type": "image_url",
"image_url": {"url": f"data:image/png;base64,{b64}"},
},
],
}
],
max_completion_tokens=4096,
)
print(response.choices[0].message.content)Para conversas com estado, a Responses API pode manter o histórico de conversa no lado do serviço, eliminando a necessidade de reenviar todo o histórico de mensagens a cada turno. Basta passar store=True, capturar o ID de resposta retornado e referenciá-lo na próxima chamada com previous_response_id:
first = client.responses.create(
model="xai.grok-4.3",
input="Remember the number 42. Just acknowledge.",
store=True,
max_output_tokens=2048,
)
second = client.responses.create(
model="xai.grok-4.3",
previous_response_id=first.id,
input="What number did I ask you to remember?",
max_output_tokens=2048,
)
print(second.output_text)
# 42Um ponto importante antes de ativar esse recurso: armazenar o estado da conversa significa que o serviço retém esses turnos. Vale revisar a documentação de proteção de dados do Amazon Bedrock para entender os detalhes de segurança e privacidade dos dados armazenados, e como desativar a retenção se necessário.
Camadas de serviço e disponibilidade por região
O Amazon Bedrock oferece múltiplas camadas de serviço para adequar custo e throughput a cada carga de trabalho. A camada Standard oferece acesso pay-per-token sem compromisso; a camada Priority oferece tratamento preferencial na fila de processamento por um preço por token mais alto; e a camada Flex oferece acesso de menor custo para cargas de trabalho sem sensibilidade a tempo. O Grok 4.3 pode ser usado com as três camadas. Para detalhes, consulte as camadas de serviço para inferência.
O Grok 4.3 usa inferência dentro da região, então o cliente deve ser fixado a uma região onde o modelo esteja disponível, com a URL base do Mantle correspondente. Inferência geográfica e cross-region global não estão disponíveis para esse modelo no lançamento. Os exemplos utilizam us-west-2. Para a lista atual de regiões suportadas, consulte a documentação de disponibilidade regional, e para preços entre as camadas, veja a página de preços do Amazon Bedrock.
Por onde começar
Para iniciar, vale revisar o model card do Grok 4.3 para a lista atual de regiões e detalhes de parâmetros, e consultar a página de preços do Amazon Bedrock para as taxas por token. A partir daí, algumas direções valem a exploração: montar o loop completo de chamada de ferramentas executando a função retornada e alimentando o resultado de volta; encadear conteúdo de raciocínio criptografado entre turnos da Responses API para dar continuidade ao pensamento de agentes de longa duração; e comparar os níveis de esforço contra suas próprias cargas de trabalho para identificar onde o raciocínio mais alto deixa de compensar o custo em tokens.
Se uma chave de API de longo prazo foi gerada para exploração, o recomendado é excluí-la pelo console do Amazon Bedrock quando não for mais necessária. Uma chave de longo prazo é uma credencial permanente — remover as que não são mais usadas mantém a superfície de ataque da conta reduzida.
Para participar da discussão com a comunidade, acesse o Amazon Bedrock community no AWS re:Post.
Fonte
Introducing Grok on Amazon Bedrock (https://aws.amazon.com/blogs/machine-learning/introducing-grok-on-amazon-bedrock/)
Leave a Reply