Costes, facturación y operaciones24 de octubre de 2026Flatkey Team

¿Se puede ejecutar Kimi K3 en local? Guía de hardware, GGUF y vLLM (2026)

Kimi K3 puede ejecutarse en local, pero el GGUF de 1 bit más pequeño necesita unos 610 GB de RAM más VRAM. Requisitos exactos de hardware, comandos de llama.cpp y vLLM, condiciones de licencia y comparación de costes con GPU alquiladas y APIs.

¿Se puede ejecutar Kimi K3 en local? Guía de hardware, GGUF y vLLM (2026)

Sí, Kimi K3 puede ejecutarse en local porque Moonshot AI publica sus pesos en Hugging Face, pero es un modelo de 2,8 billones de parámetros, así que "local" significa unos 610 GB de RAM y VRAM combinadas para el GGUF de 1 bit más pequeño, o un nodo Blackwell completo de 8 GPU para los pesos nativos. En una sola estación de trabajo con menos memoria se cargará igualmente desde disco, solo que muy despacio. Para la mayoría de los desarrolladores, ejecutar K3 en GPU alquiladas o llamarlo a través de una API sale más barato que comprar hardware.

Esta guía cubre lo que necesitas para ejecutar Kimi K3 en tus propias máquinas a 24 de octubre de 2026: la licencia, los requisitos exactos de memoria por cuantización, comandos paso a paso de llama.cpp y vLLM, cómo llamar a tu servidor local desde código y una comparación de costes con GPU alquiladas y APIs alojadas. Las cifras provienen de la ficha del modelo de Moonshot AI, de las recetas oficiales de vLLM y SGLang y de la documentación de Unsloth; todo lo que hemos estimado se indica como estimación.

Kimi K3 de un vistazo

Especificación	Valor
Desarrollador	Moonshot AI
Pesos	moonshotai/Kimi-K3 en Hugging Face
Arquitectura	Mezcla de expertos: 2,8T parámetros totales, 104B activos por token
Expertos	896 expertos enrutados, 16 seleccionados por token, más 2 compartidos
Capas	93 (69 capas de atención lineal KDA y 24 capas MLA con compuerta)
Ventana de contexto	1.048.576 tokens
Entradas	Texto e imágenes (codificador de visión MoonViT-V2, 401M parámetros)
Precisión nativa	Pesos MXFP4 con activaciones MXFP8 (entrenamiento consciente de la cuantización)
Razonamiento	Pensamiento siempre activo; `reasoning_effort` low, high o max (max por defecto)
Licencia	Kimi K3 License (MIT modificada)

Fuente: la ficha del modelo Kimi K3, consultada el 24 de octubre de 2026.

Dos notas antes de empezar. Primero, Moonshot AI ofrece ahora Kimi K3.1 Pro en su API y llama a K3 su "buque insignia de la generación anterior", pero a 24 de octubre de 2026 los pesos abiertos más recientes en Hugging Face siguen siendo Kimi K3, así que K3 es el modelo que puedes ejecutar tú mismo. Segundo, K3 solo funciona en modo de pensamiento: tu cliente debe devolver reasoning_content y las llamadas a herramientas en conversaciones de varios turnos, como describe la ficha del modelo.

¿Se puede usar Kimi K3 comercialmente?

La Kimi K3 License es de estilo MIT con dos condiciones adicionales, según el archivo de licencia en Hugging Face (octubre de 2026):

Si ofreces K3 como negocio de modelo como servicio con más de 20 millones de dólares de ingresos en los 12 meses anteriores, necesitas un acuerdo aparte con Moonshot AI.
Si tu producto tiene más de 100 millones de usuarios activos mensuales o más de 20 millones de dólares de ingresos mensuales, debes mostrar "Kimi K3" en la interfaz de usuario.

El uso interno dentro de tu empresa no está restringido por esas condiciones. Para la mayoría de startups y equipos, el uso local o autoalojado está permitido; lee el texto completo de la licencia antes de lanzar.

¿Cuánto hardware necesita Kimi K3?

Cuantizaciones GGUF (llama.cpp)

Unsloth publica cuantizaciones GGUF dinámicas. Su regla práctica: tu RAM más VRAM debe ser al menos del tamaño de la cuantización; si no, el modelo se descargará a disco y funcionará mucho más lento.

