update REDME and guides

README.md

@@ -29,8 +29,8 @@ license: apache-2.0
   <a href="https://www.minimax.io" target="_blank" style="margin: 2px;">
     <img alt="Homepage" src="https://img.shields.io/badge/_Homepage-MiniMax-FF4040?style=flat-square&labelColor=2C3E50&logo=data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIiB2aWV3Qm94PSIwIDAgNDkwLjE2IDQxMS43Ij48ZGVmcz48c3R5bGU+LmNscy0xe2ZpbGw6I2ZmZjt9PC9zdHlsZT48L2RlZnM+PHBhdGggY2xhc3M9ImNscy0xIiBkPSJNMjMzLjQ1LDQwLjgxYTE3LjU1LDE3LjU1LDAsMSwwLTM1LjEsMFYzMzEuNTZhNDAuODIsNDAuODIsMCwwLDEtODEuNjMsMFYxNDVhMTcuNTUsMTcuNTUsMCwxLDAtMzUuMDksMHY3OS4wNmE0MC44Miw0MC44MiwwLDAsMS04MS42MywwVjE5NS40MmExMS42MywxMS42MywwLDAsMSwyMy4yNiwwdjI4LjY2YTE3LjU1LDE3LjU1LDAsMCwwLDM1LjEsMFYxNDVBNDAuODIsNDAuODIsMCwwLDEsMTQwLDE0NVYzMzEuNTZhMTcuNTUsMTcuNTUsMCwwLDAsMzUuMSwwVjIxNy41aDBWNDAuODFhNDAuODEsNDAuODEsMCwxLDEsODEuNjIsMFYyODEuNTZhMTEuNjMsMTEuNjMsMCwxLDEtMjMuMjYsMFptMjE1LjksNjMuNEE0MC44Niw0MC44NiwwLDAsMCw0MDguNTMsMTQ1VjMwMC44NWExNy41NSwxNy41NSwwLDAsMS0zNS4wOSwwdi0yNjBhNDAuODIsNDAuODIsMCwwLDAtODEuNjMsMFYzNzAuODlhMTcuNTUsMTcuNTUsMCwwLDEtMzUuMSwwVjMzMGExMS42MywxMS42MywwLDEsMC0yMy4yNiwwdjQwLjg2YTQwLjgxLDQwLjgxLDAsMCwwLDgxLjYyLDBWNDAuODFhMTcuNTUsMTcuNTUsMCwwLDEsMzUuMSwwdjI2MGE0MC44Miw0MC44MiwwLDAsMCw4MS42MywwVjE0NWExNy41NSwxNy41NSwwLDEsMSwzNS4xLDBWMjgxLjU2YTExLjYzLDExLjYzLDAsMCwwLDIzLjI2LDBWMTQ1QTQwLjg1LDQwLjg1LDAsMCwwLDQ0OS4zNSwxMDQuMjFaIi8+PC9zdmc+&logoWidth=20" style="display: inline-block; vertical-align: middle;"/>
   </a>
-  <a href="https://chat.minimax.io/" target="_blank" style="margin: 2px;">
-    <img alt="Chat" src="https://img.shields.io/badge/_MiniMax_Chat-FF4040?style=flat-square&labelColor=2C3E50&logo=data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIiB2aWV3Qm94PSIwIDAgNDkwLjE2IDQxMS43Ij48ZGVmcz48c3R5bGU+LmNscy0xe2ZpbGw6I2ZmZjt9PC9zdHlsZT48L2RlZnM+PHBhdGggY2xhc3M9ImNscy0xIiBkPSJNMjMzLjQ1LDQwLjgxYTE3LjU1LDE3LjU1LDAsMSwwLTM1LjEsMFYzMzEuNTZhNDAuODIsNDAuODIsMCwwLDEtODEuNjMsMFYxNDVhMTcuNTUsMTcuNTUsMCwxLDAtMzUuMDksMHY3OS4wNmE0MC44Miw0MC44MiwwLDAsMS04MS42MywwVjE5NS40MmExMS42MywxMS42MywwLDAsMSwyMy4yNiwwdjI4LjY2YTE3LjU1LDE3LjU1LDAsMCwwLDM1LjEsMFYxNDVBNDAuODIsNDAuODIsMCwwLDEsMTQwLDE0NVYzMzEuNTZhMTcuNTUsMTcuNTUsMCwwLDAsMzUuMSwwVjIxNy41aDBWNDAuODFhNDAuODEsNDAuODEsMCwxLDEsODEuNjIsMFYyODEuNTZhMTEuNjMsMTEuNjMsMCwxLDEtMjMuMjYsMFptMjE1LjksNjMuNEE0MC44Niw0MC44NiwwLDAsMCw0MDguNTMsMTQ1VjMwMC44NWExNy41NSwxNy41NSwwLDAsMS0zNS4wOSwwdi0yNjBhNDAuODIsNDAuODIsMCwwLDAtODEuNjMsMFYzNzAuODlhMTcuNTUsMTcuNTUsMCwwLDEtMzUuMSwwVjMzMGExMS42MywxMS42MywwLDEsMC0yMy4yNiwwdjQwLjg2YTQwLjgxLDQwLjgxLDAsMCwwLDgxLjYyLDBWNDAuODFhMTcuNTUsMTcuNTUsMCwwLDEsMzUuMSwwdjI2MGE0MC44Miw0MC44MiwwLDAsMCw4MS42MywwVjE0NWExNy41NSwxNy41NSwwLDEsMSwzNS4xLDBWMjgxLjU2YTExLjYzLDExLjYzLDAsMCwwLDIzLjI2LDBWMTQ1QTQwLjg1LDQwLjg1LDAsMCwwLDQ0OS4zNSwxMDQuMjFaIi8+PC9zdmc+&logoWidth=20" style="display: inline-block; vertical-align: middle;"/>
+  <a href="https://agent.minimax.io/" target="_blank" style="margin: 2px;">
+    <img alt="Agent" src="https://img.shields.io/badge/_MiniMax_Agent-FF4040?style=flat-square&labelColor=2C3E50&logo=data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIiB2aWV3Qm94PSIwIDAgNDkwLjE2IDQxMS43Ij48ZGVmcz48c3R5bGU+LmNscy0xe2ZpbGw6I2ZmZjt9PC9zdHlsZT48L2RlZnM+PHBhdGggY2xhc3M9ImNscy0xIiBkPSJNMjMzLjQ1LDQwLjgxYTE3LjU1LDE3LjU1LDAsMSwwLTM1LjEsMFYzMzEuNTZhNDAuODIsNDAuODIsMCwwLDEtODEuNjMsMFYxNDVhMTcuNTUsMTcuNTUsMCwxLDAtMzUuMDksMHY3OS4wNmE0MC44Miw0MC44MiwwLDAsMS04MS42MywwVjE5NS40MmExMS42MywxMS42MywwLDAsMSwyMy4yNiwwdjI4LjY2YTE3LjU1LDE3LjU1LDAsMCwwLDM1LjEsMFYxNDVBNDAuODIsNDAuODIsMCwwLDEsMTQwLDE0NVYzMzEuNTZhMTcuNTUsMTcuNTUsMCwwLDAsMzUuMSwwVjIxNy41aDBWNDAuODFhNDAuODEsNDAuODEsMCwxLDEsODEuNjIsMFYyODEuNTZhMTEuNjMsMTEuNjMsMCwxLDEtMjMuMjYsMFptMjE1LjksNjMuNEE0MC44Niw0MC44NiwwLDAsMCw0MDguNTMsMTQ1VjMwMC44NWExNy41NSwxNy41NSwwLDAsMS0zNS4wOSwwdi0yNjBhNDAuODIsNDAuODIsMCwwLDAtODEuNjMsMFYzNzAuODlhMTcuNTUsMTcuNTUsMCwwLDEtMzUuMSwwVjMzMGExMS42MywxMS42MywwLDEsMC0yMy4yNiwwdjQwLjg2YTQwLjgxLDQwLjgxLDAsMCwwLDgxLjYyLDBWNDAuODFhMTcuNTUsMTcuNTUsMCwwLDEsMzUuMSwwdjI2MGE0MC44Miw0MC44MiwwLDAsMCw4MS42MywwVjE0NWExNy41NSwxNy41NSwwLDEsMSwzNS4xLDBWMjgxLjU2YTExLjYzLDExLjYzLDAsMCwwLDIzLjI2LDBWMTQ1QTQwLjg1LDQwLjg1LDAsMCwwLDQ0OS4zNSwxMDQuMjFaIi8+PC9zdmc+&logoWidth=20" style="display: inline-block; vertical-align: middle;"/>
   </a>
   <a href="https://www.minimax.io/platform" style="margin: 2px;">
     <img alt="API" src="https://img.shields.io/badge/⚡_API-Platform-FF4040?style=flat-square&labelColor=2C3E50" style="display: inline-block; vertical-align: middle;"/>
