Run MiniMax fashions on Amazon Bedrock

Organizations are more and more adopting open-weight basis fashions (FMs) to energy manufacturing AI workloads, from agentic coding assistants to long-context doc evaluation. As these workloads transfer from experimentation to enterprise deployment, two necessities form each mannequin choice determination: the mannequin should ship the capabilities the workload calls for, and the inference setting should help the group’s safety and compliance necessities. Prospects are in search of methods to entry frontier third-party fashions with out compromising on information safety, regulatory alignment, or operational management.

To handle this want, Amazon Bedrock affords a completely managed service for accessing main FMs from unbiased mannequin suppliers, with inference working fully on AWS-operated infrastructure. Your prompts and completions usually are not used to coach any fashions, and your content material isn’t shared with the mannequin suppliers.

The MiniMax household is obtainable on Amazon Bedrock, providing you with three open-weight fashions to match totally different manufacturing workloads. The household is purpose-built for software program engineering and agentic use instances. The latest mannequin on Amazon Bedrock, MiniMax M2.5, is skilled particularly for agent-native execution. The next sections cowl what every mannequin affords and the way to decide on between them.

On this submit, we stroll by easy methods to get began with MiniMax fashions on Amazon Bedrock, together with the capabilities supported by these fashions, the service tiers obtainable, how on-demand inference scales to deal with your workloads, and the totally different APIs you should use to entry them. Utilizing these fashions, clients can construct agentic purposes, long-context doc evaluation pipelines, and software program engineering workflows, all backed by the safety and operational ensures of AWS.

About MiniMax

MiniMax is a world AI expertise firm that develops multimodal basis fashions with a analysis emphasis on environment friendly architectures for production-scale workloads. Its M2 household of huge language fashions is obtainable on Amazon Bedrock as absolutely managed open-weight fashions, constructed round a mixture-of-experts (MoE) structure the place solely a small fraction of complete parameters activate per token, delivering the information capability of a a lot bigger dense mannequin at a fraction of the inference price.

The M2 household delivers sturdy efficiency on coding and agentic workloads, with M2.5 purpose-built for agent-native execution by coaching that emphasizes tool-calling, multi-step activity decomposition, and long-horizon coding duties. As a result of the fashions are open-weight, you possibly can independently consider the mannequin structure and coaching methodology, run your individual benchmarks on consultant workloads, and fine-tune on proprietary information when customization is required. You are able to do all of this by a completely managed AWS service, with out provisioning infrastructure, internet hosting mannequin weights, or working inference stacks.

For the total mannequin catalog, see the MiniMax fashions on Amazon Bedrock documentation.

MiniMax fashions on Amazon Bedrock

Amazon Bedrock helps three fashions from the MiniMax M2 household. MiniMax M2 (minimax.minimax-m2) was the primary to launch, establishing the core capabilities of the collection with sturdy multilingual textual content era, stable reasoning and coding efficiency, and a 1 million token context window. MiniMax M2.1 (minimax.minimax-m2.1) adopted, including focused enhancements to reasoning depth, coding accuracy, and instruction following. MiniMax M2.5 (minimax.minimax-m2.5) is the most recent mannequin obtainable on Amazon Bedrock and is skilled particularly for agent-native execution. Amazon Bedrock continues to broaden its catalog of MiniMax fashions as new variations turn into obtainable. For the most recent record, seek advice from the Amazon Bedrock mannequin documentation for MiniMax. The next desk summarizes the important thing variations.

MiniMax M2.5 makes use of a mixture-of-experts (MoE) structure with 230 billion complete parameters and 10 billion energetic per token. For inference price, the MoE routing mechanism is the important thing issue. It offers the information capability of a 230B mannequin whereas consuming compute proportional to solely 10B energetic parameters per ahead cross.

Two endpoints for accessing MiniMax fashions on Amazon Bedrock

Amazon Bedrock offers two endpoints for invoking MiniMax fashions: bedrock-mantle and bedrock-runtime.

