> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-hi/language-models/ling25.md).

# Ling-2.5-1T (1 ट्रिलियन पैरामीटर)

Clore.ai GPUs पर Ling-2.5-1T चलाएँ — Ant Group का 1 ट्रिलियन पैरामीटर ओपन-सोर्स LLM, हाइब्रिड लिनियर अटेंशन के साथ

Ant Group का Ling-2.5-1T (16 फ़रवरी, 2026 को जारी) अब तक जारी किए गए सबसे बड़े ओपन-सोर्स भाषा मॉडलों में से एक है — **कुल 1 ट्रिलियन पैरामीटर, जिनमें 63B सक्रिय हैं**. यह एक हाइब्रिड लीनियर अटेंशन आर्किटेक्चर पेश करता है, जो 1 मिलियन टोकन तक की कॉन्टेक्स्ट लंबाइयों पर कुशल इन्फ़रेंस सक्षम बनाता है। इसके साथ ही, Ant Group ने Ring-2.5-1T जारी किया, जो दुनिया का पहला हाइब्रिड लीनियर-आर्किटेक्चर थिंकिंग मॉडल है। मिलकर, ये ओपन-सोर्स AI में एक नया सीमांत दर्शाते हैं — जो रीजनिंग और एजेंटिक बेंचमार्क्स पर GPT-5.2, DeepSeek V3.2, और Kimi K2.5 के समकक्ष है।

