Qwen 3.8 de 125B en una RTX 4090: qué cambia para quien usa Bun

Un repositorio llamado Strata apareció en GitHub con una promesa atrevida: correr Qwen 3.8 Flash Next, un modelo de 125 mil millones de parámetros, en una RTX 4090 a 100 tokens por segundo. Es una tarjeta de videojuegos, con 24 GB de VRAM. Si esto se confirma, un modelo que hasta ayer exigía un servidor de datacenter pasa a caber debajo de tu escritorio. Aquí quiero separar lo que es física de lo que es marketing. Y mostrar cómo conectar Qwen 3.8 Flash Next a un backend Bun sin drama.

Qué promete Strata, exactamente

Strata es un runtime de inferencia. No entrena nada ni crea un modelo nuevo. Su trabajo es tomar un modelo grande y hacerlo correr en hardware que, en teoría, no debería aguantarlo.

El titular tiene tres números: 125B de parámetros, una RTX 4090 y 100 tokens por segundo. Cada uno por separado es razonable. Los tres juntos llaman la atención.

Para comparar: 100 tokens por segundo es más rápido de lo que puedes leer. Es la velocidad a la que el texto parece "volcado" en la pantalla, no tecleado. Muchas APIs de pago entregan menos que eso en hora pico.

¿Cómo cabe un modelo de 125B en 24 GB de VRAM?

Hagamos la cuenta de servilleta.

• En FP16, cada parámetro ocupa 2 bytes. 125 mil millones × 2 = 250 GB.
• Cuantizado a 4 bits, baja a algo cerca de 62 GB.
• La 4090 tiene 24 GB.

No cabe. Ni de lejos. Así que hay truco, y el truco probable está en el nombre. "Flash" suele indicar un modelo disperso, del tipo Mixture of Experts (MoE). En ese formato, el modelo tiene 125B de parámetros en total, pero solo una fracción trabaja en cada token. Un enrutador elige media docena de "expertos" y el resto se queda quieto.

Eso lo cambia todo. Si solo una parte pequeña del modelo se activa por token, no necesitas el modelo entero en la GPU. Necesitas los expertos correctos en el momento correcto. El resto puede vivir en la RAM del sistema.

Y ahí aparece el cuello de botella de verdad. La memoria de la 4090 entrega cerca de 1 TB/s. El bus PCIe 4.0 entre la RAM y la tarjeta entrega unos 25 GB/s en la práctica. Es una diferencia de 40 veces. Cada experto que tiene que venir de la RAM en mitad de la generación es un peaje caro.

Entonces los 100 tokens por segundo dependen menos de la GPU y más de una pregunta: ¿cuántas veces el experto que pidió el modelo ya estaba en la VRAM? Si Strata acierta esa caché casi siempre, el número es plausible. Si tu prompt se sale del patrón, la velocidad se desploma.

Un modelo grande en una tarjeta pequeña no es magia, es caché bien hecha.

Qué medir antes de creerte los 100 tokens/s

Un número de README es un número de README hasta que lo mides en tu máquina. Antes de reorganizar tu stack, revisa estos puntos:

• Prefill vs. decode. Generar token a token (decode) es una cosa. Procesar un prompt de 20 mil tokens antes de responder (prefill) es otra. Muchos benchmarks solo muestran el decode.
• Tamaño del contexto. Con 500 tokens de conversación todo vuela. Con el archivo entero de tu proyecto pegado en el prompt, la caché de atención también compite por la VRAM.
• Batch 1. Casi todos los números caseros son de un solo usuario. Dos peticiones a la vez pueden dividir la velocidad, o algo peor.
• RAM del sistema. Si los expertos que sobran viven en la RAM, necesitas 64 GB o más. La 4090 sola no lo resuelve.
• Calidad de la cuantización. 4 bits en un modelo MoE puede quedar genial o puede fallar en SQL básico. Prueba con tus tareas, no con el benchmark de otros.

Los tokens por segundo de un README son como el consumo de un coche en un anuncio: es verdad, pero cuesta abajo y con el viento a favor.

Cómo conectar un modelo local a un backend Bun

Ahora la parte práctica. La mayoría de los runtimes de inferencia local exponen un endpoint compatible con la API de OpenAI (/v1/chat/completions). Revisa en el README de Strata si lo hace de fábrica. Si no, cualquier servidor ligero delante de él lo resuelve. El puerto y el nombre del modelo de abajo son ejemplos, ajústalos a tu entorno.

Con Bun no necesitas ningún SDK. El fetch nativo ya maneja streaming:

// chat-local.ts
const res = await fetch("http://localhost:8080/v1/chat/completions", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    model: "qwen3.8-flash-next",
    stream: true,
    messages: [{ role: "user", content: "Explica: ERROR: deadlock detected" }],
  }),
});

const decoder = new TextDecoder();
let buffer = "";
let chunks = 0;
const start = performance.now();

for await (const part of res.body!) {
  buffer += decoder.decode(part, { stream: true });
  const lines = buffer.split("\n");
  buffer = lines.pop() ?? "";
  for (const line of lines) {
    if (!line.startsWith("data: ") || line.includes("[DONE]")) continue;
    const delta = JSON.parse(line.slice(6)).choices[0]?.delta?.content;
    if (delta) {
      chunks++;
      process.stdout.write(delta);
    }
  }
}

const secs = (performance.now() - start) / 1000;
console.log(`\n~${(chunks / secs).toFixed(1)} tokens/s`);

Lo corres con bun chat-local.ts y listo. De paso, obtienes tu propia medición de tokens por segundo. La cuenta es aproximada, porque la mayoría de los servidores manda un token por chunk. Pero ya sirve para comparar con la promesa del README.

Hay dos detalles que valen oro aquí. Primero, el tiempo incluye el prefill, así que prueba con un prompt corto y con uno largo y compara. Segundo, como el endpoint sigue el formato de OpenAI, cambiar entre modelo local y API de pago se vuelve una variable de entorno:

const BASE_URL = Bun.env.LLM_BASE_URL ?? "http://localhost:8080/v1";

En dev apuntas a tu 4090. En producción, al proveedor. El código no cambia.

¿Vale la pena cambiar la API de pago por una 4090?

Depende de lo que hagas con IA en el día a día. Una RTX 4090 cuesta más que muchos portátiles. Y encima viene con la factura de la luz y el cuarto convertido en sauna.

Dónde tiene sentido de verdad:

• Datos sensibles. Código de clientes, contratos, datos personales. Correr en local resuelve toda una discusión sobre protección de datos antes de que empiece.
• Jobs por lotes. Clasificar 50 mil tickets, generar descripciones de producto, resumir logs. Sin límite de tasa y sin factura sorpresa a fin de mes.
• Herramientas internas de dev. Revisar un diff, explicar un error de Postgres, generar fixtures de prueba. Uso de una sola persona, que es justo el escenario donde el benchmark de batch 1 vale.

Dónde no:

• Producto con muchos usuarios simultáneos. Una tarjeta doméstica no es un clúster de inferencia. Diez personas a la vez y los 100 tokens/s se vuelven un recuerdo.
• Cuando necesitas el mejor modelo del mercado. Un 125B cuantizado es bueno. No es lo más alto, y fingir que lo es solo te va a costar retrabajo.

Mi opinión sobre Strata

El número que importa en esta noticia no es el 100. Es el 125. Correr un modelo de esta escala en hardware de consumo, aunque sea a 40 tokens por segundo, ya cambia quién puede experimentar con IA sin pedirle presupuesto a nadie. Lo demás es optimización, y la optimización mejora cada mes.

Ahora, mi postura firme: no montes arquitectura sobre un benchmark de README. Mide en tu máquina, con tu prompt, y deja la URL del modelo en una variable de entorno desde el primer día. Con Bun eso cuesta diez líneas. Y te deja libre para cambiar de modelo cuando aparezca el próximo repositorio milagroso, que debería ser por ahí de la semana que viene.

Si quieres ver cómo conecto este tipo de cosas en proyectos reales, échale un vistazo a mis proyectos.

Un modelo de 125 mil millones de parámetros corriendo en una tarjeta gráfica de videojuegos. Parece broma, pero es lo que promete Strata.

La cuenta no cierra: incluso cuantizado, Qwen 3.8 necesita unos 62 GB, y la RTX 4090 tiene 24. El truco es MoE: solo algunos expertos trabajan por token, y el resto se queda en la RAM.

O sea, los 100 tokens/s dependen menos de la GPU y más de cuántas veces acierta la caché. Un modelo grande en una tarjeta pequeña no es magia, es caché bien hecha.

Mi regla: no montes arquitectura sobre un benchmark de README. Mide en tu máquina, con tu prompt.

Y deja la URL del modelo en una variable de entorno desde el primer día. Con Bun y fetch nativo son unas diez líneas, y cambiar entre modelo local y API de pago se vuelve configuración.

Escribí el paso a paso con el código completo en el blog. Si corres IA local en tu backend, cuéntame cómo lo estás midiendo.

#IA #Bun #LLM #Qwen #DesarrolloDeSoftware