Cách chạy MiniMax M3 trên máy: Thiết lập đa GPU với llama.cpp và Pi Agent

MiniMax M3 là mô hình open-weight mới nhất của MiniMax dành cho lập trình, sử dụng công cụ và quy trình tác tử dài hạn. Điểm khác biệt so với các mô hình MiniMax trước đây là sự kết hợp giữa cửa sổ ngữ cảnh 1 triệu token, hỗ trợ đa phương thức gốc cho văn bản, hình ảnh và video, cùng MiniMax Sparse Attention, được thiết kế để suy luận ngữ cảnh rất dài trở nên thực tiễn hơn. 

Nguồn: MiniMax 

Trong hướng dẫn này, tôi sẽ chỉ bạn cách chạy MiniMax M3 trên máy qua hai GPU NVIDIA RTX PRO 6000, kiểm thử mô hình qua giao diện web tích hợp sẵn, và kết nối endpoint tương thích OpenAI cục bộ với tác tử lập trình Pi. 

Thiết lập sử dụng terminal JupyterLab trên pod RunPod PyTorch thay vì SSH, với llama.cpp biên dịch cho CUDA, phục vụ mô hình trên cổng 8910.

Yêu cầu hệ thống để chạy MiniMax M3 trên máy

Trước khi chạy MiniMax M3 trên máy, hãy đảm bảo hệ thống của bạn có đủ bộ nhớ GPU và dung lượng lưu trữ để tải mô hình.

• GPU: 2× NVIDIA RTX PRO 6000, mỗi chiếc 96 GB VRAM, tổng cộng 192 GB VRAM.
• Lưu trữ: Tối thiểu 350 GB trống cho tệp mô hình, bộ nhớ đệm Hugging Face, tệp build của llama.cpp và dữ liệu tạm thời khi chạy.
• Lượng tử hóa mô hình: Dùng GGUF quantization UD-IQ3_XXS từ unsloth/MiniMax-M3-GGUF. Khoảng 159 GB và là lựa chọn thực tế nhất cho phần cứng này.
• Runtime: Bản build có CUDA của llama.cpp với hỗ trợ đa GPU.

MiniMax M3 là một mô hình mixture-of-experts lớn, vì vậy trọng số của nó phải được chia trên cả hai GPU khi suy luận. Dù hệ thống có 192 GB VRAM cộng gộp, không phải toàn bộ lượng nhớ đó đều dùng cho chính mô hình. 

Một phần VRAM cần cho chi phí runtime, xử lý prompt và KV cache.

Vì lý do này, hãy bắt đầu với lượng tử hóa UD-IQ3_XXS. Khoảng 159 GB, đủ chừa bộ nhớ để tải và chạy mô hình. 

Tránh dùng các lượng tử hóa 4-bit của MiniMax M3 trong thiết lập này, vì tệp 4-bit nhỏ nhất khoảng 208 GB đã vượt quá VRAM khả dụng trước khi tính chi phí runtime.

1. Thiết lập môi trường đa GPU trên RunPod

Tạo một Pod mới trên RunPod và chọn 2× NVIDIA RTX PRO 6000 GPUs với template RunPod PyTorch mới nhất. Template này bao gồm JupyterLab, chúng ta sẽ dùng thay cho SSH trong suốt hướng dẫn.

Cấu hình Pod với các thiết lập sau:

• Container Disk: 50 GB
• Volume Disk: 300 GB
• Expose HTTP Ports: 8910
• Biến môi trường: HF_TOKEN: Mã truy cập Hugging Face của bạn

Ổ đĩa container 50 GB chỉ dành cho hệ điều hành, gói cài và tệp tạm. Ổ đĩa volume 300 GB là nơi chứa mô hình MiniMax M3 và bộ nhớ đệm Hugging Face. 

Mở cổng HTTP 8910, vì llama.cpp sẽ chạy giao diện web và API tương thích OpenAI trên cổng này. Khi server chạy, bạn có thể truy cập qua URL theo định dạng:

https://<POD_ID>-8910.proxy.runpod.net

Cấu hình Pod dùng trong hướng dẫn này có chi phí khoảng $4,23 mỗi giờ, dù giá có thể thay đổi tùy mức sẵn có và khu vực. 

