Cara Menjalankan MiniMax M3 Secara Lokal: Setup Multi-GPU dengan llama.cpp dan Pi Agent

MiniMax M3 adalah model open-weight terbaru dari MiniMax untuk pengkodean, penggunaan tool, dan alur kerja agen jangka panjang. Yang membedakannya dari model MiniMax terdahulu adalah kombinasi jendela konteks 1M token, dukungan multimodal native untuk teks, gambar, dan video, serta MiniMax Sparse Attention yang dirancang untuk membuat inferensi konteks sangat panjang menjadi lebih praktis. 

Sumber: MiniMax 

Dalam panduan ini, saya akan menunjukkan cara menjalankan MiniMax M3 secara lokal di dua GPU NVIDIA RTX PRO 6000, menguji model melalui antarmuka web bawaannya, dan menghubungkan endpoint lokal yang kompatibel dengan OpenAI ke agen pengkodean Pi. 

Setup ini menggunakan terminal JupyterLab pada pod RunPod PyTorch alih-alih SSH, dengan llama.cpp dikompilasi untuk CUDA, melayani model pada port 8910.

Persyaratan Sistem untuk Menjalankan MiniMax M3 Secara Lokal

Sebelum menjalankan MiniMax M3 secara lokal, pastikan sistem Anda memiliki memori GPU dan penyimpanan yang cukup untuk memuat model.

• GPU: 2× NVIDIA RTX PRO 6000 dengan VRAM 96 GB masing-masing, total 192 GB VRAM.
• Penyimpanan: Minimal 350 GB ruang disk kosong untuk file model, cache Hugging Face, file build llama.cpp, dan data runtime sementara.
• Kuantisasi model: Gunakan kuantisasi GGUF UD-IQ3_XXS dari unsloth/MiniMax-M3-GGUF. Ukurannya kira-kira 159 GB dan paling praktis untuk perangkat keras ini.
• Runtime: Build llama.cpp yang mendukung CUDA dengan dukungan multi-GPU.

MiniMax M3 adalah model mixture-of-experts berukuran besar, sehingga bobotnya harus dibagi di kedua GPU saat inferensi. Meskipun sistem menyediakan total 192 GB VRAM, tidak semua memori tersebut dapat digunakan untuk model itu sendiri. 

Sebagian VRAM diperlukan untuk overhead runtime, pemrosesan prompt, dan KV cache.

Karena itu, mulailah dengan kuantisasi UD-IQ3_XXS. Dengan ukuran sekitar 159 GB, ini menyisakan memori yang cukup untuk memuat dan menjalankan model. 

Hindari kuantisasi 4-bit MiniMax M3 pada setup ini, karena file 4-bit terkecil yang tersedia berukuran sekitar 208 GB dan melebihi VRAM yang tersedia sebelum mempertimbangkan overhead runtime.

1. Siapkan Lingkungan Multi-GPU RunPod Anda

Buat Pod RunPod baru dan pilih 2× NVIDIA RTX PRO 6000 dengan template RunPod PyTorch terbaru. Template ini menyertakan JupyterLab, yang akan kita gunakan alih-alih SSH sepanjang panduan ini.

Konfigurasikan Pod dengan pengaturan berikut:

• Container Disk: 50 GB
• Volume Disk: 300 GB
• Expose HTTP Ports: 8910
• Environment Variables: HF_TOKEN: Token akses Hugging Face Anda

Disk container 50 GB hanya untuk sistem operasi, paket, dan file sementara. Volume disk 300 GB adalah tempat model MiniMax M3 dan cache Hugging Face seharusnya berada. 

Ekspos port HTTP 8910, karena llama.cpp nantinya akan menjalankan antarmuka web dan API yang kompatibel dengan OpenAI pada port ini. Setelah server berjalan, Anda dapat mengaksesnya melalui URL dengan format:

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

Konfigurasi Pod yang digunakan untuk panduan ini berbiaya sekitar $4,23 per jam, meskipun harga dapat bervariasi tergantung ketersediaan dan lokasi. 

Saya menyarankan Anda menyimpan setidaknya $10 dalam kredit RunPod, namun $15–$20 lebih aman untuk proses build awal, pengunduhan model, dan pengujian.

Setelah Pod berjalan, buka dari dasbor RunPod:

1. Buka Pod Anda.
2. Klik tab Connect .
3. Buka JupyterLab.
4. Di JupyterLab, pilih File → New → Terminal.

