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 resolution: the mannequin should ship the capabilities the workload calls for, and the inference setting should assist the group’s safety and compliance necessities. Prospects are searching for methods to entry frontier third-party fashions with out compromising on information safety, regulatory alignment, or operational management.

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

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

On this put up, we stroll by learn how 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 completely different APIs you need to use to entry them. Utilizing these fashions, prospects can construct agentic functions, 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 know-how 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 on the market on Amazon Bedrock as totally 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 data capability of a a lot bigger dense mannequin at a fraction of the inference value.

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 may independently consider the mannequin structure and coaching methodology, run your personal 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 sequence with sturdy multilingual textual content era, strong 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 grow to be obtainable. For the newest checklist, 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 lively per token. For inference value, the MoE routing mechanism is the important thing issue. It gives the data capability of a 230B mannequin whereas consuming compute proportional to solely 10B lively parameters per ahead cross.

Two endpoints for accessing MiniMax fashions on Amazon Bedrock

Amazon Bedrock gives 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, tasks, and client-side software 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 by way of the AWS SDK. Use this endpoint for native Amazon Bedrock options corresponding to Guardrails, Brokers, Flows, and mannequin analysis, that are at present obtainable by bedrock-runtime.

Within the following sections, we display each endpoints, beginning with the advisable 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 checklist, then choose MiniMax M2.5.
4. Select Apply to load the mannequin.
5. Verify that the mannequin loaded. The mannequin title seems within the playground header and the chat interface is prepared for enter.

To display 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 assessments. Clarify your design choices.”

Utilizing the bedrock-mantle endpoint (advisable)

Stipulations

For the bedrock-mantle endpoint, you want an Amazon Bedrock API key or AWS credentials configured for SigV4. To supply 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 just use. The primary assertion covers SigV4 authentication. The second covers Amazon Bedrock API key (bearer token) authentication. In the event you solely use SigV4, you may 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 authorised fashions solely, use a service management coverage (SCP).

The next instance makes use of the OpenAI Python SDK as a consumer 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 robotically (most 12 hours) and inherit the permissions of the AWS Id and Entry Administration (IAM) function that generated them. In the event 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.

Observe: The code examples on this put up invoke MiniMax M2.5, and every mannequin invocation incurs per-token prices. 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.consumer("secretsmanager", region_name="us-east-1")
api_key = secrets_client.get_secret_value(SecretId="bedrock-api-key")["SecretString"]

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

response = consumer.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)

Observe: These examples retrieve the Amazon Bedrock API key from AWS Secrets and techniques Supervisor. For native growth, you may as a substitute 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.

Device 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 consumer’s request, and your utility runs the perform and returns the outcome for the mannequin to include into its remaining response.

The next instance demonstrates this sample finish to finish. We outline a get_weather software, ship a consumer message, let the mannequin request the software name, run the perform with mock information, and cross the outcome 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.consumer("secretsmanager", region_name="us-east-1")
api_key = secrets_client.get_secret_value(SecretId="bedrock-api-key")["SecretString"]

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

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

assistant_message = response.decisions[0].message

# Step 2: Examine if the mannequin desires to name a software
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.hundreds(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")
            outcome = {
                "location": location,
                "temperature": 18 if unit == "celsius" else 64,
                "unit": unit,
                "situation": "Partly cloudy",
                "humidity": 72,
            }
        else:
            outcome = {"error": f"Unknown perform: {function_name}"}

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

    # Step 5: Get the ultimate response incorporating software outcomes
    final_response = consumer.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)

Stipulations

