MiniMax-M2.7
MiniMax-M2.7
MiniMax-M2.7은 MiniMax가 자기 진화에 깊이 참여한 첫 번째 모델이에요. 실사용 생산성을 위해 만들어졌으며, 복잡한 agent harness 구축과 고도로 정교한 생산성 작업 완료에 탁월해요. Agent Teams, 복잡한 Skills, 동적 tool 검색을 활용해요.
출처: 문서
본문
1. Model Introduction
MiniMax-M2.7은 MiniMax가 자기 진화에 깊이 참여한 첫 번째 모델이에요. 실사용 생산성을 위해 만들어졌으며, 복잡한 agent harness 구축과 고도로 정교한 생산성 작업 완료에 탁월해요. Agent Teams, 복잡한 Skills, 동적 tool 검색을 활용해요.
주요 하이라이트:
- 모델 자기 진화: 개발 중 M2.7이 자신의 메모리를 업데이트하고, RL 실험용 복잡한 스킬을 구축하며, 자신의 학습 과정을 개선해요. 내부 버전이 프로그래밍 스캐폴드를 100+ 라운드에 걸쳐 자율 최적화해 30% 성능 향상을 달성했어요. MLE Bench Lite에서 M2.7은 66.6% medal rate를 달성했어요.
- 전문 소프트웨어 엔지니어링: 뛰어난 실사용 프로그래밍 능력을 제공해요. SWE-Pro에서 M2.7은 **56.22%**를 달성했고, SWE Multilingual (76.5)과 Multi SWE Bench (52.7)에서도 강력한 결과를 보여줘요. Terminal Bench 2 (57.0%)와 NL2Repo (39.8%)에서 M2.7은 복잡한 엔지니어링 시스템에 대한 깊은 이해를 보여줘요.
- 전문 작업: GDPval-AA에서 1495의 ELO 점수(오픈소스 모델 중 최고)를 달성했어요. Toolathon에서 M2.7은 46.3% 정확도(글로벌 최상위권)를 기록했어요.
- 네이티브 Agent Teams: 안정적인 역할 정체성과 자율 의사결정을 갖춘 다중 에이전트 협업을 지원해요.
자세한 내용은 공식 MiniMax-M2.7 블로그 게시물을 참조하세요.
라이선스: Modified-MIT (MiniMax Model License)
2. SGLang Installation
SGLang은 여러 설치 방법을 제공해요. 하드웨어 플랫폼과 요구사항에 따라 가장 적합한 설치 방법을 선택할 수 있어요.
설치 지침은 공식 SGLang 설치 가이드를 참조하세요.
SGLang CPU 설치에 대해서는 CPU 버전 설치 가이드를 참조하세요.
하드웨어 플랫폼별 Docker 이미지:
| Hardware Platform | Docker Image |
|---|---|
| NVIDIA A100 / H100 / H200 / B200 | lmsysorg/sglang:v0.5.10.post1 |
| NVIDIA B300 / GB300 | lmsysorg/sglang:v0.5.10.post1-cu130 |
| AMD MI300X / MI325X | lmsysorg/sglang:v0.5.10.post1-rocm720-mi30x |
| AMD MI355X | lmsysorg/sglang:v0.5.10.post1-rocm720-mi35x |
3. Model Deployment
이 섹션은 다양한 하드웨어 플랫폼과 사용 사례에 최적화된 배포 구성을 제공해요.
3.1 Basic Configuration
상단의 Command Generator를 사용해 하드웨어 플랫폼·배포 전략·기능 구성에 맞는 배포 명령을 자동 생성하세요. 예시 기본 명령(H200, 4-GPU, FP8, thinking·tool-call 켜짐):
sglang serve \
--model-path MiniMaxAI/MiniMax-M2.7 \
--tp 4 \
--tool-call-parser minimax-m2 \
--reasoning-parser minimax-append-think \
--trust-remote-code \
--mem-fraction-static 0.85
H200/B200/GB300 (allreduce fusion):
SGLANG_USE_FUSED_PARALLEL_QKNORM=1 ... --enable-flashinfer-allreduce-fusion. Blackwell (B200/B300/GB300):--moe-runner-backend flashinfer_trtllm_routed(FP8이면--fp8-gemm-backend flashinfer_trtllm --dtype bfloat16). NVFP4 (Blackwell):nvidia/MiniMax-M2.7-NVFP4. B300:--attention-backend flashinfer. AMD:--kv-cache-dtype fp8_e4m3 --attention-backend triton --ep <TP>. XEON:--device cpu --disable-overlap-schedule --tp 6.
3.2 Configuration Tips
핵심 파라미터:
| Parameter | Description | Recommended Value |
|---|---|---|
--tool-call-parser |
함수 호출 지원용 tool call parser | minimax-m2 |
--reasoning-parser |
thinking 모드용 reasoning parser | minimax-append-think |
--trust-remote-code |
MiniMax 모델 로딩에 필요 | 항상 활성화 |
--mem-fraction-static |
KV cache용 정적 메모리 분율 | 0.85 |
--tp |
텐서 병렬화 크기 | 하드웨어에 따라 2 / 4 / 8 |
--ep |
전문가 병렬화 크기 | 8 (NVIDIA 8-GPU) 또는 EP=TP (AMD) |
--kv-cache-dtype |
KV cache 데이터 타입 (AMD 전용) | fp8_e4m3 |
--attention-backend |
어텐션 백엔드 (AMD 전용) | triton |
하드웨어 요구사항: NVIDIA
- 4-GPU 배포: 4× 고메모리 GPU(예: H200, B200, A100, H100)와 TP=4 필요
- 8-GPU 배포: 8× GPU(예: H200, B200, A100, H100)와 TP=8·EP=8 필요
하드웨어 요구사항: NVIDIA GB300
- 2-GPU 배포: GB300(다이당 275GB)은 TP=2로 모델을 호스팅할 수 있어요
- 4-GPU 배포: GB300의 최대 단일 노드 TP로, 더 높은 처리량에 권장
하드웨어 요구사항: AMD
- 2-GPU 배포: 2× 고메모리 GPU(예: MI300X, MI325X, MI355X)와 TP=2·EP=2 필요
- 4-GPU 배포: 4× GPU(예: MI300X, MI325X, MI355X)와 TP=4·EP=4 필요
- 8-GPU 배포: 8× GPU(예: MI300X, MI325X, MI355X)와 TP=8·EP=8 필요
하드웨어 요구사항: Intel Xeon CPU
- Granite Rapids (GNR) AP 2-Socket 서버에서 모델 서비스를 실행하는 것이 권장돼요.
- CPU 서비스 구성은 SGLang CPU 서버 문서의 서빙 엔진 시작 섹션 Notes 부분을 참조해 TP(tensor parallel)와 NUMA 바인딩 설정을 잘 이해하세요.
4. Model Invocation
4.1 Basic Usage
기본 API 사용과 요청 예시는 다음을 참조하세요:
배포 명령:
sglang serve \
--model-path MiniMaxAI/MiniMax-M2.7 \
--tp 4 \
--tool-call-parser minimax-m2 \
--reasoning-parser minimax-append-think \
--trust-remote-code \
--mem-fraction-static 0.85
배포 테스트:
시작 후 다음 명령으로 SGLang OpenAI 호환 API를 테스트할 수 있어요:
curl http://localhost:30000/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
"model": "MiniMaxAI/MiniMax-M2.7",
"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?"}]}
]
}'
간단 완료 예시:
from openai import OpenAI
client = OpenAI(
base_url="http://localhost:30000/v1",
api_key="EMPTY"
)
response = client.chat.completions.create(
model="MiniMaxAI/MiniMax-M2.7",
messages=[
{"role": "system", "content": "You are a helpful assistant."},
{"role": "user", "content": "Who won the world series in 2020?"}
],
max_tokens=1024
)
print(response.choices[0].message.content)
예시 출력:
thinkingThe user asks: "Who won the World Series in 2020?" That's a simple factual question. The answer: the Los Angeles Dodgers won the 2020 MLB World Series, defeating the Tampa Bay Rays. So answer accordingly.
We must be mindful of policy: it's a factual question about sports. It's allowed. Provide answer with brief context.
We should answer concisely.
Hence final answer: The Los Angeles Dodgers won the 2020 World Series, defeating the Tampa Bay Rays in six games (best-of-seven series). Possibly mention it was played at a neutral site due to COVID-19, at Globe Life Field in Arlington, Texas.
We must avoid disallowed content, no issue.
Thus final.
response
The **Los Angeles Dodgers** won the 2020 World Series. They defeated the **Tampa Bay Rays** in six games (4‑2) in a best‑of‑seven series that was played at Globe Life Field in Arlington, Texas, under the MLB bubble‑like arrangements for the COVID‑19 pandemic.
4.2 Advanced Usage
4.2.1 Reasoning Parser
MiniMax-M2.7은 Thinking 모드를 지원해요. 배포 중 reasoning parser를 켜서 thinking과 content 섹션을 분리하세요:
sglang serve \
--model-path MiniMaxAI/MiniMax-M2.7 \
--tp 4 \
--reasoning-parser minimax-append-think \
--trust-remote-code \
--mem-fraction-static 0.85
Thinking 프로세스 스트리밍
minimax-append-think에서는 thinking 콘텐츠가 content 필드 안의 thinking... response 태그로 감싸져요. 클라이언트 쪽에서 이 태그를 파싱해 thinking과 content 섹션을 분리할 수 있어요:
from openai import OpenAI
client = OpenAI(
base_url="http://localhost:30000/v1",
api_key="EMPTY"
)
# Enable streaming to see the thinking process in real-time
response = client.chat.completions.create(
model="MiniMaxAI/MiniMax-M2.7",
messages=[
{"role": "user", "content": "Solve this problem step by step: What is 15% of 240?"}
],
max_tokens=2048,
stream=True
)
# Process the stream, separating thinking... response from content
in_think = False
think_printed_header = False
content_printed_header = False
buffer = ""
for chunk in response:
if chunk.choices and len(chunk.choices) > 0:
delta = chunk.choices[0].delta
if delta.content:
buffer += delta.content
while buffer:
if in_think:
# Look for closing response tag
end_idx = buffer.find(" response")
if end_idx != -1:
print(buffer[:end_idx], end="", flush=True)
buffer = buffer[end_idx + len(" response"):]
in_think = False
else:
# Still in thinking, print what we have
print(buffer, end="", flush=True)
buffer = ""
else:
# Look for opening thinking tag
start_idx = buffer.find(" thinking")
if start_idx != -1:
# Print any content before thinking
before = buffer[:start_idx]
if before:
if not content_printed_header:
print("=============== Content =================", flush=True)
content_printed_header = True
print(before, end="", flush=True)
buffer = buffer[start_idx + len(" thinking"):]
in_think = True
if not think_printed_header:
print("=============== Thinking =================", flush=True)
think_printed_header = True
else:
# No thinking tag, print as content
if not content_printed_header and think_printed_header:
print("\n=============== Content =================", flush=True)
content_printed_header = True
print(buffer, end="", flush=True)
buffer = ""
print()
출력 예시:
=============== Thinking =================
The user asks: "Solve this problem step by step: What is 15% of 240?" Straightforward. Provide solution: 15% = 15/100 = 0.15. Multiply 240 * 0.15 = 36. Show steps. So answer: 36. Provide explanation.
But also ensure we follow any policy? No issues. Just straightforward.
I'll provide a step-by-step solution.
Also could show fraction: 15% = 15/100 = 3/20, multiply 240 * 3/20 = (240/20)*3 = 12*3 = 36.
Yes. Provide final answer. Also show verification: 10% of 240 is 24, 5% is 12, total 36.
All good.
=============== Content =================
**Step‑by‑step solution**
1. **Convert the percent to a decimal (or a fraction).**
15% = 15/100 = 0.15 = 3/20
2. **Multiply the original number (240) by this decimal/fraction.**
Using the decimal:
240 × 0.15 = 36
Or using the fraction:
240 × 3/20 = (240/20) × 3 = 12 × 3 = 36
3. **Result:**
15% of 240 = **36**
*Check:*
- 10% of 240 = 24
- 5% of 240 = 12
- Adding them: 24 + 12 = 36, which matches the calculation.
참고: minimax-append-think reasoning parser는 thinking 프로세스를 content 필드 안의 thinking... response 태그에 내장해요. 위 코드는 이 태그를 실시간으로 파싱해 thinking과 content를 분리해 보여줘요.
4.2.2 Tool Calling
MiniMax-M2.7은 tool calling 능력을 지원해요. tool call parser를 켜세요:
sglang serve \
--model-path MiniMaxAI/MiniMax-M2.7 \
--tp 4 \
--tool-call-parser minimax-m2 \
--reasoning-parser minimax-append-think \
--trust-remote-code \
--mem-fraction-static 0.85
Python 예시:
from openai import OpenAI
client = OpenAI(
base_url="http://localhost:30000/v1",
api_key="EMPTY"
)
# Define available tools
tools = [
{
"type": "function",
"function": {
"name": "get_weather",
"description": "Get the current weather for a location",
"parameters": {
"type": "object",
"properties": {
"location": {
"type": "string",
"description": "The city name"
},
"unit": {
"type": "string",
"enum": ["celsius", "fahrenheit"],
"description": "Temperature unit"
}
},
"required": ["location"]
}
}
}
]
# Non-streaming request
response = client.chat.completions.create(
model="MiniMaxAI/MiniMax-M2.7",
messages=[
{"role": "user", "content": "What's the weather in Beijing?"}
],
tools=tools
)
message = response.choices[0].message
# Check for tool calls
if message.tool_calls:
for tool_call in message.tool_calls:
print(f"Tool Call: {tool_call.function.name}")
print(f" Arguments: {tool_call.function.arguments}")
else:
print(message.content)
출력 예시:
Tool Call: get_weather
Arguments: {"location": "Beijing"}
Tool Call 결과 처리:
# After getting the tool call, execute the function
def get_weather(location, unit="celsius"):
# Your actual weather API call here
return f"The weather in {location} is 22°{unit[0].upper()} and sunny."
# Send tool result back to the model
messages = [
{"role": "user", "content": "What's the weather in Beijing?"},
{
"role": "assistant",
"content": None,
"tool_calls": [{
"id": "call_123",
"type": "function",
"function": {
"name": "get_weather",
"arguments": '{"location": "Beijing", "unit": "celsius"}'
}
}]
},
{
"role": "tool",
"tool_call_id": "call_123",
"content": get_weather("Beijing", "celsius")
}
]
final_response = client.chat.completions.create(
model="MiniMaxAI/MiniMax-M2.7",
messages=messages
)
print(final_response.choices[0].message.content)
출력 예시:
The weather in Beijing is currently 22°C and sunny.
5. Benchmark
이 섹션은 비교 가능한 벤치마크 결과를 위해 업계 표준 구성을 사용해요.
테스트 환경:
- 하드웨어: 2× NVIDIA GB300 (다이당 275GB)
- Docker Image:
lmsysorg/sglang:v0.5.10.post1-cu130 - 모델: MiniMax-M2.7 (FP8)
- 텐서 병렬화: 2
- SGLang 버전: 0.5.10.post1
5.1 Accuracy Benchmark
평가 도구: sgl-eval
평가 설정: temperature=0.6, top_p=0.95, 8회 반복, max_tokens=120,000 (GPQA와 AIME; MMLU-Pro는 greedy 단일 패스, 아래 참조)
5.1.1 GPQA Diamond
- 데이터셋: GPQA Diamond (198문제)
- 프롬프트:
eval/aai/mcq-4choices(4지선다, Artificial Analysis methodology와 일치) -- 이 벤치마크의 sgl-eval 기본값 - 평가 명령:
pip install sgl-eval
sgl-eval run gpqa \
--base-url http://localhost:30000/v1 \
--model MiniMaxAI/MiniMax-M2.7 \
--n-repeats 8 \
--max-tokens 120000 \
--temperature 0.6 \
--top-p 0.95
- 테스트 결과:
| Evaluation Mode | Accuracy | No Answer |
|---|---|---|
| pass@1 (avg-of-8) | 84.91% | 3.54% |
| majority@8 | 88.89% | 0.00% |
| pass@8 | 96.46% | 0.00% |
5.1.2 AIME 2025
- 데이터셋: AIME 2025 (30문제)
- 프롬프트:
generic/math(boxed answer 형식) -- 이 벤치마크의 sgl-eval 기본값 - 평가 명령:
sgl-eval run aime25 \
--base-url http://localhost:30000/v1 \
--model MiniMaxAI/MiniMax-M2.7 \
--n-repeats 8 \
--max-tokens 120000 \
--temperature 0.6 \
--top-p 0.95
- 테스트 결과:
| Evaluation Mode | Accuracy | No Answer |
|---|---|---|
| pass@1 (avg-of-8) | 92.50% ± 5.56% | 2.92% |
| majority@8 | 97.08% | 0.00% |
| pass@8 | 100.00% | 0.00% |
5.1.3 MMLU-Pro
- 데이터셋: MMLU-Pro (12,032문제, 10지선다)
- 프롬프트:
eval/aai/mcq-10choices(10지선다) -- 이 벤치마크의 sgl-eval 기본값 - 평가 명령:
sgl-eval run mmlu_pro \
--base-url http://localhost:30000/v1 \
--model MiniMaxAI/MiniMax-M2.7 \
--max-tokens 32768 \
--temperature 0.0
- 테스트 결과:
| Evaluation Mode | Accuracy | No Answer |
|---|---|---|
| pass@1 (greedy) | 69.41% | 18.75% |
참고: 높은 no-answer 비율은 일부 문제에서 M2.7의 확장된 thinking에 32K 토큰 제한이 부족하기 때문이에요. 120K 토큰으로 재실행하면 정확도가 크게 개선될 것으로 예상돼요.
5.1.4 GSM8K Benchmark
- 벤치마크 방법: 8-shot Chain-of-Thought, OpenAI 호환 API로 평가
- 테스트 결과:
GSM8K Results (8-shot CoT)
Model: MiniMaxAI/MiniMax-M2.7
Total: 1319
Correct: 1218
Accuracy: 92.34%
5.2 Speed Benchmark
5.2.1 Low Concurrency
- 벤치마크 명령:
python3 -m sglang.bench_serving \
--backend sglang \
--model MiniMaxAI/MiniMax-M2.7 \
--dataset-name random \
--random-input-len 1000 \
--random-output-len 1000 \
--num-prompts 10 \
--max-concurrency 1
- 테스트 결과:
============ Serving Benchmark Result ============
Backend: sglang
Traffic request rate: inf
Max request concurrency: 1
Successful requests: 10
Benchmark duration (s): 34.33
Total input tokens: 6101
Total generated tokens: 4220
Request throughput (req/s): 0.29
Input token throughput (tok/s): 177.71
Output token throughput (tok/s): 122.92
Total token throughput (tok/s): 300.63
----------------End-to-End Latency----------------
Mean E2E Latency (ms): 3431.21
Median E2E Latency (ms): 2742.57
---------------Time to First Token----------------
Mean TTFT (ms): 50.28
Median TTFT (ms): 53.85
-----Time per Output Token (excl. 1st token)------
Mean TPOT (ms): 8.02
Median TPOT (ms): 8.01
---------------Inter-Token Latency----------------
Mean ITL (ms): 8.03
Median ITL (ms): 8.02
==================================================
5.2.2 High Concurrency
- 벤치마크 명령:
python3 -m sglang.bench_serving \
--backend sglang \
--model MiniMaxAI/MiniMax-M2.7 \
--dataset-name random \
--random-input-len 1000 \
--random-output-len 1000 \
--num-prompts 500 \
--max-concurrency 100
- 테스트 결과:
============ Serving Benchmark Result ============
Backend: sglang
Traffic request rate: inf
Max request concurrency: 100
Successful requests: 500
Benchmark duration (s): 100.20
Total input tokens: 249831
Total generated tokens: 252662
Request throughput (req/s): 4.99
Input token throughput (tok/s): 2493.41
Output token throughput (tok/s): 2521.66
Total token throughput (tok/s): 5015.07
Concurrency: 90.19
----------------End-to-End Latency----------------
Mean E2E Latency (ms): 18072.69
Median E2E Latency (ms): 17761.84
---------------Time to First Token----------------
Mean TTFT (ms): 247.94
Median TTFT (ms): 92.05
-----Time per Output Token (excl. 1st token)------
Mean TPOT (ms): 35.75
Median TPOT (ms): 36.67
---------------Inter-Token Latency----------------
Mean ITL (ms): 35.34
Median ITL (ms): 30.55
==================================================