MiniMax M2.5 开源，低成本Agent时代来了！社区Day0部署、工具调用、推理&提示词参数实战来啦！

from openai import OpenAI
client = OpenAI(
    base_url='https://api-inference.modelscope.cn/v1',
    api_key='<MODELSCOPE_TOKEN>', # ModelScope Token
)
response = client.chat.completions.create(
    model='MiniMax/MiniMax-M2.5', # ModelScope Model-Id
    messages=[
        {
            'role': 'system',
            'content': 'You are a helpful assistant.'
        },
        {
            'role': 'user',
            'content': '你好'
        }
    ],
    stream=True
)
for chunk in response:
    if chunk.choices:
        print(chunk.choices[0].delta.content, end='', flush=True)

# 建议使用全新的虚拟环境
uv venv
source .venv/bin/activate
# 从源码安装 SGLang
git clone https://github.com/sgl-project/sglang
cd sglang
uv pip install -e "python" --prerelease=allow

SGLANG_USE_MODELSCOPE=true python -m sglang.launch_server \
    --model-path MiniMaxAI/MiniMax-M2.1 \
    --tp-size 4 \
    --tool-call-parser minimax-m2 \
    --reasoning-parser minimax-append-think \
    --host 0.0.0.0 \
    --trust-remote-code \
    --port 8000 \
    --mem-fraction-static 0.85

SGLANG_USE_MODELSCOPE=truepython -m sglang.launch_server \
    --model-path MiniMaxAI/MiniMax-M2.1 \
    --tp-size 8 \
    --ep-size 8 \
    --tool-call-parser minimax-m2 \
    --trust-remote-code \
    --host 0.0.0.0 \
    --reasoning-parser minimax-append-think \
    --port 8000 \
    --mem-fraction-static 0.85

curl http://localhost:8000/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d '{
        "model": "MiniMaxAI/MiniMax-M2.1",
        "messages": [
            {"role": "system", "content": [{"type": "text", "text": "You are a helpful assistant."}]},
            {"role": "user", "content": [{"type": "text", "text": "用 Python 实现一个二叉搜索树。"}]}
        ]
    }'

uv venv
source .venv/bin/activate
uv pip install -U vllm --extra-index-url https://wheels.vllm.ai/nightly

VLLM_USE_MODELSCOPE=true vllm serve \
    MiniMaxAI/MiniMax-M2.1 --trust-remote-code \
    --tensor-parallel-size 4 \
    --enable-auto-tool-choice --tool-call-parser minimax_m2 \
    --reasoning-parser minimax_m2_append_think

VLLM_USE_MODELSCOPE=true vllm serve \
    MiniMaxAI/MiniMax-M2.1 --trust-remote-code \
    --enable_expert_parallel --tensor-parallel-size 8 \
    --enable-auto-tool-choice --tool-call-parser minimax_m2 \
    --reasoning-parser minimax_m2_append_think

uv pip install transformers==4.57.1 torch accelerate --torch-backend=auto

from modelscope import AutoModelForCausalLM, AutoTokenizer
import torch
MODEL_PATH = "MiniMax/MiniMax-M2.5"
# 加载模型（自动分配到多卡）
model = AutoModelForCausalLM.from_pretrained(
    MODEL_PATH,
    device_map="auto",
    trust_remote_code=True,  # 必须开启！
)
tokenizer = AutoTokenizer.from_pretrained(MODEL_PATH)
# 构造对话消息
messages = [
    {"role": "user", "content": [
        {"type": "text", "text": "帮我写一个 Go 语言的 HTTP 服务器"}
    ]}
]
# 推理生成
model_inputs = tokenizer.apply_chat_template(
    messages, return_tensors="pt", add_generation_prompt=True
).to("cuda")
generated_ids = model.generate(
    model_inputs,
    max_new_tokens=2048,
    generation_config=model.generation_config
)
response = tokenizer.batch_decode(generated_ids)[0]
print(response)

pip install modelscope
modelscope download mlx-community/MiniMax-M2.5-3bit

# 安装 mlx-lm
pip install -U mlx-lm
# 命令行直接生成
mlx_lm.generate \
  --model PATH/MiniMax-M2.5-3bit \
  --prompt "如何用 Rust 实现一个并发安全的 HashMap？" \
  --max-tokens 1024 \
  --temp 0.7

from mlx_lm import load, generate
model, tokenizer = load("PATH/MiniMax-M2.1-4bit")
messages = [{"role": "user", "content": "解释一下 Transformer 的注意力机制"}]
prompt = tokenizer.apply_chat_template(
    messages, tokenize=False, add_generation_prompt=True
)
response = generate(
    model, tokenizer, prompt=prompt, max_tokens=512, temp=0.7, verbose=True
)
print(response)

from openai import OpenAI
import json
client = OpenAI(base_url="http://localhost:8000/v1", api_key="dummy")
# 定义工具
tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "获取指定城市的当前天气",
        "parameters": {
            "type": "object",
            "properties": {
                "location": {
                    "type": "string",
                    "description": "城市名称，如'北京'、'上海'"
                },
                "unit": {
                    "type": "string",
                    "enum": ["celsius", "fahrenheit"],
                    "description": "温度单位"
                }
            },
            "required": ["location", "unit"]
        }
    }
}]
# 发送请求
response = client.chat.completions.create(
    model=client.models.list().data[0].id,
    messages=[
        {"role": "user", "content": "上海今天天气怎么样？用摄氏度。"}
    ],
    tools=tools,
    tool_choice="auto"
)
# 解析工具调用结果
tool_call = response.choices[0].message.tool_calls[0].function
print(f"调用函数: {tool_call.name}")
print(f"参数: {tool_call.arguments}")
# 输出: 调用函数: get_weather
#       参数: {"location": "上海", "unit": "celsius"}

