O que é Strata? 6× mais rápido que llama.cpp para IA local

Autoria: Data Science in your pocket · Assistir no YouTube

Vídeo de autoria do canal indicado, não da IANIA; todos os direitos pertencem ao criador. Transcrição, resumo e tradução gerados automaticamente; o conteúdo no idioma original é preservado na versão em idioma original.

Idioma original: inglês

Vídeo original: What is Strata ? 6x Faster than Llama.cpp for local AI · Canal: Data Science in your pocket · 09:52 · Assistir no YouTube

Tópicos: Avaliação e benchmarks de IA, Inferência e otimização de modelos, Infraestrutura e hardware de IA, Modelos locais e open source

Resumo

Strata é um engine open source, com licença MIT, projetado para executar um modelo esparso de 125 bilhões de parâmetros em hardware de consumo, distribuindo o trabalho entre GPU, RAM, CPU e SSD. Segundo as medições do autor, ele alcança até 94 tokens por segundo em uma RTX 5070 e usa speculative decoding e processamento sobreposto para acelerar geração e leitura de prompts. O vídeo também apresenta as variantes do modelo, a instalação, a API local e os recursos de integração. Os resultados são medições próprias do autor, e o Strata tem limitações importantes: atende um usuário por vez e dá suporte a apenas uma família de modelos.

Pontos-chave

O Strata foi desenvolvido para executar um modelo esparso de 125 bilhões de parâmetros, embora cerca de 6 bilhões participem do cálculo de cada token.
A abordagem distribui os componentes do modelo entre GPU, RAM, CPU e SSD, em vez de tentar armazenar tudo na VRAM.
De acordo com o autor, o desempenho chega a 94 tokens por segundo em conversas curtas e a 60 tokens por segundo com 262 mil tokens de contexto.
O speculative decoding permite que o modelo proponha até três tokens e os verifique em uma única passagem, sem alterar o resultado final.
O processamento em blocos e a sobreposição de operações aceleram a leitura do prompt; o vídeo cita um pico de 2.650 tokens por segundo.
O cache KV pode ser transferido para a RAM quando o contexto ultrapassa 64 mil tokens, liberando espaço na GPU.
A instalação usa um script e baixa cerca de 70 GB de arquivos do modelo; o primeiro início pode ocupar muita RAM e congelar o PC por alguns minutos.
O Strata oferece uma API local compatível com interfaces da OpenAI e da Anthropic, além de integração com MCP e suporte opcional a imagens.
É um engine de usuário único, sem batching, e compatível com apenas uma família de modelos.
Os benchmarks são autorrelatados, e o vídeo alerta que outros programas usando muita RAM podem reduzir drasticamente o desempenho.

Capítulos

Início	Capítulo	Resumo
00:00	A proposta do Strata	O vídeo apresenta a promessa de executar um modelo de 125 bilhões de parâmetros em um PC comum e explica por que essa possibilidade desafia as expectativas.
02:04	Experts e distribuição de memória	A explicação aborda a arquitetura esparsa, a divisão do trabalho entre GPU, RAM e SSD e as variantes disponíveis conforme a memória do PC.
04:08	Aceleração e contexto longo	O vídeo descreve speculative decoding, leitura sobreposta de prompts e estratégias para lidar com o cache KV e contextos extensos.
06:13	Desempenho, instalação e integrações	São apresentados os benchmarks do autor, o processo de instalação, a API local, o MCP e os recursos opcionais de visão.
08:17	Limitações e filosofia do projeto	O vídeo ressalta que o Strata atende um usuário e uma família de modelos, alerta sobre os limites dos benchmarks e explica sua abordagem de dividir o processamento entre componentes do PC.

Citações

Cada gigabyte extra de RAM comporta aproximadamente mais 700 experts. — 02:36

A verificação é exata. Portanto, a saída é idêntica, bit a bit, ao que o modelo teria escrito de qualquer forma. — 04:40

Por que a GPU deveria ser o único chip autorizado a pensar? — 09:20

Conceitos e entidades

Strata (ferramenta): Engine local em C++ com licença MIT, especializado em executar uma família de modelos esparsos usando GPU, RAM, CPU e SSD.
llama.cpp (ferramenta): Engine usado como comparação no vídeo, que, segundo as medições citadas, executou o modelo a cerca de 15 tokens por segundo no mesmo PC de referência.
Mixture of Experts (conceito): Arquitetura esparsa em que uma rede roteadora seleciona apenas parte dos experts para processar cada token.
speculative decoding (conceito): Método em que o modelo rascunha tokens futuros e o modelo completo os verifica em uma única passagem.
cache KV (conceito): Memória que mantém informações sobre o contexto já lido e pode competir com os experts por espaço na memória da GPU.
MCP (conceito): Protocolo citado como base para um servidor que permite a um assistente instalar, iniciar, parar e avaliar o Strata.
Claude Opus (modelo): Modelo citado no vídeo em referência à coautoria registrada no histórico de commits do projeto.

