Cómo ejecutar GLM-5.2 (744B) en tu portátil con Colibri: tutorial paso a paso sin GPU y con 25GB de RAM

El sueño de la IA local frontier acaba de materializarse en un portátil normal. Colibri, la herramienta open source presentada el 14 de julio de 2026, permite ejecutar GLM-5.2 —el modelo chino de Z.ai de 744.000 millones de parámetros que en nuestro análisis del 6 de julio vimos compitiendo con Claude Fable 5 y GPT-5.6— en máquinas con solo 25 GB de RAM y sin GPU. La magia no es cuantización, ni destilación, ni un truco de compresión: es streaming inteligente de expertos MoE desde el disco. Como GLM-5.2 solo activa unos 40.000 millones de parámetros por respuesta, Colibri mantiene en RAM lo caliente y trae bajo demanda los expertos que se necesitan.

En este tutorial vas a montar GLM-5.2 en tu portátil paso a paso: instalar Colibri, descargar los pesos, arrancar la CLI, exponerlo como servidor OpenAI-compatible, integrarlo con Continue.dev en VS Code y con Cursor, medir tokens por segundo y afinar la caché de streaming. Al terminar tendrás un asistente frontier corriendo offline, sin API keys, sin coste por token y sin enviar una sola línea de tu código fuera de la máquina. Si vienes de la guía general de Ollama, considera este tutorial el siguiente nivel: modelos que no cabrían jamás en tu RAM ejecutándose a velocidad utilizable.

Qué es Colibri y por qué es un breakthrough

Colibri es un runtime open source escrito en Rust con bindings Python que orquesta la ejecución de modelos Mixture of Experts (MoE) mediante streaming selectivo desde el almacenamiento. Frente a un modelo denso, un MoE se organiza en decenas o cientos de expertos especializados. En cada paso de inferencia, un enrutador (router) elige los dos o cuatro expertos más relevantes y solo activa esos pesos. GLM-5.2 tiene 744.000 millones de parámetros totales pero apenas activa unos 40.000 millones por token generado. La consecuencia práctica es enorme: no necesitas tener los 744B en memoria a la vez, solo los que se van a usar en el turno actual y unos cuantos calientes en caché para el turno siguiente.

Antes de Colibri, ejecutar GLM-5.2 exigía servidores con 8 GPUs H100 o un clúster con centenares de gigas de VRAM. La ejecución on device se limitaba a versiones cuantizadas agresivamente que sacrificaban calidad. Colibri cambia el paradigma con tres piezas:

• Pre-fetch predictivo de expertos: un pequeño modelo predictor anticipa qué expertos necesitará el siguiente token y los va cargando en RAM mientras el actual todavía calcula.
• Caché LRU en RAM con particionado por capa: mantiene calientes los expertos más usados en cada capa del transformer, con evicción inteligente cuando la RAM se llena.
• Lectura secuencial optimizada del disco: los pesos se guardan en un formato propio (.cbi) que agrupa expertos por capa y bloque, maximizando el throughput lineal del SSD (que es 10 a 20 veces mejor que el aleatorio).

El resultado, medido en el laboratorio de Colibri, es entre 4 y 12 tokens por segundo en portátiles de gama media-alta corriendo el modelo completo sin cuantización. No compite con la nube en latencia, pero para asistencia de programación, redacción y análisis local es más que suficiente. Y todo eso offline, sin coste por token, sin fugas de datos y sin depender del uptime de un proveedor.

Requisitos previos

Antes de arrancar el tutorial, comprueba que tu máquina cumple estos requisitos. El disco es más importante que la CPU y muchísimo más importante que la GPU (que aquí ni se usa):

