MiniMax M3.1 Flash GGUF: लोकल सेटअप, मेमोरी और API लागत

MiniMax M3.1 Flash GGUF के लिए UD-Q2_K_XL से शुरू करें और 160 GiB+ मेमोरी मानकर चलें। पर्याप्त मेमोरी हो तो 256 GiB+ पर UD-Q4_K_XL चुनें। अगर कभी-कभार कोडिंग के लिए हार्डवेयर खरीदना होगा, तो पहले API आज़माने की लागत देखें।

2026-11-06 के ये Unsloth के मेमोरी अनुमान 16K टेक्स्ट कॉन्टेक्स्ट और सर्वर के एक स्लॉट पर आधारित हैं। मेमोरी RAM और VRAM में बाँटी जा सकती है, या यूनिफ़ाइड मेमोरी इस्तेमाल हो सकती है। नीचे पूरी प्रक्रिया दी गई है: लोकल API सर्वर चलाने से लेकर उसे OpenCode 1 से जोड़ने तक।

M3.1 Flash के लिए कितनी मेमोरी चाहिए?

मॉडल के पूरे क्वांटाइज़्ड वेट्स के अलावा रनटाइम के लिए भी मेमोरी रखें। MiniMax के मूल मॉडल कार्ड के अनुसार कुल लगभग 428B पैरामीटर हैं, जिनमें से हर टोकन के लिए 23B सक्रिय होते हैं। सक्रिय पैरामीटर कम होने से गणना घटती है; लोड करने के लिए यह 23B का मॉडल नहीं बन जाता।

Unsloth ने नीचे दिए आकार और मेमोरी लक्ष्य प्रकाशित किए हैं। डाउनलोड का आकार दशमलव GB में है; मेमोरी के आँकड़े GiB में हैं।

क्वांटाइज़ेशन	डाउनलोड का आकार	वेट्स का आकार	मेमोरी का लक्ष्य
UD-IQ1_M	129.4 GB	120.5 GiB	कम मेमोरी में प्रयोग के लिए; नीचे देखें
UD-Q2_K_XL	143.9 GB	134.0 GiB	160 GiB+
UD-IQ3_XXS	160.0 GB	149.1 GiB	176 GiB+
UD-IQ3_S	175.5 GB	163.4 GiB	192 GiB+
UD-Q3_K_XL	194.0 GB	180.6 GiB	208 GiB+
UD-Q4_K_XL	249.4 GB	232.3 GiB	256 GiB+
UD-Q8_K_XL	259.1 GB	241.3 GiB	272 GiB+

Unsloth वेट्स के अलावा की-वैल्यू कैश, रनटाइम और ऑपरेटिंग सिस्टम के लिए लगभग 20–32 GiB रखता है। यह कैश मौजूदा कॉन्टेक्स्ट के अटेंशन की स्थिति सहेजता है। लंबे कॉन्टेक्स्ट, अतिरिक्त स्लॉट, चित्रों की प्रोसेसिंग और स्पेक्युलेटिव डिकोडिंग के लिए अधिक मेमोरी चाहिए।

128 GiB वाली मशीन में केवल 1-bit वेट्स लोड करने के बाद 7.5 GiB बचेंगे। यह बताए गए अतिरिक्त मेमोरी अनुमान से कम है। Q2 के लिए Unsloth की अधिक सावधानी वाली 160 GiB की सिफ़ारिश अपनाएँ।

RAM और VRAM का जोड़ वेट्स रखने का कुल बजट है; दोनों एक जैसी मेमोरी का साझा पूल नहीं हैं। CPU ऑफ़लोडिंग में GPU से हटाए गए वेट्स के लिए मुख्य RAM में पर्याप्त जगह चाहिए। चुने गए डाउनलोड के लिए डिस्क पर भी पर्याप्त जगह रखें।

मॉडल के लिए घोषित 1M कॉन्टेक्स्ट का अर्थ यह नहीं कि ये मेमोरी अनुमान 1M कॉन्टेक्स्ट के लिए हैं। 16K से शुरू करें और मेमोरी का उपयोग जाँचने के बाद इसे बढ़ाएँ।

