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

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 auf Anfrage verkauft. Prüfe GPU-Preise & Verfügbarkeit bevor du eine Bereitstellung dimensionierst.

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.

Schnellstart mit vLLM

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

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

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

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:

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:

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 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) — Veröffentlichungsdetails und Benchmarks

• HuggingFace — Ling-2.5-1T — Modellgewichte und Dokumentation

• HuggingFace — Ring-2.5-1T — Thinking-Modell-Begleitmodell

• ModelScope-Mirror — Schnellere Downloads in Asien

• vLLM-Dokumentation — Serving-Framework