Tradução completa (pt-BR)

00:00 E se eu dissesse que um modelo de IA com 125 bilhões de parâmetros, maior que os da classe GPT-3, está rodando agora mesmo em um PC gamer comum? Não em um rack de servidores, nem na nuvem. Em uma única placa de vídeo para consumidores, com 12 GB de memória de vídeo, gerando texto a 94 tokens por segundo. Isso é mais rápido do que a maioria das pessoas consegue ler. Para uma configuração assim, o consenso diz que você precisaria de duas a quatro GPUs de data center só para

00:30 carregar o checkpoint oficial. Um novo mecanismo open source chamado Strata diz o contrário. Veja como ele consegue isso e quanto custa. Para entender por que isso é surpreendente, veja os cálculos que todo mundo dava como certos. 125 bilhões de parâmetros, mesmo com uma precisão agressiva, representam cerca de 250 GB de pesos. A receita oficial de implantação em servidores exige de duas a quatro GPUs de classe data center, além de uma tabela auxiliar de 51 GB armazenada na memória do host. Sua

01:01 placa gamer tem 12 GB de RAM. Uma diferença de 20 vezes. E é exatamente por isso que modelos locais desse tamanho eram considerados uma fantasia. Até agora, todas as tentativas se resumiam a uma coisa: reduzir o modelo até ele caber na placa. Strata descartou completamente essa premissa. Strata é um mecanismo em C++ gratuito, licenciado pelo MIT, criado por um desenvolvedor independente na Eslovênia, e nasceu no Reddit. Primeiro, o autor conseguiu rodar esse modelo usando llama.cpp a cerca de 15 tokens por segundo na sua

01:33 RTX 5070 e publicou o resultado em r/LocalLLaMA. Depois, fez algo diferente. Em vez de tratar o modelo como algo genérico, estudou essa arquitetura específica, adaptou o mecanismo especialmente para ela e saltou de 15 para 65 e, depois, para 95 tokens por segundo. De quatro a seis vezes mais rápido no mesmo hardware. O repo foi publicado em 24 de setembro. Dez dias depois, a internet percebeu. A primeira coisa que Strata aproveita é que

02:04 esse modelo é esparso. Qwen 3.5 Flash é uma mistura de experts. Ele tem 24.576 experts, 512 em cada uma de 48 camadas. Mas, para cada token, uma pequena rede roteadora escolhe apenas 10 deles. Então, embora o modelo tenha 125 bilhões de parâmetros, apenas cerca de 6 bilhões são efetivamente computados para cada token. É aí que está a grande oportunidade. 95% do modelo fica inativo a qualquer momento. A questão passa a ser: onde colocar os experts inativos e

02:36 com que rapidez dá para ativar os certos? A resposta de Strata é uma analogia com uma cozinha: a bancada, a despensa e o entregador. A GPU é a bancada. Ela guarda tudo que cada token acessa: camadas de atenção, roteadores, o cache, além de tantos experts ativos quantos couberem na RAM restante. Esta é a lei de escala decisiva: cada gigabyte extra de RAM comporta cerca de 700 experts a mais. E cada expert na GPU é um que a CPU não precisa computar.

03:06 A RAM do sistema é a despensa. Ela contém todos os 24 mil experts. E, quando a GPU não encontra um expert, a CPU o computa ali mesmo, na RAM, em paralelo com a GPU. Já o SSD é o entregador: uma tabela de consulta de 288 GB que só entrega algumas linhas por token. Quanto do cérebro do modelo você baixa depende da sua RAM. Strata vem em quatro tamanhos. Q20 é o mais rápido e precisa de 37,6 GB de memória combinada.

03:38 IQ2XS, o recomendado, precisa de 39,2 GB e é um pouco mais inteligente. IQ3XX precisa de 47 GB. IQ3S precisa de 54,8 GB e iguala o modelo completo nos testes publicados, mas é o mais lento. Depois, há a opção imprevisível: uma versão para programação que reduz os experts pela metade, mantém 91,3% da pontuação do modelo no SWE-bench e tem o núcleo que cabe em apenas 32 GB de RAM — a única variante que consegue isso. Regra prática: 32 GB significam