कौन-सा क्वांटाइज़ेशन चुनें?

पहले Q2 से जाँचें कि मॉडल मेमोरी में समाता है या नहीं। मेमोरी पर्याप्त हो तो अपने वास्तविक कोडिंग कामों पर Q4 से तुलना करें। Q4 मेमोरी बजट से बाहर हो तो 3-bit वाला विकल्प चुनें।

Unsloth के समग्र और श्रेणीवार आँकड़े अलग-अलग दायरे मापते हैं:

Unsloth का बताया top-1 टोकन मिलान	UD-Q2_K_XL	UD-Q4_K_XL
भारित समग्र परिणाम	91.5%	98.0%
कोडिंग	91.2%	97.6%
सामान्य बातचीत	88.5%	97.3%
गणित	95.7%	99.0%

समग्र परिणाम में सात श्रेणियों को भार दिया गया है। बातचीत और गणित की पंक्तियाँ अलग-अलग श्रेणियों के परिणाम हैं। इसी वजह से Q2 के लिए 91.5% और 88.5%, दोनों आँकड़े दिए गए हैं।

Top-1 टोकन मिलान बताता है कि क्वांटाइज़्ड मॉडल और संदर्भ मॉडल सबसे अधिक स्कोर वाला एक ही टोकन चुनते हैं या नहीं। यह कोडिंग कार्यों की सफलता दर नहीं है। कोडिंग का 91.2% आँकड़ा यह नहीं कहता कि रिपॉज़िटरी में किए गए 91.2% बदलाव अपने टेस्ट पास करेंगे।

लगभग 89.9% समग्र टोकन मिलान के बावजूद, 1-bit को बहुत कम मेमोरी में प्रयोग का विकल्प मानें। किसी भी क्वांटाइज़ेशन पर निर्भर होने से पहले फ़ाइल संपादन, टूल के आर्ग्युमेंट और कई चरणों वाला व्यवहार जाँचें।

Q8 का डाउनलोड Q4 से 9.7 GB बड़ा है। Unsloth इसे जारी किए गए वेट्स का बिना हानि वाला रूपांतरण बताता है। इसमें NVFP4 और BF16 के मिले-जुले प्रारूप बने रहते हैं, इसलिए “8-bit” का लेबल हर टेंसर की एक समान प्रिसीजन नहीं बताता।

आपके हार्डवेयर के लिए कौन-सा रनटाइम सही है?

अपने रनटाइम के लिए बनाया गया चेकपॉइंट और सेटअप तरीका चुनें। EXL3 का मेमोरी में समाना यह सिद्ध नहीं करता कि संबंधित GGUF भी समाएगा।

नीचे दिए विकल्पों के स्रोत 2026-11-06 को जाँचे गए थे:

हार्डवेयर	जाँचने योग्य विकल्प	व्यावहारिक सीमा
Apple Silicon	MLX-community का oQ3e चेकपॉइंट, oMLX के साथ	चेकपॉइंट का कुल आकार 196.152 GB / 182.681 GiB है। इसमें ड्राफ़्ट और विज़न घटक शामिल हैं। रनटाइम और कॉन्टेक्स्ट की मेमोरी अलग जोड़ें।
एक DGX Spark	vcruz305 का SAGE-EXL3 सेटअप	128 GB वाले GB10 सिस्टम के लिए है। इसमें घटकों के तय संस्करण, अनुमति मिलने पर चेकपॉइंट तक पहुँच, केवल टेक्स्ट और एक डिकोड स्ट्रीम शामिल हैं।
AMD Instinct	AMD का Quark MXFP4 चेकपॉइंट	दस्तावेज़ में MI350/MI355, Linux, ROCm 7.2.3 और चार GPU पर टेंसर पैरेललिज़्म का उदाहरण है। यह सभी Radeon कार्ड के लिए सामान्य सेटअप नहीं है।
चार RTX 3090 कार्ड	MiniMax की 1 नवंबर की सामुदायिक पोस्ट में उल्लेख किया गया कस्टम इन्फ़रेंस	MiniMax के अनुसार @superalesha का तरीका क्वांटाइज़्ड वेट्स, एक्सपर्ट कैशिंग और सिस्टम RAM को जोड़ता है। इस उल्लेख से दूसरे सेटअप पर उसी प्रदर्शन की गारंटी नहीं मिलती।

