Qwen 3.8 de 125B na RTX 4090: o que muda para quem usa Bun

Um repositório chamado Strata apareceu no GitHub com uma promessa ousada: rodar o Qwen 3.8 Flash Next, um modelo de 125 bilhões de parâmetros, numa RTX 4090 a 100 tokens por segundo. É uma placa de videogame, com 24 GB de VRAM. Se isso se confirmar, um modelo que até ontem exigia servidor de datacenter passa a caber embaixo da sua mesa. Aqui eu quero separar o que é física do que é marketing e mostrar como ligar o Qwen 3.8 Flash Next num backend Bun sem drama.

O que o Strata promete, exatamente

O Strata é um runtime de inferência. Ele não treina nada nem cria modelo novo. O trabalho dele é pegar um modelo grande e fazer ele rodar em hardware que, na teoria, não deveria aguentar.

A manchete tem três números: 125B de parâmetros, uma RTX 4090 e 100 tokens por segundo. Cada um sozinho é razoável. Os três juntos chamam atenção.

Para comparar: 100 tokens por segundo é mais rápido do que você consegue ler. É a velocidade em que o texto parece "despejado" na tela, não digitado. Muita API paga entrega menos que isso em horário de pico.

Como um modelo de 125B cabe em 24 GB de VRAM?

Vamos fazer a conta de padaria.

• Em FP16, cada parâmetro ocupa 2 bytes. 125 bilhões × 2 = 250 GB.
• Quantizado em 4 bits, cai para algo perto de 62 GB.
• A 4090 tem 24 GB.

Não cabe. Nem de longe. Então tem truque, e o truque provável está no nome: "Flash" costuma indicar um modelo esparso, do tipo Mixture of Experts (MoE). Nesse formato, o modelo tem 125B de parâmetros no total, mas só uma fração deles trabalha em cada token. Um roteador escolhe meia dúzia de "especialistas" e o resto fica parado.

Isso muda tudo. Se só uma parte pequena do modelo é ativada por token, você não precisa do modelo inteiro na GPU. Precisa dos especialistas certos na hora certa. O resto pode morar na RAM do sistema.

E aí aparece o gargalo de verdade. A memória da 4090 entrega perto de 1 TB/s. O barramento PCIe 4.0 entre a RAM e a placa entrega uns 25 GB/s na prática. É uma diferença de 40 vezes. Cada especialista que precisa vir da RAM no meio da geração é um pedágio caro.

Então os 100 tokens por segundo dependem menos da GPU e mais de uma pergunta: quantas vezes o especialista que o modelo pediu já estava na VRAM? Se o Strata acerta esse cache quase sempre, o número é plausível. Se o seu prompt cai fora do padrão, a velocidade despenca.

Modelo grande em placa pequena não é mágica, é cache bem feito.

O que medir antes de acreditar em 100 tokens/s

Número de README é número de README até você medir na sua máquina. Antes de reorganizar sua stack, confira estes pontos:

• Prefill vs. decode. Gerar token por token (decode) é uma coisa. Processar um prompt de 20 mil tokens antes de responder (prefill) é outra. Muito benchmark mostra só o decode.
• Tamanho do contexto. Com 500 tokens de conversa tudo voa. Com o arquivo inteiro do seu projeto colado no prompt, o cache de atenção também disputa a VRAM.
• Batch 1. Quase todo número caseiro é de um usuário só. Dois pedidos ao mesmo tempo podem dividir a velocidade, ou coisa pior.
• RAM do sistema. Se os especialistas que sobram moram na RAM, você precisa de 64 GB ou mais. A 4090 sozinha não resolve.
• Qualidade da quantização. 4 bits num modelo MoE pode ficar ótimo ou pode errar SQL básico. Teste com as suas tarefas, não com o benchmark dos outros.

Token por segundo em README é igual consumo de carro em propaganda: é verdade, só que na descida e com o vento a favor.

Como plugar um modelo local num backend Bun