04:08 a versão para programação; 48 GB dão conta das duas versões menores; 64 GB rodam qualquer uma. Segundo truque: o próprio modelo escreve um rascunho. A arquitetura inclui um pequeno módulo de previsão, que Strata usa para antecipar até três tokens. Aí vem a parte engenhosa: o modelo completo verifica as três previsões em uma única passagem pelas suas 48 camadas. Em média, de 2,4 a 3,2 tokens são aceitos por passagem, o que torna a geração de 1,6 a 1,8 vez

04:40 mais rápida. E isso não é uma aproximação. A verificação é exata. Portanto, a saída é idêntica, bit por bit, ao que o modelo teria escrito de qualquer maneira. É como um estagiário que vai digitando adiante, enquanto um editor aprova linhas inteiras de uma vez. O terceiro truque tem a ver com leitura, não com escrita. Antes de responder, o modelo precisa processar seu prompt. E essa costuma ser a parte lenta. Strata lê prompts em blocos de até 8.192 tokens. E, enquanto a atenção de uma camada

05:11 está em execução, os experts da camada seguinte já estão sendo transferidos pelo barramento PCI Express. Tudo acontece em paralelo. O resultado: mais de mil tokens por segundo no processamento do prompt, chegando a um pico de 2.650. Em termos humanos, um documento de 30 mil tokens — um livro pequeno — leva cerca de um minuto para ser processado antes de aparecer o primeiro token da resposta. As mensagens seguintes começam em segundos, porque o que o modelo já leu continua

05:41 em cache. Conversas longas têm seu próprio problema de memória. O cache KV — as anotações contínuas do modelo sobre tudo que leu — cresce com o contexto e compete com os experts pela VRAM. A resposta de Strata é o armazenamento em fluxo. Acima de 64 mil tokens de contexto, a maior parte do cache vai para o armazenamento, e só a parte que a atenção está lendo ativamente permanece na placa, liberando espaço para milhares de experts a mais residentes na GPU. Há também um modo opcional de 4 bits que usa uma rotação matemática antes da

06:13 compactação, reduzindo o uso de memória do cache a um custo mensurável de precisão. É uma troca que você pode ativar. A configuração padrão segura de 8 bits continua ativada. É possível chegar a 262 mil tokens de contexto em uma placa de 12 GB. Agora, os resultados, com uma ressalva que vamos repetir mais adiante: estas são as medições do próprio autor. No PC de referência, com uma RTX 5070, um Ryzen de 6 núcleos e 64 GB de RAM, o tamanho mais rápido atinge 94 tokens por

06:43 segundo em uma conversa curta, 76 com 128 mil tokens de contexto e ainda 60 no limite de 262 mil. O tamanho que maximiza a qualidade chega a 53 em uma AMD RX 9070 XT. E a estimativa para uma RTX 3090 de 24 GB — uma placa de seis anos — é de 100 a 140 tokens por segundo, porque, com mais armazenamento, a CPU quase não trabalha. Enquanto isso, a versão padrão do llama.cpp

07:15 na mesma RTX 5070 chega a 15. Fazer tudo funcionar é realmente questão de um clique. No Windows, clique duas vezes em start here.bat; no Linux, execute setup.sh. O programa faz quatro perguntas: tamanho do modelo, contexto, comprimento e imagens. Depois, instala seu próprio Python, suas próprias bibliotecas e baixa cerca de 70 GB do modelo — felizmente, com suporte à retomada do download. Em seguida, o navegador abre um aplicativo local com chat, um monitor em tempo real que mostra tokens por

07:46 segundo, uso da GPU, temperaturas e muito mais, além de uma aba “Sobre”. Um aviso sincero: na primeira inicialização, o mecanismo reserva de 34 a 55 GB de RAM, e seu PC pode congelar por um a três minutos. Isso é normal. Não feche a janela. Vá fazer um café. Strata não é apenas uma janela de chat. É um servidor de API local que se passa pelos grandes serviços de nuvem. Ele usa a interface da OpenAI em /v1/chat/completions. Então, a maioria das ferramentas

08:17 funciona diretamente com localhost na porta 8080. Também usa a interface da Anthropic, em /v1/messages, o que significa que Claude Code pode rodar na sua própria GPU se você alterar uma variável de ambiente. Há um servidor MCP que permite a um assistente de IA instalar, iniciar, parar e executar benchmarks do próprio Strata. Você pode ajustar o nível de raciocínio do modelo, de desligado a alto. E, com o codificador de visão opcional, que ocupa menos de um gigabyte, ele também lê imagens. Nada sai do seu PC.