पहले GGUF सेटअप के लिए नीचे दिए llama.cpp निर्देश अपनाएँ। व्यावसायिक इस्तेमाल से पहले MiniMax Community License पढ़ें। उसमें श्रेय देने और सूचना भेजने की शर्तें भी देखें।

llama.cpp बनाएँ और 16K सर्वर शुरू करें

Unsloth से लिंक की गई MiniMax समर्थन वाली ब्रांच इस्तेमाल करें। 2026-11-06 तक llama.cpp PR #31192 खुला था और मर्ज नहीं हुआ था। इस उदाहरण में उस समय के हेड कमिट को पिन किया गया है।

बिल्ड करें और मॉडल डाउनलोड करें

Ubuntu या WSL पर Bash इस्तेमाल करें। NVIDIA CUDA टूलकिट पहले से इंस्टॉल होना चाहिए। बाकी ज़रूरी पैकेज इंस्टॉल करके सर्वर बनाएँ:

sudo apt-get update
sudo apt-get install -y build-essential cmake git libssl-dev python3-venv curl jq

git clone https://github.com/ggml-org/llama.cpp
git -C llama.cpp fetch origin pull/31192/head:minimax-m31
git -C llama.cpp checkout --detach 6b95a9908d2c7b242817a447708aec38e937e2c0

cmake llama.cpp -B llama.cpp/build \
  -DCMAKE_BUILD_TYPE=Release \
  -DBUILD_SHARED_LIBS=OFF \
  -DGGML_CUDA=ON
cmake --build llama.cpp/build --config Release -j --target llama-server

macOS पर Xcode के कमांड लाइन टूल, CMake, Python और jq इंस्टॉल करें; apt-get वाली कमांड छोड़ दें। -DGGML_CUDA=ON को -DGGML_CUDA=OFF से बदलें। बिल्ड दस्तावेज़ के अनुसार macOS पर Metal डिफ़ॉल्ट रूप से चालू रहता है।

Hugging Face CLI से Q2 के चारों शार्ड, यानी विभाजित मॉडल फ़ाइलें, डाउनलोड करें:

python3 -m venv .venv-m31
source .venv-m31/bin/activate
python -m pip install -U huggingface_hub

hf download unsloth/MiniMax-M3.1-Flash-GGUF \
  --local-dir unsloth/MiniMax-M3.1-Flash-GGUF \
  --include "UD-Q2_K_XL/*"

शार्ड एक साथ रखें। पहले शार्ड का पथ देने पर सर्वर पूरा सेट लोड करता है।

सर्वर शुरू करें और जाँचें

एक स्लॉट, स्पष्ट 16K कॉन्टेक्स्ट और सामान्य टेक्स्ट डिकोडिंग से शुरू करें:

./llama.cpp/build/bin/llama-server \
  --model unsloth/MiniMax-M3.1-Flash-GGUF/UD-Q2_K_XL/MiniMax-M3.1-Flash-UD-Q2_K_XL-00001-of-00004.gguf \
  --alias m31-local \
  --ctx-size 16384 \
  --parallel 1 \
  --n-gpu-layers auto \
  --jinja \
  --flash-attn on \
  --temp 1.0 \
  --top-p 0.95 \
  --top-k 0 \
  --min-p 0.0 \
  --chat-template-kwargs '{"reasoning_effort":"high"}' \
  --host 127.0.0.1 \
  --port 8080

इस स्पार्स अटेंशन वाले तरीके के लिए PR में Jinja, Flash Attention और एक स्लॉट दिए गए हैं। llama-server के विकल्प GPU लेयर का आवंटन अपने-आप करने देते हैं।

यह कमांड विज़न प्रोजेक्टर या DSpark ड्राफ़्ट मॉडल नहीं जोड़ती। इसमें API कुंजी सेट नहीं है। सर्वर केवल इस मशीन के लूपबैक पते पर सुनता है।

