Ling-2.6-flash (Ant Group 104B MoE)

Ling-2.6-flash (104B MoE, 7.4B सक्रिय) को Ant Group द्वारा Clore.ai पर डिप्लॉय करें — agent-tuned flash sibling जो एक सिंगल RTX 4090 पर फिट बैठता है

स्थिति (29 अप्रैल, 2026): Ling-2.6-flash को Ant Group के inclusionAI दल द्वारा 28 अप्रैल, 2026 को जारी किया गया था (लेखन के समय से एक दिन पहले)। यह Ling-2.5-1T का छोटा, तेज़, एजेंट-ट्यून किया हुआ सहोदर है — वही वंश, वही हाइब्रिड लीनियर अटेंशन डीएनए, लेकिन केवल 7.4B सक्रिय पैरामीटरों के साथ, जो 104B sparse MoE में से हैं। वेट्स यहाँ उपलब्ध हैं huggingface.co/inclusionAI/Ling-2.6-flash के अंतर्गत MIT लाइसेंस.

जहाँ Ling-2.5-1T को बूट करने के लिए भी 8-GPU रैक चाहिए था, वहीं Ling-2.6-flash पहला inclusionAI रिलीज़ है जो एक ही उपभोक्ता GPU पर चल सकता है. 7.4B सक्रिय पाथ का मतलब है कि आप 104B पैरामीटर पूल का उपयोग करते हुए 8B dense मॉडल की inference लागत चुकाते हैं — और Ant Group ने उस पूल को खास तौर पर एजेंटिक वर्कफ़्लोके लिए ट्यून किया है: टूल कॉलिंग, मल्टी-स्टेप प्लानिंग, और संरचित फ़ंक्शन डिस्पैच।

विक्रेता द्वारा प्रकाशित आँकड़े Ling-2.6-flash को इसके आकार वर्ग में BFCL-V4 और TAU2-bench पर SOTA पर रखते हैं, लगभग 4× H20 पर 340 tok/s की थ्रूपुट के साथ, आधिकारिक बेंचमार्क कॉन्फ़िगरेशन में। Clore.ai उपयोगकर्ताओं के लिए अधिक दिलचस्प पंक्ति इससे भी छोटी है: INT4 एक ही RTX 4090 (24GB) पर आराम से फिट हो जाता है और 32K+ कॉन्टेक्स्ट के लिए जगह बचती है, और FP8 एक ही H100 80GB पर फिट हो जाता है. इससे एक नया एजेंट-ट्यून किया हुआ frontier-class छोटा मॉडल Clore.ai मार्केटप्लेस.

मुख्य विशिष्टताएँ

गुण

मान

कुल पैरामीटर

104B (MoE)

सक्रिय पैरामीटर

प्रति फॉरवर्ड पास 7.4B

आर्किटेक्चर

1:7 MLA + Lightning Linear हाइब्रिड अटेंशन

कॉन्टेक्स्ट विंडो

262,144 टोकन

क्वांटाइज़ेशन

BF16, FP8, INT4

लाइसेंस

MIT

रिलीज़ तिथि

28 अप्रैल, 2026

संगठन

Ant Group — inclusionAI

प्राथमिक टूलिंग

SGLang (अनुशंसित), vLLM, llama.cpp/Ollama (समुदाय GGUF)

Ling-2.6-flash क्यों?

एकल-GPU पर डिप्लॉय करने योग्य — एक RTX 4090 या RTX 3090पर INT4, एक H100 पर FP8। कोई मल्टी-GPU झंझट नहीं, कोई NVLink जद्दोजहद नहीं।
एजेंट-ट्यून किया हुआ — BFCL-V4 / TAU2-bench शैली के टूल-कॉलिंग लूप्स के लिए स्पष्ट रूप से प्रशिक्षित, न कि केवल बाद में उन पर बेंचमार्क किया गया।
7.4B सक्रिय लागत पर sparse MoE गुणवत्ता — आपको 7.4B inference पाथ के माध्यम से 104B पैरामीटर वाला ज्ञान पूल मिलता है।
256K कॉन्टेक्स्ट डिफ़ॉल्ट रूप में — 262K नेटिव टोकन, लंबे एजेंट ट्रेस के लिए YaRN ट्रिक्स की ज़रूरत नहीं।
MIT लाइसेंस — पूरी तरह व्यावसायिक, फाइन-ट्यून करने योग्य, पुनर्वितरण योग्य।
वंशावली — का प्रत्यक्ष उत्तराधिकारी Ling-2.5-1T और Ring-2.5 का; आर्किटेक्चर युद्ध-परीक्षित है।