Tôi khuyên bạn nên giữ ít nhất $10 tín dụng RunPod, nhưng $15–$20 sẽ an toàn hơn cho quá trình build ban đầu, tải mô hình và thử nghiệm.

Sau khi Pod chạy, mở nó từ bảng điều khiển RunPod:

1. Mở Pod của bạn.
2. Nhấp vào thẻ Connect (Kết nối)
3. Mở JupyterLab.
4. Trong JupyterLab, chọn File → New → Terminal.

Trước tiên, xác nhận cả hai GPU sẵn sàng:

nvidia-smiĐược hỗ trợ bởi

Bạn sẽ thấy hai GPU NVIDIA RTX PRO 6000, mỗi chiếc khoảng 96 GB VRAM.

Tiếp theo, cài các công cụ build cần thiết:

apt-get update && apt-get install -y \
  git \
  cmake \
  build-essential \
  curlĐược hỗ trợ bởi

Cuối cùng, kiểm tra CUDA có sẵn:

nvcc --versionĐược hỗ trợ bởi

Bạn sẽ thấy CUDA 12.8 hoặc phiên bản CUDA tương thích. Giờ bạn đã sẵn sàng build llama.cpp với hỗ trợ CUDA.

2. Build nhánh llama.cpp cho MiniMax M3 với CUDA

llama.cpp là engine suy luận mã nguồn mở để chạy các mô hình GGUF trên máy. Tôi gợi ý bạn đọc hướng dẫn đầy đủ về llama.cpp nếu bạn chưa quen. 

Nó hỗ trợ tăng tốc CUDA, offload đa GPU, giao diện web tích hợp, và máy chủ API tương thích OpenAI. 

Hỗ trợ MiniMax M3 vẫn còn thử nghiệm, nên bạn cần build llama.cpp từ nhánh minimax-m3 chuyên dụng thay vì dùng bản phát hành tiêu chuẩn. 

Chạy các lệnh sau từ terminal JupyterLab của bạn:

cd /workspace

git clone https://github.com/ggml-org/llama.cpp.git
cd llama.cpp

git fetch origin pull/24523/head:minimax-m3
git checkout minimax-m3Được hỗ trợ bởi

Tiếp theo, cấu hình llama.cpp với hỗ trợ CUDA và biên dịch các binary cho server và dòng lệnh:

cmake -B build \
  -DGGML_CUDA=ON \
  -DCMAKE_BUILD_TYPE=Release

cmake --build build \
  -j"$(nproc)" \
  --target llama-server llama-cliĐược hỗ trợ bởi

Việc này tạo ra hai binary trong build/bin/:

• llama-server, cung cấp giao diện chat trên trình duyệt và endpoint API tương thích OpenAI.
• llama-cli, cho phép bạn thử mô hình trực tiếp từ terminal.

Lưu ý: Đây là bản triển khai MiniMax M3 thử nghiệm. Nó hỗ trợ suy luận văn bản, nhưng MiniMax Sparse Attention không có trong nhánh này, nên llama.cpp dùng dense attention. Hỗ trợ thị giác và MTP/giải mã suy đoán cũng không có trong bản build này.

3. Tải trọng số mô hình GGUF của MiniMax M3

MiniMax M3 được phân phối dưới dạng nhiều tệp GGUF. Hãy tải toàn bộ thư mục UD-IQ3_XXS vào volume workspace bền vững trước khi khởi động server.

Trước tiên, cài Hugging Face Hub CLI mới nhất:

pip install -U huggingface_hubĐược hỗ trợ bởi

Tạo thư mục cho mô hình và bật tải xuống Hugging Face nhanh hơn:

mkdir -p /workspace/unsloth

export HF_XET_HIGH_PERFORMANCE=1Được hỗ trợ bởi

Sau đó tải lượng tử hóa UD-IQ3_XXS:

hf download unsloth/MiniMax-M3-GGUF \
  --include "UD-IQ3_XXS/*" \
  --local-dir /workspace/unslothĐược hỗ trợ bởi

Tải xuống khoảng 159 GB và bao gồm năm shard GGUF. Vì mô hình được lưu trong /workspace, nó sẽ vẫn có sẵn khi bạn dừng và khởi động lại Pod.

4. Phục vụ MiniMax M3 trên máy qua nhiều GPU

