MiniMax M3’ü Yerelde Çalıştırma: llama.cpp ve Pi Agent ile Çoklu GPU Kurulumu

MiniMax M3, MiniMax’in kodlama, araç kullanımı ve uzun vadeli ajan iş akışları için en yeni açık ağırlıklı modelidir. Önceki MiniMax modellerinden ayrışmasını sağlayan unsurlar; 1M belirteçlik bağlam penceresi, metin, görsel ve video için yerleşik çok kipli destek ve çok uzun bağlamlı çıkarımı daha pratik hale getirmek üzere tasarlanmış MiniMax Sparse Attention’ın birleşimidir. 

Kaynak: MiniMax 

Bu rehberde MiniMax M3’ü iki NVIDIA RTX PRO 6000 GPU’ya yayarak yerelde nasıl çalıştıracağınızı, modeli yerleşik web arayüzü üzerinden nasıl test edeceğinizi ve yerel OpenAI uyumlu uç noktayı Pi kodlama ajanına nasıl bağlayacağınızı göstereceğim. 

Kurulum, SSH yerine RunPod PyTorch pod’unda JupyterLab terminallerini kullanır; llama.cpp CUDA için derlenmiş olup modeli 8910 numaralı portta sunar.

MiniMax M3’ü Yerelde Çalıştırmak İçin Sistem Gereksinimleri

MiniMax M3’ü yerelde çalıştırmadan önce, modelin yüklenebilmesi için sisteminizde yeterli GPU belleği ve depolama alanı olduğundan emin olun.

• GPU’lar: Her biri 96 GB VRAM’e sahip 2× NVIDIA RTX PRO 6000 GPU; toplamda 192 GB VRAM.
• Depolama: Model dosyaları, Hugging Face önbelleği, llama.cpp derleme dosyaları ve geçici çalışma zamanı verileri için en az 350 GB boş disk alanı.
• Model niceleme: unsloth/MiniMax-M3-GGUF deposundaki UD-IQ3_XXS GGUF nicelemesini kullanın. Yaklaşık 159 GB’tır ve bu donanım için en pratik seçenektir.
• Çalışma zamanı: Çoklu GPU desteği olan CUDA etkin bir llama.cpp derlemesi.

MiniMax M3 büyük bir uzman karışımı (mixture-of-experts) modelidir; bu nedenle ağırlıkları çıkarım sırasında her iki GPU’ya da bölünmelidir. Sistem 192 GB birleşik VRAM sunsa da, bu belleğin tamamı model için kullanılamaz. 

Çalışma zamanı ek yükü, istem işleme ve KV önbelleği için bir miktar VRAM gereklidir.

Bu nedenle UD-IQ3_XXS nicelemesiyle başlayın. Yaklaşık 159 GB boyutuyla, modelin yüklenip çalışması için yeterli bellek bırakır. 

Bu kurulumda 4 bit MiniMax M3 nicelemelerinden kaçının; mevcut en küçük 4 bit dosya yaklaşık 208 GB’tır ve çalışma zamanı ek yükü hesaba katılmadan bile kullanılabilir VRAM’i aşar.

1. RunPod Çoklu GPU Ortamınızı Kurun

Yeni bir RunPod Pod’u oluşturun ve en güncel RunPod PyTorch şablonuyla 2× NVIDIA RTX PRO 6000 GPU seçin. Bu şablon, bu rehber boyunca SSH yerine kullanacağımız JupyterLab’i içerir.

Pod’u aşağıdaki ayarlarla yapılandırın:

• Konteyner Diski: 50 GB
• Birim Diski: 300 GB
• HTTP Portlarını Açığa Çıkarın: 8910
• Ortam Değişkenleri: HF_TOKEN: Hugging Face erişim jetonunuz

50 GB’lık konteyner diski yalnızca işletim sistemi, paketler ve geçici dosyalar içindir. 300 GB’lık birim diski ise MiniMax M3 modelinin ve Hugging Face önbelleğinin bulunacağı yerdir. 

HTTP 8910 portunu açığa çıkarın; çünkü llama.cpp daha sonra web arayüzünü ve OpenAI uyumlu API’sini bu portta çalıştıracaktır. Sunucu çalışmaya başladıktan sonra şu biçimde bir URL üzerinden erişebilirsiniz:

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

Bu rehberde kullanılan Pod yapılandırmasının maliyeti yaklaşık saatlik 4,23 $’dır; ancak fiyat, bulunabilirlik ve lokasyona göre değişebilir. 

RunPod kredinizde en az 10 $ bulundurmanızı öneririm; ancak ilk derleme, model indirme ve test için 15–20 $ daha güvenlidir.

Pod çalıştıktan sonra RunPod panosundan açın:

1. Pod’unuzu açın.
2. Connect sekmesine tıklayın
3. JupyterLab’i açın.
4. JupyterLab’de File → New → Terminal seçin.

Önce her iki GPU’nun da mevcut olduğunu doğrulayın:

nvidia-smiAltyapı:

Yaklaşık 96 GB VRAM’e sahip iki NVIDIA RTX PRO 6000 GPU görmelisiniz.

Ardından gerekli derleme araçlarını yükleyin:

apt-get update && apt-get install -y \
  git \
  cmake \
  build-essential \
  curlAltyapı:

Son olarak CUDA’nın mevcut olduğunu doğrulayın:

nvcc --versionAltyapı:

CUDA 12.8 veya uyumlu bir CUDA sürümü görmelisiniz. Artık llama.cpp’yi CUDA desteğiyle derlemeye hazırsınız.

2. MiniMax M3 için CUDA’lı llama.cpp Dalını Derleyin

llama.cpp, GGUF modellerini yerelde çalıştırmaya yönelik açık kaynaklı bir çıkarım motorudur. Aşina değilseniz tam llama.cpp rehberimizi okumanızı öneririm. 

CUDA hızlandırma, çoklu GPU’ya aktarma, yerleşik web arayüzü ve OpenAI uyumlu bir API sunucusunu destekler. 

MiniMax M3 desteği hâlâ deneysel olduğundan, standart sürüm yerine özel minimax-m3 dalından llama.cpp inşa etmeniz gerekir. 

Aşağıdaki komutları JupyterLab terminalinizde çalıştırı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-m3Altyapı:

Sonra llama.cpp’yi CUDA desteğiyle yapılandırın ve sunucu ile komut satırı ikililerini derleyin:

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

cmake --build build \
  -j"$(nproc)" \
  --target llama-server llama-cliAltyapı:

Bu işlem build/bin/ klasöründe iki ikili oluşturur:

• llama-server: Tarayıcı tabanlı sohbet arayüzünü ve OpenAI uyumlu API uç noktasını sağlar.
• llama-cli: Modeli doğrudan terminalden test etmenize olanak tanır.

Not: Bu, deneysel bir MiniMax M3 uygulamasıdır. Metin çıkarımını destekler; ancak bu dal MiniMax Sparse Attention’ı içermediğinden llama.cpp yoğun (dense) dikkat kullanır. Görü (vision) desteği ve MTP/tahmini kod çözme de bu derlemenin parçası değildir.

3. MiniMax M3 GGUF Model Ağırlıklarını İndirin

MiniMax M3 birden fazla GGUF dosyası olarak dağıtılır. Sunucuyu başlatmadan önce tam UD-IQ3_XXS klasörünü kalıcı çalışma alanı birimine indirin.

Önce en güncel Hugging Face Hub CLI’yi yükleyin:

pip install -U huggingface_hubAltyapı:

Model için bir dizin oluşturun ve daha hızlı Hugging Face indirmelerini etkinleştirin:

mkdir -p /workspace/unsloth

export HF_XET_HIGH_PERFORMANCE=1Altyapı:

Ardından UD-IQ3_XXS nicelemesini indirin:

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

İndirme yaklaşık 159 GB’tır ve beş GGUF parçası içerir. Model /workspace içine kaydedildiği için Pod’u durdurup yeniden başlattığınızda erişilebilir kalır.

4. MiniMax M3’ü Çoklu GPU’da Yerelde Sunun

llama.cpp dizinine geçin ve sunucuya her iki GPU’yu da görünür yapın:

cd /workspace/llama.cpp

export CUDA_VISIBLE_DEVICES=0,1Altyapı:

Sonra MiniMax M3’ü başlatın:

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 40Altyapı:

Bu komut, MiniMax M3’ü her iki RTX PRO 6000 GPU’ya da yükler. --tensor-split 1,1 ayarı modeli GPU’lar arasında eşit bölerken, --n-gpu-layers 99 modelin olabildiğince fazlasını GPU belleğinde tutar.

Sunucu 8910 numaralı portta çalışır ve hem llama.cpp web arayüzünü hem de OpenAI uyumlu bir API’yi sağlar. Model çalışırken bu terminali açık tutun.

8K bağlam penceresiyle başlayın. Deneysel llama.cpp dalı MiniMax Sparse Attention yerine yoğun dikkat kullandığından, çok daha büyük bir bağlam penceresi bellek sorunlarına yol açabilir. Sunucu çalışır duruma geldiğinde --ctx-size 16384’ü test edebilirsiniz.

Her iki GPU’nun da kullanıldığını doğrulamak için başka bir JupyterLab terminali açın ve şu komutu çalıştırın:

nvidia-smiAltyapı:

Model yüklendikten sonra her iki GPU’da da kayda değer VRAM kullanımı görmelisiniz.

