Amazon Bedrock に Google DeepMind の「Gemma 4」モデルシリーズが追加

Today, we are announcing the availability of the Gemma 4 family on Amazon Bedrock. Built by Google DeepMind and released under the Apache 2.0 license, Gemma 4 is a family of open-weight models designed with a focus on intelligence-per-parameter across a broad range of deployment scenarios. The family includes three instruction-tuned variants: Gemma 4 31B, Gemma 4 26B-A4B, and Gemma 4 E2B. These cover dense and mixture-of-experts (MoE) architectures, where only a fraction of the model’s parameters activate per request. The variants offer built-in reasoning, native function calling, and multimodal input across text and image.

Independent benchmarks reflect Gemma 4’s intelligence-per-parameter focus: Artificial Analysis reports an Intelligence Index of 39 for Gemma 4 31B, well above the median of 15 in the 4B–40B open-weights class.

Organizations adopting open-weight foundation models (FMs) for production face a constant trade-off: access the leading models, but without compromising on data protection, regulatory alignment, or operational control. Amazon Bedrock removes that trade-off. It gives you leading open-weight FMs through a fully managed service, with inference running entirely on infrastructure operated by AWS and the security and privacy controls you expect from Amazon Bedrock.

In this post, we walk through how to get started with Gemma 4 models on Amazon Bedrock. We cover the capabilities supported by these models, the service tiers available, how on-demand inference scales to handle your workloads, and the different APIs you can use to access them. With these models, you can build multimodal agents, lightweight applications, document understanding pipelines, and software engineering workflows on Amazon Bedrock. Your prompts and completions are not used to train any models, and your content is not shared with third parties.

Key capabilities of Gemma 4

The Gemma 4 family on Amazon Bedrock spans a 2.3B-effective-parameter compact model up to a 30.7B-parameter dense model, giving you a choice of variants to match different cost and latency profiles. All variants support a built-in reasoning mode, native function calling for agentic workflows, multimodal input that combines text and image, and out-of-the-box support for over 35 languages with pre-training across 140+. Because the models are open-weight, you can independently evaluate the model architecture and training methodology, benchmark on your own workloads, and fine-tune on proprietary data when customization is required. You can access the models through a fully managed AWS service without provisioning infrastructure, hosting model weights, or operating inference stacks yourself.anno

For the latest list of supported models, refer to the Amazon Bedrock model catalog.

The Gemma 4 family on Amazon Bedrock at a glance

The family includes three instruction-tuned variants optimized for different cost and latency profiles. The following table summarizes the key specifications for each model on Amazon Bedrock:

Choosing a variant

Select the variant that best matches your workload’s performance and cost requirements. The following table provides guidance on which model to choose based on your use case:

Across the family, Gemma 4 models share a common interface: system prompts, structured tool calling, image input, and a thinking mode that can be toggled per request. You can develop an application against the API surface once and switch between variants based on the cost and latency profile that fits the workload.

Architecture highlights

All Gemma 4 variants use a hybrid attention design that interleaves local and global attention, supporting long contexts up to 256K tokens on 31B and 26B-A4B while keeping a small memory footprint. The 26B-A4B variant is a mixture-of-experts model: 25.2B total parameters but only 3.8B active per token, giving roughly 4B-class cost and latency with the knowledge capacity of a larger model. The E2B variant uses Per-Layer Embeddings (PLE) to keep its effective parameter count (2.3B of 5.1B total) small, lowering memory and compute cost. For architecture details, refer to the Gemma 4 model card.

Note: Use the bedrock-mantle endpoint for Gemma 4 models.

Reasoning mode

Gemma 4 includes a built-in reasoning mode. When enabled, the model emits its internal thought process before producing the final answer. On the bedrock-mantle endpoint, you enable reasoning through the Responses API reasoning parameter, and the thought process is returned as a separate reasoning item alongside the final answer (see *Enable reasoning mode* in the walkthrough).

In multi-turn conversations, send back only the final answers from previous turns, not their reasoning items. Replaying prior reasoning back to the model can degrade its responses. You can still keep the reasoning in your own logs or audit trail. Strip it from the history you send on the next turn.

Accessing Gemma 4 models on Amazon Bedrock

You access Gemma 4 models on Amazon Bedrock through the bedrock-mantle endpoint, the OpenAI-compatible API purpose-built for the next-generation inference engine for Amazon Bedrock. Its endpoint URL is https://bedrock-mantle.{region}.api.aws/openai/v1, and it exposes the Chat Completions and Responses APIs.

