Modelo MoE local: lo que Colibri le pide a tu disco

Modelo MoE local con Colibri: RAM, disco NVMe, velocidades publicadas y supervisión con /metrics. Lo que dice el README antes de bajar 400 GB.
Modèle MoE local : ce que Colibri demande à votre disque

El viernes, en la reunión de equipo, alguien suelta la pregunta: ¿podemos alojar un modelo abierto grande en el equipo de la oficina, sin un servidor de ocho GPU? Con un modelo MoE local, la respuesta no depende tanto de la potencia de cálculo como de un equilibrio entre RAM, disco y paciencia. Colibri, un repositorio de GitHub de inferencia escrito en C, se ofrece justo para hacer ese reparto por ti.

Parto de la decisión operativa, no de la instalación: ¿qué conviene saber antes de bajar 400 GB? Aviso de método: no he ejecutado Colibri. Todo sale del repositorio JustVugg/colibri, leído el 10 de noviembre de 2026 (README, CHANGELOG y documentación de la API). Las velocidades citadas son las del propio proyecto, medidas en sus máquinas.

El código está bajo licencia Apache 2.0. La versión 2.1.0 es del 31 de octubre de 2026 y hay actividad a diario. GitHub mostraba unas 49 500 estrellas y 5800 forks (cifras redondeadas por la página, no exactas). Es un proyecto joven y veloz: toma sus números como mediciones que hay que reproducir.

Modelo MoE local: por qué la RAM ya no es el único cuello de botella

Un modelo MoE (mixture of experts, mezcla de expertos) ocupa muchísimo en disco, pero trabaja poco por token. Según el README, GLM-5.2 tiene 744 000 millones de parámetros, activa unos 40 000 millones por token (el 5,4 %) y solo cambian de un token al siguiente unos 11 GB: los expertos enrutados.

Esquema del README de Colibri: unos 40 000 millones de parámetros activos de 744 000 millones por token, es decir, el 5,4 %
Source : github.com

La consecuencia práctica es sencilla. El modelo no necesita caber en memoria rápida: necesita estar bien colocado. Colibri mantiene en RAM la parte densa (atención, expertos compartidos, embeddings) y va leyendo del disco los expertos que hacen falta, a través de una caché que aprende cuáles pide tu uso. Si hay GPU, se queda con los expertos más solicitados.

El proyecto insiste en algo: dónde viva un peso solo afecta a la velocidad, no al resultado. Menos memoria rápida puede costar tiempo, nunca precisión del modelo, afirma el README. Es una promesa del proyecto que no puedo confirmar sin medirla.

Cuántos tokens por segundo: lee la tabla antes de ilusionarte

Para cada modelo, el README da un mínimo de RAM por debajo del cual no arranca nada y un segundo umbral a partir del cual se alcanza la velocidad medida. Algunas filas, tal como se publican:

  • Qwen3.6-35B-A3B (23 GB de descarga): 6,0 tokens/s en CPU y 30,0 con CUDA en una RTX 3070;
  • DeepSeek V4 Flash (167 GB): 0,93 token/s con 32 GB de RAM, solo CPU;
  • GLM-5.2 (429 GB, mínimo 16 GB de RAM): de 0,05 a 0,1 token/s en frío en un portátil con 25 GB, 1,83 en una máquina de 128 GB y de 9,0 a 9,2 con seis RTX 5090;
  • Kimi K3 (1,56 TB): unos 9,4 segundos por token.

Léelo como un SRE lee un SLO: un portátil que suelta un token cada diez o veinte segundos responde «bien», pero no atiende a ningún usuario. Para trabajos por lotes nocturnos, evaluaciones o un asistente personal, menos de un token por segundo puede bastar. Si el equipo conversa en directo, apunta a modelos pequeños o a una GPU.

En los modelos grandes manda el disco. El proyecto señala que un NVMe rápido es lo que más ayuda y que dos NVMe en controladoras independientes midieron un 37,5 % más de caudal de generación. Un único disco lento no es un detalle: es tu techo.

