Modelos Gemma 4 chegam ao Amazon Bedrock

Família Gemma 4 disponível no Amazon Bedrock

A AWS anunciou a chegada da família Gemma 4 ao Amazon Bedrock. Desenvolvidos pelo Google DeepMind e lançados sob a licença Apache 2.0, esses modelos open-weight foram projetados com foco em inteligência por parâmetro, cobrindo diferentes perfis de custo e latência. A família chega com três variantes ajustadas para instrução: Gemma 4 31B, Gemma 4 26B-A4B e Gemma 4 E2B.

Os benchmarks independentes reforçam esse posicionamento: a Artificial Analysis registra um Índice de Inteligência de 39 para o Gemma 4 31B — bem acima da mediana de 15 na classe de modelos open-weight entre 4B e 40B parâmetros.

Ao rodar esses modelos no Amazon Bedrock, toda a inferência acontece dentro da infraestrutura gerenciada pela AWS, com os controles de segurança e privacidade do serviço. Os prompts e respostas não são usados para treinar modelos, e o conteúdo não é compartilhado com terceiros.

Capacidades principais da família Gemma 4

Todas as variantes da família compartilham um conjunto comum de funcionalidades:

Modo de raciocínio integrado: o modelo emite seu processo interno de pensamento antes de gerar a resposta final.
Chamada nativa de funções: suporte direto a fluxos agênticos sem necessidade de camadas adicionais.
Entrada multimodal: aceita texto e imagem em todas as variantes.
Suporte multilíngue: mais de 35 idiomas prontos para uso, com pré-treinamento em mais de 140.
Janela de contexto: até 256K tokens no 31B e no 26B-A4B; 128K tokens no E2B.

Por serem open-weight, é possível avaliar a arquitetura e a metodologia de treinamento de forma independente, realizar benchmarks com dados próprios e aplicar fine-tuning em dados proprietários quando necessário. Para a lista atualizada de modelos suportados, consulte o catálogo de modelos do Amazon Bedrock.

Comparativo entre as variantes

A tabela abaixo resume as especificações de cada modelo:

Gemma 4 31B — ID: google.gemma-4-31b | Arquitetura densa | 30,7B parâmetros | Contexto: 256K tokens
Gemma 4 26B-A4B — ID: google.gemma-4-26b-a4b | Mistura de especialistas (MoE) | 25,2B total / 3,8B ativos | Contexto: 256K tokens
Gemma 4 E2B — ID: google.gemma-4-e2b | Densa com Embeddings por Camada (PLE) | 5,1B total / 2,3B efetivos | Contexto: 128K tokens

Para escolher a variante certa:

Cargas com raciocínio ou codificação intensivos → Gemma 4 31B
Alta taxa de requisições com sensibilidade a custo → Gemma 4 26B-A4B (custo e latência próximos a um modelo 4B, com capacidade de conhecimento de um modelo muito maior)
Baixa latência ou classificação multimodal leve → Gemma 4 E2B (recomenda-se usar reasoning_effort=high nessa variante)

Para detalhes de arquitetura, consulte o model card do Gemma 4.

Acessando os modelos via endpoint bedrock-mantle

Os modelos Gemma 4 são acessados pelo endpoint bedrock-mantle, a interface pública do novo motor de inferência de próxima geração do Amazon Bedrock. A URL base é:

https://bedrock-mantle.{region}.api.aws/openai/v1

Esse endpoint expõe as APIs de Chat Completions e Responses, com interface compatível com os SDKs Python e TypeScript da OpenAI. Para quem já usa esses SDKs, a migração geralmente exige apenas atualizar a URL base e o ID do modelo. Para entender a arquitetura de isolamento e acesso zero do motor de inferência subjacente, veja o post Explorando o design de acesso zero do motor de inferência de próxima geração do Amazon Bedrock.

Pré-requisitos

Para usar os modelos Gemma 4, é necessário ter uma conta AWS com permissões para executar inferência no endpoint bedrock-mantle. A forma mais simples é anexar a política gerenciada AmazonBedrockMantleInferenceAccess ao seu principal do Controle de Identidade e Acesso (IAM). Para criar e gerenciar chaves de API, consulte a documentação de chaves de API do Amazon Bedrock.

Playground no console

O console do Amazon Bedrock oferece um playground de chat/texto para testar os modelos sem escrever código. Basta navegar até Test playgrounds → Chat/Text playground, selecionar o modelo desejado na categoria Google e clicar em Apply.

Chamada via SDK da OpenAI

O exemplo abaixo usa o SDK Python da OpenAI como cliente para chamar o endpoint bedrock-mantle. Para workloads em produção, recomenda-se usar chaves de API de curto prazo, que expiram automaticamente em até 12 horas. O pacote aws-bedrock-token-generator gera um bearer token de curto prazo a partir de credenciais AWS nativas.

from openai import OpenAI

