Strata: cómo correr un modelo MoE de 125B en 12 GB de VRAM

⏱️ Lectura: 16 min

Un modelo de lenguaje con más de 100.000 millones de parámetros normalmente necesita un servidor con varias GPU de centro de datos. Strata, un motor de inferencia open source, lo hace correr en una tarjeta gráfica de PC gamer con apenas 12 GB de VRAM gracias al offloading de expertos.

📑 En este artículo

1. TL;DR
2. ¿Qué es el offloading de expertos?
3. Por qué importa correr un MoE de 125B sin servidor
4. Cómo funciona la descarga de expertos en Strata
5. Ejemplos prácticos
6. Cómo empezar
7. Casos de uso reales
8. Errores comunes y buenas prácticas
9. Comparativa con alternativas
10. Profundizando
11. Preguntas frecuentes
    1. ¿Qué es el offloading de expertos y por qué lo necesita un modelo como Qwen3.8-Flash-Next?
    2. ¿Cuánta VRAM necesito para correr un modelo MoE de 125B con Strata?
    3. ¿Por qué la cuantización agresiva no deja a la arquitectura de mezcla de expertos inútil?
    4. ¿Strata funciona en macOS o con GPUs de Apple Silicon?
    5. ¿Puedo usar dos tarjetas gráficas para repartir la descarga de expertos a RAM entre ambas?
    6. ¿Qué pasa si mi CPU no tiene AVX2?
12. Referencias
    1. 📚 Artículos relacionados

La pieza central es Qwen3.8-Flash-Next, un modelo de mezcla de expertos (MoE) de 125.000 millones de parámetros que normalmente vive en un clúster de GPU empresariales. Strata lo comprime y lo reparte entre la VRAM y la RAM de una PC normal, con instalación de un clic para Windows y Linux.

TL;DR

• Strata corre un MoE de 125B de parámetros en una gpu de 12 GB combinando offloading de expertos y cuantización GGUF.
• Los modelos MoE activan solo unos pocos expertos por token, lo que libera al resto de la VRAM.
• GGUF reduce los pesos de Q2_0 e IQ3_S a pocos bits, y el paquete completo cabe en un disco de unos 70 GB.
• Una RTX 5070 de 12 GB llega a 94 tokens por segundo escribiendo en el nivel de cuantización más agresivo.
• Un gotcha clave: la PC puede congelarse 1 a 3 minutos mientras Strata carga 35 a 55 GB en RAM.

¿Qué es el offloading de expertos?

El offloading de expertos es la técnica de inferencia que reparte los pesos de un modelo de mezcla de expertos (MoE) entre la VRAM de la GPU y la RAM del sistema, dejando en la tarjeta gráfica solo los expertos que se activan en cada token.

La idea aprovecha una propiedad central de los modelos de mezcla de expertos: aunque el modelo tenga cientos de miles de millones de parámetros en total, cada token solo necesita un subconjunto pequeño de ellos. Strata explota esa dispersión para que el modelo completo nunca tenga que vivir entero en la VRAM, uno de los cuellos de botella más caros del hardware de IA.

Por qué importa correr un MoE de 125B sin servidor

Antes de proyectos como este, correr un modelo de 125.000 millones de parámetros significaba alquilar varias GPU de centro de datos tipo A100 o H100, con facturas de nube de miles de dólares al mes. La técnica cambia esa ecuación: convierte un problema de infraestructura en un problema de paciencia, porque la respuesta tarda más, pero corre en una gpu que cuesta una fracción de ese precio.

Para un equipo pequeño o un desarrollador independiente en América Latina, eso significa poder prototipar con un modelo de la escala de los que usan las grandes empresas sin pagar por la nube ni enviar datos a servidores de terceros. El límite ya no es el presupuesto en la nube: es cuánta paciencia tiene el desarrollador para esperar los tokens.

La contrapartida real aparece en la tabla de rendimiento: cuanto más agresiva la cuantización, más rápido corre el modelo, pero la calidad de las respuestas puede resentirse. Esa relación entre velocidad, memoria y precisión es el verdadero costo oculto de la descarga de expertos a RAM.

Cómo funciona la descarga de expertos en Strata

Un modelo MoE no es una red neuronal única y gigante. Es un conjunto de subredes (los \»expertos\») más una red de gating o router que decide, para cada token, cuáles expertos procesan ese token y con qué peso se combinan sus salidas. Mixtral, por ejemplo, popularizó el esquema de activar solo 2 de 8 expertos por capa, y buena parte de los modelos MoE actuales siguen una lógica similar.