Instalar Colibri: lo que dice el README

Hardware mínimo anunciado: 8 GB de RAM (se aconsejan 16 GB o más), 22 GB libres para el modelo más pequeño y conexión a internet. La GPU es opcional; según el motor se admiten Vulkan, CUDA y Metal. El camino de un solo paso en Linux:

sudo apt install git python3 build-essential
git clone https://github.com/JustVugg/colibri
cd colibri
./start-here.sh

En Windows se descomprime el archivo y se ejecuta START-HERE.bat; en macOS se instalan Xcode CLT, libomp, git y python con Homebrew y se lanza el mismo script. El programa analiza el equipo, recomienda el modelo más capaz que cabe en RAM, compila el motor, descarga con reanudación y abre el panel. Opciones útiles: --list compara todos los modelos con tu máquina, --model ID fuerza uno y --dir cambia el disco de destino.

Antes de comprometer 400 GB, el lanzador trae tres comandos pensados para decidir, siempre según el README: coli plan muestra dónde vivirá el modelo (VRAM, RAM, disco), coli doctor comprueba sin modificar nada y coli tune mide y guarda los ajustes seguros más rápidos para tu máquina.

Ver trabajar a los expertos

El panel (coli web) y la interfaz coli ui muestran un mapa de expertos: una celda por experto en cada bloque, blanca si se elige en el paso actual y ámbar si participó en la respuesta. La captura siguiente muestra OLMoE, el modelo pequeño de 7000 millones de parámetros que el proyecto recomienda para aprender las herramientas.

Interfaz de chat de Colibri con OLMoE: una respuesta sobre el vuelo del colibrí a 38,7 tokens/s y, a la derecha, el mapa de expertos por bloque
Source : github.com

Una segunda pantalla, el monitor, indica el estado del modelo (inactivo, leyendo, escribiendo), la velocidad, la lectura del prompt, y la RAM y la CPU del motor.

Monitor de Colibri durante la generación con LFM3-VL-2B: 31,6 tokens/s, prompt leído en 0,1 s y 2,1 GB de RAM para el motor
Source : github.com

Ambas capturas salen del repositorio del proyecto (licencia Apache 2.0). No enseñan un modelo grande sufriendo, sino modelos pequeños a gusto. No las tomes como prueba de velocidad con 744 000 millones de parámetros.

Exponer y supervisar el servidor

coli serve arranca un servidor compatible con OpenAI (/v1/chat/completions) y con Anthropic (/v1/messages). Por defecto escucha en localhost. Según la documentación, hay que definir COLI_API_KEY antes de abrirlo a la red. Hazlo lo primero: un servidor de inferencia sin clave en una red corporativa es una puerta de entrada gratis.

Para la supervisión, la documentación de la API describe dos endpoints útiles. GET /health expone los contadores de peticiones activas, en cola, terminadas y rechazadas, responde 503 con {"status": "restarting"} mientras el motor se reinicia y cuenta los reinicios en engine_restarts. GET /metrics devuelve texto Prometheus cuyos nombres empiezan todos por colibri_scheduler_, con gauges (active, queued), contadores (completed_total, failed_total, rejected_total, timed_out_total) e histogramas (queue_wait_seconds, first_output_seconds, engine_call_seconds). Las métricas no incluyen ni prompts ni rutas de modelo.

Un Collector de OpenTelemetry puede recogerlas con el receptor de Prometheus. Ejemplo mínimo, para adaptar (el destino y el exportador son valores de ejemplo):

receivers:
  prometheus:
    config:
      scrape_configs:
        - job_name: colibri
          scrape_interval: 30s
          authorization:
            credentials: ${env:COLI_API_KEY}
          static_configs:
            - targets: ["127.0.0.1:8000"]
exporters:
  otlphttp:
    endpoint: ${env:OTLP_ENDPOINT}