client = OpenAI(
    api_key="",
    base_url="https://bedrock-mantle.us-east-1.api.aws/openai/v1",
)

response = client.chat.completions.create(
    model="google.gemma-4-31b",
    messages=[
        {"role": "user", "content": "Explain the benefits of mixture-of-experts architectures for production inference."}
    ],
    max_tokens=512,
)

print(response.choices[0].message.content)

Atenção: em produção, armazene e recupere credenciais a partir de um serviço gerenciado de segredos, como o AWS Secrets Manager ou o AWS Systems Manager Parameter Store, em vez de variáveis de ambiente. Para controlar permissões de geração e uso de chaves, consulte Controle de permissões para chaves de API do Amazon Bedrock.

Entrada multimodal (imagem)

O endpoint aceita imagens como data URLs em base64 ou como URLs do Amazon S3 (s3://). URLs públicas https:// arbitrárias não são suportadas. Para melhores resultados, posicione o conteúdo de imagem antes do texto no prompt.

import base64

# Read a local image file and encode it as a base64 data URL.
with open("chart.png", "rb") as image_file:
    image_b64 = base64.b64encode(image_file.read()).decode("utf-8")

data_url = f"data:image/png;base64,{image_b64}"

response = client.chat.completions.create(
    model="google.gemma-4-31b",
    messages=[{
        "role": "user",
        "content": [
            {"type": "image_url", "image_url": {"url": data_url}},
            {"type": "text", "text": "Describe the trend shown in this chart."}
        ]
    }],
)

print(response.choices[0].message.content)

Streaming de respostas

stream = client.chat.completions.create(
    model="google.gemma-4-31b",
    messages=[
        {"role": "user", "content": "Write a short poem about distributed systems."}
    ],
    stream=True,
)

for chunk in stream:
    delta = chunk.choices[0].delta.content
    if delta:
        print(delta, end="", flush=True)

print()

Chamada de ferramentas (tool calling)

import json
from openai import OpenAI

client = OpenAI(
    api_key="",
    base_url="https://bedrock-mantle.us-east-1.api.aws/openai/v1",
)

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get the current weather for a given location",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "City and country (e.g., Seattle, US)"
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                        "description": "Temperature unit"
                    }
                },
                "required": ["location"]
            }
        }
    }
]

# Step 1: Send the user request with tool definitions
messages = [
    {"role": "user", "content": "What's the weather like in Seattle?"}
]

response = client.chat.completions.create(
    model="google.gemma-4-31b",
    messages=messages,
    tools=tools,
    tool_choice="auto",
)

assistant_message = response.choices[0].message

# Step 2: Check if the model wants to call a tool
if assistant_message.tool_calls:
    messages.append(assistant_message)
    for tool_call in assistant_message.tool_calls:
        function_name = tool_call.function.name
        arguments = json.loads(tool_call.function.arguments)

        # Step 3: Validate the function name and run it (your implementation)
        if function_name == "get_weather":
            location = arguments.get("location", "Unknown")
            unit = arguments.get("unit", "fahrenheit")
            result = {
                "location": location,
                "temperature": 18 if unit == "celsius" else 64,
                "unit": unit,
                "condition": "Partly cloudy",
                "humidity": 72,
            }
        else:
            result = {"error": f"Unknown function: {function_name}"}

        # Step 4: Return the function result to the model
        messages.append({
            "role": "tool",
            "tool_call_id": tool_call.id,
            "content": json.dumps(result),
        })

    # Step 5: Get the final response incorporating tool results
    final_response = client.chat.completions.create(
        model="google.gemma-4-31b",
        messages=messages,
        tools=tools,
    )
    print(final_response.choices[0].message.content)
else:
    print(assistant_message.content)

API de Respostas e modo de raciocínio

Além do Chat Completions, o endpoint bedrock-mantle suporta a API de Respostas da OpenAI, indicada para geração em turno único ou quando se deseja acessar o raciocínio do modelo.

response = client.responses.create(
    model="google.gemma-4-31b",
    input="Explain the benefits of mixture-of-experts architectures for production inference.",
    max_output_tokens=512,
)

print(response.output_text)

Para ativar o modo de raciocínio, utilize o parâmetro reasoning na API de Respostas. O processo de pensamento é retornado como um item separado no output:

response = client.responses.create(
    model="google.gemma-4-31b",
    input="If a train leaves at 3pm at 60 km/h and another leaves an hour later at 90 km/h from the same station, when does the second catch up?",
    reasoning={"effort": "high"},
)

# Final answer.
print(response.output_text)

# The thought process is returned as a separate output item of type "reasoning".
for item in response.output:
    if item.type == "reasoning":
        for block in item.content:
            print(block.text)

O valor de effort pode ser low, medium ou high. Para conversas em múltiplos turnos, envie de volta apenas as respostas finais — não inclua os itens de raciocínio no histórico enviado ao modelo na próxima rodada. Para o Gemma 4 E2B, recomenda-se definir reasoning_effort como high.

