DeepSeek V4 Flash com 1M de contexto no seu RTX 5090: dá pra rodar local — mas tem um porém

Todo mês tem um modelo aberto que "roda no seu PC". Quase sempre é meia-verdade.

Essa semana o r/LocalLLaMA travou num feito específico: alguém colocou o DeepSeek V4 Flash rodando com 1 milhão de tokens de contexto num único RTX 5090. Placa de consumidor. Contexto de datacenter. O print circulou, o pessoal surtou, e a conclusão preguiçosa foi a de sempre: "agora dá pra largar a API".

Calma. O feito é real e é impressionante. Mas tem um asterisco que ninguém coloca no título — e é justamente o asterisco que decide se isso serve pra você ou não. Vamos separar o que é engenharia de verdade do que é entusiasmo de thread.

TL;DR

• O que é: DeepSeek V4 Flash, modelo aberto MoE (284B de parâmetros totais, 13B ativos) com janela de 1M de tokens, preview de abril/2026.
• A notícia: um patch de comunidade destravou rodar 1M de contexto num único RTX 5090 (32GB), e a DeepSeek soltou o DSpark, uma variante ~60-80% mais rápida na geração.
• Custo/Acesso: pesos abertos no Hugging Face; via API sai por volta de US$ 0,09 por milhão de tokens de entrada (OpenRouter/DeepInfra).
• O porém: não é llama.cpp de fábrica, exige GGUF quantizado e muita RAM de sistema. Feito de hacker, não plug-and-play.

O que é o DeepSeek V4 Flash

O V4 Flash é o irmão econômico da família V4 da DeepSeek. Enquanto o V4-Pro é um monstro de 1.6 trilhão de parâmetros, o Flash é um MoE (mistura de especialistas) com 284B de parâmetros totais, mas só 13B ativos por token. Traduzindo: ele tem o repertório de um modelo grande, mas o custo de inferência de um modelo pequeno, porque só uma fração dos "especialistas" acende a cada passo.

Na prática, ele virou o que o pessoal do Reddit chama de "trabalhador barato". Ele não é o cérebro estrategista — é o executor. Você deixa um modelo mais esperto montar o plano e joga a execução clara e sem ambiguidade pro V4 Flash, que resolve rápido e por quase nada. Não é à toa que ele lidera o uso no OpenCode, com quase metade do volume observado numa semana.

O gancho que faz ele brilhar é a janela de 1M de tokens. Contexto gigante num modelo barato é uma combinação rara — e é exatamente aí que mora o problema técnico.

O feito da semana: 1M de contexto num único 5090

Aqui a história fica boa. Quem tentou rodar o V4 Flash local no contexto cheio bateu numa parede absurda: ~256GB de VRAM só pra chegar em 1M de tokens. Nenhum desktop faz isso.

O motivo era um detalhe de arquitetura. O V4 usa um componente chamado DSA lightning indexer, e o llama.cpp não tinha suporte decente pra ele — o compute buffer explodia. Um dev (spencer-zaid) foi lá, escreveu o kernel CUDA que faltava e conectou no grafo do modelo. O resultado, no hardware dele (RTX 5090 32GB + Ryzen 9950X3D + 96GB DDR5):

Repara no salto: o compute buffer a 256K caiu de 67 GiB (que estourava) pra 3,2 GiB. O 1M, que era impossível, passou a caber em ~31 GiB de pico. E não é só rodar sem crashar — ele validou a qualidade com um teste de needle-in-haystack: plantou um fato aleatório em profundidades de 10%, 50% e 90% num documento de 100K tokens, e o modelo achou toda vez. Repetiu a 512K e a 1M na profundidade mais difícil (50%). Funcionou.

Isso é engenharia de verdade. Um kernel CUDA escrito num sábado de manhã destravou um caso de uso que os fornecedores vendem como exclusivo de datacenter. O writeup completo está no GitHub, com as instruções de build.

O porém que ninguém coloca no título

Agora o asterisco. Porque "roda 1M no 5090" é verdade, mas incompleta.

Não é o llama.cpp que você baixa. É um branch com patch da comunidade, ainda não mergeado no upstream. Você compila da fonte ou não roda. Sem binário pronto.

Não é o modelo cheio. É um GGUF com quantização mista específica (Q8/Q4/Q2, o do antirez). Você tá rodando uma versão comprimida — ótima, mas não é o peso original em toda a glória.

E o gargalo real não é a VRAM. É a RAM de sistema. Esse é o ponto que o print esconde. O cara tem 96GB de DDR5. Num MoE com offload de especialistas pra CPU, o que segura o rojão é a memória do sistema, não os 32GB da placa. Quem tem 3090/4090 ou menos RAM esbarra em OOM, KV quantizado quebrado e uma dor de cabeça de configuração que não cabe num tweet.

