> 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)

Führe Ling-2.5-1T aus — das Open-Source-LLM mit 1 Billion Parametern von Ant Group mit hybrider linearer Attention auf Clore.ai-GPUs

Ling-2.5-1T von Ant Group (veröffentlicht am 16. Februar 2026) ist eines der größten je veröffentlichten Open-Source-Sprachmodelle — **1 Billion Gesamtparameter mit 63 Mrd. aktiven**. Es führt eine hybride lineare Aufmerksamkeitsarchitektur ein, die effiziente Inferenz bei Kontextlängen von bis zu 1 Million Tokens ermöglicht. Zusammen mit ihr veröffentlichte Ant Group Ring-2.5-1T, das weltweit erste Thinking-Modell mit hybrider linearer Architektur. Gemeinsam markieren 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 agentischen 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) (Thinking-/Reasoning-Variante) **Lizenz:** Open Source (Ant Group InclusionAI-Lizenz)

## Hauptfunktionen

* **1 Billion Gesamtparameter, 63 Mrd. aktiv** — enorme Größenordnung mit effizienter MoE-artiger Aktivierung
* **Hybride lineare Aufmerksamkeitsarchitektur** — kombiniert MLA (Multi-Head Linear Attention) mit Lightning Linear Attention für außergewöhnlichen Durchsatz bei langen Sequenzen
* **1-Million-Token-Kontextfenster** — dank YaRN-Erweiterung des nativen 256K-Kontexts verarbeitet es ganze Codebasen und Dokumente in Buchlänge
* **Spitzen-Reasoning** — nähert sich der Leistung von Thinking-Modellen und nutzt dabei etwa 4× weniger Ausgabetokens
* **Agentenfähigkeiten** — mit Agentic RL trainiert, kompatibel mit Claude Code, OpenCode und OpenClaw
* **Ring-2.5-1T-Begleitmodell** — dedizierte Reasoning-Variante erreicht Goldmedaillen-Niveau bei IMO 2025 und CMO 2025

## Architekturdetails

| Komponente             | Details                                            |
| ---------------------- | -------------------------------------------------- |
| Gesamtparameter        | 1 Billion (1.000 Mrd.)                             |
| Aktive Parameter       | 63 Mrd.                                            |
| Architektur            | Hybride lineare Attention (MLA + Lightning Linear) |
| Vortrainingsdaten      | 29 Billionen Tokens                                |
| Nativer Kontext        | 256K Tokens                                        |
| Erweiterter Kontext    | 1 Million Tokens (YaRN)                            |
| Veröffentlichungsdatum | 16. Februar 2026                                   |

## Anforderungen