service:
  pipelines:
    metrics:
      receivers: [prometheus]
      exporters: [otlphttp]

No he probado esta configuración con Colibri ni he comprobado la ingesta en Dynatrace, Managed o SaaS: es un Collector estándar. Las señales que merece la pena seguir: queue_wait_seconds para la contención, first_output_seconds para lo que espera el usuario, y failed_total junto con engine_restarts para detectar un motor abatido por el gestor de memoria. Si quieres profundizar en la supervisión de un motor local, mira nuestro artículo sobre Ollama y el de vLLM en producción.

Límites y asuntos abiertos

  • El repositorio es joven y cambia rápido: 387 pull requests entre las versiones 2.0.0 y 2.1.0, según el CHANGELOG. Fija una versión.
  • El propio proyecto guarda sus vías de optimización en una lista de hipótesis por reproducir, con fracasos publicados; por ejemplo, una especulación MTP que midió un 32 % más lenta con un acierto de caché cercano al 85 %. Buena señal de honestidad, pero también prueba de que los ajustes se miden máquina por máquina.
  • Todas las velocidades vienen del proyecto: ninguna se ha reproducido aquí.
  • Algunos modelos tienen licencia propia (Qwen-Image no comercial, Muse Spark Open bajo un acuerdo con Meta): la Apache 2.0 del motor no cubre los pesos.
  • Compáralo con motores más extendidos antes de decidir: consulta la comparativa de Ollama, vLLM y llama.cpp y, para un modelo grande en GPU, el autoalojamiento de Mistral Large 4.

Buenas prácticas

  • Empieza con un modelo pequeño (OLMoE o Qwen3.6) para validar toda la cadena antes de la descarga grande.
  • Coloca los modelos en el NVMe más rápido, nunca en un montaje de red ni en /mnt/c bajo WSL, algo que el README desaconseja.
  • Define COLI_API_KEY y deja la escucha en localhost hasta que haya un proxy inverso con autenticación.
  • Recoge /metrics desde el primer día, con una alerta sobre failed_total y otra sobre la duración de first_output_seconds.
  • Anota tus propias mediciones (hardware, comando, estado de la caché): el proyecto las pide, y son las que te darán un SLO creíble.

Preguntas frecuentes

¿Hace falta una GPU para un modelo MoE local con Colibri?

No, según el README: todos los motores funcionan en CPU. La GPU es solo un sitio más rápido donde guardar pesos. En los modelos grandes la velocidad la fija el disco; en los pequeños, la RAM.

¿Qué velocidad esperar en un equipo corriente?

Varía más de 100 veces según el modelo: de unos pocos tokens por segundo en uno de 35 000 millones de parámetros a menos de un token por segundo en los gigantes. Mide con coli tune en tu hardware en lugar de fiarte de una tabla.

¿Sirve Colibri para un equipo de trabajo?

El servidor gestiona una cola, huecos de caché y rechazos 429, pero no he comprobado cómo se comporta bajo carga. Prueba con tus casos de uso y vigila la cola antes de abrir el servicio.

Conclusión

Un modelo MoE local es realista porque solo una pequeña fracción de los parámetros trabaja en cada token. Colibri lleva esa idea hasta el final: la RAM guarda el núcleo del modelo y el disco guarda el resto. Antes de descargar, mira la fila de tu máquina en la tabla, ejecuta coli plan y conecta /metrics para que la velocidad anunciada pase a ser una velocidad medida.

span.observer es un blog independiente de la comunidad, no afiliado a Dynatrace LLC. Colibri es un proyecto de terceros; la información procede de su repositorio público y puede cambiar, así que compruébala antes de llevarla a producción.

Total
0
Shares
Leave a Reply

Your email address will not be published. Required fields are marked *

Previous Post
Gatus page de statut : alertes en YAML pour développeurs

Gatus página de estado: alertas YAML para desarrolladores

Related Posts