Os parâmetros de amostragem recomendados para todos os modelos Gemma 4 são temperature=1.0 e top_p=0.95, que funcionam bem tanto no modo de raciocínio quanto fora dele.

Camadas de serviço disponíveis

O Amazon Bedrock oferece três camadas (tiers) para atender diferentes perfis de workload:

Priority: para workloads críticos e voltados ao usuário final que exigem os menores tempos de resposta. Oferece até 25% mais tokens de saída por segundo (OTPS) em comparação ao Standard, com prioridade de processamento. Não exige reserva ou compromisso antecipado.
Standard: para tarefas cotidianas de IA como geração de conteúdo, análise de texto e processamento de documentos. Desempenho consistente com precificação padrão por demanda. Camada padrão quando nenhuma é especificada.
Flex: para workloads que toleram maior latência, como avaliações de modelos, sumarização e fluxos agênticos. Preço com desconto em relação ao Standard, mas com maior latência em períodos de pico.

Para detalhes de preço por camada e modelo, consulte a página de preços do Amazon Bedrock. Para disponibilidade de camadas por modelo, acesse o catálogo de modelos do Amazon Bedrock.

Escalabilidade e boas práticas em produção

A inferência por demanda no bedrock-mantle não possui cota de requisições por minuto (RPM). O controle é feito por cotas de tokens por minuto (input e output separados). Como os modelos Gemma 4 não têm cotas publicadas no console do Service Quotas, utilize lógica de retry com backoff exponencial para lidar com throttling transitório. Para detalhes, consulte as cotas do endpoint bedrock-mantle.

O SDK da OpenAI oferece suporte nativo a retries com backoff exponencial via parâmetro max_retries:

from openai import OpenAI

# Retry transient failures with exponential backoff.
client = OpenAI(
    api_key="",
    base_url="https://bedrock-mantle.us-east-1.api.aws/openai/v1",
    max_retries=6,
)

Dois códigos de erro HTTP merecem atenção especial:

HTTP 429: cota de tokens por minuto excedida. Reduza a taxa de envio e faça retry com backoff; solicite aumento de cota via AWS Support se o limite for atingido com frequência.
HTTP 503: pressão na capacidade regional para o modelo. Faça retry com backoff para respostas ocasionais; reduza a taxa de envio para respostas sustentadas.

Para aumentos bruscos de tráfego, a recomendação é escalar em incrementos graduais: se encontrar erros 503, reduza a taxa em 50% até estabilizar, mantenha por 15 minutos e então aumente 50% a cada etapa até atingir o volume alvo.

Outras boas práticas para escala em produção:

Distribua workloads grandes ao longo de vários minutos, evitando rajadas concentradas.
Ao migrar tráfego para uma nova versão de modelo, use feature flags para rampar gradualmente.
Roteie trabalhos assíncronos (avaliações, sumarização, backfills agênticos) para a camada Flex.
Para workloads sem requisitos de residência de dados, distribua entre múltiplas regiões AWS.
Planeje headroom de duas a três vezes o pico esperado como buffer para surtos de tráfego.

Para orientações completas, consulte as boas práticas de escalabilidade e throughput no Amazon Bedrock User Guide.

Cache implícito de prompts

Os modelos Gemma 4 no Amazon Bedrock suportam cache implícito de prompts, habilitado automaticamente. Requisições consecutivas que compartilham um prefixo de prompt comum podem resultar em cache hit, reduzindo a latência de inferência nos tokens correspondentes sem necessidade de alterações no código. O recurso está disponível em todas as camadas de serviço (Standard, Priority e Flex). Posicionar conteúdo estático no início do prompt e conteúdo dinâmico no final maximiza as chances de cache hit.

Disponibilidade e preços

No lançamento, os modelos Gemma 4 estão disponíveis em quatro regiões AWS: Leste dos EUA (Norte da Virgínia), Leste dos EUA (Ohio), Oeste dos EUA (Oregon) e Europa (Frankfurt). Para a lista atualizada, consulte o catálogo de modelos do Amazon Bedrock. A precificação é por token e varia conforme o modelo e a camada de serviço; para valores atuais, acesse a página de preços do Amazon Bedrock.

Próximos passos

Para começar a usar os modelos Gemma 4 no Amazon Bedrock:

Acesse o console do Amazon Bedrock e experimente o Gemma 4 no playground de Chat/Texto.
Execute os exemplos Python deste post com seus próprios dados.
Avalie as variantes 31B, 26B-A4B e E2B nos seus workloads para escolher o perfil de custo e latência ideal.
Para deploy em produção, revise as boas práticas de escalabilidade e throughput e considere a camada Priority para tráfego sensível a latência.

Recursos adicionais:

Fonte

Introducing Gemma 4 models on Amazon Bedrock (https://aws.amazon.com/blogs/machine-learning/introducing-gemma-4-models-on-amazon-bedrock/)