Kimi K2.5

Deploye Kimi K2.5 (1T MoE multimodal) von Moonshot AI auf Clore.ai-GPUs

Kimi K2.5, veröffentlicht am 27. Januar 2026 von Moonshot AI, ist ein multimodales Mixture-of-Experts-Modell mit 1 Billion Parametern mit 32B aktiven Parametern pro Token. Durch kontinuierliches Vortraining auf ~15 Billionen gemischten Bild- und Text-Token auf Basis von Kimi-K2-Base versteht es nativ Text, Bilder und Video. K2.5 führt Agent Swarm Technologie — koordiniert gleichzeitig bis zu 100 spezialisierte KI-Agenten — und erreicht Spitzenleistung bei Coding (76,8 % SWE-bench Verified), Vision und agentischen Aufgaben. Verfügbar unter einer Open-Weight-Lizenz auf HuggingFace.

Hauptfunktionen

• 1T gesamt / 32B aktiv — 384-Experten-MoE-Architektur mit MLA-Attention und SwiGLU

• Nativ multimodal — vortrainiert auf Vision-Language-Token; versteht Bilder, Video und Text

• Agent Swarm — zerlegt komplexe Aufgaben über dynamisch erzeugte Agenten in parallele Teilaufgaben

• 256K-Kontextfenster — vollständige Codebasen, lange Dokumente und Video-Transkripte verarbeiten

• Hybrides Denken — unterstützt sowohl den Sofortmodus (schnell) als auch den Denkmodus (tiefes Schlussfolgern)

• Starkes Coding — 76,8 % SWE-bench Verified, 73,0 % SWE-bench Multilingual

Anforderungen

Kimi K2.5 ist ein massives Modell — der FP8-Checkpoint ist ~630 GB groß. Selbsthosting erfordert ernstzunehmende Hardware.

Komponente	Quantisiert (GGUF Q2)	FP8 Vollständig
GPU	1× RTX 4090 + 256 GB RAM	8× H200 141GB
VRAM	24 GB + CPU-Auslagerung	1,128GB
RAM	256 GB+	256 GB
Festplatte	400 GB SSD	700GB NVMe
CUDA	12.8+	12.8+

Clore.ai-Empfehlung: Für Serving mit voller Präzision miete 8× H200 (Bare Metal). Für lokale Inferenz mit Quantisierung funktioniert eine einzelne H100 80 GB oder sogar eine RTX 4090 + starke CPU-Auslagerung mit reduzierter Geschwindigkeit.

Schnellstart mit llama.cpp (quantisiert)

Der zugänglichste Weg, K2.5 lokal auszuführen — mit den GGUF-Quantisierungen von Unsloth:

# llama.cpp klonen und bauen
git clone https://github.com/ggml-org/llama.cpp && cd llama.cpp
cmake -B build -DGGML_CUDA=ON && cmake --build build --config Release -j

# Quantisiertes Modell herunterladen (Q2_K_XL — 375 GB, gutes Verhältnis von Qualität zu Größe)
huggingface-cli download unsloth/Kimi-K2.5-GGUF \\
  Kimi-K2.5-UD-Q2_K_XL-00001-of-00005.gguf \\
  Kimi-K2.5-UD-Q2_K_XL-00002-of-00005.gguf \\
  Kimi-K2.5-UD-Q2_K_XL-00003-of-00005.gguf \\
  Kimi-K2.5-UD-Q2_K_XL-00004-of-00005.gguf \\
  Kimi-K2.5-UD-Q2_K_XL-00005-of-00005.gguf \\
  --local-dir ./models

# Inferenz ausführen (--n-gpu-layers an dein VRAM anpassen)
./build/bin/llama-server \
  -m ./models/Kimi-K2.5-UD-Q2_K_XL-00001-of-00005.gguf \\
  --n-gpu-layers 10 \\
  --threads 32 \\
  --ctx-size 16384 \\
  --host 0.0.0.0 --port 8080

Hinweis: Vision wird in GGUF/llama.cpp für K2.5 noch nicht unterstützt. Für multimodale Funktionen verwende vLLM.

vLLM-Setup (Produktion — vollständiges Modell)

Für den Produktionseinsatz mit vollständiger multimodaler Unterstützung:

# Nächtliche vLLM-Version installieren (K2.5 benötigt die neueste)
pip install -U vllm --pre \\
  --extra-index-url https://wheels.vllm.ai/nightly/cu129 \\
  --extra-index-url https://download.pytorch.org/whl/cu128 \\
  --index-strategy unsafe-best-match

Auf 8× H200 GPUs bereitstellen

vllm serve moonshotai/Kimi-K2.5 \\
  -tp 8 \\
  --mm-encoder-tp-mode data \\
  --tool-call-parser kimi_k2 \\
  --reasoning-parser kimi_k2 \\
  --trust-remote-code \
  --gpu-memory-utilization 0.90

Mit Text abfragen

from openai import OpenAI

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

response = client.chat.completions.create(
    model="moonshotai/Kimi-K2.5",
    messages=[
        {"role": "system", "content": "Du bist Kimi, ein von Moonshot AI erstellter KI-Assistent."},
        {"role": "user", "content": "Schreibe einen FastAPI-Dienst mit WebSocket-Unterstützung für Echtzeit-Chat"}
    ],
    temperature=0.6,
    max_tokens=4096
)
print(response.choices[0].message.content)