It’s helpful to keep the endpoint and the engine distinct: the *engine* is the underlying serving infrastructure—designed with Model Deployment Account isolation and zero operator access—and the *endpoint* is the HTTPS API surface you call. The bedrock-mantle endpoint is the public API for that next-generation inference engine and exposes its full feature set. For a deeper look at the underlying inference engine, refer to Exploring the zero operator access design of Amazon Bedrock’s next-generation inference engine.

The bedrock-mantle endpoint uses the same interface as the OpenAI Python and TypeScript SDKs, so teams already on those SDKs can switch to Gemma 4 models on Amazon Bedrock by updating only the base URL and model ID. It also supports Amazon Bedrock API keys, projects, and client-side tool calling.

Get started with Gemma 4 family models on Amazon Bedrock

Complete the following steps to start using Gemma 4 on Amazon Bedrock.

Prerequisites

To use Gemma 4 models, you need an AWS account with permissions to run inference on the bedrock-mantle endpoint. The simplest way to grant these is to attach the AWS managed policy AmazonBedrockMantleInferenceAccess to your AWS Identity and Access Management (IAM) principal. It grants read and inference-creation access on Mantle—the permissions the examples in this post need. These include bedrock-mantle:CreateInference (which authorizes the Chat Completions and Responses inference calls) and bedrock-mantle:CallWithBearerToken (which authorizes calling the endpoint with an Amazon Bedrock API key). For details on creating and managing API keys, refer to Amazon Bedrock API keys.

If you also need to manage projects, fine-tuning, custom models, and more, attach AmazonBedrockMantleFullAccess instead, which grants the full bedrock-mantle action set.

Console playground

The Amazon Bedrock console includes a chat/text playground where you can quickly test models without writing any code. Follow these steps to load a Gemma 4 model and prepare it for interaction:

• Navigate to the Amazon Bedrock console.

• From the left menu, choose Test playgrounds.

• Choose the Chat/Text playground.

• Choose Select model in the upper-left corner of the playground.

• From the category list, choose Google.

• Choose a Gemma 4 model.

• Choose Apply to load the model.

• Verify that the model loaded successfully: the model name appears in the playground header, and the chat interface is ready for input.

To demonstrate Gemma 4 31B’s reasoning and code generation capabilities, try the following prompt in the playground: *“Design a Python microservice that exposes a REST API for managing a task queue. Include error handling, input validation, and write unit tests. Explain your design decisions.”*

Call the bedrock-mantle endpoint from the OpenAI SDK

The following example uses the OpenAI Python SDK as a client library to call the bedrock-mantle endpoint. When using the OpenAI SDK, you need an Amazon Bedrock API key. For production workloads, use short-term API keys. They expire automatically (maximum 12 hours) and inherit the permissions of the IAM role that generated them. If you are already using native AWS credentials and don’t have an API key, the aws-bedrock-token-generator package generates a short-term bearer token from those credentials.

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)

If you are migrating an existing application that already uses the OpenAI SDK format with a different model, the migration typically requires updating only the base URL and the model ID. To control permissions for generating and using API keys, refer to Control permissions for generating and using Amazon Bedrock API keys.

Note: The code examples in this post read the API key from an environment variable for demonstration only. In production, store and retrieve credentials from a managed secrets service such as AWS Secrets Manager or AWS Systems Manager Parameter Store rather than environment variables.

Multimodal input (image)

Because Gemma 4 supports image input across all variants, the same Chat Completions API works for vision tasks. The bedrock-mantle endpoint accepts images as inline base64-encoded data URLs or as Amazon Simple Storage Service (Amazon S3) URLs (s3://); arbitrary public https:// image URLs are not supported. The following example reads a local image file, encodes it as a base64 data URL, and includes it in the message content alongside the text 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)

Alternatively, you can reference an image stored in Amazon S3 by passing an s3:// URL in place of the data URL (for example, {"url": "s3://my-bucket/chart.png"}). This avoids inlining large images in the request body. For best results, place image content before the text in the prompt, which matches Google DeepMind’s recommended ordering for Gemma 4 multimodal inputs.

Streaming responses

For chat and agent use cases where you want to surface tokens to the user as they are generated, set stream=True. The response becomes an iterator of incremental delta events:

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()

Streaming uses the same bedrock-mantle:CreateInference permission as a non-streaming call—the IAM policy shown earlier already covers it.

Tool calling

Gemma 4 supports native function calling for agentic workflows. The following example shows a complete tool-calling loop: defining a tool, receiving a tool call from the model, executing the function, and passing the result back.

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)

Responses API

In addition to Chat Completions, the bedrock-mantle endpoint supports the OpenAI Responses API, which uses a single inpu