The Amazon bedrock-mantle endpoint (https://bedrock-mantle.{area}.api.aws/v1) is the general public API for Amazon Bedrock’s next-generation inference engine. It makes use of the Chat Completions API, the identical interface because the OpenAI Python and TypeScript SDKs, so groups already on that SDK can change to MiniMax fashions on Amazon Bedrock by updating the bottom URL and mannequin ID. It helps Amazon Bedrock API keys, initiatives, and client-side instrument calling. For many workloads, we advocate the bedrock-mantle endpoint.

The bedrock-runtime endpoint (https://bedrock-runtime.{area}.amazonaws.com) makes use of the Converse and InvokeModel APIs through the AWS SDK. Use this endpoint for native Amazon Bedrock options corresponding to Guardrails, Brokers, Flows, and mannequin analysis, that are at the moment obtainable by bedrock-runtime.

Within the following sections, we show each endpoints, beginning with the beneficial bedrock-mantle endpoint and the Chat Completions API.

Getting began with MiniMax M2.5 in Amazon Bedrock

Full the next steps to begin utilizing MiniMax M2.5 in Amazon Bedrock.

Console playground

1. Navigate to the Amazon Bedrock console and choose Chat/Textual content playground from the left menu beneath the Check part.
2. Select Choose mannequin within the middle of the playground.
3. Select MiniMax from the class record, then choose MiniMax M2.5.
4. Select Apply to load the mannequin.
5. Affirm that the mannequin loaded. The mannequin title seems within the playground header and the chat interface is prepared for enter.

To show M2.5’s reasoning and code era capabilities, strive the next immediate within the playground:

“Design a Python microservice that exposes a REST API for managing a activity queue. Embody error dealing with, enter validation, and write unit exams. Clarify your design choices.”

Utilizing the bedrock-mantle endpoint (beneficial)

Conditions

For the bedrock-mantle endpoint, you want an Amazon Bedrock API key or AWS credentials configured for SigV4. To offer entry to the bedrock-mantle endpoint, use the next minimal coverage:

{
    "Model": "2012-10-17",
    "Assertion": [
        {
            "Sid": "BedrockMantleInference",
            "Effect": "Allow",
            "Action": [
                "bedrock-mantle:CreateInference",
                "bedrock-mantle:Get*",
                "bedrock-mantle:List*"
            ],
            "Useful resource": "arn:aws:bedrock-mantle:us-east-1:111122223333:venture/*"
        },
        {
            "Sid": "BedrockMantleApiKeyAccess",
            "Impact": "Permit",
            "Motion": "bedrock-mantle:CallWithBearerToken",
            "Useful resource": "*"
        }
    ]
}

Change 111122223333 along with your AWS account ID, and scope the AWS Area to the Areas that you simply use. The primary assertion covers SigV4 authentication. The second covers Amazon Bedrock API key (bearer token) authentication. When you solely use SigV4, you possibly can omit the second assertion. To manage which identities can generate or use Amazon Bedrock API keys, see Management permissions for producing and utilizing Amazon Bedrock API keys. To limit your group to authorized fashions solely, use a service management coverage (SCP).

The next instance makes use of the OpenAI Python SDK as a shopper library to name the bedrock-mantle endpoint. When utilizing the OpenAI SDK, you want an Amazon Bedrock API key. For manufacturing workloads, use short-term API keys, which expire routinely (most 12 hours) and inherit the permissions of the AWS Identification and Entry Administration (IAM) function that generated them. When you’re already utilizing AWS credentials and don’t have an API key, the aws-bedrock-token-generator bundle generates a short-term bearer token from these credentials.

Notice: The code examples on this submit invoke MiniMax M2.5, and every mannequin invocation incurs per-token expenses. See the Amazon Bedrock pricing web page for present charges.

import boto3
from openai import OpenAI

# Retrieve the Amazon Bedrock API key from AWS Secrets and techniques Supervisor
secrets_client = boto3.shopper("secretsmanager", region_name="us-east-1")
api_key = secrets_client.get_secret_value(SecretId="bedrock-api-key")["SecretString"]

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

response = shopper.chat.completions.create(
    mannequin="minimax.minimax-m2.5",
    messages=[
        {"role": "user", "content": "Explain the benefits of mixture-of-experts architectures for production inference."}
    ],
    max_tokens=512,
)

print(response.decisions[0].message.content material)

Notice: These examples retrieve the Amazon Bedrock API key from AWS Secrets and techniques Supervisor. For native improvement, you possibly can as an alternative learn the important thing from an setting variable, however keep away from that sample in manufacturing. Use AWS Secrets and techniques Supervisor or one other secrets and techniques retailer.

Software calling

MiniMax M2.5 is designed for agentic workflows, making it well-suited for tool-calling eventualities. In a tool-calling workflow, you outline features (instruments) that the mannequin can invoke, the mannequin decides when to name them based mostly on the person’s request, and your utility runs the perform and returns the end result for the mannequin to include into its remaining response.

The next instance demonstrates this sample finish to finish. We outline a get_weather instrument, ship a person message, let the mannequin request the instrument name, run the perform with mock information, and cross the end result again so the mannequin can generate a natural-language reply.

import json
import boto3
from openai import OpenAI

# Retrieve the Amazon Bedrock API key from AWS Secrets and techniques Supervisor
secrets_client = boto3.shopper("secretsmanager", region_name="us-east-1")
api_key = secrets_client.get_secret_value(SecretId="bedrock-api-key")["SecretString"]

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

instruments = [
    {
        "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: Ship the person request with instrument definitions
messages = [
    {"role": "user", "content": "What's the weather like in Seattle?"}
]

response = shopper.chat.completions.create(
    mannequin="minimax.minimax-m2.5",
    messages=messages,
    instruments=instruments,
    tool_choice="auto",
)

assistant_message = response.decisions[0].message

# Step 2: Verify if the mannequin desires to name a instrument
if assistant_message.tool_calls:
    messages.append(assistant_message)

    for tool_call in assistant_message.tool_calls:
        function_name = tool_call.perform.title
        arguments = json.masses(tool_call.perform.arguments)

        # Step 3: Validate perform title and run
        if function_name == "get_weather":
            location = arguments.get("location", "Unknown")
            unit = arguments.get("unit", "fahrenheit")
            end result = {
                "location": location,
                "temperature": 18 if unit == "celsius" else 64,
                "unit": unit,
                "situation": "Partly cloudy",
                "humidity": 72,
            }
        else:
            end result = {"error": f"Unknown perform: {function_name}"}

        # Step 4: Return the perform end result to the mannequin
        messages.append({
            "function": "instrument",
            "tool_call_id": tool_call.id,
            "content material": json.dumps(end result),
        })

    # Step 5: Get the ultimate response incorporating instrument outcomes
    final_response = shopper.chat.completions.create(
        mannequin="minimax.minimax-m2.5",
        messages=messages,
        instruments=instruments,
    )

    print(final_response.decisions[0].message.content material)
else:
    print(assistant_message.content material)

Utilizing the bedrock-runtime endpoint (boto3)

Conditions

For the bedrock-runtime endpoint, you want AWS credentials configured (IAM person or function) with permission to invoke the mannequin. Use the next minimal coverage:

{
    "Model": "2012-10-17",
    "Assertion": [
        {
            "Effect": "Allow",
            "Action": [
                "bedrock:InvokeModel",
                "bedrock:InvokeModelWithResponseStream"
            ],
            "Useful resource": "arn:aws:bedrock:us-east-1::foundation-model/minimax.minimax-m2.5"
        }
    ]
}

For manufacturing deployments, scope the Useful resource to the particular Areas you utilize. To limit your group to authorized fashions solely, use a service management coverage (SCP).

The next instance sends a single-turn request to MiniMax M2.5 utilizing the AWS SDK for Python (Boto3) with the Converse API and prints the mannequin’s response:

import boto3

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

response = shopper.converse(
    modelId="minimax.minimax-m2.5",
    messages=[{
        "role": "user",
        "content": [{"text": "What is mixture of experts?"}]
    }],
    inferenceConfig={"maxTokens": 2048, "temperature": 1.0, "topP": 0.95},
)

content_blocks = response["output"]["message"]["content"]
response_text = subsequent(
    (block["text"] for block in content_blocks if "textual content" in block),
    None
)

if response_text:
    print(response_text)
else:
    print("No textual content response.")

Notice: On the Converse API, MiniMax M2.5 returns a reasoningContent block earlier than the textual content block. The code iterates by the content material blocks to extract the ultimate textual content response.

Utilizing the AWS CLI

You too can entry MiniMax M2.5 out of your terminal utilizing the AWS Command Line Interface (AWS CLI):

aws bedrock-runtime converse 
  --model-id minimax.minimax-m2.5 
  --messages '[{"role":"user","content":[{"text":"Type_Your_Prompt_Here"}]}]' 
  --inference-config '{"maxTokens":2048}' 
  --region us-east-1

Service tiers

Amazon Bedrock affords a number of service tiers to match totally different workload necessities:

Notice: The Reserved tier isn’t at the moment obtainable for MiniMax fashions. For updates on Reserved tier availability, contact your AWS account group.

Scaling on-demand inference

While you invoke MiniMax fashions on Amazon Bedrock, requests use on-demand inference (Customary tier) by default, the place you pay per token with out reserving capability. On-demand throughput is shared and allotted per AWS Area, so during times of excessive regional demand a request could also be briefly queued or throttled. Designing for that is essential for purposes that must scale reliably in manufacturing.

On the bedrock-mantle endpoint, there isn’t any requests-per-minute (RPM) quota. Throughput is ruled by token-based limits reasonably than request counts. MiniMax fashions don’t at the moment have per-account token quotas revealed within the Service Quotas console, so their throughput is managed by the endpoint’s inside scheduling and capability. Use retry logic with exponential backoff to deal with transient throttling. Cached enter tokens learn by immediate caching don’t depend in opposition to the input-token quota. For particulars, see Quotas for the bedrock-mantle endpoint.

The 2 errors name for various responses. For a 429, cut back your submission charge or request a quota improve by AWS Help. For a 503, retry transient errors and ramp step by step, as described within the following part.

Deal with one-off 503 responses. Some on-demand inference requests might even see occasional 503 responses when the mannequin is in excessive demand, and the beneficial solution to deal with them is exponential backoff with jitter and a bounded retry depend. The AWS SDK and hottest HTTP shoppers help this by commonplace retry configuration. The next instance makes use of Boto3:

import boto3
from botocore.config import Config

config = Config(retries={"total_max_attempts": 6, "mode": "commonplace"})
shopper = boto3.shopper("bedrock-runtime", config=config)

If 503 responses turn into sustained, retries alone gained’t resolve the problem as a result of the efficient request charge is exceeding obtainable capability for the mannequin. In that case, think about routing latency-sensitive site visitors to the Precedence tier, which receives preferential processing forward of Customary and Flex requests during times of excessive demand.

Deal with steep site visitors ramps. When utilizing Customary tier on-demand inference, your utility’s incoming site visitors ought to align with how the mannequin’s regional capability scales. Sudden, massive jumps in request charge usually tend to set off 503s than gradual will increase that the system can accommodate. Everytime you improve the request charge in opposition to MiniMax fashions, scale up in measured increments reasonably than stepping straight to a brand new goal quantity. The beneficial ramp process is:

1. Begin at your goal request charge.
2. When you obtain 503 responses, cut back the speed by 50 p.c, and proceed lowering till requests are succeeding persistently.
3. Maintain at that regular state for quarter-hour.
4. Enhance the speed by 50 p.c and maintain for one more quarter-hour.
5. Repeat till you attain your goal quantity.

As a labored instance, in case your goal is 2,000 requests per minute and also you encounter 503s, you would scale back to 1,000, then to 500 if errors persist. After 500 is regular for quarter-hour, you scale to 750, then 1,125, and so forth. The 15-minute maintain is the half most groups skip, and it’s the half that issues most. With out it, each step up is actually a contemporary load take a look at.

Select the Precedence tier for latency-sensitive workloads. Past reactive use throughout sustained 503s, the Precedence tier is usually a helpful lever to scale back occurrences of 503 whereas persevering with to make use of on-demand inference. Precedence delivers as much as 25 p.c higher output tokens per second in comparison with Customary, and there’s no upfront reservation or dedication. Purposes decide in by setting the service_tier parameter to precedence on every invocation, and tiers will be blended throughout the identical utility. Buyer-facing prompts, real-time brokers, and different person interactions the place response time instantly impacts expertise are good candidates for Precedence. For background and batch-style work, Customary or Flex is often the correct alternative and avoids paying the Precedence premium on requests that wouldn’t profit from it.

Extra finest practices for manufacturing scale. A handful of extra practices assist hold inference workloads working easily at scale. Spreading massive workloads throughout a number of minutes, reasonably than firing them in tight bursts, reduces strain on Regional capability. When migrating manufacturing site visitors to a brand new MiniMax mannequin model, you should use characteristic flags to ramp the share of site visitors step by step as an alternative of slicing over abruptly. Asynchronous work, corresponding to mannequin evaluations, content material summarization, and agentic backfills, will be routed to the Flex tier, which is designed for cost-effective processing of latency-tolerant workloads. For workloads with out information residency necessities, distributing throughout a number of Areas improves resilience throughout regional demand spikes. For workloads anticipated to develop, planning headroom for 2 to 3 instances the anticipated peak offers a buffer for site visitors surges.

For full steering, see Scaling and throughput finest practices within the Amazon Bedrock Consumer Information.

Lowering latency with implicit immediate caching

MiniMax fashions on Amazon Bedrock help implicit immediate caching. When consecutive requests share a standard immediate prefix, this would possibly end in a cache hit, permitting the mannequin to reuse the cached inside state as an alternative of recomputing it. Cache hits cut back inference latency on the matching tokens, with no adjustments to your code and no cache markers required.

Implicit immediate caching is obtainable throughout all on-demand service tiers (Customary, Precedence, and Flex), so purposes can benefit from it no matter how their site visitors is routed. Cache hits usually are not assured on each request, however they’re frequent in workloads with steady prefixes. Examples embrace multi-turn brokers, retrieval-augmented era pipelines, and long-context evaluation workflows the place system prompts, instrument definitions, or supply paperwork are reused throughout requests. To maximise cache hit charges, place static content material (system prompts, instrument definitions, reference paperwork) firstly of the immediate and dynamic content material (person messages, variable context) on the finish.

Clear up

On-demand inference incurs expenses solely whenever you invoke a mannequin, so there isn’t any infrastructure to tear down. To keep away from unintended expenses, think about the next:

• When you generated short-term Amazon Bedrock API keys for testing, they expire routinely inside 12 hours. To revoke one sooner, delete the API key within the Amazon Bedrock console. Deleting a key instantly revokes entry for any utility utilizing it, so verify no energetic purposes depend upon it first.
• When you opted in to the Precedence tier for testing, take away the service_tier parameter out of your requests to return to Customary pricing for site visitors that isn’t latency-sensitive.

Pricing and availability

MiniMax M2.5 is obtainable in 14 AWS Areas: US East (N. Virginia), US East (Ohio), US West (Oregon), Europe (Frankfurt), Europe (Stockholm), Europe (Milan), Europe (Eire), Europe (London), Asia Pacific (Tokyo), Asia Pacific (Mumbai), Asia Pacific (Sydney), Asia Pacific (Jakarta), Asia Pacific (Melbourne), and South America (São Paulo). Requests are served within the Area you name. Cross-Area inference (Geo and International) isn’t at the moment obtainable for MiniMax fashions. For the most recent record, see the supported Areas web page.

Pricing is per token and varies by mannequin and repair tier. For present charges, see Amazon Bedrock pricing.

Conclusion

On this submit, we walked by easy methods to get began with MiniMax M2 household fashions on Amazon Bedrock. We explored the 2 inference endpoints, bedrock-mantle and bedrock-runtime, demonstrated instrument calling with the Chat Completions API, lined service tier choices for matching workload necessities, and mentioned scaling methods together with implicit immediate caching for latency discount.

To get began:

• Open the Amazon Bedrock console and take a look at MiniMax M2.5 within the Chat/Textual content playground.
• Run the bedrock-mantle Python pattern from this submit in opposition to your individual information.
• Consider MiniMax M2, M2.1, and M2.5 in your workloads to decide on the mannequin that matches your price and latency profile.
• For manufacturing deployment, evaluation the Scaling and throughput finest practices and think about the Precedence tier for latency-sensitive site visitors.

Assets

For extra data, seek advice from the next sources:

Concerning the authors