Cuantización	Memoria necesaria (RAM + VRAM)	Notas
1 bit dinámico S (`UD-IQ1_S`)	unos 610 GB	594 GB de archivos; el equilibrio entre tamaño y calidad recomendado por Unsloth, en torno al 79% de precisión top-1
1 bit dinámico M	unos 665 GB
2 bits dinámico XXS	unos 726 GB
2 bits dinámico XL	unos 880 GB	Unsloth reporta en torno al 90% de precisión para su 2 bits dinámico de 861 GB
Q8 (`UD-Q8_K_XL`, sin pérdidas)	unos 1,6 TB	1,56 TB de archivos; equivale a los pesos nativos MXFP4

Unsloth reporta unos 20 tokens por segundo de generación cuando la cuantización de 1 bit cabe en GPU B200. En máquinas centradas en CPU que mantienen la mayoría de los pesos en la RAM del sistema, espera velocidades muy inferiores; no las hemos medido, así que trata cualquier cifra que veas como estimación hasta probar tu propio hardware.

¿Qué significa esto en la práctica? Algunas configuraciones locales realistas:

Configuración	¿Cabe el de 1 bit (610 GB)?	Expectativa (estimación)
PC gaming: 1x RTX 4090 (24 GB) + 128 GB de RAM	No	Solo funciona con mucha descarga a disco; muy lento, útil solo para pruebas
Estación de trabajo o servidor: 1-2 GPU + 768 GB DDR5	Sí	Útil para experimentos de un solo usuario a baja velocidad
Servidor multi-GPU con 8x GPU de 80-141 GB	Sí, en VRAM	Velocidad interactiva para uno o pocos usuarios
Nodo 8x B300 / clase GB300	Pesos nativos MXFP4	Servicio en producción con vLLM o SGLang

Pesos nativos (vLLM y SGLang)

Para los pesos oficiales, la receta de vLLM para Kimi K3 pide al menos 8x GPU GB300 (o al menos 8x MI355X o MI350X en AMD ROCm), con la imagen vllm/vllm-openai:kimi-k3, que requiere CUDA 13 y el controlador NVIDIA r580 o posterior. El cookbook de SGLang enumera formatos de nodo como B300 1x8, GB300 2x4, B200 2x8, GB200 4x4, H200 2x8, H100 4x8 y MI350X/MI355X 1x8, pero a octubre de 2026 solo la configuración B300 1x8 figura como verificada. Dicho de otro modo, un despliegue con H100 necesita cuatro nodos de 8 GPU, algo fuera del alcance de casi cualquiera que lo ejecute "en local".

Para profundizar en el dimensionamiento, consulta nuestra guía de requisitos de memoria GPU para LLM y la guía de despliegue con paralelismo de expertos en vLLM.

Ejecutar Kimi K3 en local con llama.cpp (GGUF)

Estos pasos siguen la guía de Unsloth. El soporte de visión de K3 requiere por ahora el fork de Unsloth de llama.cpp; el uso solo de texto sigue los mismos pasos.

1. Compila llama.cpp. Usa -DGGML_CUDA=OFF si no tienes GPU NVIDIA.

git clone https://github.com/unslothai/llama.cpp
cd llama.cpp
git fetch origin pull/48/head:kimi-k3-fullsize-vision
git checkout kimi-k3-fullsize-vision
cd ..
cmake llama.cpp -B llama.cpp/build -DBUILD_SHARED_LIBS=OFF -DGGML_CUDA=ON
cmake --build llama.cpp/build --config Release -j --clean-first \
  --target llama-cli llama-mtmd-cli llama-server llama-gguf-split
cp llama.cpp/build/bin/llama-* llama.cpp

2. Descarga la cuantización de 1 bit (unos 594 GB) y el proyector de visión. Comprueba antes el espacio libre en disco.

pip install -U huggingface_hub
df -h .   # need roughly 650 GB free
hf download unsloth/Kimi-K3-GGUF \
  --local-dir unsloth/Kimi-K3-GGUF \
  --include "*mmproj-BF16*" \
  --include "*UD-IQ1_S*"