**HuggingFace:** [inclusionAI/Ling-2.5-1T](https://huggingface.co/inclusionAI/Ling-2.5-1T) **सहायक मॉडल:** [inclusionAI/Ring-2.5-1T](https://huggingface.co/inclusionAI/Ring-2.5-1T) (थिंकिंग/रीजनिंग वेरिएंट) **लाइसेंस:** ओपन सोर्स (Ant Group InclusionAI License)

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

* **कुल 1 ट्रिलियन पैरामीटर, 63B सक्रिय** — कुशल MoE-शैली सक्रियण के साथ विशाल पैमाना
* **हाइब्रिड लीनियर अटेंशन** — लंबे सीक्वेंस पर असाधारण थ्रूपुट के लिए MLA (मल्टी-हेड लीनियर अटेंशन) को Lightning Linear Attention के साथ जोड़ता है
* **1M टोकन कॉन्टेक्स्ट विंडो** — मूल 256K से YaRN एक्सटेंशन के माध्यम से, पूरे कोडबेस और किताब-लंबाई वाले दस्तावेज़ों को संभालता है
* **अग्रणी रीजनिंग** — लगभग 4× कम आउटपुट टोकन इस्तेमाल करते हुए थिंकिंग-मॉडल प्रदर्शन के करीब पहुँचता है
* **एजेंटिक क्षमताएँ** — Agentic RL के साथ प्रशिक्षित, Claude Code, OpenCode, और OpenClaw के साथ संगत
* **Ring-2.5-1T सहायक** — समर्पित रीजनिंग वेरिएंट IMO 2025 और CMO 2025 स्वर्ण पदक स्तर प्राप्त करता है

## आर्किटेक्चर विवरण

| घटक                   | विवरण                                           |
| --------------------- | ----------------------------------------------- |
| कुल पैरामीटर          | 1T (1,000B)                                     |
| सक्रिय पैरामीटर       | 63B                                             |
| आर्किटेक्चर           | हाइब्रिड लीनियर अटेंशन (MLA + Lightning Linear) |
| प्री-ट्रेनिंग डेटा    | 29T टोकन                                        |
| मूल कॉन्टेक्स्ट       | 256K टोकन                                       |
| विस्तारित कॉन्टेक्स्ट | 1M टोकन (YaRN)                                  |
| रिलीज़ तिथि           | 16 फ़रवरी, 2026                                 |

## आवश्यकताएँ

{% hint style="warning" %}
**Clore.ai marketplace पर multi-GPU 80GB-class rigs सूचीबद्ध नहीं हैं।** आज सूचीबद्ध सबसे बड़े boxes 4× RTX PRO 6000 Blackwell (प्रत्येक 96GB, कुल 380GB) और 8–11× RTX 5090 (प्रत्येक 32GB) हैं। A100 / H200 / B200 क्षमता [bare metal](https://clore.ai/bare-metal) के रूप में अनुरोध पर बेची जाती है। देखें [GPU मूल्य और उपलब्धता](/guides/guides_v2-hi/getting-started/pricing.md) किसी deployment का आकार तय करने से पहले।
{% endhint %}

पूर्ण प्रिसीजन पर Ling-2.5-1T चलाने के लिए पर्याप्त संसाधनों की आवश्यकता होती है। क्वांटाइज़्ड संस्करण इसे अधिक सुलभ बनाते हैं।

| कॉन्फ़िगरेशन | क्वांटाइज़्ड (Q4 GGUF) | FP8            | BF16 (पूर्ण)     |
| ------------ | ---------------------- | -------------- | ---------------- |
| GPU          | 8× RTX 4090            | 8× H100 80GB   | 16× H100 80GB    |
| VRAM         | 8×24GB (192GB)         | 8×80GB (640GB) | 16×80GB (1.28TB) |
| RAM          | 256GB                  | 512GB          | 1TB              |
| डिस्क        | 600GB                  | 1.2TB          | 2TB+             |
| CUDA         | 12.8+                  | 12.8+          | 12.8+            |

**अनुशंसित Clore.ai सेटअप:**

* **क्वांटाइज़्ड (Q4):** 8× RTX 4090 ($1.12–3.36/घंटा) — प्रयोग और मध्यम वर्कलोड के लिए उपयोगी
* **प्रोडक्शन (FP8):** 8× H100 (\~$8.32/घंटा) — अच्छी थ्रूपुट के साथ पूर्ण गुणवत्ता
* **ध्यान दें:** यह एक अत्यंत बड़ा मॉडल है। बजट-चेतन उपयोगकर्ताओं के लिए, Ling परिवार के छोटे मॉडल देखें [HuggingFace](https://huggingface.co/inclusionAI).

## vLLM के साथ क्विक स्टार्ट

Ling-2.5-1T के लिए vLLM अनुशंसित सर्विंग फ्रेमवर्क है:

```bash
# vLLM इंस्टॉल करें
pip install vllm

# 8 GPUs पर टेंसर पैरेललिज़्म के साथ Ling-2.5-1T सर्व करें
vllm serve inclusionAI/Ling-2.5-1T \
    --tensor-parallel-size 8 \\
    --max-model-len 65536 \
    --gpu-memory-utilization 0.90 \
    --trust-remote-code \
    --host 0.0.0.0 \
    --port 8000

# कम मेमोरी के लिए, कॉन्टेक्स्ट लंबाई सीमित करें:
vllm serve inclusionAI/Ling-2.5-1T \
    --tensor-parallel-size 8 \\
    --max-model-len 16384 \
    --gpu-memory-utilization 0.95 \
    --trust-remote-code \
    --host 0.0.0.0 \
    --port 8000
```

## llama.cpp के साथ क्विक स्टार्ट (क्वांटाइज़्ड)

कंज़्यूमर GPU सेटअप के लिए, GGUF क्वांटाइज़ेशन उपलब्ध हैं:

```bash
# llama.cpp इंस्टॉल करें
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
cmake -B build -DGGML_CUDA=ON
cmake --build build --config Release -j$(nproc)

# एक क्वांटाइज़्ड GGUF डाउनलोड करें (उपलब्ध क्वांट्स के लिए HuggingFace देखें)
huggingface-cli download inclusionAI/Ling-2.5-1T-GGUF \
    --include "*.Q4_K_M.gguf" \
    --local-dir ./models/

# llama-server के साथ सर्व करें (अपने GPU count के लिए -ngl समायोजित करें)
./build/bin/llama-server \
    -m ./models/Ling-2.5-1T-Q4_K_M.gguf \
    -ngl 99 \
    -c 8192 \
    --host 0.0.0.0 \
    --port 8000
```

## उपयोग के उदाहरण

### 1. OpenAI API के माध्यम से चैट कम्प्लीशन

एक बार vLLM या llama-server चलने लगे:

```python
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="not-needed"
)

response = client.chat.completions.create(
    model="inclusionAI/Ling-2.5-1T",
    messages=[
        {"role": "system", "content": "आप एक विश्वस्तरीय रीजनिंग असिस्टेंट हैं। चरण-दर-चरण सोचें।"},
        {"role": "user", "content": "साबित करें कि 2 का वर्गमूल अपरिमेय है।"}
    ],
    temperature=0.1,
    max_tokens=4096
)

print(response.choices[0].message.content)
```

### 2. लंबे-कॉन्टेक्स्ट दस्तावेज़ विश्लेषण

Ling-2.5-1T की हाइब्रिड लीनियर अटेंशन इसे लंबे दस्तावेज़ों के लिए असाधारण रूप से कुशल बनाती है:

```python
from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="n/a")

# एक बड़ा दस्तावेज़ लोड करें
with open("full_codebase.txt", "r") as f:
    codebase = f.read()  # यह सैकड़ों हज़ार टोकन हो सकते हैं

response = client.chat.completions.create(
    model="inclusionAI/Ling-2.5-1T",
    messages=[
        {"role": "system", "content": "आप एक वरिष्ठ सॉफ़्टवेयर आर्किटेक्ट हैं।"},
        {"role": "user", "content": f"इस कोडबेस का सुरक्षा कमजोरियों और आर्किटेक्चरल समस्याओं के लिए विश्लेषण करें:\n\n{codebase}"}
    ],
    temperature=0.1,
    max_tokens=8192
)

print(response.choices[0].message.content)
```

### 3. एजेंटिक टूल उपयोग

Ling-2.5-1T को टूल कॉलिंग के लिए Agentic RL के साथ प्रशिक्षित किया गया है:

```python
from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="n/a")

tools = [
    {
        "type": "function",
        "function": {
            "name": "search_database",
            "description": "उत्पाद डेटाबेस खोजें",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {"type": "string"},
                    "category": {"type": "string", "enum": ["electronics", "clothing", "books"]},
                    "max_price": {"type": "number"}
                },
                "required": ["query"]
            }
        }
    }
]

response = client.chat.completions.create(
    model="inclusionAI/Ling-2.5-1T",
    messages=[{"role": "user", "content": "मुझे अच्छे रिव्यू वाले $1000 से कम का लैपटॉप ढूँढकर दें"}],
    tools=tools,
    tool_choice="auto"
)

print(response.choices[0].message.tool_calls)
```

## Ling-2.5-1T बनाम Ring-2.5-1T

| पहलू                | Ling-2.5-1T                        | Ring-2.5-1T                            |
| ------------------- | ---------------------------------- | -------------------------------------- |
| प्रकार              | तत्काल (तेज़) मॉडल                 | थिंकिंग (रीजनिंग) मॉडल                 |
| आर्किटेक्चर         | हाइब्रिड लीनियर अटेंशन             | हाइब्रिड लीनियर अटेंशन                 |
| किसके लिए सर्वोत्तम | सामान्य चैट, कोडिंग, एजेंटिक कार्य | गणित, औपचारिक रीजनिंग, जटिल समस्याएँ   |
| आउटपुट शैली         | सीधे उत्तर                         | चेन-ऑफ़-थॉट रीजनिंग                    |
| टोकन दक्षता         | उच्च (कम आउटपुट टोकन)              | रीजनिंग के लिए अधिक टोकन उपयोग करता है |
| IMO 2025            | प्रतिस्पर्धी                       | स्वर्ण पदक स्तर                        |

## Clore.ai उपयोगकर्ताओं के लिए सुझाव

1. **इस मॉडल के लिए गंभीर हार्डवेयर चाहिए** — 1T पैरामीटर पर, Q4 क्वांटाइज़ेशन के लिए भी \~500GB स्टोरेज और 192GB+ VRAM की आवश्यकता होती है। डाउनलोड करने से पहले सुनिश्चित करें कि आपके Clore.ai instance में पर्याप्त डिस्क और मल्टी-GPU है।
2. **से शुरू करें `--max-model-len 8192`** — पहली बार परीक्षण करते समय, मॉडल के लोड और सही ढंग से चलने की पुष्टि के लिए छोटा कॉन्टेक्स्ट उपयोग करें। सब कुछ ठीक हो जाने के बाद कॉन्टेक्स्ट लंबाई बढ़ाएँ।
3. **स्थायी स्टोरेज का उपयोग करें** — मॉडल का आकार 1–2TB है। दोबारा डाउनलोड से बचने के लिए Clore.ai पर एक बड़ा स्थायी वॉल्यूम जोड़ें। एक बार डाउनलोड करें `huggingface-cli download`.
4. **रीजनिंग कार्यों के लिए Ring-2.5-1T पर विचार करें** — यदि आपका उपयोग मुख्यतः गणित, तर्क, या औपचारिक रीजनिंग है, तो सहायक Ring-2.5-1T मॉडल विशेष रूप से चेन-ऑफ़-थॉट रीजनिंग के लिए अनुकूलित है।
5. **GPU मेमोरी मॉनिटर करें** — 8-GPU सेटअप के साथ, उपयोग करें `nvidia-smi -l 1` मेमोरी उपयोग की निगरानी करने और लंबे कॉन्टेक्स्ट के साथ जनरेशन के दौरान OOM पर नज़र रखने के लिए।

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

| समस्या                                  | समाधान                                                                                                                                     |
| --------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
| `CUDA out of memory`                    | कम करें `--max-model-len`; सुनिश्चित करें `--tensor-parallel-size` GPU count से मेल खाता है; आज़माएँ `--gpu-memory-utilization 0.95`       |
| बहुत धीमी जनरेशन                        | लीनियर अटेंशन को वार्मअप चाहिए; शुरुआती कुछ अनुरोध धीमे हो सकते हैं। यह भी जाँचें कि GPUs के बीच NVLink है                                 |
| मॉडल डाउनलोड विफल होता है               | मॉडल BF16 में \~2TB का है। पर्याप्त डिस्क स्थान सुनिश्चित करें। उपयोग करें `--resume-download` फ्लैग के साथ `huggingface-cli`              |
| vLLM इस आर्किटेक्चर को सपोर्ट नहीं करता | सुनिश्चित करें कि आप vLLM ≥0.7.0 का उपयोग `--trust-remote-code`कर रहे हैं; कस्टम अटेंशन लेयर्स को इस फ्लैग की आवश्यकता होती है             |
| GGUF उपलब्ध नहीं है                     | जाँचें [unsloth](https://huggingface.co/unsloth) या समुदायिक क्वांटाइज़ेशन; संभव है समुदाय को मॉडल को क्वांटाइज़ करने में समय लगे          |
| कमज़ोर गुणवत्ता वाले उत्तर              | तथ्यात्मक कार्यों के लिए temperature ≤0.1 उपयोग करें; एक system prompt जोड़ें; सुनिश्चित करें कि आप कॉन्टेक्स्ट को ट्रंकेट नहीं कर रहे हैं |

## अधिक पढ़ें

* [आधिकारिक घोषणा (BusinessWire)](https://www.businesswire.com/news/home/20260215551663/en/) — रिलीज़ विवरण और बेंचमार्क्स
* [HuggingFace — Ling-2.5-1T](https://huggingface.co/inclusionAI/Ling-2.5-1T) — मॉडल वेट्स और दस्तावेज़ीकरण
* [HuggingFace — Ring-2.5-1T](https://huggingface.co/inclusionAI/Ring-2.5-1T) — थिंकिंग मॉडल सहायक
* [ModelScope मिरर](https://www.modelscope.cn/models/inclusionAI/Ling-2.5-1T) — एशिया में तेज़ डाउनलोड
* [vLLM दस्तावेज़ीकरण](https://docs.vllm.ai/) — सर्विंग फ्रेमवर्क


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-hi/language-models/ling25.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