Pertama, konfirmasikan bahwa kedua GPU tersedia:

nvidia-smi

Anda akan melihat dua NVIDIA RTX PRO 6000, masing-masing dengan sekitar 96 GB VRAM.

Selanjutnya, pasang build tools yang diperlukan:

apt-get update && apt-get install -y \
  git \
  cmake \
  build-essential \
  curl

Terakhir, verifikasi bahwa CUDA tersedia:

nvcc --version

Anda akan melihat CUDA 12.8 atau versi CUDA yang kompatibel. Anda kini siap membangun llama.cpp dengan dukungan CUDA.

2. Build Cabang llama.cpp MiniMax M3 dengan CUDA

llama.cpp adalah mesin inferensi open-source untuk menjalankan model GGUF secara lokal. Saya sarankan membaca panduan lengkap llama.cpp kami jika Anda belum familiar. 

Ia mendukung akselerasi CUDA, offloading multi-GPU, antarmuka web bawaan, dan server API yang kompatibel dengan OpenAI. 

Dukungan MiniMax M3 masih eksperimental, jadi Anda perlu membangun llama.cpp dari cabang khusus minimax-m3 alih-alih menggunakan rilis standar. 

Jalankan perintah berikut dari terminal JupyterLab Anda:

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

Selanjutnya, konfigurasikan llama.cpp dengan dukungan CUDA dan kompilasi binary server dan command-line:

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

cmake --build build \
  -j"$(nproc)" \
  --target llama-server llama-cli

Ini membuat dua binary di build/bin/:

• llama-server, yang menyediakan antarmuka chat berbasis browser dan endpoint API yang kompatibel dengan OpenAI.
• llama-cli, yang memungkinkan Anda menguji model langsung dari terminal.

Catatan: Ini adalah implementasi MiniMax M3 yang bersifat eksperimental. Ia mendukung inferensi teks, tetapi MiniMax Sparse Attention tidak disertakan dalam cabang ini, sehingga llama.cpp menggunakan dense attention. Dukungan visi dan MTP/speculative decoding juga belum menjadi bagian dari build ini.

3. Unduh Bobot Model GGUF MiniMax M3

MiniMax M3 didistribusikan sebagai beberapa file GGUF. Unduh folder lengkap UD-IQ3_XXS ke volume workspace persisten sebelum memulai server.

Pertama, pasang Hugging Face Hub CLI terbaru:

pip install -U huggingface_hub

Buat direktori untuk model dan aktifkan pengunduhan Hugging Face yang lebih cepat:

mkdir -p /workspace/unsloth

export HF_XET_HIGH_PERFORMANCE=1

Lalu unduh kuantisasi UD-IQ3_XXS:

hf download unsloth/MiniMax-M3-GGUF \
  --include "UD-IQ3_XXS/*" \
  --local-dir /workspace/unsloth

Unduhan berukuran sekitar 159 GB dan mencakup lima shard GGUF. Karena model disimpan di /workspace, model akan tetap tersedia saat Anda menghentikan dan memulai ulang Pod.

4. Layani MiniMax M3 Secara Lokal di Beberapa GPU

Pindah ke direktori llama.cpp dan buat kedua GPU tersedia untuk server:

cd /workspace/llama.cpp

export CUDA_VISIBLE_DEVICES=0,1

Lalu mulai 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

Perintah ini memuat MiniMax M3 di kedua GPU RTX PRO 6000. Pengaturan --tensor-split 1,1 membagi model secara merata di antara GPU, sementara --n-gpu-layers 99 menjaga sebanyak mungkin lapisan model berada di memori GPU.

Server berjalan pada port 8910 dan menyediakan antarmuka web llama.cpp serta API yang kompatibel dengan OpenAI. Biarkan terminal ini tetap terbuka saat model berjalan.

Mulailah dengan jendela konteks 8K. Cabang llama.cpp eksperimental ini menggunakan dense attention alih-alih MiniMax Sparse Attention, sehingga penggunaan jendela konteks yang jauh lebih besar dapat menyebabkan masalah memori. Setelah server berfungsi, Anda dapat menguji --ctx-size 16384.

Buka terminal JupyterLab lain dan jalankan perintah berikut untuk memastikan bahwa kedua GPU sedang digunakan:

nvidia-smi

Setelah model dimuat, kedua GPU akan menampilkan penggunaan VRAM yang signifikan.

