Ling-2.5-1T (1 Billion Parameter)

Führen Sie Ling-2.5-1T aus — Ant Groups 1 Billion Parameter Open-Source-LLM mit hybrider linearer Aufmerksamkeit auf Clore.ai GPUs

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

Schnellstart mit vLLM

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

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

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

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:

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:

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

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

• HuggingFace — Ring-2.5-1T — Denkmodell-Begleiter

• ModelScope Mirror — Schnellere Downloads in Asien

• vLLM-Dokumentation — Serving-Framework