VRAM आवंटन विफल हो तो GPU लेयर की संख्या घटाएँ और मुख्य RAM में खाली जगह जाँचें। कुल मेमोरी कम हो तो छोटा क्वांटाइज़ेशन चुनें या मेमोरी बढ़ाएँ। ऑफ़लोडिंग से वेट्स रखने के लिए ज़रूरी जगह कम नहीं होती।

दूसरे Bash टर्मिनल में सर्वर तैयार होने की जाँच करें:

curl -sS -i http://127.0.0.1:8080/health

HTTP 200 और {"status":"ok"} मिलने पर आगे बढ़ें। HTTP 503 के साथ Loading model आए तो मॉडल अभी लोड हो रहा है।

फिर मॉडल की सूची लें और जवाब माँगें:

curl -sS http://127.0.0.1:8080/v1/models | jq '.data[].id'

curl -sS http://127.0.0.1:8080/v1/chat/completions \
  -H 'Content-Type: application/json' \
  --data '{
    "model": "m31-local",
    "messages": [
      {"role": "user", "content": "Reply with LOCAL_OK."}
    ],
    "reasoning_effort": "low",
    "max_tokens": 4096,
    "stream": false
  }' | jq '{message: .choices[0].message, finish_reason: .choices[0].finish_reason}'

जाँचें कि मॉडल की सूची में m31-local है और message.content में माँगा गया जवाब है। इस शुरुआती जाँच में अनुरोध का low स्तर, सर्वर के डिफ़ॉल्ट high स्तर की जगह लागू होता है।

finish_reason का मान length हो तो जवाब ने अपनी आउटपुट सीमा पूरी कर ली है। इसे मॉडल लोड होने की समस्या मानने से पहले, कुल कॉन्टेक्स्ट सीमा के भीतर आउटपुट सीमा बढ़ाएँ।

OpenCode 1 जोड़ें और टूल कॉल जाँचें

कोडिंग क्लाइंट जोड़ने के लिए OpenCode के दस्तावेज़ में दिया कस्टम प्रोवाइडर तरीका अपनाएँ। OpenCode फ़ाइलों पर काम करने वाले टूल चलाता है; llama-server मॉडल के जवाब बनाता है।

यह कॉन्फ़िगरेशन OpenCode 1 के दस्तावेज़ पर आधारित है। OpenCode 1 और OpenCode 2, दोनों opencode कमांड इस्तेमाल करते हैं। अगर आप पहले से V2 चलाते हैं, तो अलग वातावरण इस्तेमाल करें।

नया V1 इंस्टॉल करने के लिए Node.js और npm उपलब्ध होने चाहिए:

npm install -g opencode-ai
opencode --version

प्रोजेक्ट की मुख्य डायरेक्टरी में opencode.json में यह कॉन्फ़िगरेशन जोड़ें। मौजूदा सेटिंग हों तो उनके साथ मिलाएँ। यह आधिकारिक llama.cpp प्रोवाइडर उदाहरण पर आधारित है:

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "local": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "MiniMax local",
      "options": {
        "baseURL": "http://127.0.0.1:8080/v1"
      },
      "models": {
        "m31-local": {
          "name": "MiniMax M3.1 Flash Q2",
          "limit": {
            "context": 16384,
            "output": 4096
          }
        }
      }
    }
  }
}

इस लोकल कॉन्फ़िगरेशन के लिए नकली API कुंजी भरने की ज़रूरत नहीं है। कॉन्टेक्स्ट सीमा चल रहे सर्वर से मेल खाती है। आउटपुट सीमा इस उदाहरण में चुना गया जवाब का बजट है, मॉडल की अधिकतम सीमा नहीं।

जिस Node प्रोजेक्ट में package.json हो, उसमें यह कमांड चलाएँ:

opencode run --model local/m31-local \
  "Read package.json with a file tool. Report scripts.test, or say it is missing. Do not edit files or run commands."

टूल से फ़ाइल पढ़े जाने का असली चरण देखें और जवाब को फ़ाइल की सामग्री से मिलाएँ। केवल मॉडल का यह कहना पर्याप्त नहीं कि उसने फ़ाइल पढ़ी है।

