Kimi K2.5

Despliega Kimi K2.5 (1T MoE multimodal) de Moonshot AI en GPUs de Clore.ai

Kimi K2.5, lanzado el 27 de enero de 2026 por Moonshot AI, es un modelo multimodal Mixture-of-Experts de 1 billón de parámetros con 32B de parámetros activos por token. Construido mediante preentrenamiento continuo en ~15 billones de tokens mixtos visuales y de texto sobre la base Kimi-K2-Base, entiende de forma nativa texto, imágenes y vídeo. K2.5 introduce Agent Swarm tecnología — coordinando hasta 100 agentes de IA especializados simultáneamente — y alcanza rendimiento de vanguardia en programación (76.8% SWE-bench Verified), visión y tareas agentivas. Disponible bajo una licencia de pesos abiertos en HuggingFace.

Características clave

• 1T total / 32B activos — arquitectura MoE de 384 expertos con atención MLA y SwiGLU

• Multimodal nativo — preentrenado en tokens visión–lenguaje; entiende imágenes, vídeo y texto

• Agent Swarm — descompone tareas complejas en sub-tareas paralelas mediante agentes generados dinámicamente

• Ventana de contexto de 256K — procesa bases de código completas, documentos largos y transcripciones de vídeo

• Razonamiento híbrido — soporta tanto modo instantáneo (rápido) como modo de pensamiento (razonamiento profundo)

• Fuerte en programación — 76.8% SWE-bench Verified, 73.0% SWE-bench Multilingual

Requisitos

Kimi K2.5 es un modelo masivo — el checkpoint FP8 es ~630GB. Alojarlo uno mismo requiere hardware serio.

Componente	Cuantizado (GGUF Q2)	FP8 Completo
GPU	1× RTX 4090 + 256GB RAM	8× H200 141GB
VRAM	24GB + descarga a CPU	1.128GB
RAM	256GB+	256GB
Disco	400GB SSD	700GB NVMe
CUDA	12.0+	12.0+

recomendación de Clore.ai: Para serving en precisión completa, alquila 8× H200 (~$24–48/día). Para inferencia local cuantizada, una sola H100 80GB o incluso una RTX 4090 + fuerte descarga a CPU funciona a velocidad reducida.

Inicio rápido con llama.cpp (Cuantizado)

La forma más accesible de ejecutar K2.5 localmente — usando las cuantizaciones GGUF de Unsloth:

# Clonar y compilar 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

# Descargar modelo cuantizado (Q2_K_XL — 375GB, buen equilibrio calidad/tamaño)
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

# Ejecutar inferencia (ajusta --n-gpu-layers según tu VRAM)
./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

Nota: La visión aún no es compatible en GGUF/llama.cpp para K2.5. Para funciones multimodales, usa vLLM.

Configuración vLLM (Producción — Modelo completo)

Para serving en producción con soporte multimodal completo:

# Instalar vLLM nightly (K2.5 requiere la última versión)
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

Servir en 8× GPUs H200

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

Consultar con texto

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": "Eres Kimi, un asistente de IA creado por Moonshot AI."},
        {"role": "user", "content": "Escribe un servicio FastAPI con soporte WebSocket para chat en tiempo real"}
    ],
    temperature=0.6,
    max_tokens=4096
)
print(response.choices[0].message.content)

Consultar con imagen (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": "Describe este diagrama en detalle y extrae todo el texto."
            }
        ]
    }],
    max_tokens=2048
)
print(response.choices[0].message.content)

Acceso a la API (No se necesita GPU)

Si alojarlo uno mismo es excesivo, usa la API oficial de Moonshot:

from openai import OpenAI

# Plataforma Moonshot — API compatible con OpenAI
client = OpenAI(
    api_key="tu-moonshot-api-key",
    base_url="https://api.moonshot.ai/v1"
)

response = client.chat.completions.create(
    model="kimi-k2.5",
    messages=[
        {"role": "user", "content": "Explica la arquitectura Agent Swarm en Kimi K2.5"}
    ],
    temperature=0.6,
    max_tokens=2048
)
print(response.choices[0].message.content)

Llamada a herramientas

K2.5 sobresale en el uso agentivo de herramientas:

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": "Buscar en una base de código archivos y funciones relevantes",
        "parameters": {
            "type": "object",
            "required": ["query"],
            "properties": {
                "query": {"type": "string", "description": "Consulta de búsqueda"}
            }
        }
    }
}]

response = client.chat.completions.create(
    model="moonshotai/Kimi-K2.5",
    messages=[{"role": "user", "content": "Encuentra todo el código relacionado con autenticación en el proyecto"}],
    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)}")

Inicio rápido con Docker

# Usando vLLM Docker con 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

Consejos para usuarios de Clore.ai

• Compensación API vs self-hosting: K2.5 completo necesita 8× H200 a ~$24–48/día. La API de Moonshot tiene nivel gratuito o pago por token — usa la API para exploración, aloja tú mismo para cargas sostenidas en producción.

• Cuantizado en GPU única: El Unsloth GGUF Q2_K_XL (~375GB) puede ejecutarse en una RTX 4090 ($0.5–2/día) con 256GB de RAM vía descarga a CPU — espera ~5–10 tok/s. Suficiente para uso personal y desarrollo.

• K2 solo texto para configuraciones económicas: Si no necesitas visión, moonshotai/Kimi-K2-Instruct es el predecesor solo de texto — mismo MoE de 1T pero más ligero de desplegar (sin sobrecarga del codificador de visión).

• Ajusta la temperatura correctamente: Usa temperature=0.6 para modo instantáneo, temperature=1.0 para modo de pensamiento. Una temperatura incorrecta provoca repetición o incoherencia.

• Paralelismo de expertos para rendimiento: En configuraciones multinodo, usa --enable-expert-parallel en vLLM para mayor rendimiento. Consulta la documentación de vLLM para la configuración de EP.

Solución de problemas

Problema	Solución
OutOfMemoryError con modelo completo	Necesita 8× H200 (1128GB en total). Usa pesos FP8, configura --gpu-memory-utilization 0.90.
GGUF inferencia muy lenta	Asegura suficiente RAM para el tamaño cuantizado. Q2_K_XL necesita ~375GB combinados de RAM+VRAM.
Visión no funciona en llama.cpp	El soporte de visión para K2.5 GGUF no está disponible aún — usa vLLM para multimodal.
Salida repetitiva	Establecer temperature=0.6 (instantáneo) o 1.0 (pensamiento). Añade min_p=0.01.
La descarga del modelo dura una eternidad	~630GB checkpoint FP8. Usa huggingface-cli download con --resume-download.
Llamadas a herramientas no parseadas	Agregar --tool-call-parser kimi_k2 --enable-auto-tool-choice al comando vLLM serve.

Lecturas adicionales

• Kimi K2.5 en HuggingFace

• Blog técnico de Kimi K2.5

• Paper de Kimi K2.5

• Receta vLLM K2.5

• Cuantizaciones GGUF de Unsloth

• Plataforma API de Moonshot

• Kimi K2 GitHub