Chuyển đến thư mục llama.cpp và bật cả hai GPU cho server:

cd /workspace/llama.cpp

export CUDA_VISIBLE_DEVICES=0,1Được hỗ trợ bởi

Sau đó khởi động MiniMax M3:

MODEL_FILE="/workspace/unsloth/UD-IQ3_XXS/MiniMax-M3-UD-IQ3_XXS-00001-of-00005.gguf"

./build/bin/llama-server \
  -m "$MODEL_FILE" \
  --host 0.0.0.0 \
  --port 8910 \
  --ctx-size 8192 \
  --parallel 1 \
  --split-mode layer \
  --tensor-split 1,1 \
  --n-gpu-layers 99 \
  --flash-attn on \
  --jinja \
  --temp 1.0 \
  --top-p 0.95 \
  --top-k 40Được hỗ trợ bởi

Lệnh này tải MiniMax M3 trên cả hai GPU RTX PRO 6000. Thiết lập --tensor-split 1,1 chia mô hình đều giữa các GPU, còn --n-gpu-layers 99 giữ tối đa phần mô hình trong bộ nhớ GPU.

Máy chủ chạy trên cổng 8910 và cung cấp cả giao diện web của llama.cpp lẫn API tương thích OpenAI. Giữ terminal này mở khi mô hình đang chạy.

Bắt đầu với cửa sổ ngữ cảnh 8K. Nhánh llama.cpp thử nghiệm này dùng dense attention thay vì MiniMax Sparse Attention, nên dùng ngữ cảnh quá lớn có thể gây vấn đề bộ nhớ. Khi server đã hoạt động, bạn có thể thử --ctx-size 16384.

Mở một terminal JupyterLab khác và chạy lệnh sau để xác nhận cả hai GPU đang được sử dụng:

nvidia-smiĐược hỗ trợ bởi

Sau khi mô hình tải xong, cả hai GPU sẽ hiển thị mức sử dụng VRAM đáng kể.

5. Kiểm thử endpoint API tương thích OpenAI của MiniMax M3

Mở một terminal JupyterLab mới và trước tiên xác nhận server đang chạy và đã tải MiniMax M3:

curl -s http://127.0.0.1:8910/v1/models \
  | python3 -c "import sys, json; print(json.load(sys.stdin)['data'][0]['id'])"Được hỗ trợ bởi

Bạn sẽ thấy một ID mô hình tương tự:

MiniMax-M3-UD-IQ3_XXS-00001-of-00005.ggufĐược hỗ trợ bởi

Tiếp theo, gửi yêu cầu thử đến endpoint chat completions tương thích OpenAI:

curl http://127.0.0.1:8910/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "MiniMax-M3-UD-IQ3_XXS-00001-of-00005.gguf",
    "messages": [
      {
        "role": "user",
        "content": "Write a Python function that checks whether a number is prime."
      }
    ],
    "temperature": 1.0,
    "top_p": 0.95,
    "max_tokens": 512
  }'Được hỗ trợ bởi

Máy chủ MiniMax M3 cục bộ của bạn hoạt động bình thường.

Nó đã sinh ra một hàm Python is_prime() hiệu quả, dùng math.isqrt() và tối ưu hóa 6k ± 1. 

Phản hồi bị cắt vì đạt tới giới hạn max_tokens là 512, thể hiện qua: "finish_reason": "length"

Trong thử nghiệm này, server xử lý prompt khoảng 357 token/giây và sinh văn bản khoảng 73 token/giây. 

Tốc độ của bạn có thể khác tùy độ dài ngữ cảnh, tải GPU và kích thước prompt. 

6. Truy cập Web UI của llama.cpp cho MiniMax M3

Vì cổng 8910 được mở qua RunPod, bạn cũng có thể thử MiniMax M3 qua giao diện web tích hợp của llama.cpp.

Trong bảng điều khiển RunPod, mở Pod của bạn và nhấp nút Connect. Dưới các cổng HTTP được mở, chọn liên kết cho cổng 8910.

Giao diện web llama.cpp sẽ mở trong trình duyệt của bạn. Nó hoạt động như một ứng dụng chat kiểu ChatGPT gọn nhẹ, với mô hình MiniMax M3 chạy cục bộ đã được chọn sẵn. Giờ bạn có thể gửi prompt và thử mô hình mà không cần dùng terminal hay API.