5. Uji Endpoint API yang Kompatibel dengan OpenAI untuk MiniMax M3

Buka terminal JupyterLab baru dan pertama-tama konfirmasikan bahwa server berjalan dan telah memuat 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'])"

Anda akan melihat ID model seperti:

MiniMax-M3-UD-IQ3_XXS-00001-of-00005.gguf

Selanjutnya, kirim permintaan uji ke endpoint chat completions yang kompatibel dengan 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
  }'

Server MiniMax M3 lokal Anda berfungsi dengan benar.

Model menghasilkan fungsi Python is_prime() yang efisien menggunakan math.isqrt() dan optimisasi 6k ± 1. 

Respons terpotong karena mencapai batas max_tokens 512, ditunjukkan oleh: "finish_reason": "length"

Dalam pengujian ini, server memproses prompt sekitar 357 token per detik dan menghasilkan teks sekitar 73 token per detik. 

Kecepatan Anda dapat bervariasi tergantung panjang konteks, beban GPU, dan ukuran prompt. 

6. Akses Web UI llama.cpp untuk MiniMax M3

Karena port 8910 diekspos melalui RunPod, Anda juga dapat menguji MiniMax M3 melalui antarmuka web bawaan llama.cpp.

Di dasbor RunPod, buka Pod Anda dan klik tombol Connect. Di bawah port HTTP yang diekspos, pilih tautan untuk port 8910.

Ini akan membuka antarmuka web llama.cpp di browser Anda. Cara kerjanya mirip aplikasi chat bergaya ChatGPT yang ringan, dengan model MiniMax M3 yang berjalan lokal sudah dipilih. Anda kini dapat mengirim prompt dan menguji model tanpa menggunakan terminal atau API.

Untuk uji praktis, saya meminta MiniMax M3 membuat antarmuka web Python untuk melayani model machine learning. Ia menghasilkan desain dasbor berbasis FastAPI yang terperinci dengan penggantian model, permintaan prediksi JSON, unggah batch CSV, streaming WebSocket langsung, registry model, endpoint health, logging terstruktur, pengujian, dan setup Docker.

Respons menghasilkan 5.510 token dalam 1 menit 19 detik, mencapai sekitar 69 token per detik. 

Untuk kuantisasi lokal 3-bit yang berjalan di dua RTX PRO 6000, ini adalah hasil yang kuat dan menunjukkan bahwa MiniMax M3 dapat menangani permintaan pengkodean yang lebih panjang dengan kecepatan interaktif.

7. Hubungkan Pi Coding Agent ke LLM Lokal Anda

Pi adalah agen pengkodean berbasis terminal yang dapat bekerja langsung dengan file proyek lokal Anda, menjalankan perintah, memeriksa kode, dan menggunakan model MiniMax M3 yang Anda host secara lokal.

Buka terminal JupyterLab ketiga. Biarkan terminal pertama menjalankan llama-server, lalu gunakan terminal ini untuk memasang dan mengonfigurasi Pi.

Pasang Pi dengan skrip instalasi resmi:

curl -fsSL https://pi.dev/install.sh | sh

Jika penginstal menanyakan apakah harus memasang Node.js, ketik Y lalu tekan Enter. Pi kemudian akan memasang runtime Node.js yang diperlukan dan tool baris perintah pi.

Saat instalasi selesai, penginstal mungkin menampilkan perintah untuk memperbarui lingkungan shell Anda. Jalankan perintah yang diberikan, lalu mulai ulang shell:

exec bash -l

Konfirmasikan bahwa Pi tersedia:

pi --version

Anda akan melihat nomor versi Pi yang terpasang.

0.79.10

Pi mendukung penyedia kustom yang kompatibel dengan OpenAI melalui file models.json. Buat direktori konfigurasi Pi:

mkdir -p ~/.pi/agent

Lalu buat konfigurasi penyedia:

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

Konfigurasi ini memberi tahu Pi untuk menggunakan server llama.cpp lokal yang berjalan pada port 8910. Pengaturan API openai-completions sesuai dengan endpoint chat completions yang kompatibel dengan OpenAI milik llama.cpp.

Pengaturan kompatibilitas mencegah Pi mengirim field atau role pesan yang tidak didukung yang dapat menimbulkan masalah pada beberapa server lokal yang kompatibel dengan OpenAI. Secara khusus, Pi akan menggunakan role system standar alih-alih role developer yang lebih baru dan akan mengirim max_tokens, seperti yang diharapkan oleh llama.cpp.