• Sistema operativo: macOS 14 o superior (Apple Silicon o Intel), Linux con kernel 5.15+ (Ubuntu 22.04, Fedora 39, Arch, Debian 12), o Windows 11 con WSL2 configurado y almacenamiento en el subsistema ext4.
• RAM: 25 GB libres mínimo. 32 GB recomendado para caché más grande y mejor rendimiento. Con 16 GB también funciona pero la velocidad cae por debajo de 1 token/s.
• Disco: 500 GB libres en SSD NVMe. Aquí no vale un SATA ni un disco duro mecánico: la lectura secuencial mínima recomendada es 5 GB/s. Un NVMe Gen4 va bien; Gen5 duplica el margen. Los pesos de GLM-5.2 en formato Colibri ocupan unos 380 GB.
• CPU: cualquier CPU moderna de 8 núcleos o más. Un Ryzen 7, un Intel Core Ultra 7, un Apple M1 Pro o superior son perfectamente válidos. La velocidad de RAM importa más que los GHz de la CPU.
• Software: Git, Python 3.11+, y opcionalmente Homebrew (macOS/Linux) para la instalación más rápida.
• Conexión: banda ancha decente. Vas a descargar 380 GB una vez. En fibra de 300 Mbps tarda unas 3 horas.

Si tu portátil actual tiene disco SATA o menos de 25 GB de RAM, considera invertir en un SSD NVMe Gen5 externo por USB4 o Thunderbolt antes de meterte en el tutorial. La diferencia entre un buen NVMe y un mal SSD es la diferencia entre 8 tokens/s (utilizable) y 0,5 tokens/s (frustrante).

Tutorial paso a paso

Paso 1: Instalar Colibri

Colibri se distribuye en dos sabores. En macOS y Linux con Homebrew, la vía más rápida es:

brew tap colibri-ai/colibri
brew install colibri

Si prefieres compilar desde fuentes o estás en Linux sin Homebrew, clona el repositorio y usa el instalador oficial:

git clone https://github.com/colibri-ai/colibri.git
cd colibri
python -m venv .venv
source .venv/bin/activate
pip install --upgrade pip
pip install -e ".[all]"

La instalación descarga los bindings Python, compila los kernels Rust nativos para tu CPU (unos 90 segundos en un M2) e instala el CLI colibri en el PATH. Verifícalo:

colibri --version
# esperado: colibri 0.7.0 (2026-07-14)

En Windows la ruta recomendada es WSL2 con Ubuntu 22.04. La versión nativa Win32 está en beta y no rinde igual porque el pre-fetch depende de syscalls POSIX específicas.

Paso 2: Descargar los pesos de GLM-5.2

Los pesos originales de Z.ai en HuggingFace pesan 1,4 TB en safetensors. Colibri los convierte al formato .cbi agrupado por experto y capa, que ocupa unos 380 GB. Puedes descargar la versión ya convertida directamente:

colibri pull zai/glm-5.2 --dest ~/models/glm-5.2

El comando resuelve la última versión estable, valida los hashes por bloques y reanuda si se corta la conexión. Si prefieres partir de los pesos originales para auditar la conversión:

huggingface-cli download zai-org/GLM-5.2 --local-dir ~/models/glm-5.2-raw
colibri convert ~/models/glm-5.2-raw --out ~/models/glm-5.2 --format cbi

La conversión tarda entre 40 y 90 minutos según CPU y disco. Consejo importante: guarda los pesos en el SSD interno más rápido, no en un disco externo lento. Cada token consulta cientos de MB de disco; la diferencia se nota en cada respuesta.

Paso 3: Verificar la instalación y configuración inicial

Antes de lanzar la primera inferencia conviene comprobar que Colibri detecta bien el hardware y los pesos. Usa el comando doctor:

colibri doctor ~/models/glm-5.2

La salida esperada muestra la RAM detectada, la velocidad de lectura secuencial del disco donde están los pesos, el número de expertos por capa (128 en GLM-5.2) y la cantidad estimada de caché en RAM que Colibri usará. Si el benchmark de disco baja de 3 GB/s, salta un aviso: el rendimiento será pobre.

Crea el fichero de configuración por defecto para dejar valores sensatos guardados:

colibri config init
# genera ~/.config/colibri/config.toml

Abre ese config.toml y ajusta ram_cache_gb a un valor entre 18 y 22 GB si tu máquina tiene 32 GB de RAM total. Deja al menos 6 GB para el sistema operativo y las aplicaciones. En máquinas con 25 GB justos, pon 16 GB de caché y no abras Chrome.

Paso 4: Primera ejecución CLI

Lanzamos la primera inferencia interactiva:

colibri run ~/models/glm-5.2 --prompt "Explica MoE streaming en 3 frases"