Cho một bài thử thực tế, tôi yêu cầu MiniMax M3 tạo giao diện web Python để phục vụ các mô hình máy học. Nó đã đưa ra một thiết kế bảng điều khiển dựa trên FastAPI chi tiết với chuyển đổi mô hình, yêu cầu dự đoán JSON, tải lên hàng loạt CSV, streaming WebSocket trực tiếp, sổ đăng ký mô hình, endpoint sức khỏe, log có cấu trúc, kiểm thử và thiết lập Docker.

Phản hồi đã sinh 5.510 token trong 1 phút 19 giây, đạt khoảng 69 token/giây. 

Với lượng tử hóa 3-bit chạy cục bộ trên hai GPU RTX PRO 6000, đây là kết quả mạnh mẽ, cho thấy MiniMax M3 có thể xử lý các yêu cầu lập trình dài ở tốc độ tương tác.

7. Kết nối Pi Coding Agent với LLM cục bộ của bạn

Pi là tác tử lập trình chạy trong terminal, có thể làm việc trực tiếp với tệp dự án cục bộ của bạn, chạy lệnh, kiểm tra mã và sử dụng mô hình MiniMax M3 chạy tại chỗ.

Mở một terminal JupyterLab thứ ba. Giữ terminal đầu tiên đang chạy llama-server, sau đó dùng terminal này để cài và cấu hình Pi.

Cài Pi bằng script cài đặt chính thức:

curl -fsSL https://pi.dev/install.sh | shĐược hỗ trợ bởi

Nếu trình cài đặt hỏi có nên cài Node.js không, hãy gõ Y và nhấn Enter. Pi sẽ cài runtime Node.js cần thiết và công cụ dòng lệnh pi.

Khi cài xong, trình cài có thể hiển thị lệnh để cập nhật môi trường shell của bạn. Chạy lệnh đó rồi khởi động lại shell:

exec bash -lĐược hỗ trợ bởi

Xác nhận Pi đã sẵn sàng:

pi --versionĐược hỗ trợ bởi

Bạn sẽ thấy số phiên bản Pi đã cài.

0.79.10Được hỗ trợ bởi

Pi hỗ trợ nhà cung cấp tùy chỉnh tương thích OpenAI thông qua tệp models.json. Tạo thư mục cấu hình của Pi:

mkdir -p ~/.pi/agentĐược hỗ trợ bởi

Sau đó tạo cấu hình nhà cung cấp:

cat > ~/.pi/agent/models.json <<'EOF'
{
  "providers": {
    "local-minimax": {
      "baseUrl": "http://127.0.0.1:8910/v1",
      "api": "openai-completions",
      "apiKey": "none",
      "compat": {
        "supportsDeveloperRole": false,
        "supportsReasoningEffort": false,
        "supportsUsageInStreaming": false,
        "maxTokensField": "max_tokens"
      },
      "models": [
        {
          "id": "MiniMax-M3-UD-IQ3_XXS-00001-of-00005.gguf",
          "name": "MiniMax M3 Local 3-bit",
          "reasoning": false,
          "input": ["text"],
          "contextWindow": 8192,
          "maxTokens": 2048,
          "cost": {
            "input": 0,
            "output": 0,
            "cacheRead": 0,
            "cacheWrite": 0
          }
        }
      ]
    }
  }
}
EOFĐược hỗ trợ bởi

Cấu hình này báo cho Pi dùng máy chủ llama.cpp cục bộ chạy trên cổng 8910. Thiết lập API openai-completions khớp với endpoint chat completions tương thích OpenAI của llama.cpp.

Các thiết lập tương thích ngăn Pi gửi các trường hoặc vai trò tin nhắn không được hỗ trợ có thể gây lỗi trên một số máy chủ tương thích OpenAI cục bộ. Cụ thể, Pi sẽ dùng vai trò system thay vì vai trò developer mới và sẽ gửi max_tokens, thứ mà llama.cpp mong đợi.

Mô hình được liệt kê là chỉ văn bản với cửa sổ ngữ cảnh 8K, khớp cấu hình server bạn đã khởi động trước đó. Chi phí được đặt bằng 0 vì MiniMax M3 chạy cục bộ trên phiên RunPod của bạn thay vì qua API trả phí.