क्लाइंट जुड़ न पाए तो /v1 सहित बेस URL और मॉडल का उपनाम जाँचें। सर्वर चालू है या नहीं, यह भी देखें। टेक्स्ट काम करे लेकिन टूल न चले तो --jinja जाँचें। रिपॉज़िटरी में संपादन करने से पहले यही सीमित जाँच दोहराएँ।

पहला सत्र छोटा रखें। अगर टूल की परिभाषाएँ बहुत कॉन्टेक्स्ट लेती हैं, तो उनका उपयोग मापें। सर्वर की विंडो बढ़ाने से पहले MCP कॉन्टेक्स्ट लागत की मार्गदर्शिका का तरीका अपनाएँ।

API कब चुनें?

कभी-कभार इस्तेमाल के लिए नया हार्डवेयर खरीदना पड़े तो API से शुरू करें। पर्याप्त हार्डवेयर पहले से हो या मॉडल को स्थानीय रूप से चलाना ज़रूरी हो, तो लोकल सेटअप पर विचार करें।

2026-11-06 को MiniMax की मानक API दरें ये थीं:

बिलिंग मद	प्रति 1 मिलियन टोकन, USD
बिना कैश वाला इनपुट	$0.15
कैश में रखे इनपुट को पढ़ना	$0.015
आउटपुट	$0.60

API उपयोग के ये शुल्क खाते के बैलेंस से कटते हैं। MiniMax भी Flash के लिए एकसमान दरें बताता है। उसके कैश शुल्क के सूत्र में नए इनपुट, कैश से मिले टोकन और आउटपुट का शुल्क जुड़ता है। कैश में लिखने का अलग शुल्क नहीं जोड़ा जाता।

उदाहरण के लिए, एक महीने में 20 मिलियन बिना कैश वाले इनपुट टोकन और 2 मिलियन बिल किए गए आउटपुट टोकन मानें:

API token charge = 20 × $0.15 + 2 × $0.60
                 = $4.20 per month

इस उदाहरण में केवल टेक्स्ट अनुरोध हैं। इसमें कैश से मिले टोकन या सर्वर के सशुल्क टूल शामिल नहीं हैं। कर और भुगतान के समय लगने वाले शुल्क भी बाहर हैं।

तुलना के लिए लोकल सेटअप का यह उदाहरण लें:

Hardware allocation = $3,000 ÷ 36 months
                    = $83.33 per month

Active electricity  = 0.15 kW × 60 hours × $0.20/kWh
                    = $1.80 per month

Local subtotal      = $85.13 per month

लोकल गणना का हर आँकड़ा एक धारणा है। यह किसी जाँची गई मशीन की कीमत नहीं है। इससे यह भी सिद्ध नहीं होता कि मशीन 60 घंटे में पूरा काम कर लेगी। खरीद का फैसला करने से पहले निष्क्रिय अवस्था की बिजली, सेटअप, रखरखाव और हार्डवेयर अपग्रेड का खर्च जोड़ें।

असली रन की तुलना करते समय रीजनिंग का स्तर समान रखें। MiniMax के API में डिफ़ॉल्ट max है, जबकि इस लोकल सर्वर का डिफ़ॉल्ट high है। बिल किए गए आउटपुट टोकन गिनें और एक कोडिंग कार्य पूरा करने की लागत मापें। दोबारा किए गए अनुरोध और विफल टूल चरण भी इसमें गिनें।

2026-11-06 की सूची में BetterToken पर भी MiniMax-M3.1-Flash उपयोग के अनुसार भुगतान के साथ उपलब्ध है। उसका दस्तावेज़ में दिया OpenAI-संगत बेस URL https://www.bettertoken.ai/v1 है। इस विकल्प का खर्च निकालने के लिए उसकी मौजूदा कीमतें देखें।

हार्डवेयर पहले से हो तो उदाहरण के हार्डवेयर खर्च की जगह इस्तेमाल से बढ़ने वाला अपना वास्तविक खर्च रखें। फिर सामान्य कामों पर मापें। लोकल सेटअप तभी उपयोगी है जब मॉडल मेमोरी में समाए, काम पूरा होने का समय स्वीकार्य हो और परिणाम आपकी ज़रूरतें पूरी करें।