Initial commit

.gitattributes

@@ -0,0 +1,9 @@
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+*.bin         filter=lfs diff=lfs merge=lfs -text
+*.pt          filter=lfs diff=lfs merge=lfs -text
+*.onnx        filter=lfs diff=lfs merge=lfs -text
+tokenizer.json filter=lfs diff=lfs merge=lfs -text
+vibe_processed_by_imagy.png filter=lfs diff=lfs merge=lfs -text
+docs/Thrift.pdf filter=lfs diff=lfs merge=lfs -text
+docs/Progressive[[:space:]]Expert[[:space:]]Pruning[[:space:]]with[[:space:]]Teacher-Guided[[:space:]]Distillation[[:space:]]for[[:space:]]MoE[[:space:]]LLMs.pdf filter=lfs diff=lfs merge=lfs -text
+preview.png filter=lfs diff=lfs merge=lfs -text

LICENSE

@@ -0,0 +1 @@
+Apache-2.0

README.md

@@ -0,0 +1,333 @@
+---
+tags:
+- moe
+- minimax
+- bfloat16
+- sglang
+- gguf
+license: mit
+datasets:
+- nick007x/github-code-2025
+- tatsu-lab/alpaca
+base_model:
+- MiniMaxAI/MiniMax-M2
+---
+
+<p align="center">
+  <img src="logo.png" alt="Lemura Labs" width="110"/>
+</p>
+
+# lemuralabs/MiniMax-M2-Pruned-25 — Expert-Pruned for Inference and Fine-Tuning
+
+![Format](https://img.shields.io/badge/Format-Safetensors-0b7285?style=flat) ![Type](https://img.shields.io/badge/Type-Expert%20Pruned-862e9c?style=flat) ![License](https://img.shields.io/badge/License-mit-6c757d?style=flat)
+
+
+A performance-optimized variant of the base model that delivers faster responses and lower memory usage while preserving quality for everyday tasks, developed by Lemura Labs.
+
+## TLDR
+
+We, over-caffinated researchers at Lemura Labs wanted to create a 50% pruned version of the SOTA MiniMax M2 that is best suited for local/air-gapped coding. This version we achieved ~25%. A 50% pruned version is under development while a not so sucky team of ours is working on a 50% pruned version of Kimi K2 Thinking.We’re writing the paper and expanding the evaluation set to substantiate the results. Check back later, cheers!
+
+## Why it’s useful
+
+* **Lower latency:** Snappier responses for interactive apps and chatbots.
+* **Smaller memory footprint:** Runs on cheaper GPUs or with fewer resources per replica.
+* **Higher throughput:** Serve more concurrent users at the same cost.
+* **Deployment-friendly:** Drop-in replacement for the base model in most inference stacks.
+* **Adaptable:** Supports light fine-tuning to match your domain and style guidelines.
+
+## Intended use
+
+* General chat and coding assistance
+* Enterprise assistants with strict latency/VRAM budgets
+* Batch or realtime serving in cloud and on-prem environments
+* Edge or cost-sensitive deployments where efficiency matters
+
+## When to use it
+
+* You’re constrained by GPU memory or need shorter response times
+* You want to increase QPS without scaling infrastructure
+* You need a model that is “good enough” for most tasks at a better cost profile
+
+---
+
+# Model Comparison Report
+
+**Models Under Evaluation**
+
+| Model | Type |
+| :--------------------------- | :------------------- |
+| ModelCloud/MiniMax-M2-BF16 | Base Model |
+| lemuralabs/MiniMax-M2-Pruned-25 | Compressed/Optimized |
+
+**Evaluation Dates:** November 7–9, 2025
+
+## Results Comparison
+
+### 1) Multiple Choice Q&A (lm-eval)
+
+**Overall MMLU Performance**
+
+| Model | MMLU Overall | Humanities | STEM | Social Sciences | Other |
+| :----------------- | -----------: | ---------: | -----: | --------------: | -----: |
+| MiniMax-M2-BF16 | **83.16%** | 77.45% | 80.91% | **90.02%** | 87.29% |
+| MiniMax-M2-Pruned-25 | **77.72%** | 70.14% | 77.61% | 86.84% | 80.27% |
+| **Δ (Difference)** | **-5.44%** | -7.31% | -3.30% | -3.18% | -7.02% |
+
+**Individual Task Performance**
+
+| Task | BF16 (Base) | Pruned-25-BF16 | Difference |
+| :----------------------- | ----------: | ----------: | ------------: |
+| arc_challenge (acc_norm) | 73.21% | 61.01% | -12.20% |
+| arc_easy | 88.30% | 83.08% | -5.22% |
+| boolq | 87.95% | 84.95% | -3.00% |
+| hellaswag (acc_norm) | 83.00% | 77.09% | -5.91% |
+| mmlu | 83.16% | 77.72% | -5.44% |
+| openbookqa (acc_norm) | 48.60% | 43.00% | -5.60% |
+| rte | 75.45% | **80.14%** | **+4.69%** |
+| winogrande | 76.48% | 74.90% | -1.58% |
+
+**Average Accuracy Drop:** **-4.28%**
+
+### 2) Code Generation (EvalPlus)
+
+**MBPP Results (Python, 378 problems)**
+
+| Model | MBPP (base) | MBPP+ (extended) | Average |
+| :----------------- | ----------: | ---------------: | --------: |
+| MiniMax-M2-BF16 | **73.8%** | **64.0%** | 68.9% |
+| MiniMax-M2-Pruned-25 | **70.1%** | **60.1%** | 65.1% |
+| **Δ (Difference)** | **-3.7%** | **-3.9%** | **-3.8%** |
+
+**HumanEval Results (164 problems)**
+
+| Model | HumanEval (base) | HumanEval+ (extended) | Average |
+| :----------------- | ---------------: | --------------------: | --------: |
+| MiniMax-M2-BF16 | **72.6%** | **71.3%** | 72.0% |
+| MiniMax-M2-Pruned-25 | **65.2%** | **63.4%** | 64.3% |
+| **Δ (Difference)** | **-7.4%** | **-7.9%** | **-7.7%** |
+
+### 3) Math Benchmarks
+
+**GSM8K Results**
+
+| Model | Accuracy | Problems | Status |
+| :----------------- | ------------: | -------: | :------------------- |
+| MiniMax-M2-BF16 | **92.72%** | 1,319 | Yes — Complete |
+| MiniMax-M2-Pruned-25 | **93.25%** | 1,319 | Yes — Complete |
+| **Δ (Difference)** | **+0.53%** | - | **Pruned-25 Better!** |
+
+| Benchmark | MiniMax-M2-BF16 | MiniMax-M2-Pruned-25 | Change |
+|-----------|------|------------|--------|
+| **GSM8K** | 92.72% | 93.25% | **+0.53%** |
+| **MATH-500 (Levels 1-4)** | 91.25% | 90.75% | -0.5% (near-parity) |
+
+### 4) LiveCodeBench (Live Coding Problems)
+
+| Model | pass@1 | Problems | Status |
+| :-------------------- | ------------: | -------: | :------------------- |
+| **MiniMax-M2-BF16** | **35.71%** | 182 | Yes — Complete |
+| **MiniMax-M2-Pruned-25** | **36.81%** | 182 | Yes — Complete |
+| **Δ (Difference)** | **+1.10%** | - | **Pruned-25 Better!** |
+
+---
+
+## Analysis (Updated)
+
+**Highlights**
+
+* **Pruned-25 wins** on **GSM8K (+0.53%)** and **LiveCodeBench (+1.10%)**, and on **RTE (+4.69%)**.
+* **BF16 leads** on broad **MMLU**, **HumanEval**, **MBPP**, and tasks like **arc_challenge**.
+
+**Compression Trade-off**
+
+* Average knowledge-task drop for Pruned-25 is ~**4–5%**, with **math preserved or slightly improved**.
+
+**Subject Breakdown (MMLU)**
+
+| Category | BF16 (Base) | Pruned-25-BF16 | Difference | Status |
+| :--------------------- | ----------: | ----------: | ---------: | :---------------- |
+| High School Government | 97.93% | 94.82% | -3.11% | Yes — Still Excellent |
+| High School Psychology | 95.41% | 93.58% | -1.83% | Yes — Well Preserved |
+| Marketing | 95.73% | 91.88% | -3.85% | Yes — Good |
+| Professional Medicine | 92.28% | 79.78% | -12.50% | Notable Drop |
+| Clinical Knowledge | 92.83% | 85.66% | -7.17% | Moderate Drop |
+
+---
+
+## **sglang 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:
+
+```shell
+git clone -b v0.5.4.post1 https://github.com/sgl-project/sglang.git
+cd sglang
+
+# Install the python packages
+pip install --upgrade pip
+pip install -e "python"
+```
+
+Run the following command to start the SGLang server. SGLang will automatically download and cache the MiniMax-M2 model from Hugging Face.
+
+**4-GPU deployment command:**
+
+```shell
+python -m sglang.launch_server \
+  --model-path MiniMaxAI/MiniMax-M2 \
+  --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
+```
+
+**8-GPU deployment command:**
+
+```shell
+python -m sglang.launch_server \
+  --model-path MiniMaxAI/MiniMax-M2 \
+  --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
+```
+
+## **Testing Deployment**
+
+After startup, you can test the SGLang OpenAI-compatible API with the following command:
+
+```shell
+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?"}]}
+ ]
+ }'
+```
+
+## Benchmarks
+
+See the tables above for the latest **MMLU**, **MBPP**, **HumanEval**, **GSM8K**, **MATH-500**, and **LiveCodeBench** results (updated **November 9, 2025**).
+
+## Research paper
+
+Coming soon.
+
+---
+
+## License
+
+This model is derived from MiniMax-M2 and distributed under the MIT License [http://github.com/MiniMax-AI/MiniMax-M2/blob/main/LICENSE](http://github.com/MiniMax-AI/MiniMax-M2/blob/main/LICENSE)
+
+---
+
+## Credits
+
+Model conversion and HF Transformers code by @Qubitum at ModelCloud.
+
+## **References (BibTeX)**
+
+```
+@article{cai2025thinking,
+ title = {Thinking with DistilQwen: A Tale of Four Distilled Reasoning and Reward Model Series},
+ author = {Cai, Wenrui and Wang, Chengyu and Yan, Junbing and Huang, Jun and Fang, Xiangzhong},
+ journal = {arXiv preprint arXiv:2511.01354},
+ year = {2025},
+ eprinttype = {arXiv},
+ eprint = {2511.01354},
+ primaryclass = {cs.CL},
+ institution = {Shanghai Jiao Tong University and Alibaba Cloud Computing},
+ note = {License: arXiv.org perpetual non-exclusive license}
+}
+
+@misc{lasby-reap,
+ title = {{REAP the Experts: Why Pruning Prevails for One-Shot MoE compression}},
+ author = {Lasby, Mike and Lazarevich, Ivan and Sinnadurai, Nish and Lie, Sean and Ioannou, Yani and Thangarasa, Vithursan},
+ year = {2025},
+ publisher = {arXiv},
+ note = {arXiv:2510.13999v1 [cs]},
+ url = {https://arxiv.org/abs/2510.13999v1},
+}
+
+@article{yang2025wanda++,
+ title = {Wanda++: Pruning Large Language Models via Regional Gradients},
+ author = {Yang, Yifan and Zhen, Kai and Ganesh, Bhavana and Galstyan, Aram and Huybrechts, Goeric and Müller, Markus and Kübler, Jonas M. and Swaminathan, Rupak Vignesh and Mouchtaris, Athanasios and Bodapati, Sravan Babu and Susanj, Nathan and Zhang, Zheng and FitzGerald, Jack and Kumar, Abhishek},
+ journal = {arXiv preprint arXiv:2503.04992},
+ year = {2025},
+ eprinttype = {arXiv},
+ eprint = {2503.04992},
+ primaryclass = {cs.CL}
+}
+
+@article{li2025tyr,
+ title = {Týr-the-Pruner: Structural Pruning LLMs via Global Sparsity Distribution Optimization},
+ author = {Li, G. and Xu, Yixing and Li, Zeping and Liu, Ji and Yin, Xuanwu and Li, Dong and Barsoum, Emad},
+ journal = {arXiv preprint arXiv:2503.09657},
+ year = {2025},
+ eprinttype = {arXiv},
+ eprint = {2503.09657},
+ primaryclass = {cs.CL}
+}
+
+@article{xia2023sheared,
+ title = {Sheared LLaMA: Accelerating Language Model Pre-training via Structured Pruning},
+ author = {Xia, Mengzhou and Gao, Tianyu and Zeng, Zhiyuan and Chen, Danqi},
+ journal = {arXiv preprint arXiv:2310.06694},
+ year = {2023},
+ eprinttype = {arXiv},
+ eprint = {2310.06694},
+ primaryclass = {cs.CL}
+}
+
+@article{ma2023llmpruner,
+ title = {LLM-Pruner: On the Structural Pruning of Large Language Models},
+ author = {Ma, Xinyin and Fang, Gongfan and Wang, Xinchao},
+ journal = {arXiv preprint arXiv:2305.11627},
+ year = {2023},
+ eprinttype = {arXiv},
+ eprint = {2305.11627},
+ primaryclass = {cs.CL}
+}
+
+@article{yang2023wanda,
+ title = {Wanda: Pruning by Weights and Activation-based Discriminant Analysis},
+ author = {Yang, Yifan and Ganesh, Bhavana and Galstyan, Aram and Huybrechts, Goeric and Müller, Markus and Kübler, Jonas M. and Swaminathan, Rupak Vignesh and Mouchtaris, Athanasios and Bodapati, Sravan Babu and Zhang, Zheng and FitzGerald, Jack and Kumar, Abhishek},
+ journal = {arXiv preprint arXiv:2306.11695},
+ year = {2023},
+ eprinttype = {arXiv},
+ eprint = {2306.11695},
+ primaryclass = {cs.CL}
+}
+
+@article{frantar2023sparsegpt,
+ title = {SparseGPT: Massive Language Models Can Be Accurately Pruned in One-Shot},
+ author = {Frantar, Elias and Alistarh, Dan},
+ journal = {arXiv preprint arXiv:2301.00774},
+ year = {2023},
+ eprinttype = {arXiv},
+ eprint = {2301.00774},
+ primaryclass = {cs.CL}
+}
+
+@article{dettmers2023qlora,
+ title = {QLoRA: Efficient Finetuning of Quantized LLMs},
+ author = {Dettmers, Tim and Pagnoni, Artidoro and Holtzman, Ari and Zettlemoyer, Luke},
+ journal = {arXiv preprint arXiv:2307.02973},
+ year = {2023},
+ eprinttype = {arXiv},
+ eprint = {2307.02973},
+ primaryclass = {cs.CL}
+}
+```

added_tokens.json

@@ -0,0 +1,56 @@
+{
+  "</minimax:tool_call>": 200053,
+  "</think>": 200051,
+  "<add_file>": 200036,
+  "<code_context>": 200043,
+  "<code_interpreter>": 200023,
+  "<commit_after>": 200018,
+  "<commit_before>": 200016,
+  "<commit_message>": 200040,
+  "<commit_msg>": 200017,
+  "<delete_file>": 200037,
+  "<edit_file>": 200039,
+  "<empty_output>": 200015,
+  "<empty_source_file>": 200041,
+  "<file_content>": 200044,
+  "<file_sep>": 200049,
+  "<filename>": 200006,
+  "<filepath>": 200048,
+  "<fim_middle>": 200002,
+  "<fim_pad>": 200004,
+  "<fim_prefix>": 200001,
+  "<fim_suffix>": 200003,
+  "<function_call>": 200022,
+  "<gh_stars>": 200007,
+  "<issue_closed>": 200010,
+  "<issue_comment>": 200009,
+  "<issue_start>": 200008,
+  "<jupyter_code>": 200013,
+  "<jupyter_error>": 200035,
+  "<jupyter_output>": 200014,
+  "<jupyter_start>": 200011,
+  "<jupyter_text>": 200012,
+  "<minimax:tool_call>": 200052,
+  "<pr_start>": 200046,
+  "<rename_file>": 200038,
+  "<repo_struct>": 200042,
+  "<reponame>": 200005,
+  "<review_comment>": 200047,
+  "<source_files>": 200045,
+  "<think>": 200050,
+  "[e~[": 200020,
+  "]!d~[": 200021,
+  "]!p~[": 200000,
+  "]<]end of image[>[": 200030,
+  "]<]end of speech[>[": 200028,
+  "]<]end of video[>[": 200032,
+  "]<]image[>[": 200025,
+  "]<]speech[>[": 200024,
+  "]<]start of image[>[": 200029,
+  "]<]start of speech[>[": 200027,
+  "]<]start of video[>[": 200031,
+  "]<]video[>[": 200026,
+  "]<]vision pad[>[": 200033,
+  "]~!b[": 200034,
+  "]~b]": 200019
+}

chat_template.jinja

@@ -0,0 +1,159 @@
+{# ----------‑‑‑ special token variables ‑‑‑---------- #}
+{%- set toolcall_begin_token   = '<minimax:tool_call>'         -%}
+{%- set toolcall_end_token     = '</minimax:tool_call>'        -%}
+{#- Tool Rendering Functions ============================================== -#}
+{%- macro render_tool_namespace(namespace_name, tool_list) -%}
+{%- for tool in tool_list -%}
+<tool>{{ tool.function | tojson(ensure_ascii=False) }}</tool>
+{% endfor -%}
+{%- endmacro -%}
+{%- macro visible_text(content) -%}
+    {%- if content is string -%}
+        {{ content }}
+    {%- elif content is iterable and content is not mapping -%}
+        {%- for item in content -%}
+            {%- if item is mapping and item.type == 'text' -%}
+                {{- item.text }}
+            {%- elif item is string -%}
+                {{- item }}
+            {%- endif -%}
+        {%- endfor -%}
+    {%- else -%}
+        {{- content }}
+    {%- endif -%}
+{%- endmacro -%}
+{#- System Message Construction ============================================ -#}
+{%- macro build_system_message(system_message) -%}
+    {%- if system_message and system_message.content -%}
+        {{- visible_text(system_message.content) }}
+    {%- else -%}
+        {%- if model_identity is not defined -%}
+            {%- set model_identity = "You are a helpful assistant." -%}
+        {%- endif -%}
+        {{- model_identity }}
+    {%- endif -%}
+    
+    {#- Handle current_date -#}
+    {%- if system_message and system_message.current_date -%}
+        {{- '\n' ~ 'Current date: ' + system_message.current_date }}
+    {%- endif -%}
+    {#- Handle current_location -#}
+    {%- if system_message and system_message.current_location -%}
+        {{- '\n' ~ 'Current location: ' + system_message.current_location }}
+    {%- endif -%}
+{%- endmacro -%}
+{#- Main Template Logic ================================================= -#}
+{#- Extract system message (only first message if it's system) -#}
+{%- set system_message = none -%}
+{%- set conversation_messages = messages -%}
+{%- if messages and messages[0].role == "system" -%}
+    {%- set system_message = messages[0] -%}
+    {%- set conversation_messages = messages[1:] -%}
+{%- endif -%}
+{#- Get the last user message turn, for interleved thinking -#}
+{%- set ns = namespace(last_user_index=-1) %}
+{% for m in conversation_messages %}
+    {%- if m.role == 'user' %}
+        {% set ns.last_user_index = loop.index0 -%}
+    {%- endif %}
+{%- endfor %}
+{#- Render system message -#}
+{{- ']~!b[' ~ ']~b]system' ~ '\n' }}
+{{- build_system_message(system_message) }}
+{#- Render tools if available -#}
+{%- if tools -%}
+    {{- '\n\n' ~ '# Tools' ~ '\n' ~ 'You may call one or more tools to assist with the user query.\nHere are the tools available in JSONSchema format:' ~ '\n' }}
+    {{- '\n' ~ '<tools>' ~ '\n' }}
+    {{- render_tool_namespace("functions", tools) }}
+    {{- '</tools>' ~ '\n\n' }}
+{{- 'When making tool calls, use XML format to invoke tools and pass parameters:' ~ '\n' }}
+{{- '\n' ~ toolcall_begin_token }}
+<invoke name="tool-name-1">
+<parameter name="param-key-1">param-value-1</parameter>
+<parameter name="param-key-2">param-value-2</parameter>
+...
+</invoke>
+{{- '\n' ~ toolcall_end_token }}
+{%- endif -%}
+{{- '[e~[\n' }}
+
+{#- Render messages -#}
+{%- set last_tool_call = namespace(name=none) -%}
+{%- for message in conversation_messages -%}
+    {%- if message.role == 'assistant' -%}
+        {#- Only render reasoning_content if no user message follows -#}
+        {{- ']~b]ai' ~ '\n' }}
+
+        {%- set reasoning_content = '' %}
+        {%- set content = visible_text(message.content) %}
+        {%- if message.reasoning_content is string %}
+            {%- set reasoning_content = message.reasoning_content %}
+        {%- else %}
+            {%- if '</think>' in content %}
+                {%- set reasoning_content = content.split('</think>')[0].strip('\n').split('<think>')[-1].strip('\n') %}
+                {%- set content = content.split('</think>')[-1].strip('\n') %}
+            {%- endif %}
+        {%- endif %}
+        {%- if reasoning_content and loop.index0 > ns.last_user_index -%}
+            {{- '<think>' ~ '\n' ~ reasoning_content ~ '\n' ~ '</think>' ~ '\n\n' }}
+        {%- endif -%}
+        {%- if content -%}
+            {{- content }}
+        {%- endif -%}
+        {%- if message.tool_calls -%}
+            {{- '\n' ~ toolcall_begin_token ~ '\n' }}
+
+            {%- for tool_call in message.tool_calls -%}
+                {%- if tool_call.function %}
+                    {%- set tool_call = tool_call.function %}
+                {%- endif %}
+                {{- '<invoke name="' + tool_call.name + '">' }}
+                {% set _args = tool_call.arguments %}
+                {%- for k, v in _args.items() %}
+                {{- '<parameter name="' + k + '">' }}
+                {{- v | tojson(ensure_ascii=False) if v is not string else v }}
+                {{- '</parameter>' }}
+                {% endfor %}
+                {{- '</invoke>' ~ '\n' }}
+            {%- endfor -%}
+            
+            {{- toolcall_end_token}}
+            {%- set last_tool_call.name = message.tool_calls[-1].name -%}
+        {%- else -%}
+            {%- set last_tool_call.name = none -%}
+        {%- endif -%}
+        {{- '[e~[' ~ '\n' }}
+        
+    {%- elif message.role == 'tool' -%}
+    {%- if last_tool_call.name is none -%}
+        {{- raise_exception("Message has tool role, but there was no previous assistant message with a tool call!") }}
+    {%- endif -%}
+    {%- if loop.first or (conversation_messages[loop.index0 - 1].role != 'tool') -%}
+        {{- ']~b]tool' }}
+    {%- endif -%}
+    {%- if message.content is string -%}
+        {{- '\n<response>' }}
+        {{- message.content }}
+        {{- '</response>' }}
+    {%- else -%}
+        {%- for tr in message.content -%}
+            {{- '\n<response>' }}
+            {{- tr.output if tr.output is defined else (tr.text if tr.type == 'text' and tr.text is defined else tr) }}
+            {{- '\n</response>' }}
+        {%- endfor -%}
+    {%- endif -%}
+    {%- if loop.last or (conversation_messages[loop.index0 + 1].role != 'tool') -%}
+        {{- '[e~[\n' -}}
+    {%- endif -%}
+        
+    {%- elif message.role == 'user' -%}
+        {{- ']~b]user' ~ '\n' }}
+        {{- visible_text(message.content) }}
+        {{- '[e~[' ~ '\n' }}
+    {%- endif -%}
+{%- endfor -%}
+
+{#- Generation prompt -#}
+{%- if add_generation_prompt -%}
+{{- ']~b]ai' ~ '\n' ~ '<think>' ~ '\n' }}
+{%- endif -%}

config.json

@@ -0,0 +1,120 @@
+{
+  "architectures": [
+    "MiniMaxM2ForCausalLM"
+  ],
+  "attention_dropout": 0.0,
+  "attn_type_list": [
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1
+  ],
+  "attn_window_size": null,
+  "auto_map": {
+    "AutoConfig": "configuration_minimax_m2.MiniMaxM2Config",
+    "AutoModelForCausalLM": "modeling_minimax_m2.MiniMaxM2ForCausalLM"
+  },
+  "head_dim": 128,
+  "hidden_act": "silu",
+  "hidden_size": 3072,
+  "initializer_range": 0.02,
+  "intermediate_size": 1536,
+  "layernorm_full_attention_beta": 1.0,
+  "layernorm_linear_attention_beta": 1.0,
+  "layernorm_mlp_beta": 1.0,
+  "max_model_len": null,
+  "max_position_embeddings": 196608,
+  "mlp_intermediate_size": 8192,
+  "model_type": "minimax",
+  "mtp_transformer_layers": 1,
+  "num_attention_heads": 48,
+  "num_expert_group": null,
+  "num_experts_per_tok": 8,
+  "num_hidden_layers": 62,
+  "num_key_value_heads": 8,
+  "num_local_experts": 192,
+  "num_mtp_modules": 3,
+  "output_router_logits": false,
+  "partial_rotary_factor": 0.5,
+  "qk_norm_type": "per_layer",
+  "rms_norm_eps": 1e-06,
+  "rope_scaling": null,
+  "rope_theta": 5000000,
+  "rotary_dim": 64,
+  "routed_scaling_factor": 1.0,
+  "router_aux_loss_coef": 0.001,
+  "router_jitter_noise": 0.0,
+  "scoring_func": "sigmoid",
+  "shared_intermediate_size": 0,
+  "shared_moe_mode": "sigmoid",
+  "sliding_window": null,
+  "swa_rope_theta": -1.0,
+  "tie_word_embeddings": false,
+  "topk_group": null,
+  "torch_dtype": "bfloat16",
+  "transformers_version": "4.55.0",
+  "use_cache": false,
+  "use_grouped_topk": true,
+  "use_mtp": true,
+  "use_qk_norm": true,
+  "use_routing_bias": true,
+  "vocab_size": 200064
+}

configuration_minimax_m2.py

@@ -0,0 +1,131 @@
+# SPDX-FileCopyrightText: 2024-2025 ModelCloud.ai
+# SPDX-FileCopyrightText: 2024-2025 qubitium@modelcloud.ai
+# SPDX-License-Identifier: Apache-2.0
+# Contact: qubitium@modelcloud.ai, x.com/qubitium
+
+"""Configuration for the MiniMax M2 architecture."""
+
+from __future__ import annotations
+
+from typing import List, Optional, Union
+
+from transformers.configuration_utils import PretrainedConfig
+
+
+class MiniMaxM2Config(PretrainedConfig):
+    model_type = "minimax"
+
+    def __init__(
+        self,
+        vocab_size: int = 200_064,
+        hidden_size: int = 3_072,
+        intermediate_size: int = 1_536,
+        mlp_intermediate_size: int = 8_192,
+        num_hidden_layers: int = 62,
+        num_attention_heads: int = 48,
+        num_key_value_heads: int = 8,
+        head_dim: Optional[int] = 128,
+        num_local_experts: int = 256,
+        num_experts_per_tok: int = 8,
+        attn_type_list: Optional[List[int]] = None,
+        attention_dropout: float = 0.0,
+        hidden_act: str = "silu",
+        rms_norm_eps: float = 1e-6,
+        max_position_embeddings: int = 196_608,
+        rope_theta: float = 5_000_000.0,
+        rotary_dim: int = 64,
+        rope_scaling: Optional[dict] = None,
+        use_qk_norm: bool = True,
+        qk_norm_type: str = "per_layer",
+        use_routing_bias: bool = True,
+        scoring_func: str = "sigmoid",
+        router_aux_loss_coef: float = 0.001,
+        router_jitter_noise: float = 0.0,
+        output_router_logits: bool = False,
+        use_grouped_topk: bool = True,
+        num_expert_group: Optional[int] = None,
+        topk_group: Optional[int] = None,
+        routed_scaling_factor: float = 1.0,
+        layernorm_full_attention_beta: float = 1.0,
+        layernorm_linear_attention_beta: float = 1.0,
+        layernorm_mlp_beta: float = 1.0,
+        shared_intermediate_size: int = 0,
+        shared_moe_mode: str = "sigmoid",
+        use_mtp: bool = True,
+        num_mtp_modules: int = 3,
+        mtp_transformer_layers: int = 1,
+        attn_window_size: Optional[Union[int, List[int]]] = None,
+        swa_rope_theta: float = -1.0,
+        sliding_window: Optional[int] = None,
+        initializer_range: float = 0.02,
+        tie_word_embeddings: bool = False,
+        max_model_len: Optional[int] = None,
+        bos_token_id: Optional[int] = None,
+        eos_token_id: Optional[int] = None,
+        pad_token_id: Optional[int] = None,
+        use_cache: bool = True,
+        **kwargs,
+    ) -> None:
+        quantization_config = kwargs.pop("quantization_config", None)
+        transformers_version = kwargs.pop("transformers_version", None)
+
+        super().__init__(
+            bos_token_id=bos_token_id,
+            eos_token_id=eos_token_id,
+            tie_word_embeddings=tie_word_embeddings,
+            pad_token_id=pad_token_id,
+            **kwargs,
+        )
+
+        self.vocab_size = vocab_size
+        self.hidden_size = hidden_size
+        self.intermediate_size = intermediate_size
+        self.mlp_intermediate_size = mlp_intermediate_size
+        self.num_hidden_layers = num_hidden_layers
+        self.num_attention_heads = num_attention_heads
+        self.num_key_value_heads = num_key_value_heads
+        self.head_dim = head_dim or hidden_size // num_attention_heads
+        self.num_local_experts = num_local_experts
+        self.num_experts_per_tok = num_experts_per_tok
+        self.attn_type_list = attn_type_list or [1] * num_hidden_layers
+        self.attention_dropout = attention_dropout
+        self.hidden_act = hidden_act
+        self.rms_norm_eps = rms_norm_eps
+        self.max_position_embeddings = max_position_embeddings
+        self.rope_theta = rope_theta
+        self.rotary_dim = rotary_dim
+        self.rope_scaling = rope_scaling
+        self.use_qk_norm = use_qk_norm
+        self.qk_norm_type = qk_norm_type
+        self.use_routing_bias = use_routing_bias
+        self.scoring_func = scoring_func
+        self.router_aux_loss_coef = router_aux_loss_coef
+        self.router_jitter_noise = router_jitter_noise
+        self.output_router_logits = output_router_logits
+        self.use_grouped_topk = use_grouped_topk
+        self.num_expert_group = num_expert_group
+        self.topk_group = topk_group
+        self.routed_scaling_factor = routed_scaling_factor
+        self.layernorm_full_attention_beta = layernorm_full_attention_beta
+        self.layernorm_linear_attention_beta = layernorm_linear_attention_beta
+        self.layernorm_mlp_beta = layernorm_mlp_beta
+        self.shared_intermediate_size = shared_intermediate_size
+        self.shared_moe_mode = shared_moe_mode
+        self.use_mtp = use_mtp
+        self.num_mtp_modules = num_mtp_modules
+        self.mtp_transformer_layers = mtp_transformer_layers
+        self.attn_window_size = attn_window_size
+        self.swa_rope_theta = swa_rope_theta
+        self.sliding_window = sliding_window
+        self.initializer_range = initializer_range
+        self.max_model_len = max_model_len
+        self.use_cache = use_cache
+
+        # Convenient accessor used by rotary embedding helper
+        self.partial_rotary_factor = float(self.rotary_dim) / float(self.head_dim)
+        if quantization_config is not None:
+            self.quantization_config = quantization_config
+        self.transformers_version = transformers_version
+
+
+__all__ = ["MiniMaxM2Config"]

docs/MiniMax M2 Model SGLang Deployment Guide.md

@@ -0,0 +1,106 @@
+# 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:
+
+```shell
+git clone -b v0.5.4.post1 https://github.com/sgl-project/sglang.git
+cd sglang
+
+# Install the python packages
+pip install --upgrade pip
+pip install -e "python"
+```
+
+Run the following command to start the SGLang server. SGLang will automatically download and cache the MiniMax-M2 model from Hugging Face.
+
+4-GPU deployment command:
+
+```shell
+python -m sglang.launch_server \
+    --model-path MiniMaxAI/MiniMax-M2 \
+    --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
+```
+
+8-GPU deployment command:
+
+```shell
+python -m sglang.launch_server \
+    --model-path MiniMaxAI/MiniMax-M2 \
+    --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
+```
+
+## Testing Deployment
+
+After startup, you can test the SGLang OpenAI-compatible API with the following command:
+
+```shell
+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.
+
+```shell
+export HF_ENDPOINT=https://hf-mirror.com
+```
+
+### MiniMax-M2 model is not currently supported
+
+Please upgrade to the latest stable version, \>= v0.5.4.post3.
+

docs/Progressive Expert Pruning with Teacher-Guided Distillation for MoE LLMs.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fc929abde5d13d43bd9c7b894d52de6fc8c9f3fea20b13e9833c3a1bac1c3c0d
+size 194014

docs/tool_calling_guide.md

@@ -0,0 +1,484 @@
+# MiniMax-M2 Tool Calling Guide
+
+## Introduction
+
+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 tool call example based on the OpenAI SDK:
+
+```py
+from openai import OpenAI
+import json
+
+client = OpenAI(base_url="http://localhost:8000/v1", api_key="dummy")
+
+def get_weather(location: str, unit: str):
+    return f"Getting the weather for {location} in {unit}..."
+
+tool_functions = {"get_weather": get_weather}
+
+tools = [{
+    "type": "function",
+    "function": {
+        "name": "get_weather",
+        "description": "Get the current weather in a given location",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "location": {"type": "string", "description": "City and state, e.g., 'San Francisco, CA'"},
+                "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
+            },
+            "required": ["location", "unit"]
+        }
+    }
+}]
+
+response = client.chat.completions.create(
+    model=client.models.list().data[0].id,
+    messages=[{"role": "user", "content": "What's the weather like in San Francisco? use celsius."}],
+    tools=tools,
+    tool_choice="auto"
+)
+
+print(response)
+
+tool_call = response.choices[0].message.tool_calls[0].function
+print(f"Function called: {tool_call.name}")
+print(f"Arguments: {tool_call.arguments}")
+print(f"Result: {get_weather(**json.loads(tool_call.arguments))}")
+```
+
+**Output Example:**
+
+```
+Function called: get_weather
+Arguments: {"location": "San Francisco, CA", "unit": "celsius"}
+Result: Getting the weather for San Francisco, CA in celsius...
+```
+
+## Manually Parsing Model Output
+
+**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
+
+Here is a complete example using the transformers library:
+
+```py
+from transformers import AutoTokenizer
+
+def get_default_tools():
+    return [
+        {
+          "name": "get_current_weather",
+          "description": "Get the latest weather for a location",
+          "parameters": {
+              "type": "object", 
+              "properties": {
+                  "location": {
+                      "type": "string", 
+                      "description": "A certain city, such as Beijing, Shanghai"
+                  }
+              }, 
+          }
+          "required": ["location"],
+          "type": "object"
+        }
+    ]
+
+# Load model and tokenizer
+tokenizer = AutoTokenizer.from_pretrained(model_id)
+prompt = "What's the weather like in Shanghai today?"
+messages = [
+    {"role": "system", "content": "You are a helpful assistant."},
+    {"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,
+    add_generation_prompt=True,
+    tools=tools
+)
+
+# Send request (using any inference service)
+import requests
+payload = {
+    "model": "MiniMaxAI/MiniMax-M2",
+    "prompt": text,
+    "max_tokens": 4096
+}
+response = requests.post(
+    "http://localhost:8000/v1/completions",
+    headers={"Content-Type": "application/json"},
+    json=payload,
+    stream=False,
+)
+
+# Model output needs manual parsing
+raw_output = response.json()["choices"][0]["text"]
+print("Raw output:", raw_output)
+
+# Use the parsing function below to process the output
+tool_calls = parse_tool_calls(raw_output, tools)
+```
+
+## 🛠️ Tool Call Definition
+
+### Tool Structure
+
+Tool calls need to define the `tools` field in the request body. Each tool consists of the following parts:
+
+```json
+{
+  "tools": [
+    {
+      "name": "search_web",
+      "description": "Search function.",
+      "parameters": {
+        "properties": {
+          "query_list": {
+            "description": "Keywords for search, list should contain 1 element.",
+            "items": { "type": "string" },
+            "type": "array"
+          },
+          "query_tag": {
+            "description": "Category of query",
+            "items": { "type": "string" },
+            "type": "array"
+          }
+        },
+        "required": [ "query_list", "query_tag" ],
+        "type": "object"
+      }
+    }
+  ]
+}
+```
+
+**Field Descriptions:**
+
+- `name`: Function name  
+- `description`: Function description  
+- `parameters`: Function parameter definition  
+  - `properties`: Parameter property definition, where key is the parameter name and value contains detailed parameter description  
+  - `required`: List of required parameters  
+  - `type`: Parameter type (usually "object")
+
+### Internal Processing Format
+
+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
+You are a helpful assistant.
+
+# Tools
+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": "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:
+
+<minimax:tool_call>
+<invoke name="tool-name-1">
+<parameter name="param-key-1">param-value-1</parameter>
+<parameter name="param-key-2">param-value-2</parameter>
+...
+</invoke>
+[e~[
+]~b]user
+When were the latest announcements from OpenAI and Gemini?[e~[
+]~b]ai
+<think>
+```
+
+**Format Description:**
+
+- `]~!b[]~b]system`: System message start marker  
+- `[e~[`: Message end marker  
+- `]~b]user`: User message start marker  
+- `]~b]ai`: Assistant message start marker  
+- `]~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>...</think>`: Thinking process marker during generation
+
+### Model Output Format
+
+MiniMax-M2 uses structured XML tag format:
+
+```xml
+<minimax:tool_call>
+<invoke name="search_web">
+<parameter name="query_tag">["technology", "events"]</parameter>
+<parameter name="query_list">["\"OpenAI\" \"latest\" \"release\""]</parameter>
+</invoke>
+<invoke name="search_web">
+<parameter name="query_tag">["technology", "events"]</parameter>
+<parameter name="query_list">["\"Gemini\" \"latest\" \"release\""]</parameter>
+</invoke>
+</minimax:tool_call>
+```
+
+Each tool call uses the `<invoke name="function_name">` tag, and parameters use the `<parameter name="parameter_name">` tag wrapper.
+
+## Manually Parsing Tool Call Results
+
+### Parsing Tool Calls
+
+MiniMax-M2 uses structured XML tags, which require a different parsing approach. The core function is as follows:
+
+```py
+import re
+import json
+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]
+    elif 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:
+    """Convert parameter value based on parameter type"""
+    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 (ValueError, TypeError):
+            return value
+    elif param_type in ["number", "float"]:
+        try:
+            val = float(value)
+            return val if val != int(val) else int(val)
+        except (ValueError, TypeError):
+            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 json.JSONDecodeError:
+            return value
+    else:
+        # Try JSON parsing, return string if failed
+        try:
+            return json.loads(value)
+        except json.JSONDecodeError:
+            return value
+
+
+def parse_tool_calls(model_output: str, tools: Optional[List[Dict]] = None) -> List[Dict]:
+    """
+    Extract all tool calls from model output
+    
+    Args:
+        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:
+        Parsed tool call list, each element contains name and arguments fields
+    
+    Example:
+        >>> tools = [{
+        ...     "name": "get_weather",
+        ...     "parameters": {
+        ...         "type": "object",
+        ...         "properties": {
+        ...             "location": {"type": "string"},
+        ...             "unit": {"type": "string"}
+        ...         }
+        ...     }
+        ... }]
+        >>> output = '''<minimax:tool_call>
+        ... <invoke name="get_weather">
+        ... <parameter name="location">San Francisco</parameter>
+        ... <parameter name="unit">celsius</parameter>
+        ... </invoke>
+        ... </minimax:tool_call>'''
+        >>> result = parse_tool_calls(output, tools)
+        >>> 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:
+        # 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)
+        
+        # Iterate through all tool_call blocks
+        for tool_call_match in tool_call_regex.findall(model_output):
+            # 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:
+                        tool_name = tool.get("name") or tool.get("function", {}).get("name")
+                        if tool_name == function_name:
+                            params = tool.get("parameters") or tool.get("function", {}).get("parameters")
+                            if isinstance(params, dict) and "properties" in params:
+                                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)
+                    if param_match:
+                        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]:
+                                param_type = param_config[param_name]["type"]
+                        
+                        param_dict[param_name] = convert_param_value(param_value, param_type)
+                
+                tool_calls.append({
+                    "name": function_name,
+                    "arguments": param_dict
+                })
+    
+    except Exception as e:
+        print(f"Failed to parse tool calls: {e}")
+        return []
+    
+    return tool_calls
+```
+
+**Usage Example:**
+
+```py
+# Define tools
+tools = [
+    {
+        "name": "get_weather",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "location": {"type": "string"},
+                "unit": {"type": "string"}
+            },
+            "required": ["location", "unit"]
+        }
+    }
+]
+
+# Model output
+model_output = """Let me help you query the weather.
+<minimax:tool_call>
+<invoke name="get_weather">
+<parameter name="location">San Francisco</parameter>
+<parameter name="unit">celsius</parameter>
+</invoke>
+</minimax:tool_call>"""
+
+# Parse tool calls
+tool_calls = parse_tool_calls(model_output, tools)
+
+# Output results
+for call in tool_calls:
+    print(f"Function called: {call['name']}")
+    print(f"Arguments: {call['arguments']}")
+    # Output: Function called: get_weather
+    #         Arguments: {'location': 'San Francisco', 'unit': 'celsius'}
+```
+
+### Executing Tool Calls
+
+After parsing is complete, you can execute the corresponding tool and construct the return result:
+
+```py
+def execute_function_call(function_name: str, arguments: dict):
+    """Execute function call and return result"""
+    if function_name == "get_weather":
+        location = arguments.get("location", "Unknown location")
+        unit = arguments.get("unit", "celsius")
+        # Build function execution result
+        return {
+            "role": "tool", 
+            "content": [
+              {
+                "name": function_name,
+                "type": "text",
+                "text": json.dumps({
+                    "location": location, 
+                    "temperature": "25", 
+                    "unit": unit, 
+                    "weather": "Sunny"
+                }, ensure_ascii=False)
+              }
+            ] 
+          }
+    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"Search keywords: {query_list}, Category: {query_tag}\nSearch results: Relevant information found"
+              }
+            ]
+          }
+    
+    return None
+```
+### Returning Tool Execution Results to the Model
+
+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)  
+- [SGLang Project Homepage](https://github.com/sgl-project/sglang)  
+- [OpenAI Python SDK](https://github.com/openai/openai-python)

generation_config.json

@@ -0,0 +1,6 @@
+{
+  "do_sample": true,
+  "top_k": 40,
+  "top_p": 0.95,
+  "transformers_version": "4.55.0"
+}

model-00001-of-00070.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:92ce9d4dac7d33263ec980a594d86593272d3ab1907ae152775f355ee17602a1
+size 4997842560

model-00002-of-00070.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:22f4f1bc412143547a5cc5a9492cc31add89c9c26f88df33ace8a71c43b9e028
+size 4996692376

model-00003-of-00070.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:969ec2fe7af75411b511a8dab9dc380c201a0fd579808e43babf105b5edb8578
+size 4996692392

model-00004-of-00070.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4cbb2d048f6f177917de1a1ade7b000bb88d4ac03283b15faf7b157572f09f88
+size 4996692432

model-00005-of-00070.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:48d0da24d5a8f2486a2686c44f896e8d30c6c42888d7bdc629d7bdb24e9dc5cf
+size 4996692432

model-00006-of-00070.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:adb79dba9bb640bf26a39fcadee3c625a958e8b311dca95a4e429643001bb3a0
+size 4996692432

model-00007-of-00070.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:14198f3595051135c45de69c2e6be6658db6a6e8b70f1aa804cfd37c080f471a
+size 4996692432

model-00008-of-00070.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d036567118e18a6796312aef53a8787b3f8e1c4f77aeedc50fc11c1b772ebedc
+size 4977802792

model-00009-of-00070.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:76d004002f3bcdc3f1ed018624712e9f49178fe7e849583722a85345ad514bb5
+size 4992354664

model-00010-of-00070.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:037abcefe796e54d0d811ae5e1f8896aa81207dfc9533e6370fc034fd4a0b3fe
+size 4996692368

model-00011-of-00070.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5eb8f27d65720a4d7e2502aedeb17ac34add567e278eb12c7193cd06d60768b7
+size 4996692376

model-00012-of-00070.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ca3734e67fdb4fdaa9eab3bce7b3f58d81b5185a8687275702e1f2c312444bcc
+size 4996692736

model-00013-of-00070.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d5fa2066ba143889e76f267a4483f097388b4422220589b4623af592988fda4f
+size 4996692904

model-00014-of-00070.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4f9ff75bf7e987a72e1457ed1480b220c0edd354b3775d7ee13979174226bec3
+size 4996692960

model-00015-of-00070.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fca8287025bb9bc461dae02ba76a0fb6920ce756ff4cc0eaab02ada55164135d
+size 4996692960

model-00016-of-00070.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:72fb56372bd4f2862bfe102d14eaf5ad2e378d4374b74e96fdf144e68cc4bc0b
+size 4996692960

model-00017-of-00070.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5427acfa913f92ae7c7ea986d96dbe729806ce4c731cfb9deaf1be2167a1718f
+size 4996692960

model-00018-of-00070.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:99dd2779ddb568eec957580653923ec05879e05027a8d30a56070c1cfa4fa8f9
+size 4996692968

model-00019-of-00070.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ab3d12ad435507ea42c97c63220acdb5471027e4646940145705fa0f7bbcb231
+size 4992340208

model-00020-of-00070.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fb4c4f4b9a7739d48d521126da70f36d1411e683acf6ecec2a131bc208b9cbad
+size 4996692896

model-00021-of-00070.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:774792c0526a5315515556087ec8ee87c8861a41c1d28d175343e46bacecbed1
+size 4996692896

model-00022-of-00070.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:703b9887e755a866e68737620f67eb668eae3456bb1fe1439c5865a27a7ae988
+size 4996692904

model-00023-of-00070.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e6c70264fd3a71f44f9adb646470018c6f5b1a996947067310e084116e749c52
+size 4996692904

model-00024-of-00070.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cf94a3627fb32d9505c95fcac7ff112ba65d10d4ff65479b802b6457b05974d1
+size 4996692936

model-00025-of-00070.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:95ef12862c60786dce34383a4ba0db2ab706a3c5117d70dd56f4eb2f4c65e6e6
+size 4996692960

model-00026-of-00070.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:740b8a48b514c4855d74c5262d11a8e8f890a3c0c26038ad7579a5b09dd13144
+size 4996692960

model-00027-of-00070.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:91f105473920bc03907183f076b729fbdc2eb378a1bb23dfea23b62815545f97
+size 4996692960

model-00028-of-00070.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4bc19c9e7cb7c01625f2a8fca20b216900ee75582708e46e84d8aedb249143cf
+size 4996692960

model-00029-of-00070.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:251dfaca5c3b81362e54d4e4e5ace14d2837dd7e2b3958a7168246244e2279d9
+size 4992340240

model-00030-of-00070.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d98a6dc2c1ddd6eef7f24af38f2a2068c47a0b385fa23c5219ab4c8e062d1d34
+size 4996692888

model-00031-of-00070.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:671334330b78709a02a1b9dcc20be5ce575a0177cf46bc538539941c1c26f335
+size 4996692896

model-00032-of-00070.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7fc96ad8210ca4941622e7f9313d4d98683b4f1e66165629727025ffe7e36b1b
+size 4996692904

model-00033-of-00070.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:28c0e3c7a66485517126362209eaabc261128c24fcc26fd8c33e62aec4998b66
+size 4996692904

model-00034-of-00070.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1bdd65a4af8e04fa9ee17476523fa5e7eec493439cbbd8e2922b11eaf2a8c8a1
+size 4996692912

model-00035-of-00070.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7c38159eb713042e382f6e7b39a96074a400d360d01926ef8a1fba9a567f9c63
+size 4996692960

model-00036-of-00070.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0b1470e6b21485c800b5ca78ac2eb234a4fe68a48ad81a927061e8cdc267d55c
+size 4996692960

model-00037-of-00070.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7ec6ee695578b68ab3e44a8e0b156ca30dbf9295b2a31843965b47c1b92d265b
+size 4996692960