8. Chạy Pi với MiniMax M3

Mở một terminal JupyterLab mới cho Pi. Để trải nghiệm tác tử lập trình thoải mái hơn, chuyển JupyterLab sang chế độ tối bằng cách chọn Settings → Theme → JupyterLab Dark.

Tiếp theo, clone dự án bạn muốn MiniMax M3 làm việc cùng:

cd /workspace

git clone https://github.com/kingabzpro/semantic-web-cache
cd semantic-web-cacheĐược hỗ trợ bởi

Khởi chạy Pi:

piĐược hỗ trợ bởi

Bên trong Pi, gõ:

/modelĐược hỗ trợ bởi

Tìm local, sau đó chọn MiniMax M3 Local 3-bit. Pi sẽ hiển thị nhà cung cấp cục bộ và xác nhận mô hình GGUF MiniMax M3 đã được chọn.

Hãy bắt đầu với một nhiệm vụ chỉ đọc để Pi có thể kiểm tra kho mà không thay đổi tệp. Ví dụ:

"Read the README.md file and explain how this project is structured."Được hỗ trợ bởi

Pi sẽ dùng các công cụ terminal như ls và read để khám phá kho, xem README và rà soát các tệp hỗ trợ như .env.example, requirements.txt và notebook Jupyter.

Trong ví dụ này, MiniMax M3 đã xác định đúng các tệp chính của dự án và giải thích rằng kho là một demo cache ngữ nghĩa xây dựng với Olostep và Qdrant. 

Nó đã nêu bật quy trình dựa trên notebook, các biến môi trường cần cho API, ngưỡng cache và cài đặt TTL, cùng các đánh giá về độ trễ, tỉ lệ cache-hit và tiết kiệm tín dụng trong dự án.

Tôi cũng yêu cầu tạo sơ đồ quy trình ASCII của pipeline cache ngữ nghĩa. Nó đã tạo một luồng rõ ràng cho thấy cách truy vấn người dùng được nhúng, kiểm tra với cache Qdrant, đánh giá so với ngưỡng tương đồng, và hoặc trả về từ cache hoặc gửi đến Olostep trước khi lưu kết quả.

Với các kho lớn hơn hoặc nhiệm vụ nhiều bước sâu hơn, bạn có thể cần cửa sổ ngữ cảnh lớn hơn. Cập nhật giá trị --ctx-size trong lệnh llama-server và khởi động lại server. Bắt đầu bằng cách tăng từ 8192 lên 16384, sau đó thử 32768` nếu VRAM vẫn còn.

Tránh nhảy ngay lên cửa sổ ngữ cảnh 100K. Nhánh llama.cpp MiniMax M3 thử nghiệm này dùng dense attention thay vì MiniMax Sparse Attention, nên ngữ cảnh rất lớn sẽ tăng mạnh mức dùng bộ nhớ và có thể gây lỗi hết bộ nhớ.

Kết luận

Sau khi chạy MiniMax M3 trên máy, tôi cho rằng nó cân bằng tốt hơn so với cố gắng chạy các mô hình lập trình cực lớn như GLM 5.2 hoặc Kimi K2.7 Code. 

Các mô hình đó có thể mạnh hơn trong vài trường hợp, nhưng cũng đòi hỏi bộ nhớ GPU nhiều hơn rất nhiều và có thể trở nên rất tốn kém khi thuê và phục vụ tại chỗ.

Với MiniMax M3, tôi có thể chạy một mô hình có khả năng lập trình và tác tử trên hai GPU RTX PRO 6000, dùng qua giao diện trình duyệt, mở API tương thích OpenAI và kết nối với Pi như một tác tử lập trình cục bộ. 

Trong các thử nghiệm, nó sinh khoảng 70 token/giây và xử lý tốt việc khám phá kho, phân tích README, thực thi lệnh, giải thích dự án và sơ đồ quy trình.

Thiết lập này chưa hoàn hảo. Hỗ trợ trong llama.cpp vẫn thử nghiệm, Sparse Attention chưa có, và cửa sổ ngữ cảnh cần giữ tương đối nhỏ trừ khi bạn có nhiều VRAM hơn. Dù vậy, với một mô hình 3-bit chạy cục bộ, kết quả rất ấn tượng.