> 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-de/sprachmodelle/ling25.md).

# Ling-2.5-1T (1 Billion Parameter)

Ling-2.5-1T von Ant Group (veröffentlicht am 16. Februar 2026) ist eines der größten jemals veröffentlichten Open-Source-Sprachmodelle — **1 Billion Gesamtparameter mit 63B aktiv**. Es führt eine hybride lineare Aufmerksamkeitsarchitektur ein, die effiziente Inferenz bei Kontextlängen von bis zu 1 Million Token ermöglicht. Begleitend dazu veröffentlichte Ant Group Ring-2.5-1T, das weltweit erste Denkmodell mit hybrider linearer Architektur. Zusammen repräsentieren sie eine neue Grenze in der Open-Source-KI — konkurrenzfähig mit GPT-5.2, DeepSeek V3.2 und Kimi K2.5 bei Reasoning- und Agentic-Benchmarks.

**HuggingFace:** [inclusionAI/Ling-2.5-1T](https://huggingface.co/inclusionAI/Ling-2.5-1T) **Begleitmodell:** [inclusionAI/Ring-2.5-1T](https://huggingface.co/inclusionAI/Ring-2.5-1T) (Denk-/Reasoning-Variante) **Lizenz:** Open Source (Ant Group InclusionAI Lizenz)

## Hauptmerkmale

* **1 Billion Gesamtparameter, 63B aktiv** — massive Größe mit effizienter MoE-ähnlicher Aktivierung
* **Hybride lineare Aufmerksamkeit** — kombiniert MLA (Multi-head Linear Attention) mit Lightning Linear Attention für außergewöhnlichen Durchsatz bei langen Sequenzen
* **1M Token-Kontextfenster** — über YaRN-Erweiterung von nativen 256K, verarbeitet ganze Codebasen und bücherlange Dokumente
* **Grenzen des Reasoning** — nähert sich der Leistung von Denkmodellen an und verwendet dabei etwa 4× weniger Ausgabetoken
* **Agentische Fähigkeiten** — trainiert mit Agentic RL, kompatibel mit Claude Code, OpenCode und OpenClaw
* **Ring-2.5-1T Begleiter** — dedizierte Reasoning-Variante erreicht IMO 2025 und CMO 2025 Goldmedaillen-Niveau

## Architekturdetails

| Komponente             | Details                                                 |
| ---------------------- | ------------------------------------------------------- |
| Gesamtparameter        | 1T (1.000B)                                             |
| Aktive Parameter       | 63B                                                     |
| Architektur            | Hybride lineare Aufmerksamkeit (MLA + Lightning Linear) |
| Vortrainingsdaten      | 29T Token                                               |
| Nativer Kontext        | 256K Token                                              |
| Erweiterter Kontext    | 1M Token (YaRN)                                         |
| Veröffentlichungsdatum | 16. Februar 2026                                        |

## Anforderungen

Ling-2.5-1T im Vollpräzisionsbetrieb auszuführen erfordert erhebliche Ressourcen. Quantisierte Versionen machen es zugänglicher.

| Konfiguration | Quantisiert (Q4 GGUF) | FP8            | BF16 (Vollständig) |
| ------------- | --------------------- | -------------- | ------------------ |
| 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                |
| Festplatte    | 600GB                 | 1,2TB          | 2TB+               |
| CUDA          | 12.0+                 | 12.0+          | 12.0+              |

**Empfohlene Clore.ai-Konfiguration:**

* **Quantisiert (Q4):** 8× RTX 4090 (\~$4–16/Tag) — geeignet für Experimente und moderate Workloads
* **Produktion (FP8):** 8× H100 (\~$24–48/Tag) — volle Qualität mit gutem Durchsatz
* **Hinweis:** Dies ist ein extrem großes Modell. Für budgetbewusste Nutzer sollten Sie die kleineren Modelle der Ling-Familie auf [HuggingFace](https://huggingface.co/inclusionAI).

## Schnellstart mit vLLM

vLLM ist das empfohlene Serving-Framework für Ling-2.5-1T:

```bash
# Installiere vLLM
pip install vllm

# Serviere Ling-2.5-1T mit Tensor-Parallelismus über 8 GPUs
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

# Für reduzierten Speicherbedarf, begrenzen Sie die Kontextlänge:
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
```

## Schnellstart mit llama.cpp (quantisiert)

Für Consumer-GPU-Setups sind GGUF-Quantisierungen verfügbar:

```bash
# Installiere 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)

# Lade eine quantisierte GGUF herunter (prüfe HuggingFace auf verfügbare Quants)
huggingface-cli download inclusionAI/Ling-2.5-1T-GGUF \
    --include "*.Q4_K_M.gguf" \
    --local-dir ./models/

# Serviere mit llama-server (passe -ngl an deine GPU-Anzahl an)
./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
```

## Beispielanwendungen

### 1. Chat-Vervollständigung über die OpenAI-API

Sobald vLLM oder llama-server läuft:

```python
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="nicht benötigt"
)

response = client.chat.completions.create(
    model="inclusionAI/Ling-2.5-1T",
    messages=[
        {"role": "system", "content": "Sie sind ein erstklassiger Reasoning-Assistent. Denken Sie Schritt für Schritt."},
        {"role": "user", "content": "Beweise, dass die Quadratwurzel von 2 irrational ist."}
    ],
    temperature=0.1,
    max_tokens=4096
)

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

### 2. Langkontext-Dokumentenanalyse

Die hybride lineare Aufmerksamkeit von Ling-2.5-1T macht es außerordentlich effizient für lange Dokumente:

```python
from openai import OpenAI

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

# Lade ein großes Dokument
with open("full_codebase.txt", "r") as f:
    codebase = f.read()  # Kann Hunderttausende von Token enthalten

response = client.chat.completions.create(
    model="inclusionAI/Ling-2.5-1T",
    messages=[
        {"role": "system", "content": "Sie sind ein leitender Softwarearchitekt."},
        {"role": "user", "content": f"Analysiere diese Codebasis auf Sicherheitslücken und Architekturprobleme:\n\n{codebase}"}
    ],
    temperature=0.1,
    max_tokens=8192
)

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

### 3. Agentischer Tool-Einsatz

Ling-2.5-1T wurde mit Agentic RL für Tool-Aufrufe trainiert:

```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": "Durchsucht die Produktdatenbank",
            "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": "Finde mir einen Laptop unter $1000 mit guten Bewertungen"}],
    tools=tools,
    tool_choice="auto"
)

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

## Ling-2.5-1T vs Ring-2.5-1T

| Aspekt                 | Ling-2.5-1T                                   | Ring-2.5-1T                                       |
| ---------------------- | --------------------------------------------- | ------------------------------------------------- |
| Typ                    | Instant (schnelles) Modell                    | Denk- (Reasoning-) Modell                         |
| Architektur            | Hybride lineare Aufmerksamkeit                | Hybride lineare Aufmerksamkeit                    |
| Am besten geeignet für | Allgemeinen Chat, Coding, agentische Aufgaben | Mathematik, formales Reasoning, komplexe Probleme |
| Ausgabestil            | Direkte Antworten                             | Chain-of-Thought-Reasoning                        |
| Token-Effizienz        | Hoch (weniger Ausgabetoken)                   | Verwendet mehr Token für Reasoning                |
| IMO 2025               | Wettbewerbsfähig                              | Goldmedaillen-Niveau                              |

## Tipps für Clore.ai-Nutzer

1. **Dieses Modell benötigt ernsthafte Hardware** — Bei 1T Parametern erfordert selbst Q4-Quantisierung etwa \~500GB Speicherplatz und 192GB+ VRAM. Stellen Sie sicher, dass Ihre Clore.ai-Instanz über ausreichend Festplatte und Multi-GPU verfügt, bevor Sie den Download starten.
2. **Beginnen Sie mit `--max-model-len 8192`** — Beim ersten Testen verwenden Sie einen kurzen Kontext, um zu prüfen, ob das Modell korrekt geladen und ausgeführt wird. Erhöhen Sie die Kontextlänge, sobald alles funktioniert.
3. **Verwenden Sie persistenten Speicher** — Das Modell wiegt 1–2TB. Hängen Sie ein großes persistentes Volume an Clore.ai an, um erneutes Herunterladen zu vermeiden. Laden Sie einmal mit `huggingface-cli download`.
4. **Erwägen Sie Ring-2.5-1T für Reasoning-Aufgaben** — Wenn Ihr Anwendungsfall hauptsächlich Mathematik, Logik oder formales Reasoning ist, ist das Begleitmodell Ring-2.5-1T speziell für Chain-of-Thought-Reasoning optimiert.
5. **Überwachen Sie den GPU-Speicher** — Bei 8-GPU-Setups verwenden Sie `nvidia-smi -l 1` um die Speichernutzung zu überwachen und auf OOM während der Generierung mit langen Kontexten zu achten.

## Fehlerbehebung

| Problem                                | Lösung                                                                                                                                                               |
| -------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `CUDA out of memory`                   | Reduzieren `--max-model-len`; stellen Sie sicher `--tensor-parallel-size` entspricht der GPU-Anzahl; versuchen Sie `--gpu-memory-utilization 0.95`                   |
| Sehr langsame Generierung              | Lineare Aufmerksamkeit benötigt Aufwärmzeit; die ersten Anfragen können langsam sein. Prüfen Sie auch, ob NVLink zwischen den GPUs vorhanden ist                     |
| Modelldownload schlägt fehl            | Das Modell ist \~2TB in BF16. Stellen Sie ausreichend Festplattenspeicher sicher. Verwenden Sie `--resume-download` Flag mit `huggingface-cli`                       |
| vLLM unterstützt die Architektur nicht | Stellen Sie sicher, dass Sie vLLM ≥0.7.0 mit `--trust-remote-code`; die benutzerdefinierten Attention-Schichten benötigen dieses Flag                                |
| GGUF nicht verfügbar                   | Überprüfen Sie [unsloth](https://huggingface.co/unsloth) oder Community-Quantisierungen; das Modell könnte Zeit benötigen, bis es von der Community quantisiert wird |
| Schlechte Antwortqualität              | Verwenden Sie Temperatur ≤0,1 für faktische Aufgaben; fügen Sie einen Systemprompt hinzu; stellen Sie sicher, dass Sie den Kontext nicht abschneiden                 |

## Weiterführende Lektüre

* [Offizielle Ankündigung (BusinessWire)](https://www.businesswire.com/news/home/20260215551663/en/) — Veröffentlichungsdetails und Benchmarks
* [HuggingFace — Ling-2.5-1T](https://huggingface.co/inclusionAI/Ling-2.5-1T) — Modellgewichte und Dokumentation
* [HuggingFace — Ring-2.5-1T](https://huggingface.co/inclusionAI/Ring-2.5-1T) — Denkmodell-Begleiter
* [ModelScope Mirror](https://www.modelscope.cn/models/inclusionAI/Ling-2.5-1T) — Schnellere Downloads in Asien
* [vLLM-Dokumentation](https://docs.vllm.ai/) — Serving-Framework


---

# 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:

```
GET https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/ling25.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.
