Kimi K2.5

Setzen Sie Kimi K2.5 (1T MoE multimodal) von Moonshot AI auf Clore.ai GPUs ein

Kimi K2.5, veröffentlicht am 27. Januar 2026 von Moonshot AI, ist ein 1-Billionen-Parameter Mixture-of-Experts multimodales Modell mit 32B aktiven Parametern pro Token. Durch kontinuierliches Pretraining auf ~15 Billionen gemischter visueller und textlicher Tokens aufgebaut, basierend auf dem Kimi-K2-Base, versteht es nativ Text, Bilder und Video. K2.5 führt ein Agenten-Schwarm Technologie ein — koordiniert gleichzeitig bis zu 100 spezialisierte KI-Agenten — und erreicht Spitzenleistungen beim Programmieren (76,8% SWE-bench Verified), in der Vision und bei agentischen Aufgaben. Verfügbar unter einer Open-Weight-Lizenz auf HuggingFace.

Hauptmerkmale

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

• Natives Multimodal — vortrainiert auf Vision–Language-Tokens; versteht Bilder, Video und Text

• Agenten-Schwarm — zerlegt komplexe Aufgaben in parallele Teilaufgaben mithilfe dynamisch erzeugter Agenten

• 256K Kontextfenster — verarbeitet ganze Codebasen, lange Dokumente und Videoabschriften

• Hybrides Reasoning — unterstützt sowohl Instant-Modus (schnell) als auch Thinking-Modus (tiefes Nachdenken)

• Stark beim Programmieren — 76,8% SWE-bench Verified, 73,0% SWE-bench Multilingual

Anforderungen

Kimi K2.5 ist ein riesiges Modell — der FP8-Checkpoint ist ~630GB. Self-Hosting erfordert ernsthafte Hardware.

Komponente	Quantisiert (GGUF Q2)	FP8 Voll
GPU	1× RTX 4090 + 256GB RAM	8× H200 141GB
VRAM	24GB + CPU-Offload	1.128GB
RAM	256GB+	256GB
Festplatte	400GB SSD	700GB NVMe
CUDA	12.0+	12.0+

Clore.ai-Empfehlung: Für Serving in voller Präzision mieten Sie 8× H200 (~24–48$/Tag). Für quantisierte lokale Inferenz funktioniert eine einzelne H100 80GB oder sogar eine RTX 4090 mit umfangreichem CPU-Offload bei reduzierter Geschwindigkeit.

Schnellstart mit llama.cpp (quantisiert)

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

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

# Lade quantisiertes Modell herunter (Q2_K_XL — 375GB, gutes Qualitäts-/Größen-Verhältnis)
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

# Führe Inferenz aus (passe --n-gpu-layers an deinen VRAM an)
./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 verwenden Sie vLLM.

vLLM-Einrichtung (Produktion — Volles Modell)

Für Production-Serving mit voller multimodaler Unterstützung:

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

Serviere auf 8× H200 GPUs

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

Abfrage per Text

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-Service mit WebSocket-Unterstützung für Echtzeit-Chat"}
    ],
    temperature=0.6,
    max_tokens=4096
)
print(response.choices[0].message.content)

Abfrage mit Bild (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 im Detail und extrahiere allen Text."
            }
        ]
    }],
    max_tokens=2048
)
print(response.choices[0].message.content)

API-Zugriff (Keine GPU erforderlich)

Wenn Self-Hosting übertrieben ist, verwenden Sie Moonshots offizielle API:

from openai import OpenAI

# Moonshot Platform — OpenAI-kompatible API
client = OpenAI(
    api_key="dein-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 Agenten-Schwarm-Architektur in Kimi K2.5"}
    ],
    temperature=0.6,
    max_tokens=2048
)
print(response.choices[0].message.content)

Tool-Aufrufe

K2.5 glänzt bei agentischem Tool-Einsatz:

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 allen authentifizierungsbezogenen Code 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 Quick Start

# Verwendung von vLLM Docker mit 8 GPUs
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

• API- vs. Self-Hosting-Abwägung: Volles K2.5 benötigt 8× H200 für ~24–48$/Tag. Moonshots API bietet Free-Tier oder Pay-per-Token — verwende die API zur Erkundung, Self-Hosting für dauerhafte Produktionslasten.

• Quantisiert auf einer einzelnen GPU: Das Unsloth GGUF Q2_K_XL (~375GB) kann auf einer RTX 4090 (0,5–2$/Tag) mit 256GB RAM via CPU-Offload laufen — erwarte ~5–10 tok/s. Gut genug für persönliche Nutzung und Entwicklung.

• Text-only K2 für Budget-Setups: Wenn du keine Vision benötigst, moonshotai/Kimi-K2-Instruct ist der text-only Vorgänger — dieselbe 1T MoE, aber leichter bereitzustellen (kein Vision-Encoder-Overhead).

• Temperatur korrekt einstellen: Verwende temperature=0.6 für den Instant-Modus, temperature=1.0 für den Thinking-Modus. Falsche Temperatur verursacht Wiederholungen oder Inkohärenz.

• Expert-Parallelismus für Durchsatz: In Multi-Node-Setups verwende --enable-expert-parallel in vLLM für höheren Durchsatz. Siehe vLLM-Dokumentation für EP-Konfiguration.

Fehlerbehebung

Problem	Lösung
OutOfMemoryError mit vollem Modell	Benötigt 8× H200 (insgesamt 1128GB). Verwende FP8-Gewichte, setze --gpu-memory-utilization 0.90.
GGUF-Inferenz sehr langsam	Stelle genug RAM für die Quant-Größe sicher. Q2_K_XL benötigt ~375GB RAM+VRAM kombiniert.
Vision funktioniert nicht in llama.cpp	Vision-Unterstützung für K2.5 GGUF ist noch nicht verfügbar — verwende vLLM für multimodal.
Repetitive Ausgabe	Setze temperature=0.6 (instant) oder 1.0 (thinking). Füge hinzu min_p=0.01.
Modelldownload dauert ewig	~630GB FP8-Checkpoint. Verwende huggingface-cli download mit --resume-download.
Tool-Aufrufe werden nicht geparst	Hinzufügen --tool-call-parser kimi_k2 --enable-auto-tool-choice zum vLLM serve Befehl.

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