{% hint style="warning" %}
**Multi-GPU-Rigs der 80GB-Klasse sind auf dem Clore.ai-Marktplatz nicht gelistet.** Die größten heute gelisteten Systeme sind 4× RTX PRO 6000 Blackwell (je 96 GB, 380 GB gesamt) und 8–11× RTX 5090 (je 32 GB). Kapazitäten für A100 / H200 / B200 werden als [Bare Metal](https://clore.ai/bare-metal) auf Anfrage verkauft. Prüfe [GPU-Preise & Verfügbarkeit](/guides/guides_v2-de/erste-schritte/pricing.md) bevor du eine Bereitstellung dimensionierst.
{% endhint %}

Der Betrieb von Ling-2.5-1T in voller Präzision erfordert erhebliche Ressourcen. Quantisierte Versionen machen es zugänglicher.

| Konfiguration | Quantisiert (Q4 GGUF) | FP8              | BF16 (Voll)        |
| ------------- | --------------------- | ---------------- | ------------------ |
| GPU           | 8× RTX 4090           | 8× H100 80 GB    | 16× H100 80 GB     |
| VRAM          | 8×24 GB (192 GB)      | 8×80 GB (640 GB) | 16×80 GB (1,28 TB) |
| RAM           | 256 GB                | 512 GB           | 1 TB               |
| Festplatte    | 600 GB                | 1,2 TB           | 2 TB+              |
| CUDA          | 12.8+                 | 12.8+            | 12.8+              |

**Empfohlene Clore.ai-Einrichtung:**

* **Quantisiert (Q4):** 8× RTX 4090 (1,12–3,36 $/Std.) — für Experimente und mittlere Workloads nutzbar
* **Produktion (FP8):** 8× H100 (\~8,32 $/Std.) — volle Qualität mit gutem Durchsatz
* **Hinweis:** Dies ist ein extrem großes Modell. Für preisbewusste 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
# vLLM installieren
pip install vllm

# Ling-2.5-1T mit Tensor Parallelism über 8 GPUs bereitstellen
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 geringeren Speicherbedarf die Kontextlänge begrenzen:
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
# llama.cpp installieren
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
cmake -B build -DGGML_CUDA=ON
cmake --build build --config Release -j$(nproc)

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

# Mit llama-server bereitstellen (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
```

## Anwendungsbeispiele

### 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="not-needed"
)

response = client.chat.completions.create(
    model="inclusionAI/Ling-2.5-1T",
    messages=[
        {"role": "system", "content": "Du bist ein erstklassiger Reasoning-Assistent. Denke 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. Dokumentenanalyse mit langem Kontext

Die hybride lineare Attention von Ling-2.5-1T macht es für lange Dokumente außergewöhnlich effizient:

```python
from openai import OpenAI

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

# Ein großes Dokument laden
with open("full_codebase.txt", "r") as f:
    codebase = f.read()  # Kann Hunderttausende von Tokens umfassen

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

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

### 3. Agentische Werkzeugnutzung

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": "Die Produktdatenbank durchsuchen",
            "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-Modell (schnell)                      | Thinking-Modell (Reasoning-Modell)                |
| Architektur            | Hybride lineare Attention                     | Hybride lineare Attention                         |
| Am besten geeignet für | Allgemeiner Chat, Coding, agentische Aufgaben | Mathematik, formales Reasoning, komplexe Probleme |
| Ausgabestil            | Direkte Antworten                             | Chain-of-thought-Reasoning                        |
| Token-Effizienz        | Hoch (weniger Ausgabetokens)                  | Verwendet mehr Tokens für Reasoning               |
| IMO 2025               | Konkurrenzfähig                               | Goldmedaillen-Niveau                              |

## Tipps für Clore.ai-Nutzer

1. **Dieses Modell braucht ernsthafte Hardware** — Bei 1T Parametern erfordert selbst Q4-Quantisierung etwa 500 GB Speicher und 192 GB+ VRAM. Stelle sicher, dass deine Clore.ai-Instanz vor dem Download über ausreichend Festplattenspeicher und Multi-GPU verfügt.
2. **Beginne mit `--max-model-len 8192`** — Verwende beim ersten Testen eine kurze Kontextlänge, um zu überprüfen, ob das Modell korrekt lädt und läuft. Erhöhe die Kontextlänge, sobald alles funktioniert.
3. **Persistenten Speicher verwenden** — Das Modell wiegt 1–2 TB. Hänge auf Clore.ai ein großes persistentes Volume an, um erneutes Herunterladen zu vermeiden. Einmal herunterladen mit `huggingface-cli download`.
4. **Ring-2.5-1T für Reasoning-Aufgaben in Betracht ziehen** — Wenn dein 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. **GPU-Speicher überwachen** — Bei 8-GPU-Setups verwende `nvidia-smi -l 1` um die Speichernutzung zu überwachen und während der Generierung mit langen Kontexten auf OOM zu achten.

## Fehlerbehebung

| Problem                                | Lösung                                                                                                                                                          |
| -------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `CUDA-Speicher erschöpft`              | Reduziere `--max-model-len`; stelle sicher, `--tensor-parallel-size` der GPU-Anzahl entspricht; versuche `--gpu-memory-utilization 0.95`                        |
| Sehr langsame Generierung              | Lineare Attention braucht ein Warm-up; die ersten paar Anfragen können langsam sein. Prüfe außerdem, ob deine GPUs per NVLink verbunden sind                    |
| Modell-Download schlägt fehl           | Das Modell ist im BF16-Format etwa 2 TB groß. Stelle sicher, dass genügend Speicherplatz vorhanden ist. Verwende `--resume-download` Flag mit `huggingface-cli` |
| vLLM unterstützt die Architektur nicht | Stelle sicher, dass du vLLM ≥0.7.0 mit `--trust-remote-code`; die benutzerdefinierten Attention-Schichten erfordern dieses Flag                                 |
| GGUF nicht verfügbar                   | Prüfe [unsloth](https://huggingface.co/unsloth) oder Community-Quantisierungen; es kann eine Weile dauern, bis das Modell von der Community quantisiert wird    |
| Schlechte Antwortqualität              | Verwende für faktische Aufgaben eine Temperatur von ≤0.1; füge einen System-Prompt hinzu; stelle sicher, dass du den Kontext nicht abschneidest                 |

## 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) — Thinking-Modell-Begleitmodell
* [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, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/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.