आवश्यकताएँ

Clore के लिए अनुकूल। यह inclusionAI लाइनअप का पहला मॉडल है जो एक ही उपभोक्ता GPU पर चलता है। यदि आप Ling-2.5-1T या GLM-5.1की कीमत के कारण बाहर हो गए थे, तो यही प्रवेश बिंदु है।

घटक

INT4 (एकल 24GB)

FP8 (एकल 80GB)

BF16 (पूर्ण गुणवत्ता)

GPU VRAM

1× RTX 4090 / 3090 (24GB)

1× H100 / A100 80GB

2× A100 80GB या 1× H200 141GB

RAM

32GB

64GB

128GB

डिस्क

60GB NVMe

120GB NVMe

220GB NVMe

CUDA

12.0+

12.4+

व्यावहारिक कॉन्टेक्स्ट

32K–64K

128K

256K

Clore.ai चयन: अधिकांश एजेंट वर्कलोड के लिए, एक RTX 4090 (~$0.70–2.50/घंटा) पर चल रहा INT4 GGUF कीमत के लिहाज़ से बेहतरीन है। यदि आपको FP8 गुणवत्ता या 128K+ कॉन्टेक्स्ट चाहिए, तो एकल H100 पर जाएँ।

विकल्प A — Ollama / GGUF (क्वांटाइज़्ड, एकल GPU)

यह वह रास्ता है जिसे अधिकांश Clore.ai उपयोगकर्ता चाहेंगे। समुदाय GGUFs आमतौर पर inclusionAI रिलीज़ के कुछ दिनों के भीतर HuggingFace पर दिखाई देते हैं।

पहले दिन की सूचना: Ling-2.6-flash 28 अप्रैल, 2026 को जारी हुआ। इस लेखन के समय GGUF समुदाय क्वांट्स शायद अभी आ रहे हों। देखें huggingface.co/models?search=ling-2.6-flash+gguf और unsloth पर शुरुआती बिल्ड्स के लिए। यदि ollama pull 404 दिखाए, तो llama.cpp को सीधे GGUF फ़ाइल पर इंगित करें।

# जैसे ही समुदाय Q4_K_M बिल्ड प्रकाशित हो
docker exec ollama ollama pull ling-2.6-flash:q4_K_M
docker exec ollama ollama run ling-2.6-flash:q4_K_M

# या डाउनलोड किए गए GGUF पर सीधे llama.cpp के साथ
docker run --gpus all -it --rm -p 8080:8080 \
  -v $(pwd)/models:/models \
  ghcr.io/ggerganov/llama.cpp:server-cuda \
  -m /models/ling-2.6-flash-q4_k_m.gguf \
  --n-gpu-layers 99 --ctx-size 32768 \
  --port 8080 --host 0.0.0.0

एक RTX 4090 से ~80–120 tok/s Q4_K_M पर 32K कॉन्टेक्स्ट के साथ मिलना चाहिए — इंटरैक्टिव एजेंट काम के लिए पर्याप्त।

विकल्प B — vLLM (प्रोडक्शन API)

कई समकालीन एजेंटों को Ling-2.6-flash सर्व करने के लिए vLLM सबसे उपयुक्त है। एकल H100 / A100 80GB पर FP8 चेकपॉइंट इस्तेमाल करें:

version: "3.8"
services:
  vllm:
    image: vllm/vllm-openai:latest
    ports:
      - "8000:8000"
    volumes:
      - hf_cache:/root/.cache/huggingface
    command: >
      --model inclusionAI/Ling-2.6-flash-FP8
      --tensor-parallel-size 1
      --max-model-len 65536
      --gpu-memory-utilization 0.90
      --enable-auto-tool-choice
      --tool-call-parser hermes
      --served-model-name ling-2.6-flash
      --trust-remote-code
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
    shm_size: "16gb"

volumes:
  hf_cache:

# एजेंट पाथ का परीक्षण करें
curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "ling-2.6-flash",
    "messages": [
      {"role": "system", "content": "आप टूल्स तक पहुँच वाले एक एजेंट हैं। योजना बनाएँ, टूल्स कॉल करें, फिर उत्तर दें।"},
      {"role": "user", "content": "मुझे अभी Clore.ai पर सबसे सस्ता RTX 4090 ढूँढकर दें।"}
    ],
    "tools": [{"type": "function", "function": {"name": "search_marketplace", "parameters": {"type":"object","properties":{"gpu":{"type":"string"}}}}}],
    "tool_choice": "auto",
    "max_tokens": 2048
  }'

लंबे कॉन्टेक्स्ट (200K+) पर BF16 पूर्ण गुणवत्ता के लिए, बढ़ाएँ --tensor-parallel-size 2 को 2× A100 80GB पर, या एकल H200 141GB पर पिन करें।

विकल्प C — SGLang (अधिकतम थ्रूपुट के लिए अनुशंसित)

आधिकारिक 340 tok/s बेंचमार्क के लिए Ant Group द्वारा SGLang का उपयोग किया जाता है — SGLang के रनटाइम में हाइब्रिड लीनियर अटेंशन पाथ सबसे तेज़ है।

docker pull lmsysorg/sglang:latest

python3 -m sglang.launch_server \\
  --model-path inclusionAI/Ling-2.6-flash-FP8 \
  --tp-size 1 \\
  --tool-call-parser hermes \
  --mem-fraction-static 0.90 \\
  --context-length 65536 \
  --served-model-name ling-2.6-flash \
  --host 0.0.0.0 --port 30000

# विक्रेता के 340 tok/s नंबर को दोहराने के लिए (4x H20 / H100 वर्ग आवश्यक)
python3 -m sglang.launch_server \\
  --model-path inclusionAI/Ling-2.6-flash \
  --tp-size 4 \
  --mem-fraction-static 0.92 \
  --context-length 32768 \
  --served-model-name ling-2.6-flash

Clore.ai GPU सिफ़ारिशें

सेटअप

VRAM

क्वांट

अपेक्षित थ्रूपुट

Clore.ai लागत

1× RTX 3090

24GB

INT4 GGUF

~60–90 tok/s

~$0.33–1.24/घंटा

1× RTX 4090

24GB

INT4 GGUF

~80–120 tok/s

~$0.70–2.50/घंटा

1× A100 80GB

80GB

FP8

~120–180 tok/s

~$2–4/घंटा

1× H100 80GB

80GB

FP8

~150–220 tok/s

~$6–8/घंटा

4× H100 80GB

320GB

BF16 + TP=4

~340 tok/s (विक्रेता)

~$24–32/घंटा

सर्वोत्तम मूल्य: $0.70/घंटा से एक RTX 4090 पर Q4_K_M GGUF चल रहा है। आपको 32K कॉन्टेक्स्ट वाला एक एजेंट-ट्यून किया हुआ, MIT-लाइसेंस प्राप्त, 104B-MoE मॉडल मिलता है, वह भी प्रति घंटे एक कॉफी की कीमत से कम में। यही वह डिप्लॉयमेंट रूप है जिसके लिए Clore.ai का उपभोक्ता-GPU मार्केटप्लेस बनाया गया था।

उपयोग के मामले

टूल-कॉलिंग एजेंट — BFCL-V4 और TAU2-bench ट्यूनिंग का मतलब है कि संरचित फ़ंक्शन डिस्पैच एक ताकत है, बाद की सोच नहीं।
मल्टी-स्टेप प्लानिंग लूप्स — छोटे मॉडलों में आम ड्रिफ्ट के बिना लंबे समय तक टूल-कॉल ट्रेस।
स्थानीय Claude Code / OpenHands विकल्प — अपने RTX 4090 पर सीधे OpenAI-संगत API।
उच्च-आयतन एजेंटिक बैच जॉब्स — 4×H100 पर 340 tok/s इसे प्रति घंटे हज़ारों एजेंट ट्रांसक्रिप्ट प्रोसेस करने के लिए व्यावहारिक बनाता है।
लंबा-संदर्भ RAG — 256K नेटिव ctx अधिकांश एंटरप्राइज़ डॉक्यूमेंट सेट्स को एक ही प्रॉम्प्ट में कवर करता है।
के लिए सस्ता डेवलपमेंट सैंडबॉक्स Ling-2.5-1T वर्कफ़्लोज़ — flash पर प्रोटोटाइप बनाइए, 1T वेरिएंट पर डिप्लॉय कीजिए।