<minimax:tool_call>
<invoke name="get_weather">
<parameter name="location">上海</parameter>
<parameter name="unit">celsius</parameter>
</invoke>
</minimax:tool_call>

<minimax:tool_call>
<invoke name="search_web">
<parameter name="query_list">["OpenAI 最新发布"]</parameter>
</invoke>
<invoke name="search_web">
<parameter name="query_list">["Gemini 最新发布"]</parameter>
</invoke>
</minimax:tool_call>

from transformers import AutoTokenizer
import requests
import json
tokenizer = AutoTokenizer.from_pretrained("MiniMaxAI/MiniMax-M2.1")
# 定义工具
tools = [{
    "name": "get_current_weather",
    "description": "获取指定城市的最新天气",
    "parameters": {
        "type": "object",
        "properties": {
            "location": {
                "type": "string",
                "description": "城市名称，如北京、上海"
            }
        },
        "required": ["location"]
    }
}]
# 构造消息
messages = [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "上海今天天气怎么样？"},
]
# 应用 chat template，传入工具定义
text = tokenizer.apply_chat_template(
    messages,
    tokenize=False,
    add_generation_prompt=True,
    tools=tools
)
# 发送请求到推理服务
payload = {
    "model": "MiniMaxAI/MiniMax-M2.1",
    "prompt": text,
    "max_tokens": 4096
}
response = requests.post(
    "http://localhost:8000/v1/completions",
    headers={"Content-Type": "application/json"},
    json=payload
)
# 获取原始输出并解析
raw_output = response.json()["choices"][0]["text"]
tool_calls = parse_tool_calls(raw_output, tools)  # 使用下方的解析函数

import re
import json
from typing import Any, Optional, List, Dict
def extract_name(name_str: str) -> str:
    """从引号字符串中提取名称"""
    name_str = name_str.strip()
    if (name_str.startswith('"') and name_str.endswith('"')) or \
       (name_str.startswith("'") and name_str.endswith("'")):
        return name_str[1:-1]
    return name_str
def convert_param_value(value: str, param_type: str) -> Any:
    """根据参数类型转换参数值"""
    if value.lower() == "null":
        return None
    param_type = param_type.lower()
    if param_type in ["string", "str", "text"]:
        return value
    elif param_type in ["integer", "int"]:
        try: return int(value)
        except: return value
    elif param_type in ["number", "float"]:
        try:
            val = float(value)
            return val if val != int(val) else int(val)
        except: return value
    elif param_type in ["boolean", "bool"]:
        return value.lower() in ["true", "1"]
    elif param_type in ["object", "array"]:
        try: return json.loads(value)
        except: return value
    else:
        try: return json.loads(value)
        except: return value
def parse_tool_calls(
    model_output: str,
    tools: Optional[List[Dict]] = None
) -> List[Dict]:
    """
    从模型输出中提取所有工具调用
    返回: [{"name": "func_name", "arguments": {...}}, ...]
    """
    if "<minimax:tool_call>" not in model_output:
        return []
    tool_calls = []
    try:
        tc_regex = re.compile(
            r"<minimax:tool_call>(.*?)</minimax:tool_call>", re.DOTALL)
        inv_regex = re.compile(r"<invoke name=(.*?)</invoke>", re.DOTALL)
        param_regex = re.compile(
            r"<parameter name=(.*?)</parameter>", re.DOTALL)
        for tc_match in tc_regex.findall(model_output):
            for inv_match in inv_regex.findall(tc_match):
                name_match = re.search(r'^([^>]+)', inv_match)
                if not name_match:
                    continue
                func_name = extract_name(name_match.group(1))
                # 查找参数类型配置
                param_config = {}
                if tools:
                    for tool in tools:
                        tn = tool.get("name") or \
                             tool.get("function", {}).get("name")
                        if tn == func_name:
                            params = tool.get("parameters") or \
                                     tool.get("function", {}).get("parameters")
                            if isinstance(params, dict):
                                param_config = params.get("properties", {})
                            break
                param_dict = {}
                for match in param_regex.findall(inv_match):
                    pm = re.search(r'^([^>]+)>(.*)', match, re.DOTALL)
                    if pm:
                        pname = extract_name(pm.group(1))
                        pvalue = pm.group(2).strip()
                        ptype = "string"
                        if pname in param_config and \
                           isinstance(param_config[pname], dict):
                            ptype = param_config[pname].get("type", "string")
                        param_dict[pname] = convert_param_value(pvalue, ptype)
                tool_calls.append({
                    "name": func_name, "arguments": param_dict
                })
    except Exception as e:
        print(f"解析工具调用失败: {e}")
        return []
    return tool_calls

# 构造工具执行结果
tool_result = {
    "role": "tool",
    "content": [{
        "name": "get_current_weather",
        "type": "text",
        "text": json.dumps({
            "location": "上海",
            "temperature": "28",
            "unit": "celsius",
            "weather": "多云"
        }, ensure_ascii=False)
    }]
}
# 将结果加入对话历史，继续对话
messages.append({"role": "assistant", "content": raw_output})
messages.append(tool_result)
# 再次调用模型，获取最终回答
# ...

temperature = 1.0
top_p = 0.95
top_k = 40

You are a helpful assistant. Your name is MiniMax-M2.5 and is built by MiniMax.

请先分析需求，给出系统架构设计和模块拆分方案，然后再开始编写代码。
要求覆盖：数据模型设计、API 接口定义、错误处理策略、测试方案。