For the bedrock-runtime endpoint, you want AWS credentials configured (IAM consumer 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 precise Areas you employ. To limit your group to authorised 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

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

response = consumer.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.")

Observe: 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 can even 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 provides a number of service tiers to match completely different workload necessities:

Observe: The Reserved tier isn’t at present obtainable for MiniMax fashions. For updates on Reserved tier availability, contact your AWS account crew.

Scaling on-demand inference

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

On the bedrock-mantle endpoint, there is no such thing as a requests-per-minute (RPM) quota. Throughput is ruled by token-based limits moderately than request counts. MiniMax fashions don’t at present have per-account token quotas revealed within the Service Quotas console, so their throughput is managed by the endpoint’s inner 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 fee or request a quota improve by AWS Assist. 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 advisable method to deal with them is exponential backoff with jitter and a bounded retry depend. The AWS SDK and hottest HTTP shoppers assist this by normal retry configuration. The next instance makes use of Boto3:

import boto3
from botocore.config import Config

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

If 503 responses grow to be sustained, retries alone gained’t resolve the problem as a result of the efficient request fee 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 Normal and Flex requests in periods of excessive demand.

Deal with steep site visitors ramps. When utilizing Normal 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 fee usually tend to set off 503s than gradual will increase that the system can accommodate. Everytime you improve the request fee in opposition to MiniMax fashions, scale up in measured increments moderately than stepping straight to a brand new goal quantity. The advisable ramp process is:

1. Begin at your goal request fee.
2. In the event you obtain 503 responses, cut back the speed by 50 %, and proceed decreasing till requests are succeeding persistently.
3. Maintain at that regular state for quarter-hour.
4. Enhance the speed by 50 % and maintain for an additional 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 check.

Select the Precedence tier for latency-sensitive workloads. Past reactive use throughout sustained 503s, the Precedence tier generally is 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 % higher output tokens per second in comparison with Normal, and there’s no upfront reservation or dedication. Purposes choose in by setting the service_tier parameter to precedence on every invocation, and tiers might be blended throughout the identical utility. Buyer-facing prompts, real-time brokers, and different consumer interactions the place response time instantly impacts expertise are good candidates for Precedence. For background and batch-style work, Normal or Flex is often the suitable selection and avoids paying the Precedence premium on requests that wouldn’t profit from it.

Extra greatest practices for manufacturing scale. A handful of further practices assist preserve inference workloads working easily at scale. Spreading massive workloads throughout a number of minutes, moderately than firing them in tight bursts, reduces strain on Regional capability. When migrating manufacturing site visitors to a brand new MiniMax mannequin model, you need to use characteristic flags to ramp the share of site visitors step by step as a substitute of chopping over abruptly. Asynchronous work, corresponding to mannequin evaluations, content material summarization, and agentic backfills, might 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 a few instances the anticipated peak gives a buffer for site visitors surges.

For full steerage, see Scaling and throughput greatest practices within the Amazon Bedrock Consumer Information.

Lowering latency with implicit immediate caching

MiniMax fashions on Amazon Bedrock assist implicit immediate caching. When consecutive requests share a typical immediate prefix, this would possibly end in a cache hit, permitting the mannequin to reuse the cached inner state as a substitute 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 on the market throughout all on-demand service tiers (Normal, Precedence, and Flex), so functions can make the most of it no matter how their site visitors is routed. Cache hits are usually not assured on each request, however they’re widespread in workloads with secure prefixes. Examples embrace multi-turn brokers, retrieval-augmented era pipelines, and long-context evaluation workflows the place system prompts, software definitions, or supply paperwork are reused throughout requests. To maximise cache hit charges, place static content material (system prompts, software definitions, reference paperwork) firstly of the immediate and dynamic content material (consumer messages, variable context) on the finish.

Clear up

On-demand inference incurs prices solely while you invoke a mannequin, so there is no such thing as a infrastructure to tear down. To keep away from unintended prices, think about the next:

• In the event you generated short-term Amazon Bedrock API keys for testing, they expire robotically 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 affirm no lively functions depend upon it first.
• In the event you opted in to the Precedence tier for testing, take away the service_tier parameter out of your requests to return to Normal pricing for site visitors that isn’t latency-sensitive.

Pricing and availability

MiniMax M2.5 is on the market 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 World) isn’t at present obtainable for MiniMax fashions. For the newest checklist, 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 put up, we walked by learn how to get began with MiniMax M2 household fashions on Amazon Bedrock. We explored the 2 inference endpoints, bedrock-mantle and bedrock-runtime, demonstrated software 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 check out MiniMax M2.5 within the Chat/Textual content playground.
• Run the bedrock-mantle Python pattern from this put up in opposition to your personal information.
• Consider MiniMax M2, M2.1, and M2.5 in your workloads to decide on the mannequin that matches your value and latency profile.
• For manufacturing deployment, overview the Scaling and throughput greatest 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