Model dicantumkan sebagai teks saja dengan jendela konteks 8K, sesuai dengan konfigurasi server yang Anda jalankan sebelumnya. Nilai biaya disetel ke nol karena MiniMax M3 berjalan secara lokal di instance RunPod Anda, bukan melalui API berbayar.

8. Jalankan Pi dengan MiniMax M3

Buka terminal JupyterLab baru untuk Pi. Untuk pengalaman agen pengkodean yang lebih nyaman, ubah JupyterLab ke mode gelap dengan memilih Settings → Theme → JupyterLab Dark.

Selanjutnya, klon proyek yang ingin Anda kerjakan dengan MiniMax M3:

cd /workspace

git clone https://github.com/kingabzpro/semantic-web-cache
cd semantic-web-cache

Luncurkan Pi:

pi

Di dalam Pi, ketik:

/model

Cari local, lalu pilih MiniMax M3 Local 3-bit. Pi akan menampilkan penyedia lokal dan mengonfirmasi bahwa model GGUF MiniMax M3 terpilih.

Mulailah dengan tugas read-only agar Pi dapat memeriksa repositori tanpa mengubah file apa pun. Misalnya:

"Read the README.md file and explain how this project is structured."

Pi akan menggunakan tool terminal seperti ls dan read untuk menelusuri repositori, memeriksa README, dan meninjau file pendukung seperti .env.example, requirements.txt, dan Jupyter notebook.

Dalam contoh ini, MiniMax M3 mengidentifikasi dengan benar file utama proyek dan menjelaskan bahwa repositori ini adalah demo caching semantik yang dibangun dengan Olostep dan Qdrant. 

Ia menyoroti alur kerja berbasis notebook, variabel lingkungan yang diperlukan untuk API, pengaturan ambang cache dan TTL, serta evaluasi latensi, cache-hit, dan penghematan kredit yang disertakan dalam proyek.

Saya juga memintanya membuat diagram alur kerja ASCII untuk pipeline cache semantik. Ia membuat alur yang jelas yang menunjukkan bagaimana kueri pengguna di-embed, diperiksa terhadap cache Qdrant, dievaluasi terhadap ambang kemiripan, lalu dikembalikan dari cache atau dikirim ke Olostep sebelum hasilnya disimpan.

Untuk repositori yang lebih besar atau tugas bertahap yang lebih mendalam, Anda mungkin membutuhkan jendela konteks yang lebih besar. Perbarui nilai --ctx-size pada perintah llama-server dan mulai ulang server. Mulailah dengan menaikkannya dari 8192 ke 16384, lalu uji 32768` jika memori GPU masih tersedia.

Hindari langsung melompat ke jendela konteks 100K. Cabang llama.cpp MiniMax M3 yang eksperimental ini menggunakan dense attention alih-alih MiniMax Sparse Attention, sehingga konteks yang sangat besar dapat meningkatkan penggunaan memori secara signifikan dan mungkin menyebabkan error kehabisan memori.

Pemikiran Akhir

Setelah menjalankan MiniMax M3 secara lokal, saya rasa ia menawarkan keseimbangan yang jauh lebih baik dibanding mencoba menjalankan model pengkodean yang sangat besar seperti GLM 5.2 atau Kimi K2.7 Code. 

Model-model tersebut mungkin lebih kuat dalam beberapa kasus, tetapi juga membutuhkan memori GPU yang jauh lebih besar dan bisa menjadi sangat mahal untuk disewa dan dijalankan secara lokal.

Dengan MiniMax M3, saya dapat menjalankan model pengkodean dan agen yang mumpuni di dua RTX PRO 6000, menggunakannya melalui antarmuka browser, mengeksposnya melalui API yang kompatibel dengan OpenAI, dan menghubungkannya ke Pi sebagai agen pengkodean lokal. 

Dalam pengujian saya, ia menghasilkan sekitar 70 token per detik dan menangani penelusuran repositori, analisis README, eksekusi perintah, penjelasan proyek, dan diagram alur kerja dengan baik.

Setup ini belum sempurna. Dukungan llama.cpp masih eksperimental, Sparse Attention belum tersedia, dan jendela konteks perlu tetap relatif kecil kecuali Anda memiliki VRAM yang lebih banyak. Meski begitu, untuk model 3-bit yang dijalankan secara lokal, hasilnya mengesankan.