08:48 Hora de esfriar os ânimos. Primeiro: uma solicitação por vez. Este é um mecanismo para um único usuário. Não oferece processamento em lote nem atendimento multi-inquilino. Se você precisa disso, quer o VLM. Segundo: Strata executa exatamente uma família de modelos. llama.cpp e Ollama executam centenas de arquiteturas. Strata é rápido justamente porque foi adaptado especificamente para esta. Terceiro: esses benchmarks foram divulgados pelo próprio autor e feitos em dois PCs, então trate-os como números fornecidos pelo fabricante. Quarto,

09:20 a versão para programação é mais fraca em chinês, japonês e coreano; é um problema conhecido. Quinto: se outros aplicativos consumirem sua RAM, os experts vão para o disco e tudo fica extremamente lento. Rápido, mas não é mágica. Então, por que isso viralizou? 8.600 stars em 10 dias, 38 releases no mesmo período e destaque entre as tendências de todo o GitHub três dias após o lançamento. Há também um detalhe deliciosamente metalinguístico: o registro de commits dá crédito abertamente a Claude Opus como coautor. Um mecanismo de IA local substancialmente escrito com IA,

09:52 mas a verdadeira história é a filosofia. Todo mundo perguntava: “Como reduzir o modelo para caber na GPU?” Strata perguntou: “Por que só a GPU pode pensar? Distribua o trabalho entre GPU, RAM, CPU e SSD. Faça tudo acontecer em paralelo e, de repente, o data center deixa de ser necessário.” Os links estão abaixo. Vá ler a documentação. Ela é metade da diversão.

Transcrição original

[00:00] What if I told you a 1-00-20-5- billion-parameter AI model bigger than GPT3 class is running right now on an ordinary gaming PC? Not a server rack, not the cloud. One consumer graphics card with 12 GB of video memory, writing text at 94 tokens per second. That’s faster than most people can read. For a setup like this, the conventional wisdom says you’d need two to four data center GPUs just to

[00:30] load the official checkpoint. A new open- source engine called straighta says otherwise. Here’s how it pulls that off and what it costs you. To see why this is surprising, look at the math everyone assumed. 125 billion parameters, even at aggressive precision, is on the order of 250 GB of weights. The official server deployment recipe wants two to four data center class GPUs with a 51 GB side table parked in host memory on top. Your

[01:01] gaming card 12 GB of RAM. That is a 20 times gap. And that’s exactly why local models this size were considered a fantasy. Every attempt so far boiled down to one move. Shrink the model until it fits the card. Straighta threw out that assumption entirely. Strata is a free MIT licensed C++ engine built by a solo developer in Slovenia and it was born on Reddit. The author first got this model running through llama.cpp at about 15 tokens per second on his

[01:33] RTX570 and posted it on r/local law ma. Then he did something different. Instead of treating the model as generic, he studied this one architecture, hardwired the engine around it and jumped from 15 to 65, then up to 95 tokens per second. Four to six times faster on identical hardware. The repo went up on September 24th. 10 days later, the internet noticed. The first thing Strata exploits is that

[02:04] this model is sparse. Quen 3.8 flash. Next is a mixture of experts. It has 24,576 experts, 512 in each of 48 layers. But for every single token, a small router network picks just 10 of them. So while the model owns 125 billion parameters, only about 6 billion actually compute on any given token. That’s the entire opening. 95% of the model is asleep at any moment. The question becomes, where do you put the sleeping experts and how

[02:36] fast can you wake the right ones? Strata’s answer is a kitchen analogy. The counter, the pantry, and the seller. The GPU is the counter. It holds everything every token touches. Attention layers, routters, the cache, plus as many hot experts as the remaining RAM fits. Here’s the killer scaling law. Every extra gigabyte of RAM holds roughly 700 more experts. And every expert on the GPU is one the CPU never has to compute.

[03:06] System RAM is the pantry. It holds all 24,000 experts. And when the GPU misses, the CPU computes that expert right there in RAM in parallel with the GPU. And the SSD, that’s the seller. A 20-8-8 GB lookup table that only hands over a few rows per token. How much brain you download depends on your RAM. Strat ships four sizes. Q20 is the fastest and needs 37.6 GB of combined memory.

[03:38] IQ2XS, the recommended one, needs 39.2 and is a bit smarter. IQ3XX needs 47. IQ3S needs 54.8 and matches the full model on the published tests, but it’s the slowest. Then there’s the wild card, a coder build that prunes the experts in half, keeps 91.3% of the model’s S.WE bench score, and its core fits in just 32 GB of RAM, the only variant that does. Rule of thumb, 32 gigs means