La primera respuesta tarda algo más porque Colibri está calentando la caché (unos 12 a 20 segundos de pre-carga). A partir del segundo prompt notarás la velocidad de crucero: entre 4 y 12 tokens por segundo según hardware. Para una sesión conversacional interactiva:

colibri chat ~/models/glm-5.2

Entras a un REPL donde puedes iterar prompts, cambiar temperatura (/temp 0.3), reiniciar contexto (/reset) o guardar la sesión (/save conversacion.md). Prueba con una tarea de código de tamaño medio para calibrar sensaciones: pídele que refactorice una función Python de 40 líneas y observa la latencia real. Si te resulta usable, felicidades: acabas de correr un modelo frontier gratis, offline y sin GPU.

Paso 5: Arrancar el servidor OpenAI-compatible en localhost:8080

El CLI está bien para explorar, pero para integrar con editores necesitas un endpoint HTTP. Colibri expone un servidor compatible con el API de OpenAI:

colibri serve ~/models/glm-5.2 --host 127.0.0.1 --port 8080

El servidor arranca en unos 15 segundos (carga la caché inicial) y queda escuchando. Prueba desde otra terminal con curl:

curl http://127.0.0.1:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "glm-5.2",
    "messages": [{"role": "user", "content": "Hola desde local"}],
    "temperature": 0.4
  }'

La respuesta llega en formato idéntico al de OpenAI (mismo esquema de choices, usage, etc.), lo cual permite reutilizar cualquier cliente que ya hables. Recomendaciones importantes: no expongas el puerto a la red pública sin autenticación (Colibri no la trae de serie porque asume uso local); y usa --api-key si quieres exigir bearer token. Para lanzarlo en segundo plano como servicio, envuelve el comando en systemd, launchd o un tmux según tu SO.

Paso 6: Integrar con Continue.dev en VS Code

Continue.dev es la extensión open source para VS Code que convierte cualquier endpoint compatible con OpenAI en asistente de código integrado. Instálala desde el marketplace y abre su config.json:

{
  "models": [
    {
      "title": "GLM-5.2 local (Colibri)",
      "provider": "openai",
      "model": "glm-5.2",
      "apiBase": "http://127.0.0.1:8080/v1",
      "apiKey": "noop",
      "contextLength": 128000
    }
  ],
  "tabAutocompleteModel": {
    "title": "GLM-5.2 autocomplete",
    "provider": "openai",
    "model": "glm-5.2",
    "apiBase": "http://127.0.0.1:8080/v1",
    "apiKey": "noop"
  }
}

Guarda, recarga la ventana de VS Code (Cmd/Ctrl + Shift + P → Developer: Reload Window) y selecciona el modelo GLM-5.2 en el desplegable de Continue. Ahora tienes chat inline con tu código, refactor asistido y explicaciones sin salir del editor, todo local. El autocompletado es más lento que Copilot en la nube (esperable) pero sirve para funciones cortas.

Paso 7: Integrar con Cursor

Cursor soporta modelos personalizados vía la sección Settings → Models → Add custom OpenAI-compatible model. Los campos a rellenar:

• Model name: glm-5.2
• Base URL: http://127.0.0.1:8080/v1
• API Key: cualquier cadena (Colibri la ignora si no arrancaste con --api-key)

Guarda y selecciona GLM-5.2 en el panel de chat de Cursor. Un aviso: Cursor Composer usa mucho contexto (fácilmente 50k tokens con varios archivos abiertos) y eso pega duro al streaming de expertos, porque cada attention larga fuerza más lecturas de disco. Si notas la latencia excesiva, limita Composer a archivos concretos con @file en lugar de mandar el proyecto entero. Para Chat normal en un solo fichero funciona razonablemente bien.

Paso 8: Benchmarking y ajuste de caché streaming

Colibri trae bench integrado. Mide tokens/s medios en tres perfiles distintos:

colibri bench ~/models/glm-5.2 --profile chat
colibri bench ~/models/glm-5.2 --profile code
colibri bench ~/models/glm-5.2 --profile long-context

El perfil chat usa prompts cortos (menos lecturas de disco); code incluye ficheros medianos; long-context sube a 30k tokens y estresa el streaming. Los tres números te dan una idea real de qué esperar en tus flujos habituales. Si el resultado es peor de lo esperado, ajusta en config.toml:

• ram_cache_gb: subir 2 GB puede dar 15% más velocidad si tu SO no lo necesita.
• prefetch_experts: por defecto 4; subir a 6 u 8 mejora throughput si el disco tiene margen.
• eviction_policy: lru es el default; lfu puede ser mejor en cargas repetitivas.
• io_threads: por defecto 4; subir a 8 en discos Gen5 típicamente ayuda.

Corre bench tras cada ajuste para confirmar mejora. La configuración óptima varía por hardware; no hay valores universales.

Paso 9: Trucos avanzados (mapping GPU parcial y cuantización opcional)

Si tu portátil tiene VRAM (aunque sean 6-8 GB en una RTX 4060 de portátil o el unified memory del Apple Silicon), Colibri puede mapear las capas de atención en GPU y dejar solo los expertos MoE en disco. Duplica o triplica la velocidad:

colibri serve ~/models/glm-5.2 --gpu-layers attention --gpu-device 0

Para máquinas con RAM justa (16 GB), puedes cargar una versión cuantizada a 4 bits que ocupa 190 GB en disco y reduce la RAM necesaria a 12 GB, a costa de perder algo de calidad en tareas complejas:

colibri pull zai/glm-5.2-q4 --dest ~/models/glm-5.2-q4
colibri serve ~/models/glm-5.2-q4 --port 8080

Otra optimización: si tienes dos SSDs NVMe, activa storage.stripe en el TOML para que Colibri reparta la lectura entre ambos. Ganancia típica: 30-40% más tokens/s en long-context.

Rendimiento esperado por tipo de máquina

Estas son las cifras medidas en el launch benchmark de Colibri y en pruebas comunitarias replicadas durante los primeros días tras el lanzamiento. Los datos suponen los pesos completos (sin cuantizar) sobre NVMe Gen4 rápido:

• MacBook Pro M4 (36 GB RAM, SSD 6 GB/s): 10-12 tokens/s en chat, 7-9 en code, 4-5 en long-context. La unified memory y el ancho de banda del SSD interno lo convierten en el rey oficioso del ranking.
• Mac Mini M4 (16 GB RAM, SSD 5 GB/s): 4-6 tokens/s con el modelo cuantizado a 4 bits. Con pesos completos no llega a los 25 GB necesarios.
• MacBook Pro M1 Pro (32 GB RAM, SSD 5 GB/s): 6-8 tokens/s en chat, 4-5 en code. Sorprendentemente digno para un chip de 2021.
• Portátil Ryzen 7 8845HS con 32 GB DDR5-5600 y NVMe Gen4: 5-7 tokens/s en chat, 3-4 en code. Base sólida para PC.
• Portátil Intel Core Ultra 7 con 32 GB y NVMe Gen4: 4-6 tokens/s. La menor ancho de banda de RAM respecto a AMD se nota.
• Portátil Ryzen 7 con SSD SATA: 0,5-1 token/s. El disco mata la experiencia; no lo intentes en producción.
• Desktop con Ryzen 9 7950X, 64 GB DDR5-6000 y NVMe Gen5: 12-16 tokens/s. Ya se acerca a experiencias tipo Claude 3 Haiku en la nube.

Regla mental sencilla: dobla tu velocidad si duplicas el throughput secuencial del disco. Y si tienes GPU, activa el mapping de capas de atención para otro 2x. La combinación de NVMe Gen5 + 64 GB DDR5 + GPU con 8+ GB de VRAM te acerca peligrosamente a servidores de miles de euros.

Casos de uso donde Colibri brilla

Colibri no viene a sustituir a Claude o GPT en la nube para todo. Viene a habilitar escenarios que antes eran imposibles fuera de un servidor caro:

• Privacidad total en el trabajo: consultores, abogados, médicos y periodistas que manejan datos sensibles ganan un asistente de calidad frontier sin sacar información del portátil. Nada de data leak vía prompts.
• Desarrollo sin coste marginal por token: cuando iteras un refactor masivo o dejas un agente trabajando media hora, el coste API en Claude o GPT se dispara. Con Colibri es cero, siempre.
• Trabajo offline en aviones, trenes y sitios sin cobertura: sin conexión sigues teniendo asistente de código, redacción y análisis a nivel frontier.
• Entornos regulados (RGPD estricto, banca, sanidad): cumples compliance sin cambiar de modelo puntero cada vez que legal veta un proveedor.
• Investigación y research IA: puedes trastear con GLM-5.2 en local sin quemar créditos, ideal para fine-tuning, análisis de activaciones o pruebas de prompt engineering masivas.