3. Chatea en la terminal. Usa el muestreo recomendado por Moonshot: temperature 1.0 y top_p 0.95 (top_p 1.0 para tareas agénticas).

FIRST=$(ls unsloth/Kimi-K3-GGUF/UD-IQ1_S/*00001-of-*.gguf | head -1)
./llama.cpp/llama-cli --model "$FIRST" \
  --mmproj unsloth/Kimi-K3-GGUF/mmproj-BF16.gguf \
  --temp 1.0 --top-p 0.95

4. Sirve una API compatible con OpenAI. llama-server expone /v1/chat/completions. Un tamaño de contexto menor ahorra memoria para la caché KV.

./llama.cpp/llama-server --model "$FIRST" \
  --mmproj unsloth/Kimi-K3-GGUF/mmproj-BF16.gguf \
  --ctx-size 32768 --temp 1.0 --top-p 0.95 \
  --host 127.0.0.1 --port 8080

Servir Kimi K3 con vLLM (nodo completo)

Si tienes, o alquilas, un nodo de 8 GPU compatible, vLLM te da rendimiento de producción, llamadas a herramientas y el contexto completo de 1M. El comando básico de la receta oficial:

docker run --gpus all --ipc=host -p 8000:8000 \
  -v ~/.cache/huggingface:/root/.cache/huggingface \
  vllm/vllm-openai:kimi-k3 \
  moonshotai/Kimi-K3 --trust-remote-code \
  --tensor-parallel-size 8 \
  --tool-call-parser kimi_k3 --reasoning-parser kimi_k3 \
  --enable-auto-tool-choice \
  --max-model-len 1048576 \
  --enable-prefix-caching --kv-cache-dtype fp8

La receta también advierte que el formato de las llamadas a herramientas a veces sale mal formado, así que valida los argumentos y reintenta cuando falle el análisis. Nuestra guía de despliegue de vLLM y la guía de inferencia multi-GPU cubren la monitorización y el ajuste.

Llamar a tu servidor local de Kimi K3

Tanto llama-server (puerto 8080 arriba) como vLLM (puerto 8000) hablan la API de OpenAI, así que funciona cualquier SDK de OpenAI.

curl

curl -s http://127.0.0.1:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{"model":"moonshotai/Kimi-K3","temperature":1.0,"top_p":0.95,
       "messages":[{"role":"user","content":"Write a bash one-liner that finds the 5 largest files in a directory."}]}'

Python

from openai import OpenAI

# Local vLLM server; use base_url="http://127.0.0.1:8080/v1" for llama-server
client = OpenAI(base_url="http://127.0.0.1:8000/v1", api_key="local")

r = client.chat.completions.create(
    model="moonshotai/Kimi-K3",
    temperature=1.0, top_p=0.95,
    messages=[{"role": "user", "content": "Explain MoE routing in 3 sentences."}],
)
msg = r.choices[0].message
print(getattr(msg, "reasoning_content", None))  # thinking trace, when the server returns it
print(msg.content)

Node.js

import OpenAI from "openai";

const client = new OpenAI({ baseURL: "http://127.0.0.1:8000/v1", apiKey: "local" });
const r = await client.chat.completions.create({
  model: "moonshotai/Kimi-K3",
  temperature: 1.0,
  top_p: 0.95,
  messages: [{ role: "user", content: "Give me a regex for ISO 8601 dates." }],
});
console.log(r.choices[0].message.content);

En chats de varios turnos, añade al historial el mensaje del asistente con su reasoning_content y cualquier tool_calls antes del siguiente turno, como exige la ficha del modelo.

Local vs GPU alquiladas vs API: ¿cuánto cuesta Kimi K3?

Alquilar GPU. El índice de precios de GPU de Flatkey (actualizado el 24 de octubre de 2026) muestra tarifas en tiempo real de 7,49 $ por hora de GPU para B200, 7,34 $ para B300, 3,60 $ para H200 y 2,48 $ para H100. Un nodo 8x B200 cuesta, por tanto, unos 59,92 $ por hora, o aproximadamente 43.700 $ al mes funcionando 24/7 (nuestra estimación: 8 x 7,49 $ x 730 horas).

API alojada. La plataforma oficial de Moonshot fija Kimi K3 en 3,00 $ por millón de tokens de entrada, 0,30 $ para entrada en caché y 15,00 $ por millón de tokens de salida. En la página del modelo en Flatkey, Kimi K3 cuesta 1,80 $ de entrada, 0,18 $ de entrada en caché y 9,00 $ de salida por millón de tokens, con el mismo contexto de 1.048.576 tokens (ambos consultados el 24 de octubre de 2026).

Punto de equilibrio (estimación). Con una proporción de entrada a salida de 3:1, el precio de Flatkey equivale a unos 3,60 $ por millón de tokens combinados. 43.700 $ al mes compran unos 12.000 millones de tokens combinados, o unos 400 millones de tokens al día. Por debajo de ese volumen, una API es más barata que un nodo 8x B200 dedicado, sin contar el tiempo de ingeniería.

Opción	Coste inicial	Ideal para
GGUF de 1 bit local en una estación con mucha RAM	Hardware propio	Experimentos sensibles a la privacidad, trabajo offline, aprendizaje
Nodo de 8 GPU alquilado con vLLM o SGLang	Alquiler por horas	Control de los datos más rendimiento de producción, investigación de fine-tuning
API alojada (Moonshot o Flatkey)	Ninguno	La mayoría de apps, prototipos y tráfico variable

Puedes llamar al modelo alojado con el mismo código de arriba cambiando la base URL:

import os
from openai import OpenAI

client = OpenAI(base_url="https://router.flatkey.ai/v1", api_key=os.environ["FLATKEY_API_KEY"])
r = client.chat.completions.create(model="kimi-k3",
    messages=[{"role": "user", "content": "Summarize the Kimi K3 license in two sentences."}])
print(r.choices[0].message.content)

Más información en nuestro análisis del coste por millón de tokens de un LLM autoalojado, la comparación nube GPU vs API de modelos y la guía de acceso a la API de Kimi K3.

Solución de problemas

Problema	Causa probable	Solución
La generación es extremadamente lenta	El modelo no cabe en RAM + VRAM y se lee desde disco	Usa una cuantización menor, añade RAM o pasa a un servidor GPU
`out of memory` al iniciar llama-server	Caché KV demasiado grande	Reduce `--ctx-size`
Se ignora la entrada de imagen	Falta el archivo del proyector o se usa llama.cpp upstream	Pasa `--mmproj` y compila el fork de Unsloth
La imagen de vLLM no arranca	CUDA o controlador demasiado antiguos	Usa CUDA 13 con el controlador r580 o posterior
Llamadas a herramientas rotas	Salida ocasional mal formada	Valida los argumentos y reintenta
El segundo turno se comporta raro	No se devuelve el contenido de pensamiento	Incluye `reasoning_content` en el historial
La descarga se detiene	Transferencia grande de muchos archivos	Vuelve a ejecutar `hf download`; se reanuda

Preguntas frecuentes

¿Kimi K3 puede ejecutarse en local?

Sí. Los pesos son públicos y el GGUF de 1 bit más pequeño necesita unos 610 GB de RAM y VRAM combinadas para funcionar a una velocidad razonable. Con menos memoria también funciona, pero lento, porque llama.cpp lee los pesos desde disco.

¿Puedo ejecutar Kimi en un PC gaming?

No de forma útil. Una sola GPU de 24 GB con 64-128 GB de RAM está muy por debajo de los unos 610 GB que necesita la cuantización más pequeña, así que dependerías de la descarga a disco. Usa una API o alquila un servidor GPU.

¿Cuánta VRAM necesita Kimi K3?

Para los pesos nativos, la receta oficial de vLLM pide al menos 8x GPU GB300. Para GGUF, lo que importa es la suma de RAM y VRAM: unos 610 GB para 1 bit y unos 880 GB para 2 bits (Unsloth, octubre de 2026).

¿Kimi K3 es realmente más barato que otros modelos?

A través de la API tiene un precio medio: 3 $ / 15 $ por millón de tokens en la plataforma de Moonshot y 1,80 $ / 9 $ en Flatkey a octubre de 2026. El autoalojamiento solo supera al precio de la API con volúmenes muy altos y constantes.