[04:08] coder, 48 means the small two, 64 runs anything. Trick number two, the model writes its own rough draft. Built into the architecture is a small prediction module, and Strata uses it to draft up to three tokens ahead. Then here’s the clever part. The full model checks all three guesses in a single pass through its 48 layers. On average, 2.4 to 3.2 two tokens get accepted per pass, which makes generation 1.6 to 1.8 times

[04:40] faster. And this isn’t approximation. The check is exact. So the output is bit for bit what the model would have written anyway. It’s like an intern typing ahead and an editor approving whole lines at once. Trick three is about reading, not writing. Before the model can answer, it has to ingest your prompt. And that’s usually the slow part. Strata reads prompts and chunks of up to 8,192 tokens. And while one layer’s attention

[05:11] runs, the next layer’s experts are already streaming over the PCI Express bus. Everything overlaps. The result, over a,000 tokens per second of prompt processing, peaking at 2,650. In human terms, a 30,000 token document, a small book, takes about 1 minute before the first answer token appears. Follow-up messages start in seconds because what it already read stays

[05:41] cached. Long conversations have their own memory problem. The KV cache, the model’s running notes on everything it’s read, grows with context, and it competes with experts for VOM. straight his answer is streaming. Past 64,000 tokens of context, most of the cash moves to ROM and only the part attention is actively reading stays on the card, freeing room for thousands more GPU resident experts. There’s also an optional 4-bit mode that uses a mathematical rotation before

[06:13] compression, having cache memory at a measurable cost to precision. It’s a trade you can switch on. The safe 8-bit default stays on the point. 262,000 tokens of context is reachable on a 12 gig card. Now, the receipts with a caveat we’ll repeat later. These are the author’s own measurements. On the reference PC, an RTX 570, a 6 core Ryzen, 64 gigs of RAM. The fastest size hits 94 tokens per

[06:43] second in short chat, 76 at 128,000 tokens of context, and still 60 at the full 262K. The quality maxing size manages 53 on an AMD RX 970 XT 60. And the estimate for a 24 GB RTX 30090, a 6-year-old card is 100 to 140 tokens per second because more ROM means the CPU barely works at all. Meanwhile, stock lama.cpp

[07:15] on the same 570 15. Getting it running is genuinely one click. Doubleclick start here.bat on Windows or run setup.sh on Linux. It asks four questions. Model size, context, length, images. Then it installs its own Python, its own libraries, and downloads about 70 GB of model resumable thankfully. Then your browser opens a local app with chat, a live monitor showing tokens per

[07:46] second, GPU load, temperatures, the works, and an about tab. One honest warning, on first start, the engine pins 34 to 55 GB into RAM, and your PC may freeze for 1 to 3 minutes. That’s normal. Don’t close the window. Go make coffee. Strata isn’t just a chat window. It’s a local API server pretending to be the big clouds. It speaks OpenAI’s interface at /v1 chat completions. So most tools

[08:17] just work against localhost port 8080. It also speaks anthropics interface/v1 messages which means clawed code can run against your own GPU by changing one environment variable star. There’s an MCP server so an AI assistant can install, start, stop, and benchmark strata itself. You can dial the model’s thinking level from off to high. And with the optional vision encoder under a gigabyte, it reads images, too. Nothing leaves your PC.

[08:48] Time for the cold water. First, one request at a time. This is a single user engine. No batching, no multi-tenant serving. If you want that, you want VLM. Second, Strata runs exactly one model family. Llama.cpp CPP and OAMA run hundreds of architectures. Strata is fast precisely because it’s hardwired to this one. Third, those benchmarks are self-reported by the author on two PCs, so treat them as vendor numbers. Fourth,

[09:20] the coder build is weaker in Chinese, Japanese, and Korean, a known bug. Fifth, if other apps eat your RAM, experts spill to disk and everything crawls fast, but not magic. So, why did this blow up? 8.6,000 stars in 10 days, 38 releases in the same span, trending across all of GitHub 3 days after launch and a delightfully meta detail. The commit log openly credits Claude Opus’ co-author, a local AI engine substantially written with II,

[09:52] but the real story is the philosophy. Everyone else asked, “How do we shrink the model to fit the GPU?” Strata asked, “Why is the GPU the only chip allowed to think? Spread the work across GPU, RAM, CPU, and SSD. Overlap everything, and suddenly the data center is optional. Links below. Go read the docs. They’re half the fun.