5. MiniMax M3’ün OpenAI Uyumlu API Uç Noktasını Test Edin

Yeni bir JupyterLab terminali açın ve önce sunucunun çalıştığını ve MiniMax M3’ün yüklendiğini doğrulayın:

curl -s http://127.0.0.1:8910/v1/models \
  | python3 -c "import sys, json; print(json.load(sys.stdin)['data'][0]['id'])"Altyapı:

Şuna benzer bir model kimliği görmelisiniz:

MiniMax-M3-UD-IQ3_XXS-00001-of-00005.ggufAltyapı:

Ardından OpenAI uyumlu sohbet tamamlama uç noktasına bir test isteği gönderin:

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
  }'Altyapı:

Yerel MiniMax M3 sunucunuz doğru çalışıyor.

Yanıt, max_tokens sınırınız olan 512’ye ulaştığı için kesildi ve şu şekilde gösterildi: "finish_reason": "length"

Bu testte sunucu, istemi saniyede yaklaşık 357 belirteç hızında işledi ve metni saniyede yaklaşık 73 belirteç hızında oluşturdu. 

Hızınız; bağlam uzunluğu, GPU yükü ve istem boyutuna bağlı olarak değişebilir. 

6. MiniMax M3 için llama.cpp Web Arayüzüne Erişin

RunPod üzerinden 8910 portu açığa çıkarıldığı için, MiniMax M3’ü yerleşik llama.cpp web arayüzü üzerinden de test edebilirsiniz.

RunPod panosunda Pod’unuzu açın ve Connect düğmesine tıklayın. Açığa çıkarılan HTTP portları altında 8910 portunun bağlantısını seçin.

Bu, tarayıcınızda llama.cpp web arayüzünü açar. Yerelde çalışan MiniMax M3 modeli önceden seçili olacak biçimde, hafif bir ChatGPT tarzı sohbet uygulaması gibi çalışır. Artık istemler gönderebilir ve modeli terminal veya API kullanmadan test edebilirsiniz.

Uygulamalı bir test için, MiniMax M3’ten makine öğrenimi modellerini sunan bir Python web arayüzü oluşturmasını istedim. Model geçişi, JSON tahmin istekleri, CSV toplu yüklemeleri, canlı WebSocket akışı, bir model kayıt defteri, sağlık uç noktaları, yapılandırılmış günlükleme, testler ve bir Docker kurulumu içeren ayrıntılı bir FastAPI tabanlı pano tasarımı üretti.

Yanıt 1 dakika 19 saniyede 5.510 belirteç üretti ve saniyede yaklaşık 69 belirtece ulaştı. 

İki RTX PRO 6000 GPU üzerinde çalışan 3 bit yerel niceleme için bu güçlü bir sonuçtur ve MiniMax M3’ün daha uzun kodlama isteklerini etkileşimli hızda yönetebildiğini gösterir.

7. Pi Kodlama Ajanını Yerel LLM’inize Bağlayın

Pi, yerel proje dosyalarınızla doğrudan çalışabilen, komut çalıştırabilen, kodu inceleyebilen ve yerel olarak barındırılan MiniMax M3 modelinizi kullanabilen terminal tabanlı bir kodlama ajanıdır.

Üçüncü bir JupyterLab terminali açın. İlk terminalde llama-server’ı çalışır durumda tutun; ardından bu terminali Pi’yi yükleyip yapılandırmak için kullanın.

Pi’yi resmi kurulum betiğiyle yükleyin:

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

Yükleyici Node.js kurulup kurulmayacağını sorarsa Y yazıp Enter’a basın. Ardından Pi, gerekli Node.js çalışma zamanını ve pi komut satırı aracını yükleyecektir.

Kurulum tamamlandığında, yükleyici kabuk ortamınızı güncellemek için bir komut gösterebilir. Verdiği komutu çalıştırın ve kabuğu yeniden başlatın:

exec bash -lAltyapı:

Pi’nin kullanılabilir olduğunu doğrulayın:

pi --versionAltyapı:

Yüklü Pi sürüm numarasını görmelisiniz.

0.79.10Altyapı:

Pi, models.json dosyası aracılığıyla özel OpenAI uyumlu sağlayıcıları destekler. Pi’nin yapılandırma dizinini oluşturun:

mkdir -p ~/.pi/agentAltyapı:

Ardından sağlayıcı yapılandırmasını oluşturun:

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
          }
        }
      ]
    }
  }
}
EOFAltyapı:

Bu yapılandırma, 8910 portunda çalışan yerel llama.cpp sunucusunu Pi’nin kullanmasını söyler. openai-completions API ayarı, llama.cpp’nin OpenAI uyumlu sohbet tamamlama uç noktasıyla eşleşir.