@@ -59,7 +59,8 @@ license: apache-2.0
 
 # Meet MiniMax-M2
 
-Today, we release (and open source?) MiniMax-M2, a **Mini** model built for **Max** coding & agentic workflows.
+Today, we release and open source MiniMax-M2, a **Mini** model built for **Max** coding & agentic workflows.
+
 **MiniMax-M2** redefines efficiency for agents. It's a compact, fast, and cost-effective model built for elite performance in coding and agentic tasks, all while maintaining powerful general intelligence. With just 10 billion activated parameters, MiniMax-M2 provides the sophisticated, end-to-end tool use performance expected from today's leading models, but in a streamlined form factor that makes deployment and scaling easier than ever.
 
 <p align="center">
@@ -77,7 +78,7 @@ Today, we release (and open source?) MiniMax-M2, a **Mini** model built for **Ma
 
 **Agent Performance**. MiniMax-M2 plans and executes complex, long-horizon toolchains across shell, browser, retrieval, and code runners. In BrowseComp-style evaluations, it consistently locates hard-to-surface sources, maintains evidence traceable, and gracefully recovers from flaky steps.
 
-**Efficient Design**. With 10 billion activated parameters (200 billion in total), MiniMax-M2 delivers lower latency, lower cost, and higher throughput for interactive agents and batched sampling—perfectly aligned with the shift toward highly deployable models that still shine on coding and agentic tasks.
+**Efficient Design**. With 10 billion activated parameters (230 billion in total), MiniMax-M2 delivers lower latency, lower cost, and higher throughput for interactive agents and batched sampling—perfectly aligned with the shift toward highly deployable models that still shine on coding and agentic tasks.
 
 ---
 
