> 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 ट्रिलियन पैरामीटर)

Ant Group द्वारा Ling-2.5-1T (रिलीज़ 16 फ़रवरी, 2026) अब तक जारी किए गए सबसे बड़े ओपन-सोर्स भाषा मॉडलों में से एक है — **कुल 1 ट्रिलियन पैरामीटर जिनमें 63B सक्रिय हैं**. यह एक हाइब्रिड लिनियर अटेंशन आर्किटेक्चर पेश करता है जो 1 मिलियन टोकन तक के कॉन्टेक्स्ट लंबाई पर कुशल इन्फरेंस सक्षम करता है। इसके साथ ही, Ant Group ने Ring-2.5-1T जारी किया, जो दुनिया का पहला हाइब्रिड लिनियर-आर्किटेक्चर थिंकिंग मॉडल है। साथ मिलकर, ये ओपन-सोर्स एआई में एक नया फ्रंटियर प्रतिनिधित्व करते हैं — तर्क और एजेंटिक बेंचमार्क्स पर 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 लाइसेंस)

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

* **कुल 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                                 |

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

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.0+                  | 12.0+          | 12.0+            |

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

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

## vLLM के साथ त्वरित प्रारंभ

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

```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 काउंट के लिए -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": "Prove that the square root of 2 is irrational."}
    ],
    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 इंस्टेंस में पर्याप्त डिस्क और मल्टी-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 में आउट ऑफ मेमोरी`             | घटाएँ `--max-model-len`; सुनिश्चित करें `--tensor-parallel-size` GPU काउंट से मेल खाता है; प्रयास करें `--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) या समुदाय-क्वांटाइज़ेशन; मॉडल को समुदाय द्वारा क्वांटाइज़ होने में समय लग सकता है       |
| खराब गुणवत्ता वाले उत्तर             | तथ्यात्मक कार्यों के लिए तापमान ≤0.1 का उपयोग करें; एक सिस्टम प्रॉम्प्ट जोड़ें; सुनिश्चित करें कि आप कॉन्टेक्स्ट को कट नहीं कर रहे हैं   |

## अधिक पढ़ने के लिए

* [आधिकारिक घोषणा (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.
