# Kimi K2.5

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:

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

```bash
# 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

```bash
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

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

```python
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:

```python
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:

```python
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

```bash
# 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](https://huggingface.co/moonshotai/Kimi-K2.5)
* [Kimi K2.5 Tech-Blog](https://www.kimi.com/blog/kimi-k2-5.html)
* [Kimi K2.5 Paper](https://arxiv.org/abs/2602.02276)
* [vLLM K2.5 Rezept](https://docs.vllm.ai/projects/recipes/en/latest/moonshotai/Kimi-K2.5.html)
* [Unsloth GGUF-Quantisierungen](https://huggingface.co/unsloth/Kimi-K2.5-GGUF)
* [Moonshot API Plattform](https://platform.moonshot.ai)
* [Kimi K2 GitHub](https://github.com/MoonshotAI/Kimi-K2)