Agora a parte prática. A maioria dos runtimes de inferência local expõe um endpoint compatível com a API da OpenAI (/v1/chat/completions). Confira no README do Strata se ele faz isso de fábrica. Se não fizer, qualquer servidor fino na frente dele resolve. A porta e o nome do modelo abaixo são exemplos, ajuste para o seu ambiente.

Com Bun você não precisa de SDK nenhum. O fetch nativo já lida com 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: "Explique: 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`);

Roda com bun chat-local.ts e pronto. De quebra, você ganha a sua própria medição de tokens por segundo. A conta é aproximada, porque a maioria dos servidores manda um token por chunk, mas já serve para comparar com a promessa do README.

Tem dois detalhes que valem ouro aqui. Primeiro, o tempo inclui o prefill, então teste com um prompt curto e com um longo e compare. Segundo, como o endpoint segue o formato da OpenAI, trocar entre modelo local e API paga vira uma variável de ambiente:

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

Em dev você aponta para a sua 4090. Em produção, para o provedor. O código não muda.

Vale trocar a API paga por uma 4090?

Depende do que você faz com IA no dia a dia. Uma RTX 4090 custa mais que muito notebook, e ainda vem com a conta de luz e o quarto virando sauna.

Onde faz sentido de verdade:

• Dados sensíveis. Código de cliente, contrato, dado pessoal. Rodar local resolve uma conversa inteira de LGPD antes dela começar.
• Jobs em lote. Classificar 50 mil tickets, gerar descrição de produto, resumir logs. Sem limite de taxa e sem fatura surpresa no fim do mês.
• Ferramentas internas de dev. Revisar diff, explicar erro do Postgres, gerar fixture de teste. Uso de uma pessoa, que é exatamente o cenário em que o benchmark de batch 1 vale.

Onde não faz:

• Produto com muitos usuários simultâneos. Uma placa doméstica não é cluster de inferência. Dez pessoas ao mesmo tempo e os 100 tokens/s viram lembrança.
• Quando você precisa do melhor modelo do mercado. Um 125B quantizado é bom. Não é o topo, e fingir que é só vai te custar retrabalho.

Minha opinião sobre o Strata

O número que importa nessa notícia não é o 100. É o 125. Rodar um modelo dessa escala em hardware de consumidor, mesmo que a 40 tokens por segundo, já muda quem pode experimentar com IA sem pedir orçamento para ninguém. O resto é otimização, e otimização melhora todo mês.

Agora, a minha posição forte: não monte arquitetura em cima de benchmark de README. Meça na sua máquina, com o seu prompt, e deixe a URL do modelo numa variável de ambiente desde o primeiro dia. Com Bun isso custa dez linhas e te deixa livre para trocar de modelo quando aparecer o próximo repositório milagroso, que deve ser lá pela semana que vem.

Se você quiser ver como eu ligo esse tipo de coisa em projetos reais, dá uma olhada nos meus projetos.

Um modelo de 125 bilhões de parâmetros rodando numa placa de videogame. Parece piada, mas é o que o Strata promete.

A conta não fecha: mesmo quantizado, o Qwen 3.8 precisa de uns 62 GB, e a RTX 4090 tem 24. O truque é MoE: só alguns especialistas trabalham por token, e o resto fica na RAM.

Ou seja, os 100 tokens/s dependem menos da GPU e mais de quantas vezes o cache acerta. Modelo grande em placa pequena não é mágica, é cache bem feito.

Minha regra: não monte arquitetura em cima de benchmark de README. Meça na sua máquina, com o seu prompt.

E deixe a URL do modelo numa variável de ambiente desde o primeiro dia. Com Bun e fetch nativo são umas dez linhas, e trocar entre modelo local e API paga vira configuração.

Escrevi o passo a passo com o código completo no blog. Se você roda IA local no seu backend, me conta como está medindo.

#IA #Bun #LLM #Qwen #DesenvolvimentoDeSoftware