@@ -104,7 +105,7 @@ These comprehensive evaluations test real-world end-to-end coding and agentic to
 >Notes: Data points marked with an asterisk (*) are taken directly from the model's official tech report or blog. All other metrics were obtained using the evaluation methods described below.
 >- SWE-bench Verified:  We use the same scaffold as [R2E-Gym](https://arxiv.org/pdf/2504.07164) (Jain et al. 2025) on top of OpenHands to test with agents on SWE tasks. All scores are validated on our internal infrastructure with 128k context length, 100 max steps, and no test-time scaling. All git-related content is removed to ensure agent sees only the code at the issue point. 
 >- Multi-SWE-Bench & SWE-bench Multilingual: All scores are averaged across 8 runs using the [claude-code](https://github.com/anthropics/claude-code) CLI (300 max steps) as the evaluation scaffold.
->- Terminal-Bench: All scores are evaluated with the official claude-code from the original [Terminal-Bench](https://www.tbench.ai/) repository(commit 94bf692), averaged over 8 runs to report the mean pass rate.
+>- Terminal-Bench: All scores are evaluated with the official claude-code from the original [Terminal-Bench](https://www.tbench.ai/) repository(commit `94bf692`), averaged over 8 runs to report the mean pass rate.
 >- ArtifactsBench: All Scores are computed by averaging three runs with the official implementation of [ArtifactsBench](https://github.com/Tencent-Hunyuan/ArtifactsBenchmark), using the stable Gemini-2.5-Pro as the judge model.
 >- BrowseComp & BrowseComp-zh & GAIA (text only) & xbench-DeepSearch: All scores reported use the same agent framework as [WebExplorer](https://arxiv.org/pdf/2509.06501) (Liu et al. 2025), with minor tools description adjustment. We use the 103-sample text-only GAIA validation subset following [WebExplorer](https://arxiv.org/pdf/2509.06501) (Liu et al. 2025).
 >- HLE (w/ tools): All reported scores are obtained using search tools and a Python tool. The search tools employ the same agent framework as [WebExplorer](https://arxiv.org/pdf/2509.06501) (Liu et al. 2025), and the Python tool runs in a Jupyter environment.
@@ -138,7 +139,7 @@ We align with **Artificial Analysis**, which aggregates challenging benchmarks u
 
 ## Why activation size matters
 
-Keeping activations at **10B** compresses the critical path of agentic workflow - plan → act → verify - so loops feel responsive and cheaper to run:
+By maintaining activations around **10B** , the plan → act → verify loop in the agentic workflow is streamlined, improving responsiveness and reducing compute overhead:
 
 - **Faster feedback cycles** in compile-run-test and browse-retrieve-cite chains.
 
@@ -156,8 +157,30 @@ We look forward to your feedback and to collaborating with developers and resear
 
 ## How to Use
 
-- **MiniMax Agent**: Our general agent product, built on MiniMax-M2, is now publicly available and free for a limited time: https://agent.minimax.io/
+- Our product **MiniMax Agent**, built on MiniMax-M2, is now **publicly available and free** for a limited time: https://agent.minimaxi.io/
+
+- The MiniMax-M2 API is now live on the **MiniMax Open Platform** and is **free** for a limited time: https://platform.minimax.io/docs/guides/text-generation
+
+- The MiniMax-M2 model weights are now **open-source**, allowing for local deployment and use: https://huggingface.co/MiniMaxAI/MiniMax-M2. 
+
+## Local Deployment Guide
+
+Download the model from HuggingFace repository: https://huggingface.co/MiniMaxAI/MiniMax-M2
+
+### vLLM
+
+We recommend using [vLLM](https://docs.vllm.ai/en/latest/) to serve MiniMax-M2. vLLM provides efficient day-0 support of MiniMax-M2 model, check https://docs.vllm.ai/projects/recipes/en/latest/MiniMax/MiniMax-M2.html for latest deployment guide. We also provide our [vLLM Deployment Guide](https://huggingface.co/MiniMaxAI/MiniMax-M2/blob/main/docs/vllm_deploy_guide.md).
+
+### SGLang
+We recommend using [SGLang](https://docs.sglang.ai/) to serve MiniMax-M2. Please refer to our [SGLang Deployment Guide](https://huggingface.co/MiniMaxAI/MiniMax-M2/blob/main/docs/sglang_deploy_guide.md).
+
+### Inference Parameters
+We recommend using the following parameters for best performance: `temperature=1.0`, `top_p = 0.95`, `top_k = 20`.
+
+## Tool Calling Guide
+
+Please refer to our [Tool Calling Guide](https://huggingface.co/MiniMaxAI/MiniMax-M2/blob/main/docs/tool_calling_guide.md).
 
-- **MiniMax Open Platform**: https://www.minimax.io/
+# Contact Us
 
-- **MiniMax-M2 Model Weights**: The open-source model weights are available on Hugging Face: https://huggingface.co/MiniMaxAI/ . vLLM provides efficient day-0 support of MiniMax-M2 model, check https://docs.vllm.ai/projects/recipes/en/latest/ for latest deployment guide.
+Contact us at [model@minimax.io](mailto:model@minimax.io).

docs/sglang_deploy_guide.md

@@ -0,0 +1,98 @@
+# MiniMax M2 Model SGLang Deployment Guide
+
+We recommend using [SGLang](https://github.com/sgl-project/sglang) to deploy the [MiniMax-M2](https://huggingface.co/MiniMaxAI/MiniMax-M2) model. SGLang is a high-performance inference engine with excellent serving throughput, efficient and intelligent memory management, powerful batch request processing capabilities, and deeply optimized underlying performance. We recommend reviewing SGLang's official documentation to check hardware compatibility before deployment.
+
+## Applicable Models
+
+This document applies to the following models. You only need to change the model name during deployment.
+
+- [MiniMaxAI/MiniMax-M2](https://huggingface.co/MiniMaxAI/MiniMax-M2)
+
+The deployment process is illustrated below using MiniMax-M2 as an example.
+
+## System Requirements
+
+- OS: Linux
+
+- Python: 3.9 - 3.12
+
+- GPU:
+
+  - compute capability 7.0 or higher
+
+  - Memory requirements: 220 GB for weights, 240 GB per 1M context tokens
+
+The following are recommended configurations; actual requirements should be adjusted based on your use case:
+
+- 4x 96GB GPUs: Supported context length of up to 400K tokens.
+
+- 8x 144GB GPUs: Supported context length of up to 3M tokens.
+
+## Deployment with Python
+
+It is recommended to use a virtual environment (such as **venv**, **conda**, or **uv**) to avoid dependency conflicts. 
+
+We recommend installing SGLang in a fresh Python environment. Since it has not been released yet, you need to manually build it from the source code:
+
+```bash
+git clone https://github.com/sgl-project/sglang.git
+cd sglang
+uv pip install ./python --torch-backend=auto
+```
+
+Run the following command to start the SGLang server. SGLang will automatically download and cache the MiniMax-M2 model from Hugging Face.
+
+8-GPU deployment command:
+
+```bash
+python -m sglang.launch_server \
+    --model-path MiniMaxAI/MiniMax-M2 \
+    --tp-size 8 \
+    --ep-size 8 \
+    --tool-call-parser minimax-m2 \
+    --reasoning-parser minimax \
+    --trust-remote-code \
+    --port 8000 \
+    --mem-fraction-static 0.7
+```
+
+## Testing Deployment
+
+After startup, you can test the vLLM OpenAI-compatible API with the following command:
+
+```bash
+curl http://localhost:8000/v1/chat/completions \
+    -H "Content-Type: application/json" \
+    -d '{
+        "model": "MiniMaxAI/MiniMax-M2",
+        "messages": [
+            {"role": "system", "content": [{"type": "text", "text": "You are a helpful assistant."}]},
+            {"role": "user", "content": [{"type": "text", "text": "Who won the world series in 2020?"}]}
+        ]
+    }'
+```
+
+## Common Issues
+
+### Hugging Face Network Issues
+
+If you encounter network issues, you can set up a proxy before pulling the model.
+
+```bash
+export HF_ENDPOINT=https://hf-mirror.com
+```
+
+### MiniMax-M2 model is not currently supported
+
+This vLLM version is outdated. Please upgrade to the latest version.
+
+## Getting Support
+
+If you encounter any issues while deploying the MiniMax model:
+
+- Contact our technical support team through official channels such as email at [api@minimaxi.com](mailto:api@minimaxi.com)
+
+- Submit an issue on our [GitHub](https://github.com/MiniMax-AI) repository
+
+We continuously optimize the deployment experience for our models. Feedback is welcome!
+

docs/sglang_deploy_guide_cn.md

@@ -0,0 +1,95 @@
+# MiniMax M2 模型 SGLang 部署指南
+
+我们推荐使用 [SGLang](https://github.com/sgl-project/sglang) 来部署 [MiniMax-M2](https://huggingface.co/MiniMaxAI/MiniMax-M2) 模型。vLLM 是一个高性能的推理引擎，其具有卓越的服务吞吐、高效智能的内存管理机制、强大的批量请求处理能力、深度优化的底层性能等特性。我们建议在部署之前查看 SGLang 的官方文档以检查硬件兼容性。
+
+## 本文档适用模型
+
+本文档适用以下模型，只需在部署时修改模型名称即可。
+
+- [MiniMaxAI/MiniMax-M2](https://huggingface.co/MiniMaxAI/MiniMax-M2)
+
+以下以 MiniMax-M2 为例说明部署流程。
+
+## 环境要求
+
+- OS：Linux
+
+- Python：3.9 - 3.12
+
+- GPU：
+
+  - compute capability 7.0 or higher
+
+  - 显存需求：权重需要 220 GB，每 1M 上下文 token 需要 240 GB
+
+以下为推荐配置，实际需求请根据业务场景调整：
+
+- 96G x4 GPU：支持 40 万 token 的总上下文。
+
+- 144G x8 GPU：支持长达 300 万 token 的总上下文。
+
+## 使用 Python 部署
+
+建议使用虚拟环境（如 **venv**、**conda**、**uv**）以避免依赖冲突。
+
+建议在全新的 Python 环境中安装 SGLang。由于尚未 release，需要从源码手动编译：
+```bash
+git clone https://github.com/sgl-project/sglang.git
+cd sglang
+uv pip install ./python --torch-backend=auto
+```
+
+运行如下命令启动 SGLang 服务器，SGLang 会自动从 Huggingface 下载并缓存 MiniMax-M2 模型。
+
+8 卡部署命令：
+
+```bash
+python -m sglang.launch_server \
+    --model-path MiniMaxAI/MiniMax-M2 \
+    --tp-size 8 \
+    --ep-size 8 \
+    --tool-call-parser minimax-m2 \
+    --reasoning-parser minimax \
+    --trust-remote-code \
+    --port 8000 \
+    --mem-fraction-static 0.7
+```
+
+## 测试部署
+
+启动后，可以通过如下命令测试 SGLang OpenAI 兼容接口：
+
+```bash
+curl http://localhost:8000/v1/chat/completions \
+    -H "Content-Type: application/json" \
+    -d '{
+        "model": "MiniMaxAI/MiniMax-M2",
+        "messages": [
+            {"role": "system", "content": [{"type": "text", "text": "You are a helpful assistant."}]},
+            {"role": "user", "content": [{"type": "text", "text": "Who won the world series in 2020?"}]}
+        ]
+    }'
+```
+
+## 常见问题
+
+### Huggingface 网络问题
+
+如果遇到网络问题，可以设置代理后再进行拉取。
+
+```bash
+export HF_ENDPOINT=https://hf-mirror.com
+```
+
+### MiniMax-M2 model is not currently supported
+
+该 vLLM 版本过旧，请升级到最新版本。
+
+## 获取支持
+
+如果在部署 MiniMax 模型过程中遇到任何问题：
+
+- 通过邮箱 [api@minimaxi.com](mailto:api@minimaxi.com) 等官方渠道联系我们的技术支持团队
+
+- 在我们的 [GitHub](https://github.com/MiniMax-AI) 仓库提交 Issue
+我们会持续优化模型的部署体验，欢迎反馈！

docs/{function_call_guide.md → tool_calling_guide.md}

@@ -1,12 +1,12 @@
-# MiniMax-M2 Function Call Guide
+# MiniMax-M2 Tool Calling Guide
 
 ## Introduction
 
-The MiniMax-M2 model supports function calling capabilities, enabling the model to identify when external functions need to be called and output function call parameters in a structured format. This document provides detailed instructions on how to use the function calling features of MiniMax-M2.
+The MiniMax-M2 model supports tool calling capabilities, enabling the model to identify when external tools need to be called and output tool call parameters in a structured format. This document provides detailed instructions on how to use the tool calling features of MiniMax-M2.
 
 ## Basic Example
 
-The following Python script implements a weather query function call example based on the OpenAI SDK:
+The following Python script implements a weather query tool call example based on the OpenAI SDK:
 
 ```python
 from openai import OpenAI
@@ -59,7 +59,7 @@ Result: Getting the weather for San Francisco, CA in celsius...
 
 ## Manually Parsing Model Output
 
-If you cannot use the built-in parser of inference engines that support MiniMax-M2, or need to use other inference frameworks (such as transformers, TGI, etc.), you can manually parse the model's raw output using the following method. This approach requires you to parse the XML tag format of the model output yourself.
+**We strongly recommend using vLLM or SGLang for parsing tool calls.** If you cannot use the built-in parser of inference engines (e.g., vLLM and SGLang) that support MiniMax-M2, or need to use other inference frameworks (such as transformers, TGI, etc.), you can manually parse the model's raw output using the following method. This approach requires you to parse the XML tag format of the model output yourself.
 
 ### Example Using Transformers
 
@@ -125,14 +125,14 @@ raw_output = response.json()["choices"][0]["text"]
 print("Raw output:", raw_output)
 
 # Use the parsing function below to process the output
-function_calls = parse_tool_calls(raw_output, tools)
+tool_calls = parse_tool_calls(raw_output, tools)
 ```
 
-## 🛠️ Function Call Definition
+## 🛠️ Tool Call Definition
 
-### Function Structure
+### Tool Structure
 
-Function calls need to define the `tools` field in the request body. Each function consists of the following parts:
+Tool calls need to define the `tools` field in the request body. Each tool consists of the following parts:
 
 ```json
 {
@@ -171,7 +171,7 @@ Function calls need to define the `tools` field in the request body. Each functi
 
 ### Internal Processing Format
 
-When processing within the MiniMax-M2 model, function definitions are converted to a special format and concatenated to the input text. Here is a complete example:
+When processing within the MiniMax-M2 model, tool definitions are converted to a special format and concatenated to the input text. Here is a complete example:
 
 ```
 ]~!b[]~b]system
@@ -209,7 +209,7 @@ When were the latest announcements from OpenAI and Gemini?[e~[
 - `]~b]tool`: Tool result message start marker
 - `<tools>...</tools>`: Tool definition area, each tool is wrapped with `<tool>` tag, content is JSON Schema
 - `<minimax:tool_call>...</minimax:tool_call>`: Tool call area
-- `<think>`: Thinking process marker during generation (optional)
+- `<think>...</think>`: Thinking process marker during generation
 
 ### Model Output Format
 
@@ -228,11 +228,11 @@ MiniMax-M2 uses structured XML tag format:
 </minimax:tool_call>
 ```
 
-Each function call uses the `<invoke name="function_name">` tag, and parameters use the `<parameter name="parameter_name">` tag wrapper.
+Each tool call uses the `<invoke name="function_name">` tag, and parameters use the `<parameter name="parameter_name">` tag wrapper.
 
-## Manually Parsing Function Call Results
+## Manually Parsing Tool Call Results
 
-### Parsing Function Calls
+### Parsing Tool Calls
 
 MiniMax-M2 uses structured XML tags, which require a different parsing approach. The core function is as follows:
 
@@ -427,9 +427,9 @@ for call in tool_calls:
     #         Arguments: {'location': 'San Francisco', 'unit': 'celsius'}
 ```
 
-### Executing Function Calls
+### Executing Tool Calls
 
-After parsing is complete, you can execute the corresponding function and construct the return result:
+After parsing is complete, you can execute the corresponding tool and construct the return result:
 
 ```python
 def execute_function_call(function_name: str, arguments: dict):
@@ -471,12 +471,13 @@ def execute_function_call(function_name: str, arguments: dict):
     return None
 ```
 
-### Returning Function Execution Results to the Model
+### Returning Tool Execution Results to the Model
 
-After successfully parsing function calls, you should add the function execution results to the conversation history so that the model can access and utilize this information in subsequent interactions. Refer to chat_template.jinja for concatenation format.
+After successfully parsing tool calls, you should add the tool execution results to the conversation history so that the model can access and utilize this information in subsequent interactions. Refer to [chat_template.jinja](https://huggingface.co/MiniMaxAI/MiniMax-M2/blob/main/chat_template.jinja) for concatenation format.
 
 ## References
 
 - [MiniMax-M2 Model Repository](https://github.com/MiniMax-AI/MiniMax-M2)
 - [vLLM Project Homepage](https://github.com/vllm-project/vllm)
-- [OpenAI Python SDK](https://github.com/openai/openai-python)
+- [SGLang Project Homepage](https://github.com/sgl-project/sglang)
+- [OpenAI Python SDK](https://github.com/openai/openai-python)

docs/{function_call_guide_cn.md → tool_calling_guide_cn.md}

@@ -1,12 +1,12 @@
-# MiniMax-M2 函数调用（Function Call）功能指南
+# MiniMax-M2 工具调用指南
 
 ## 简介
 
-MiniMax-M2 模型支持函数调用功能，使模型能够识别何时需要调用外部函数，并以结构化格式输出函数调用参数。本文档详细介绍了如何使用 MiniMax-M2 的函数调用功能。
+MiniMax-M2 模型支持工具调用功能，使模型能够识别何时需要调用外部工具，并以结构化格式输出工具调用参数。本文档提供了有关如何使用 MiniMax-M2 工具调用功能的详细说明。
 
 ## 基础示例
 
-以下 Python 脚本基于 OpenAI SDK 实现了一个天气查询函数的调用示例：
+以下 Python 脚本基于 OpenAI SDK 实现了一个天气查询工具调用示例：
 
 ```python
 from openai import OpenAI
@@ -59,11 +59,11 @@ Result: Getting the weather for San Francisco, CA in celsius...
 
 ## 手动解析模型输出
 
-如果您无法使用已支持 MiniMax-M2 的推理引擎的内置解析器，或者需要使用其他推理框架（如 transformers、TGI 等），可以使用以下方法手动解析模型的原始输出。这种方法需要您自己解析模型输出的 XML 标签格式。
+**我们强烈建议使用 vLLM 或 SGLnag 来解析工具调用。** 如果您无法使用支持 MiniMax-M2 的推理引擎（如 vLLM 和 SGLang）的内置解析器，或需要使用其他推理框架（如 transformers、TGI 等），您可以使用以下方法手动解析模型的原始输出。这种方法需要您自己解析模型输出的 XML 标签格式。
 
 ### 使用 Transformers 的示例
 
-以下是使用 transformers 库的完整示例：
+这是一个使用 transformers 库的完整示例：
 
 ```python
 from transformers import AutoTokenizer
@@ -87,7 +87,7 @@ def get_default_tools():
         }
     ]
 
-# 加载模型和分词器
+# Load model and tokenizer
 tokenizer = AutoTokenizer.from_pretrained(model_id)
 prompt = "What's the weather like in Shanghai today?"
 messages = [
@@ -95,10 +95,10 @@ messages = [
     {"role": "user", "content": prompt},
 ]
 
-# 启用函数调用工具
+# Enable function calling tools
 tools = get_default_tools()
 
-# 应用聊天模板，并加入工具定义
+# Apply chat template and include tool definitions
 text = tokenizer.apply_chat_template(
     messages,
     tokenize=False,
@@ -106,7 +106,7 @@ text = tokenizer.apply_chat_template(
     tools=tools
 )
 
-# 发送请求（这里使用任何推理服务）
+# Send request (using any inference service)
 import requests
 payload = {
     "model": "MiniMaxAI/MiniMax-M2",
@@ -120,35 +120,35 @@ response = requests.post(
     stream=False,
 )
 
-# 模型输出需要手动解析
+# Model output needs manual parsing
 raw_output = response.json()["choices"][0]["text"]
-print("原始输出:", raw_output)
+print("Raw output:", raw_output)
 
-# 使用下面的解析函数处理输出
-function_calls = parse_tool_calls(raw_output, tools)
+# Use the parsing function below to process the output
+tool_calls = parse_tool_calls(raw_output, tools)
 ```
 
-## 🛠️ 函数调用的定义
+## 🛠️ 工具调用定义
 
-### 函数结构体
+### 工具结构
 
-函数调用需要在请求体中定义 `tools` 字段，每个函数由以下部分组成：
+工具调用需要在请求体中定义 `tools` 字段。每个工具由以下部分组成：
 
 ```json
 {
   "tools": [
     {
       "name": "search_web",
-      "description": "搜索函数。",
+      "description": "Search function.",
       "parameters": {
         "properties": {
           "query_list": {
-            "description": "进行搜索的关键词，列表元素个数为1。",
+            "description": "Keywords for search, list should contain 1 element.",
             "items": { "type": "string" },
             "type": "array"
           },
           "query_tag": {
-            "description": "query的分类",
+            "description": "Category of query",
             "items": { "type": "string" },
             "type": "array"
           }
@@ -162,16 +162,16 @@ function_calls = parse_tool_calls(raw_output, tools)
 ```
 
 **字段说明：**
-- `name`: 函数名称
-- `description`: 函数功能描述
-- `parameters`: 函数参数定义
-  - `properties`: 参数属性定义，key 是参数名，value 包含参数的详细描述
-  - `required`: 必填参数列表
-  - `type`: 参数类型（通常为 "object"）
+- `name`：函数名称
+- `description`：函数描述
+- `parameters`：函数参数定义
+  - `properties`：参数属性定义，其中键是参数名称，值包含详细的参数描述
+  - `required`：必需参数列表
+  - `type`：参数类型（通常为 "object"）
 
-### 模型内部处理格式
+### 内部处理格式
 
-在 MiniMax-M2 模型内部处理时，函数定义会被转换为特殊格式并拼接到输入文本中。以下是一个完整的示例：
+在 MiniMax-M2 模型内部处理时，工具定义会被转换为特殊格式并连接到输入文本中。以下是一个完整示例：
 
 ```
 ]~!b[]~b]system
@@ -182,7 +182,7 @@ You may call one or more tools to assist with the user query.
 Here are the tools available in JSONSchema format:
 
 <tools>
-<tool>{"name": "search_web", "description": "搜索函数。", "parameters": {"type": "object", "properties": {"query_list": {"type": "array", "items": {"type": "string"}, "description": "进行搜索的关键词，列表元素个数为1。"}, "query_tag": {"type": "array", "items": {"type": "string"}, "description": "query的分类"}}, "required": ["query_list", "query_tag"]}}</tool>
+<tool>{"name": "search_web", "description": "Search function.", "parameters": {"type": "object", "properties": {"query_list": {"type": "array", "items": {"type": "string"}, "description": "Keywords for search, list should contain 1 element."}, "query_tag": {"type": "array", "items": {"type": "string"}, "description": "Category of query"}}, "required": ["query_list", "query_tag"]}}</tool>
 </tools>
 
 When making tool calls, use XML format to invoke tools and pass parameters:
@@ -195,25 +195,25 @@ When making tool calls, use XML format to invoke tools and pass parameters:
 </invoke>
 [e~[
 ]~b]user
-OpenAI 和 Gemini 的最近一次发布会都是什么时候?[e~[
+When were the latest announcements from OpenAI and Gemini?[e~[
 ]~b]ai
 <think>
 ```
 
 **格式说明：**
 
-- `]~!b[]~b]system`: System 消息开始标记
-- `[e~[`: 消息结束标记
-- `]~b]user`: User 消息开始标记
-- `]~b]ai`: Assistant 消息开始标记
-- `]~b]tool`: Tool 结果消息开始标记
-- `<tools>...</tools>`: 工具定义区域，每个工具用 `<tool>` 标签包裹，内容为 JSON Schema
-- `<minimax:tool_call>...</minimax:tool_call>`: 工具调用区域
-- `<think>`: 生成时的思考过程标记（可选）
+- `]~!b[]~b]system`：系统消息开始标记
+- `[e~[`：消息结束标记
+- `]~b]user`：用户消息开始标记
+- `]~b]ai`：助手消息开始标记
+- `]~b]tool`：工具结果消息开始标记
+- `<tools>...</tools>`：工具定义区域，每个工具都用 `<tool>` 标签包装，内容为 JSON Schema
+- `<minimax:tool_call>...</minimax:tool_call>`：工具调用区域
+- `<think>...</think>`：生成过程中的思考过程标记
 
 ### 模型输出格式
 
-MiniMax-M2使用结构化的 XML 标签格式：
+MiniMax-M2 使用结构化的 XML 标签格式：
 
 ```xml
 <minimax:tool_call>
@@ -228,13 +228,13 @@ MiniMax-M2使用结构化的 XML 标签格式：
 </minimax:tool_call>
 ```
 
-每个函数调用使用 `<invoke name="函数名">` 标签，参数使用 `<parameter name="参数名">` 标签包裹。
+每个工具调用使用 `<invoke name="function_name">` 标签，参数使用 `<parameter name="parameter_name">` 标签包装。
 
-## 手动解析函数调用结果
+## 手动解析工具调用结果
 
-### 解析函数调用
+### 解析工具调用
 
-MiniMax-M2使用结构化的 XML 标签，需要不同的解析方式。核心函数如下：
+MiniMax-M2 使用结构化的 XML 标签，这需要一种不同的解析方法。核心函数如下：
 
 ```python
 import re
@@ -243,7 +243,7 @@ from typing import Any, Optional, List, Dict
 
 
 def extract_name(name_str: str) -> str:
-    """从引号包裹的字符串中提取名称"""
+    """Extract name from quoted string"""
     name_str = name_str.strip()
     if name_str.startswith('"') and name_str.endswith('"'):
         return name_str[1:-1]
@@ -253,7 +253,7 @@ def extract_name(name_str: str) -> str:
 
 
 def convert_param_value(value: str, param_type: str) -> Any:
-    """根据参数类型转换参数值"""
+    """Convert parameter value based on parameter type"""
     if value.lower() == "null":
         return None
         
@@ -280,7 +280,7 @@ def convert_param_value(value: str, param_type: str) -> Any:
         except json.JSONDecodeError:
             return value
     else:
-        # 尝试 JSON 解析，失败则返回字符串
+        # Try JSON parsing, return string if failed
         try:
             return json.loads(value)
         except json.JSONDecodeError:
@@ -289,16 +289,16 @@ def convert_param_value(value: str, param_type: str) -> Any:
 
 def parse_tool_calls(model_output: str, tools: Optional[List[Dict]] = None) -> List[Dict]:
     """
-    从模型输出中提取所有工具调用
+    Extract all tool calls from model output
     
     Args:
-        model_output: 模型的完整输出文本
-        tools: 工具定义列表，用于获取参数类型信息，格式可以是：
+        model_output: Complete output text from the model
+        tools: Tool definition list for getting parameter type information, format can be:
                - [{"name": "...", "parameters": {...}}]
                - [{"type": "function", "function": {"name": "...", "parameters": {...}}}]
     
     Returns:
-        解析后的工具调用列表，每个元素包含 name 和 arguments 字段
+        Parsed tool call list, each element contains name and arguments fields
     
     Example:
         >>> tools = [{
@@ -321,30 +321,30 @@ def parse_tool_calls(model_output: str, tools: Optional[List[Dict]] = None) -> L
         >>> print(result)
         [{'name': 'get_weather', 'arguments': {'location': 'San Francisco', 'unit': 'celsius'}}]
     """
-    # 快速检查是否包含工具调用标记
+    # Quick check if tool call marker is present
     if "<minimax:tool_call>" not in model_output:
         return []
     
     tool_calls = []
     
     try:
-        # 匹配所有 <minimax:tool_call> 块
+        # Match all <minimax:tool_call> blocks
         tool_call_regex = re.compile(r"<minimax:tool_call>(.*?)</minimax:tool_call>", re.DOTALL)
         invoke_regex = re.compile(r"<invoke name=(.*?)</invoke>", re.DOTALL)
         parameter_regex = re.compile(r"<parameter name=(.*?)</parameter>", re.DOTALL)
         
-        # 遍历所有 tool_call 块
+        # Iterate through all tool_call blocks
         for tool_call_match in tool_call_regex.findall(model_output):
-            # 遍历该块中的所有 invoke
+            # Iterate through all invokes in this block
             for invoke_match in invoke_regex.findall(tool_call_match):
-                # 提取函数名
+                # Extract function name
                 name_match = re.search(r'^([^>]+)', invoke_match)
                 if not name_match:
                     continue
                 
                 function_name = extract_name(name_match.group(1))
                 
-                # 获取参数配置
+                # Get parameter configuration
                 param_config = {}
                 if tools:
                     for tool in tools:
@@ -355,7 +355,7 @@ def parse_tool_calls(model_output: str, tools: Optional[List[Dict]] = None) -> L
                                 param_config = params["properties"]
                             break
                 
-                # 提取参数
+                # Extract parameters
                 param_dict = {}
                 for match in parameter_regex.findall(invoke_match):
                     param_match = re.search(r'^([^>]+)>(.*)', match, re.DOTALL)
@@ -363,13 +363,13 @@ def parse_tool_calls(model_output: str, tools: Optional[List[Dict]] = None) -> L
                         param_name = extract_name(param_match.group(1))
                         param_value = param_match.group(2).strip()
                         
-                        # 去除首尾的换行符
+                        # Remove leading and trailing newlines
                         if param_value.startswith('\n'):
                             param_value = param_value[1:]
                         if param_value.endswith('\n'):
                             param_value = param_value[:-1]
                         
-                        # 获取参数类型并转换
+                        # Get parameter type and convert
                         param_type = "string"
                         if param_name in param_config:
                             if isinstance(param_config[param_name], dict) and "type" in param_config[param_name]:
@@ -383,7 +383,7 @@ def parse_tool_calls(model_output: str, tools: Optional[List[Dict]] = None) -> L
                 })
     
     except Exception as e:
-        print(f"解析工具调用失败: {e}")
+        print(f"Failed to parse tool calls: {e}")
         return []
     
     return tool_calls
@@ -392,7 +392,7 @@ def parse_tool_calls(model_output: str, tools: Optional[List[Dict]] = None) -> L
 **使用示例：**
 
 ```python
-# 定义工具
+# Define tools
 tools = [
     {
         "name": "get_weather",
@@ -407,8 +407,8 @@ tools = [
     }
 ]
 
-# 模型输出
-model_output = """我来帮你查询天气。
+# Model output
+model_output = """Let me help you query the weather.
 <minimax:tool_call>
 <invoke name="get_weather">
 <parameter name="location">San Francisco</parameter>
@@ -416,28 +416,28 @@ model_output = """我来帮你查询天气。
 </invoke>
 </minimax:tool_call>"""
 
-# 解析工具调用
+# Parse tool calls
 tool_calls = parse_tool_calls(model_output, tools)
 
-# 输出结果
+# Output results
 for call in tool_calls:
-    print(f"调用函数: {call['name']}")
-    print(f"参数: {call['arguments']}")
-    # 输出: 调用函数: get_weather
-    #      参数: {'location': 'San Francisco', 'unit': 'celsius'}
+    print(f"Function called: {call['name']}")
+    print(f"Arguments: {call['arguments']}")
+    # Output: Function called: get_weather
+    #         Arguments: {'location': 'San Francisco', 'unit': 'celsius'}
 ```
 
-### 执行函数调用
+### 执行工具调用
 
-解析完成后，您可以执行对应的函数并构建返回结果：
+完成解析后，您可以执行相应的工具并构造返回结果：
 
 ```python
 def execute_function_call(function_name: str, arguments: dict):
-    """执行函数调用并返回结果"""
+    """Execute function call and return result"""
     if function_name == "get_weather":
-        location = arguments.get("location", "未知位置")
+        location = arguments.get("location", "Unknown location")
         unit = arguments.get("unit", "celsius")
-        # 构建函数执行结果
+        # Build function execution result
         return {
             "role": "tool", 
             "content": [
@@ -448,7 +448,7 @@ def execute_function_call(function_name: str, arguments: dict):
                     "location": location, 
                     "temperature": "25", 
                     "unit": unit, 
-                    "weather": "晴朗"
+                    "weather": "Sunny"
                 }, ensure_ascii=False)
               }
             ] 
@@ -456,14 +456,14 @@ def execute_function_call(function_name: str, arguments: dict):
     elif function_name == "search_web":
         query_list = arguments.get("query_list", [])
         query_tag = arguments.get("query_tag", [])
-        # 模拟搜索结果
+        # Simulate search results
         return {
             "role": "tool",
             "content": [
               {
                 "name": function_name,
                 "type": "text",
-                "text": f"搜索关键词: {query_list}, 分类: {query_tag}\n搜索结果: 相关信息已找到"
+                "text": f"Search keywords: {query_list}, Category: {query_tag}\nSearch results: Relevant information found"
               }
             ]
           }
@@ -471,12 +471,13 @@ def execute_function_call(function_name: str, arguments: dict):
     return None
 ```
 
-### 将函数执行结果返回给模型
+### 将工具执行结果返回给模型
 
-成功解析函数调用后，您应将函数执行结果添加到对话历史中，以便模型在后续交互中能够访问和利用这些信息，拼接格式参考chat_template.jinja
+在成功解析工具调用后，您应该将工具执行结果添加到对话历史中，以便模型在后续交互中可以访问和利用这些信息。请参考 [chat_template.jinja](https://huggingface.co/MiniMaxAI/MiniMax-M2/blob/main/chat_template.jinja) 了解连接格式。
 
-## 参考资料
+## 参考文献
 
 - [MiniMax-M2 模型仓库](https://github.com/MiniMax-AI/MiniMax-M2)
 - [vLLM 项目主页](https://github.com/vllm-project/vllm)
+- [SGLang 项目主页](https://github.com/sgl-project/sglang)
 - [OpenAI Python SDK](https://github.com/openai/openai-python)

docs/vllm_deploy_guide.md

@@ -2,6 +2,14 @@
 
 We recommend using [vLLM](https://docs.vllm.ai/en/stable/) to deploy the [MiniMax-M2](https://huggingface.co/MiniMaxAI/MiniMax-M2) model. vLLM is a high-performance inference engine with excellent serving throughput, efficient and intelligent memory management, powerful batch request processing capabilities, and deeply optimized underlying performance. We recommend reviewing vLLM's official documentation to check hardware compatibility before deployment.
 
+## Applicable Models
+
+This document applies to the following models. You only need to change the model name during deployment.
+
+- [MiniMaxAI/MiniMax-M2](https://huggingface.co/MiniMaxAI/MiniMax-M2)
+
+The deployment process is illustrated below using MiniMax-M2 as an example.
+
 ## System Requirements
 
 - OS: Linux
@@ -12,38 +20,37 @@ We recommend using [vLLM](https://docs.vllm.ai/en/stable/) to deploy the [MiniMa
 
   - compute capability 7.0 or higher
 
-  - Memory requirements: 220 GB for weights, 60 GB per 1M context tokens
+  - Memory requirements: 220 GB for weights, 240 GB per 1M context tokens
 
 The following are recommended configurations; actual requirements should be adjusted based on your use case:
 
-- 4x 96GB GPUs: Supports context input of up to 400K tokens.
+- 4x 96GB GPUs: Supported context length of up to 400K tokens.
 
-- 8x 144GB GPUs: Supports context input of up to 3M tokens.
+- 8x 144GB GPUs: Supported context length of up to 3M tokens.
 
 ## Deployment with Python
 
-It is recommended to use a virtual environment (such as venv, conda, or uv) to avoid dependency conflicts. We recommend installing vLLM in a fresh Python environment:
+It is recommended to use a virtual environment (such as **venv**, **conda**, or **uv**) to avoid dependency conflicts. 
+
+We recommend installing vLLM in a fresh Python environment. Since it has not been released yet, you need to manually build it from the source code:
 
 ```bash
-# Not yet released, please install nightly build
-uv pip install -U vllm \
-    --torch-backend=auto \
-    --extra-index-url https://wheels.vllm.ai/nightly
-# If released, install using uv
-uv pip install "vllm" --torch-backend=auto
+git clone https://github.com/vllm-project/vllm.git
+cd vllm
+uv pip install . --torch-backend=auto
 ```
 
 Run the following command to start the vLLM server. vLLM will automatically download and cache the MiniMax-M2 model from Hugging Face.
 
-4-GPU deployment command:
+8-GPU deployment command:
 
 ```bash
-SAFETENSORS_FAST_GPU=1 VLLM_USE_V1=0 vllm serve \
-    --model MiniMaxAI/MiniMax-M2 \
-    --trust-remote-code \
-    --enable-expert-parallel --tensor-parallel-size 4 \
+SAFETENSORS_FAST_GPU=1 vllm serve \
+    MiniMaxAI/MiniMax-M2 --trust-remote-code \
+    --enable_expert_parallel --tensor-parallel-size 8 \
     --enable-auto-tool-choice --tool-call-parser minimax_m2 \
-    --reasoning-parser minimax_m2
+    --reasoning-parser minimax_m2_append_think \
+    --compilation-config "{\"cudagraph_mode\": \"PIECEWISE\"}"
 ```
 
 ## Testing Deployment
@@ -80,7 +87,7 @@ This vLLM version is outdated. Please upgrade to the latest version.
 
 If you encounter any issues while deploying the MiniMax model:
 
-- Contact our technical support team through official channels such as email at api@minimaxi.com
+- Contact our technical support team through official channels such as email at [api@minimaxi.com](mailto:api@minimaxi.com)
 
 - Submit an issue on our [GitHub](https://github.com/MiniMax-AI) repository
 

docs/vllm_deploy_guide_cn.md

@@ -2,6 +2,14 @@
 
 我们推荐使用 [vLLM](https://docs.vllm.ai/en/stable/) 来部署 [MiniMax-M2](https://huggingface.co/MiniMaxAI/MiniMax-M2) 模型。vLLM 是一个高性能的推理引擎，其具有卓越的服务吞吐、高效智能的内存管理机制、强大的批量请求处理能力、深度优化的底层性能等特性。我们建议在部署之前查看 vLLM 的官方文档以检查硬件兼容性。
 
+## 本文档适用模型
+
+本文档适用以下模型，只需在部署时修改模型名称即可。
+
+- [MiniMaxAI/MiniMax-M2](https://huggingface.co/MiniMaxAI/MiniMax-M2)
+
+以下以 MiniMax-M2 为例说明部署流程。
+
 ## 环境要求
 
 - OS：Linux
@@ -12,37 +20,36 @@
 
   - compute capability 7.0 or higher
 
-  - 显存需求：权重需要 220 GB，每 1M 上下文 token 需要 60 GB
+  - 显存需求：权重需要 220 GB，每 1M 上下文 token 需要 240 GB
 
 以下为推荐配置，实际需求请根据业务场景调整：
 
-- 96G x4 GPU：支持 40 万 token 的上下文输入。
+- 96G x4 GPU：支持 40 万 token 的总上下文。
 
-- 144G x8 GPU：支持长达 300 万 token 的上下文输入。
+- 144G x8 GPU：支持长达 300 万 token 的总上下文。
 
 ## 使用 Python 部署
 
-建议使用虚拟环境（如 venv、conda、uv）以避免依赖冲突。建议在全新的 Python 环境中安装 vLLM：
+建议使用虚拟环境（如 **venv**、**conda**、**uv**）以避免依赖冲突。
+
+建议在全新的 Python 环境中安装 vLLM。由于尚未 release，需要从源码手动编译：
 ```bash
-# 尚未 release，请安装 nightly 构建
-uv pip install -U vllm \
-    --torch-backend=auto \
-    --extra-index-url https://wheels.vllm.ai/nightly
-# 如果 release，使用 uv 安装
-uv pip install "vllm" --torch-backend=auto
+git clone https://github.com/vllm-project/vllm.git
+cd vllm
+uv pip install . --torch-backend=auto
 ```
 
 运行如下命令启动 vLLM 服务器，vLLM 会自动从 Huggingface 下载并缓存 MiniMax-M2 模型。
 
-4 卡部署命令：
+8 卡部署命令：
 
 ```bash
-SAFETENSORS_FAST_GPU=1 VLLM_USE_V1=0 vllm serve \
-    --model MiniMaxAI/MiniMax-M2 \
-    --trust-remote-code \
-    --enable-expert-parallel --tensor-parallel-size 4 \
+SAFETENSORS_FAST_GPU=1 vllm serve \
+    MiniMaxAI/MiniMax-M2 --trust-remote-code \
+    --enable_expert_parallel --tensor-parallel-size 8 \
     --enable-auto-tool-choice --tool-call-parser minimax_m2 \
-    --reasoning-parser minimax_m2
+    --reasoning-parser minimax_m2_append_think \
+    --compilation-config "{\"cudagraph_mode\": \"PIECEWISE\"}"
 ```
 
 ## 测试部署
@@ -79,7 +86,7 @@ export HF_ENDPOINT=https://hf-mirror.com
 
 如果在部署 MiniMax 模型过程中遇到任何问题：
 
-- 通过邮箱 api@minimaxi.com 等官方渠道联系我们的技术支持团队
+- 通过邮箱 [api@minimaxi.com](mailto:api@minimaxi.com) 等官方渠道联系我们的技术支持团队
 
 - 在我们的 [GitHub](https://github.com/MiniMax-AI) 仓库提交 Issue
 我们会持续优化模型的部署体验，欢迎反馈！