Strata usa esa dispersión para decidir qué vive en la GPU y qué vive en la RAM. Los pesos que se consultan con más frecuencia quedan cerca de la GPU; los que rara vez se activan quedan en la RAM del sistema, más lenta pero mucho más barata por gigabyte. Cuando el router elige un experto que no está en VRAM, Strata lo trae desde la RAM a través del bus PCIe antes de poder usarlo.

flowchart TD
    A[\"Prompt del usuario\"] --> B[\"Router del modelo MoE\"]
    B --> C[\"Expertos activos para este token\"]
    B --> D[\"Expertos inactivos\"]
    C --> E[(\"VRAM de la GPU, 12 GB\")]
    D --> F[(\"RAM del sistema\")]
    subgraph Strata
    C
    D
    E
    F
    end

Esto explica por qué la velocidad de lectura del prompt y la de escritura de la respuesta son tan distintas en los benchmarks de Strata. Leer el prompt es paralelizable: la GPU procesa miles de tokens del contexto de una sola pasada, con los expertos ya cargados. Escribir la respuesta es secuencial, token por token, y cada token nuevo puede obligar a traer pesos frescos desde la RAM. Esa caída de velocidad al escribir frente a leer es la huella más clara del offloading de expertos funcionando en tiempo real.

Medido por los mantenedores en una RTX 5070 de 12 GB, con un Ryzen 5 7600 y 64 GB de RAM, usando respuestas de 4.000 tokens sobre prompts de 32.000 tokens. En una AMD RX 9070 XT de 16 GB los números bajan a 60 tokens/s en Q2_0: la VRAM extra no compensa una GPU más lenta.

💭 Clave: el modelo completo pesa unos 70 GB en el disco, pero Strata solo carga entre 35 y 55 GB en RAM según el nivel de cuantización elegido. La diferencia es justamente lo que la cuantización logra comprimir antes de que el modelo llegue a memoria.

Ejemplos prácticos

Strata expone una API compatible con OpenAI y Anthropic en localhost, así que cualquier cliente HTTP sirve para hablarle. El primer ejemplo es literalmente un \»hola mundo\»:

curl http://127.0.0.1:8080/v1/chat/completions \\
  -H \"Content-Type: application/json\" \\
  -d '{
    \"model\": \"qwen3.8-flash-next\",
    \"messages\": [{\"role\": \"user\", \"content\": \"Hola, preséntate en una línea\"}]
  }'

La respuesta sigue el formato estándar de chat completions, con la estructura:

{
  \"id\": \"chatcmpl-001\",
  \"object\": \"chat.completion\",
  \"choices\": [
    {
      \"message\": {
        \"role\": \"assistant\",
        \"content\": \"Soy Qwen3.8-Flash-Next, corriendo localmente a través de Strata.\"
      },
      \"finish_reason\": \"stop\"
    }
  ]
}

El segundo ejemplo es un caso real: pedirle al modelo una función de Python desde un script, igual que haría un agente de código apuntando a una API en la nube.

import requests

respuesta = requests.post(
    \"http://127.0.0.1:8080/v1/chat/completions\",
    json={
        \"model\": \"qwen3.8-flash-next\",
        \"messages\": [
            {\"role\": \"user\", \"content\": \"Escribe una función en Python que calcule el máximo común divisor\"}
        ],
    },
)
print(respuesta.json()[\"choices\"][0][\"message\"][\"content\"]])

El script imprime el texto que devuelve el modelo, típicamente una función def mcd(a, b): con una implementación del algoritmo de Euclidio. La ventaja frente a usar una API en la nube es que el prompt, el código generado y cualquier dato sensible del repositorio nunca salen de la PC.

sequenceDiagram
    participant U as Usuario
    participant R as Router
    participant G as GPU
    participant Ram as RAM
    U->>R: envia un prompt
    R->>G: activa los expertos necesarios
    G->>Ram: pide los pesos de los expertos frios
    Ram-->>G: transfiere los pesos por PCIe
    G-->>U: devuelve el siguiente token
    Note over G,Ram: este intercambio se repite en cada token nuevo

Cómo empezar

Antes de instalar, confirmá tres cosas: una GPU NVIDIA serie 20 a 50 o AMD Radeon RX 7900/7800/7700/9060/9070 con 12 GB de VRAM o más, al menos 32 GB de RAM (64 GB si querés correr cualquier tamaño de modelo), y unos 80 GB libres en disco, idealmente en una unidad SSD para que el primer arranque no sea lentísimo. Todo esto está detallado en el repositorio oficial de Strata.

En Windows, el camino es descargar o clonar el repositorio y hacer doble clic en START-HERE.bat dentro de la carpeta de Strata. El instalador detecta la tarjeta gráfica, pregunta qué modelo y qué tamaño de cuantización querés, cuánto contexto necesitás y si vas a usar entrada de imágenes, y con Enter acepta la opción recomendada en cada paso. En Linux, el equivalente es correr ./setup.sh desde esa misma carpeta.

Después de responder las preguntas, Strata descarga el modelo (unos 70 GB) y lo retoma automáticamente si la descarga se interrumpe. Al terminar, abre el navegador en http://127.0.0.1:8080. Durante la carga inicial la PC puede volverse lenta o no responder durante 1 a 3 minutos mientras Strata mueve entre 35 y 55 GB a la RAM: es esperado, no hay que cerrar la ventana.

💡 Tip: si usás un asistente de código como Claude Code, Cursor o GitHub Copilot, podés pegarle directamente \»Set up Strata on this PC for me: https://github.com/Niko1221/Strata, follow docs/AI_SETUP.md\» y deja que el agente detecte tu hardware y elija el tamaño de modelo por vos.

Para confirmar que la GPU realmente está reteniendo los expertos activos, el chequeo más directo es mirar cuánta VRAM está ocupada mientras el modelo responde:

nvidia-smi --query-gpu=memory.used,memory.total --format=csv

La salida esperada en una gpu de 12 GB con el modelo cargado se ve así:

memory.used [MiB], memory.total [MiB]
11852 MiB, 12288 MiB

No hay forma directa de verificar desde afuera cuántos expertos concretos están en VRAM en un instante dado: Strata no documenta públicamente un comando para eso. La señal indirecta es justamente esa, VRAM casi llena de forma sostenida mientras la RAM del sistema sube según la tabla de 35 a 55 GB del README.

Casos de uso reales

Un desarrollador que prueba agentes de código sin mandar su repositorio privado a una API externa es el caso más directo: el endpoint local compatible con OpenAI y Anthropic permite enchufar herramientas que ya esperan ese formato sin cambiar una línea de integración.

Un equipo chico evaluando si un modelo MoE grande sirve para un bot de soporte puede correr la prueba de concepto completa en una sola PC antes de decidir si vale la pena pagar por inferencia en la nube. Y alguien que investiga cuantización puede comparar directamente Q2_0 contra IQ3_S en su propio hardware, en vez de confiar en benchmarks ajenos.

El soporte experimental de entrada de imágenes, según el propio repositorio, también habilita prototipos de asistentes multimodales locales, aunque con el costo de rendimiento que implica procesar visión además de texto.

Errores comunes y buenas prácticas

El error más frecuente es subestimar la RAM. Con 32 GB, los tamaños de modelo más grandes pueden no entrar completos; 64 GB es lo que el propio proyecto recomienda para correr cualquier tamaño sin sobresaltos.

Otro error es comparar mal las dos columnas del benchmark: una gpu que \»lee rápido\» (prefill) no necesariamente \»escribe rápido\» (decode), y son las dos métricas las que definen si un caso de uso es viable. Un chatbot interactivo depende de la velocidad de escritura; un pipeline que resume documentos largos depende más de la velocidad de lectura.

Instalar en un disco mecánico en vez de un SSD también castiga el primer arranque de forma notoria, según advierte el propio README. Y mezclar dos GPU de generaciones muy distintas en modo multi-GPU puede dejar que la más lenta marque el ritmo de todo el sistema.

⚠️ Ojo: el freeze de 1 a 3 minutos durante la primera carga es esperado. Cerrar la ventana en ese momento puede interrumpir la carga del modelo y obligar a reiniciar el proceso.

Comparativa con alternativas

Profundizando

La red de gating de un modelo de mezcla de expertos funciona, en términos simples, calculando un puntaje para cada experto y quedándose con los de mayor puntaje (el \»top-k\»). La salida final combina las respuestas de esos expertos ponderadas por su puntaje, no un promedio simple.

flowchart LR
    T[\"Token de entrada\"] --> Gt[\"Red de gating (router)\"]
    Gt --> S1[\"Experto 1: puntaje\"]
    Gt --> S2[\"Experto 2: puntaje\"]
    Gt --> S3[\"Experto N: puntaje\"]
    S1 --> K[\"Top-k expertos seleccionados\"]
    S2 --> K
    S3 --> K
    K --> O[\"Salida combinada del token\"]

El cuello de botella físico detrás de todo esto es el bus PCIe que conecta la GPU con la RAM: en PCIe 4.0 x16, el ancho de banda teórico ronda los 31,5 GB/s en una dirección, muy por debajo del ancho de banda interno de la VRAM. Cada vez que un experto no está en la GPU, ese viaje por PCIe es el verdadero costo de la descarga de expertos a RAM, no el cómputo en sí.

El propio proyecto documenta soporte experimental para hardware fuera del catálogo principal: GPU más viejas como Tesla P40, V100 o Radeon VII, Intel Arc compilado desde el código fuente en Linux, y procesadores sin AVX2, que funcionan pero notablemente más lentos. También admite repartir el modelo entre 2 o 3 tarjetas gráficas simultáneas, lo que reduce cuánta RAM del sistema necesita cada una individualmente.

Una limitación real que vale la pena decir sin vueltas: la técnica no hace que el modelo sea gratis en cómputo, solo cambia dónde vive ese costo. Si tu caso de uso necesita baja latencia garantizada para muchos usuarios a la vez, un servidor dedicado sigue siendo la opción correcta; el offloading de expertos brilla para uso individual o prototipos, no para servir tráfico de producción a escala.

📖 Resumen en Telegram: Ver resumen

Tu próximo paso: cloná el repositorio de Strata, corré ./setup.sh (o START-HERE.bat en Windows) y medí vos mismo con nvidia-smi cuánta VRAM ocupa Q2_0 frente a IQ3_S en tu propia gpu.

Preguntas frecuentes

¿Qué es el offloading de expertos y por qué lo necesita un modelo como Qwen3.8-Flash-Next?

Es la técnica que mantiene en VRAM solo los expertos que el router activa para cada token y deja el resto en RAM. Qwen3.8-Flash-Next la necesita porque sus 125.000 millones de parámetros no entran enteros en una gpu de 12 GB.

¿Cuánta VRAM necesito para correr un modelo MoE de 125B con Strata?

El mínimo documentado es 12 GB, en GPU NVIDIA serie 20 a 50 o AMD Radeon RX 7900/7800/7700/9060/9070, según el repositorio del proyecto. Una RTX 3090 de 24 GB debería moverse entre 100 y 140 tokens por segundo.

¿Por qué la cuantización agresiva no deja a la arquitectura de mezcla de expertos inútil?

Porque solo reduce la precisión numérica de los pesos, no la cantidad de expertos ni la lógica del router. Un modelo cuantizado a 2-3 bits sigue siendo el mismo modelo, con menos detalle por parámetro.

¿Strata funciona en macOS o con GPUs de Apple Silicon?

El repositorio no menciona soporte para Apple Silicon ni macOS: la lista de hardware soportado se limita a GPU NVIDIA y AMD en Windows o Linux.

¿Puedo usar dos tarjetas gráficas para repartir la descarga de expertos a RAM entre ambas?

Sí. Strata admite compartir el modelo entre 2 o 3 tarjetas gráficas, lo que reduce cuánta RAM del sistema necesita cargar cada GPU individualmente.

¿Qué pasa si mi CPU no tiene AVX2?

Según el proyecto, modelos de mezcla de expertos como este siguen corriendo en CPUs sin AVX2, pero de forma notablemente más lenta; es soporte experimental, no la configuración recomendada.

Referencias

• Repositorio de Strata en GitHub: README con requisitos de hardware, instrucciones de instalación y tablas de benchmark.
• Mixture of experts, Wikipedia: contexto sobre la arquitectura de mezcla de expertos y el routing top-k.
• llama.cpp en GitHub: origen del formato de cuantización GGUF usado por niveles como Q2_0 e IQ3_S.

📱 ¿Te gusta este contenido? Únete a nuestro canal de Telegram @programacion donde publicamos a diario lo más relevante de tecnología, IA y desarrollo. Resúmenes rápidos, contenido fresco todos los días.

Imagen destacada: Foto de Rafael Pol en Unsplash