O consenso dos guias de infra é direto: um RTX 5090 de 32GB, sozinho, não trata o V4 Flash como inferência normal de placa única. E 1M de contexto "de produção" — servindo requisições de verdade, com concorrência — ainda quer H200 ou B200. O feito é um teto de possibilidade, não o seu setup de terça-feira.

DSpark: o boost de 60-80% é real?

No meio dessa onda, a DeepSeek soltou o DSpark — e a thread de novo pegou fogo. É uma variante do V4 Flash com speculative decoding revisado. A ideia: um modelo rascunho propõe vários tokens de uma vez, o modelo principal só valida, e você ganha velocidade sem perder qualidade.

Os números são bons. Em 2× DGX Spark (GB10) com paralelismo de tensor, o single-stream subiu de ~40-45 tok/s pra ~60-67 tok/s — um ganho de 60-80% na faixa que interessa. Os detalhes estão no fórum de desenvolvedores da NVIDIA.

Mas vale a dose de ceticismo que o próprio Reddit trouxe: speculative decoding não é invenção da DeepSeek. Como um comentário resumiu bem, o DSpark é "evolução em cima de EAGLE-3, MTP e afins", não uma revolução de arquitetura. E, mais importante: o boost só vira prático pra você quando cair no llama.cpp ou no vLLM. Até lá, é benchmark de hardware que você provavelmente não tem.

Roda no SEU PC? O reality-check por hardware

A pergunta que importa não é "dá pra rodar", é "vale pra mim". Depende brutalmente da máquina:

• RTX 5090 (32GB) + 96GB+ de RAM: sim, dá — com o branch patcheado, o GGUF quantizado e paciência de build. É o cenário do feito. Excelente pra experimentar contexto longo local.
• RTX 4090 / 3090 (24GB): possível em contextos menores, mas você vai depender pesado de offload pra CPU e RAM sobrando. Prepare-se pra brigar com configuração.
• Setup multi-GPU (2x3090 e afins): funciona com layer/tensor split + experts na CPU, e é onde muita gente da comunidade tá rodando de fato. Mais VRAM somada, mais fôlego.
• Mac (Apple Silicon): o port pro Metal ainda tá em andamento. Fica de olho, mas não conte com ele hoje.

E tem a conta que ninguém gosta de fazer: pra maioria dos casos, a API é mais barata que o seu tempo. A US$ 0,09 por milhão de tokens no OpenRouter/DeepInfra, você processa um volume absurdo antes de pagar o custo de energia, o desgaste da placa e as horas compilando kernel. Rodar local faz sentido por privacidade, por aprendizado ou por soberania sobre o stack — não por economia pura. Se o que te interessa é o custo, o jogo é outro: escrevi sobre o preço dinâmico peak/valley da V4, que muda a conta a seu favor dependendo do horário.

FAQ rápido

Preciso de uma RTX 5090 pra rodar o V4 Flash? Não pra rodar — pra rodar 1M de contexto local com folga, sim, ou um equivalente em VRAM+RAM. Em contextos menores (32K-128K) dá pra experimentar em placas mais modestas com offload, mas a experiência piora rápido conforme você aperta o hardware.

Esse patch de 1M já está no llama.cpp oficial? Ainda não. É um branch de comunidade (PR #24231 e o kernel CUDA do spencer-zaid). Pra usar hoje, você compila da fonte. É provável que algo suba pro upstream em breve, mas não conte com apt install.

DSpark é a mesma coisa que o V4 Flash normal? Não. É uma variante com speculative decoding revisado, focada em velocidade de geração. O modelo base é o mesmo; o que muda é como ele decodifica. E o ganho só chega pra você quando o runtime que você usa (llama.cpp, vLLM) suportar.

Vale mais rodar local ou usar a API? Pra economia pura, API — a US$ 0,09 é difícil de bater com hardware próprio. Local vale por privacidade, controle do stack e aprendizado. Decida pelo motivo certo, não pelo hype de "roda no meu PC".

O que fica

O DeepSeek V4 Flash rodando 1M de contexto num 5090 é um daqueles momentos que mostram o quanto a comunidade open source anda rápido — um kernel CUDA bem colocado transformou "impossível" em "cabe em 31 GiB". Isso é real e merece aplauso.

Mas maturidade técnica é saber ler o print inteiro, não só a manchete. O feito é um teto de possibilidade patcheado à mão, não um tutorial de fim de semana. Rodar modelo aberto local é sobre entender arquitetura, memória, quantização e trade-off de custo — não sobre baixar um GGUF e esperar mágica.

E é exatamente esse pulo — de "usei o modelo" pra "sei construir um sistema em cima dele, com contexto, avaliação e limite bem entendidos" — que a gente vai colocar na mesa no Do Prompt ao Harness, nos dias 11 e 12 de julho, construindo um agente de vendas de verdade, do zero, com as decisões de engenharia na frente de todo mundo. Se essa parte de "o que é real e o que é asterisco" te interessa, é lá que ela vira código rodando.