Uyumluluk ayarları, Pi’nin bazı yerel OpenAI uyumlu sunucularda sorunlara yol açabilecek desteklenmeyen alanları veya ileti rollerini göndermesini engeller. Özellikle Pi, daha yeni developer rolü yerine standart system rolünü kullanacak ve llama.cpp’nin beklediği max_tokens alanını gönderecektir.

Model, daha önce başlattığınız sunucu yapılandırmasına uygun şekilde yalnızca metin ve 8K bağlam penceresiyle listelenmiştir. MiniMax M3, ücretli bir API yerine RunPod örneğinizde yerelde çalıştığı için maliyet değerleri sıfırdır.

8. MiniMax M3 ile Pi’yi Çalıştırın

Pi için yeni bir JupyterLab terminali açın. Daha konforlu bir kodlama ajanı deneyimi için Ayarlar → Tema → JupyterLab Dark seçerek JupyterLab’i koyu moda alın.

Sonra MiniMax M3’ün üzerinde çalışmasını istediğiniz projeyi klonlayın:

cd /workspace

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

Pi’yi başlatın:

piAltyapı:

Pi içinde şunu yazın:

/modelAltyapı:

local anahtarını arayın ve ardından MiniMax M3 Local 3-bit’i seçin. Pi yerel sağlayıcıyı gösterecek ve MiniMax M3 GGUF modelinin seçildiğini doğrulayacaktır.

Pi’nin depoyu dosyalarda değişiklik yapmadan incelemesi için yalnızca okuma görevle başlayın. Örneğin:

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

Pi, depoyu keşfetmek, README’yi incelemek ve .env.example, requirements.txt ve Jupyter defteri gibi destekleyici dosyaları gözden geçirmek için ls ve read gibi terminal araçlarını kullanacaktır.

Bu örnekte MiniMax M3 ana proje dosyalarını doğru şekilde belirledi ve deponun Olostep ve Qdrant ile oluşturulmuş bir anlamsal önbellekleme demosu olduğunu açıkladı. 

Not defteri tabanlı iş akışını, API’ler için gerekli ortam değişkenlerini, önbellek eşik ve TTL ayarlarını ve projeye dahil edilen gecikme, önbellek isabeti ve kredi tasarrufu değerlendirmelerini vurguladı.

Ayrıca anlamsal önbellek veri hattının ASCII bir iş akışı diyagramını oluşturmasını istedim. Bir kullanıcı sorgusunun nasıl gömüldüğünü, Qdrant önbelleğine karşı kontrol edildiğini, benzerlik eşiğine göre değerlendirildiğini ve sonucun ya önbellekten döndürüldüğünü ya da sonuç depolanmadan önce Olostep’e gönderildiğini açıkça gösteren bir akış oluşturdu.

Daha büyük depolar veya daha derin çok adımlı görevler için daha büyük bir bağlam penceresine ihtiyaç duyabilirsiniz. llama-server komutundaki --ctx-size değerini güncelleyin ve sunucuyu yeniden başlatın. Önce 8192’den 16384’e artırarak başlayın; GPU belleği uygunsa 32768` değerini test edin.

Doğrudan 100K bağlam penceresine atlamaktan kaçının. Bu deneysel MiniMax M3 llama.cpp dalı, MiniMax Sparse Attention yerine yoğun dikkat kullandığından, çok büyük bağlamlar bellek kullanımını önemli ölçüde artırabilir ve bellek taşması hatalarına neden olabilir.

Son Düşünceler

MiniMax M3’ü yerelde çalıştırdıktan sonra, GLM 5.2 veya Kimi K2.7 Code gibi son derece büyük kodlama modellerini çalıştırmaya kıyasla çok daha iyi bir denge sunduğunu düşünüyorum. 

Bu modeller bazı durumlarda daha güçlü olabilir; ancak çok daha fazla GPU belleği gerektirir ve yerelde kiralayıp sunmak çok pahalıya mal olabilir.

MiniMax M3 ile iki RTX PRO 6000 GPU üzerinde yetenekli bir kodlama ve ajansal modeli çalıştırabildim; tarayıcı arayüzü üzerinden kullanabildim, OpenAI uyumlu bir API aracılığıyla dışa açabildim ve Pi’ye yerel bir kodlama ajanı olarak bağlayabildim. 

Testlerimde saniyede yaklaşık 70 belirteç hızında çıktı üretti ve depo keşfi, README analizi, komut yürütme, proje açıklamaları ve iş akışı diyagramlarını iyi yönetti.

Henüz mükemmel bir kurulum değil. llama.cpp desteği hâlâ deneysel; Sparse Attention mevcut değil ve daha fazla VRAM yoksa bağlam penceresinin nispeten küçük kalması gerekiyor. Yine de yerelde çalışan 3 bit nicelemeli bir model için sonuçlar etkileyiciydi.