बेंचमार्क

विक्रेता द्वारा दावा किया गया — स्वतंत्र रूप से सत्यापित करें। नीचे दिए गए सभी आँकड़े inclusionAI के 28 अप्रैल, 2026 मॉडल कार्ड से लिए गए हैं। मॉडल केवल एक दिन पुराना है; BFCL-V4 और TAU2-bench पर समुदाय के पुनरुत्पादन अभी प्रकाशित नहीं हुए हैं। इन्हें दिशात्मक मानें, अंतिम सत्य नहीं।

बेंचमार्क

Ling-2.6-flash (विक्रेता)

नोट्स

BFCL-V4

आकार वर्ग में SOTA

Berkeley Function Calling Leaderboard v4

TAU2-bench

आकार वर्ग में SOTA

Tool agent benchmark v2

SWE-bench Verified / Resolved

~61.2%

सत्यापित विभाजन पर resolved rate

MathArena AIME 2026

73.85

MathArena HMMT फ़रवरी 2026

49.29

थ्रूपुट

~340 tok/s

4× H20-3e, TP=4, batch 32

समस्या-निवारण

समस्या

समाधान

OutOfMemoryError RTX 4090 पर

Q4_K_S या Q3_K_M पर घटाएँ; --ctx-size को 16384 तक कम करें; अन्य GPU प्रक्रियाएँ बंद करें

GGUF अभी HuggingFace पर नहीं है

मॉडल केवल एक दिन पुराना है। देखें unsloth, bartowskiऔर TheBloke मिरर्स; या स्वयं BF16 से क्वांटाइज़ करें llama-quantize

vLLM आर्किटेक्चर को अस्वीकार करता है

सुनिश्चित करें कि vLLM ≥ 0.7.x हो --trust-remote-code; हाइब्रिड लीनियर अटेंशन लेयर्स कस्टम हैं

टूल कॉल्स सादा टेक्स्ट के रूप में लौटे

सेट करें --enable-auto-tool-choice --tool-call-parser hermes vLLM में; SGLang इसे स्वतः संभालता है

लंबे कॉन्टेक्स्ट पर धीमा प्रीफिल

लीनियर अटेंशन में वॉर्मअप ओवरहेड होता है; पहला अनुरोध हमेशा सबसे धीमा होता है। उपयोग करें --enable-chunked-prefill vLLM में

थ्रूपुट 340 tok/s से काफी कम

विक्रेता का नंबर 4× H20, TP=4 और batch 32 पर है। एकल-GPU + batch 1 स्वाभाविक रूप से बहुत धीमा होगा — यह अपेक्षित है, बग नहीं

उच्च तापमान पर विकृत आउटपुट

इसे घटाकर temperature=0.7 चैट के लिए, 0.1 टूल कॉलिंग के लिए

अगले कदम

बड़ा सहोदर: Ling-2.5-1T — वही परिवार, 1T कुल / 63B सक्रिय, मल्टी-GPU लागत पर frontier reasoning
समान एकल-GPU एजेंट: MiMo-V2-Flash — 309B/15B सक्रिय, अंतर्निहित speculative decoding के साथ
ओपन-वेट कोडिंग विकल्प: GLM-5.1 — 744B/40B सक्रिय, SWE-Bench Pro लीडर
सस्ते GPU किराए: RTX 4090 किराए पर लें $0.70/घंटा से या RTX 3090 $0.33/घंटा से
Clore.ai Marketplace: clore.ai/marketplace — ऑन-डिमांड और स्पॉट प्राइसिंग सहित पूर्ण GPU कैटलॉग

लिंक

HuggingFace पर Ling-2.6-flash
inclusionAI संगठन — Ant Group की ओपन-सोर्स AI लैब
SGLang रिपो — अनुशंसित सर्विंग फ़्रेमवर्क
vLLM दस्तावेज़
BFCL-V4 लीडरबोर्ड — Berkeley Function Calling

पिछलाMiniMax M2.7 (229B MoE Coding)अगलाQwen3.6-27B (Dense, Single-GPU)

अंतिम अपडेट 3 माह पहले

क्या यह उपयोगी था?