Mit Bild abfragen (multimodal)

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY", timeout=3600)

response = client.chat.completions.create(
    model="moonshotai/Kimi-K2.5",
    messages=[{
        "role": "user",
        "content": [
            {
                "type": "image_url",
                "image_url": {"url": "https://example.com/diagram.png"}
            },
            {
                "type": "text",
                "text": "Beschreibe dieses Diagramm detailliert und extrahiere den gesamten Text."
            }
        ]
    }],
    max_tokens=2048
)
print(response.choices[0].message.content)

API-Zugriff (keine GPU erforderlich)

Wenn Selbsthosting übertrieben ist, verwende die offizielle API von Moonshot:

from openai import OpenAI

# Moonshot-Plattform — OpenAI-kompatible API
client = OpenAI(
    api_key="your-moonshot-api-key",
    base_url="https://api.moonshot.ai/v1"
)

response = client.chat.completions.create(
    model="kimi-k2.5",
    messages=[
        {"role": "user", "content": "Erkläre die Agent-Swarm-Architektur in Kimi K2.5"}
    ],
    temperature=0.6,
    max_tokens=2048
)
print(response.choices[0].message.content)

Tool-Aufrufe

K2.5 glänzt bei agentischer Tool-Nutzung:

import json
from openai import OpenAI

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

tools = [{
    "type": "function",
    "function": {
        "name": "search_code",
        "description": "Durchsuche eine Codebasis nach relevanten Dateien und Funktionen",
        "parameters": {
            "type": "object",
            "required": ["query"],
            "properties": {
                "query": {"type": "string", "description": "Suchanfrage"}
            }
        }
    }
}]

response = client.chat.completions.create(
    model="moonshotai/Kimi-K2.5",
    messages=[{"role": "user", "content": "Finde alle sicherheitsbezogenen Code-Stellen im Projekt"}],
    tools=tools,
    tool_choice="auto",
    temperature=0.6
)

for tool_call in response.choices[0].message.tool_calls:
    print(f"Function: {tool_call.function.name}")
    print(f"Args: {json.loads(tool_call.function.arguments)}")

Docker-Schnellstart

# vLLM-Docker mit 8 GPUs verwenden
docker run --gpus all -p 8000:8000 \
  --ipc=host \
  -v ~/.cache/huggingface:/root/.cache/huggingface \\
  vllm/vllm-openai:latest \
  --model moonshotai/Kimi-K2.5 \\
  --tensor-parallel-size 8 \
  --mm-encoder-tp-mode data \\
  --tool-call-parser kimi_k2 \\
  --reasoning-parser kimi_k2 \\
  --trust-remote-code

Tipps für Clore.ai-Nutzer

• Abwägung zwischen API und Selbsthosting: Vollständiges K2.5 benötigt 8× H200 bei Bare Metal. Moonshots API ist im Free-Tier oder per Token bezahlbar — verwende die API zum Ausprobieren, Selbsthosting für dauerhafte Produktionslasten.

• Quantisiert auf einer einzelnen GPU: Das Unsloth GGUF Q2_K_XL (~375 GB) kann auf einer RTX 4090 (0,14–0,42 $/Std.) mit 256 GB RAM per CPU-Auslagerung laufen — erwarte ~5–10 Token/s. Gut genug für den persönlichen Gebrauch und die Entwicklung.

• Text-only K2 für preisgünstige Setups: Wenn du keine Vision brauchst, moonshotai/Kimi-K2-Instruct ist der text-only Vorgänger — dasselbe 1T-MoE, aber leichter bereitzustellen (kein Overhead durch Vision-Encoder).

• Temperatur korrekt einstellen: Verwende temperature=0.6 für den Sofortmodus, temperature=1.0 für den Denkmodus. Die falsche Temperatur verursacht Wiederholungen oder Unstimmigkeiten.

• Expert Parallelism für Durchsatz: Verwende in Multi-Node-Setups --enable-expert-parallel in vLLM für höheren Durchsatz. Prüfe die vLLM-Dokumentation zur EP-Konfiguration.

Fehlerbehebung

Problem	Lösung
OutOfMemoryError mit vollständigem Modell	Benötigt 8× H200 (1128 GB insgesamt). Verwende FP8-Gewichte, setze --gpu-memory-utilization 0.90.
GGUF-Inferenz sehr langsam	Stelle sicher, dass genügend RAM für die Quantisierungsgröße vorhanden ist. Q2_K_XL benötigt zusammen etwa 375 GB RAM+VRAM.
Vision funktioniert in llama.cpp nicht	Vision-Unterstützung für K2.5 GGUF ist noch nicht verfügbar — verwende vLLM für multimodale Funktionen.
Wiederholte Ausgabe	Setze temperature=0.6 (sofort) oder 1.0 (Denken). Füge min_p=0.01.
Modell-Download dauert ewig	~630 GB FP8-Checkpoint. Verwende huggingface-cli download mit --resume-download.
Tool-Aufrufe werden nicht geparst	Fügen Sie --tool-call-parser kimi_k2 --enable-auto-tool-choice zum vLLM-serve-Befehl hinzu.

Weiterführende Lektüre

• Kimi K2.5 auf HuggingFace

• Kimi K2.5 Tech-Blog

• Kimi K2.5 Paper

• vLLM K2.5 Rezept

• Unsloth GGUF-Quantisierungen

• Moonshot API-Plattform

• Kimi K2 GitHub