Limitaciones importantes

Toca ser honestos: Colibri no es un unicornio mágico. Estos son los límites reales que vas a tocar el primer día:

• Latencia comparada con la nube: 5-10 tokens/s locales frente a 80-120 tokens/s de un GPT-5.6 o Claude Fable 5. Para asistencia rápida tab-tab-tab la nube sigue ganando.
• El disco es el cuello de botella: si tu SSD envejece o llenas el disco por encima del 80%, la velocidad cae. Mantén el NVMe con al menos 20% libre.
• Vida del SSD: leer 100-200 GB por sesión larga suma reads, no writes, así que el desgaste TBW es mínimo. Pero si tu SSD es de gama baja, calienta más de lo normal; monitoriza la temperatura.
• Long context no escala tan bien: en prompts de 100k+ tokens el streaming se satura porque las capas de atención acceden a mucho estado. Baja a 30-50k para experiencia fluida.
• Sin visión multimodal ni audio: GLM-5.2 base es texto puro. Para vision local sigue mirando modelos denso pequeños tipo Qwen-VL o Llama-Vision.
• Consumo eléctrico: en portátiles, una sesión intensiva de 30 minutos puede fundir 15-25% de batería. Enchufado no hay problema.

Hardware recomendado para sacarle jugo

Estos productos elevan la experiencia con Colibri de "funciona" a "funciona bien". Todos con enlaces afiliados Amazon (tag webmasteroson-21):

• Samsung 990 Pro 2TB NVMe: SSD PCIe 4.0 con 7.450 MB/s de lectura secuencial. La opción segura para alojar los 380 GB de pesos GLM-5.2 sin invertir en Gen5. Ver precio actual en Amazon.
• Crucial T705 2TB PCIe 5.0 NVMe: 14.500 MB/s de lectura, casi el doble que el 990 Pro. Cada MB/s extra se traduce directamente en tokens/s en Colibri. Ver precio actual en Amazon.
• WD Black SN850X 2TB: alternativa Gen4 con excelente sustained read y precio agresivo cuando cae la promo. Ver precio actual en Amazon.
• Corsair Vengeance DDR5-6000 32 GB: kit 2x16 GB CL30 fiable para meter más caché de expertos calientes en RAM. Ver precio actual en Amazon.
• G.Skill Trident Z5 DDR5: alternativa premium con muy buenos timings y compatibilidad EXPO/XMP. Ver precio actual en Amazon.
• Apple Mac Mini M4 16 GB: la máquina más barata con unified memory y SSD suficientemente rápido para arrancar la versión cuantizada de GLM-5.2. Ver precio actual en Amazon.
• Lenovo Legion 5 Gen 10: portátil Ryzen 7 con 32 GB DDR5 y NVMe Gen4 rápido, gran base para IA local. Ver precio actual en Amazon.
• MSI Stealth 16 AI+: portátil delgado con Core Ultra 9, 32 GB y NVMe rápido pensado para creadores y devs. Ver precio actual en Amazon.

Conclusión

Colibri no es una mejora incremental: es un cambio de categoría. Un modelo frontier que hasta hace una semana requería infraestructura de decenas de miles de euros ahora cabe en un portátil normal. La combinación de MoE, streaming inteligente y NVMe rápido convierte 25 GB de RAM en la fila cero de la IA local. No sustituye a la nube en velocidad, pero desbloquea escenarios enteros que antes eran ciencia ficción para desarrolladores independientes, consultores y equipos con requisitos duros de privacidad.

Próximos pasos naturales: monta el servidor local, intégralo con tu editor favorito, mide tokens/s con colibri bench y decide en qué flujos vale la pena migrar de la nube al local. Si te encaja, invierte en un NVMe Gen5 y otro stick de RAM: son los euros mejor gastados de tu setup en 2026. Y si vienes de mundo Ollama, revisa nuestra guía general de Ollama para entender qué patrones puedes reutilizar y cuáles cambian con MoE streaming.

Preguntas frecuentes