Download do DeepSeek V4 feito: qual hardware você precisa pra rodar local?

O arquivo terminou de baixar e aí vem a pergunta que realmente importa: a tua máquina aguenta isso?

A DeepSeek soltou o V4 em preview e com pesos abertos, em duas versões ao mesmo tempo: V4-Pro e V4-Flash

O Flash já saiu do preview, o checkpoint DeepSeek-V4-Flash-0731 é a versão oficial e substitui a de preview

O Pro continua em preview, com a DeepSeek dizendo que a versão oficial vem em breve, sem data anunciada

E só um desses dois é conversa de máquina local, se liga nisso antes de perder horas

O que você precisa ter antes de tentar rodar

Antes de qualquer comando, o checklist honesto:

• Memória total somando VRAM da GPU e RAM do sistema, com folga confortável acima do tamanho do arquivo quantizado
• Espaço em disco pro GGUF (spoiler: são centenas de gigas nas versões maiores)
• llama.cpp pra servir o modelo
• A CLI hf, que é quem baixa os pesos do Hugging Face

Formação Recomendada

Formação Vibe Coding

Do Prompt ao Produto: Crie Software Real com IA

• 474 aulas
• 20 projetos
• 39h 27min

Conhecer formação

Repara que a primeira linha do checklist não é "placa de vídeo do PC da Nasa"

É memória TOTAL, VRAM mais RAM, somadas

Esse é o número que decide se dá ou não dá

Por que só o Flash entra nessa conversa:

O V4-Flash é o modelo menor, com arquitetura MoE de 284B parâmetros totais e 13B ativados por token

O V4-Pro é o irmão grande: 1.6T parâmetros totais e 49B ativados por token

As duas versões têm janela de contexto de 1 milhão de tokens, o que é insano, mas guarda essa informação que ela volta a doer lá na frente

O Flash ainda tem um detalhe que muda tudo: ele foi treinado com quantização embutida, o famoso QAT

E o que isso significa na prática? Que os experts roteados, que são 96% do modelo, já vêm nativamente em MXFP4, e o resto dos tensores em FP8 ou BF16

Ou seja: o modelo já nasceu comprimido, não é você que vai comprimir ele depois

Se você ainda está escolhendo o programa que vai servir o modelo, o caminho geral de rodar o DeepSeek localmente ajuda a decidir isso antes de mexer em flag

Tome cuidado com a procedência do arquivo!

Esse aqui não é papo de paranoia, é caso real

Os pesos oficiais ficam no Hugging Face, na organização deepseek-ai, nos repositórios DeepSeek-V4-Flash-0731, DeepSeek-V4-Flash e DeepSeek-V4-Pro

Cerca de 45 minutos depois do anúncio oficial, golpistas puseram no ar uma organização falsa no GitHub chamada DeepSeek-V4, com logo e gráficos reais copiados do lançamento

O que ela distribuía não era modelo nenhum: era instalador entregando o infostealer Vidar

A org falsa juntou 91 stars e 27 forks em quatro dias, até a Microsoft avisar o GitHub e o repositório, a organização e a conta do operador serem removidos

Moral da história: confira de qual org você está baixando, sempre

E aqui vale separar duas coisas que confundem MUITA gente

Os pesos oficiais do modelo ficam na org deepseek-ai, como falei ali em cima

Já os arquivos GGUF, que são a versão empacotada pro llama.cpp, saem da org unsloth: é o repositório que o próprio guia da Unsloth manda usar no comando de download

São duas origens nomeadas em documentação, cada uma entregando uma coisa diferente

O que não pode é baixar de uma terceira org que apareceu do nada no resultado de busca com o nome parecidinho

Q8, Q4 ou Q3: qual quantização do V4-Flash escolher

Aqui mora a parte contraintuitiva do post, e é ela que vale o teu tempo

Na maioria dos modelos, descer de 8 pra 4 bits corta o tamanho quase pela metade

No V4-Flash, não

O Q8 (UD-Q8_K_XL) é sem perda, lossless, e ocupa 162 GB

O Q4 (UD-Q4_K_XL) fica apenas 7 GB menor que ele

E por quê? Porque o Q4 mantém os experts bit a bit, exatamente como vieram do QAT, e só quantiza os tensores não-expert pra Q8_0

Como os experts são 96% do modelo, sobra pouquíssima coisa pra encolher

Então se você ia baixar o Q4 achando que estava economizando metade da memória: não estava

O corte real de memória só aparece no 3 bits, que desce pra 103 GB e roda em máquina com 110 GB de memória

legal né? 🙂 é o tipo de detalhe que só aparece depois de você já ter torrado a banda larga baixando a versão errada

Passo a passo: do download ao primeiro prompt local

1. Meça a memória disponível e escolha a quantização pela tabela

Soma VRAM da GPU com a RAM do sistema e compara com o tamanho do arquivo, deixando margem por cima

O erro comum deste passo: olhar só pra VRAM da placa de vídeo e concluir que "não dá", ou o oposto, achar que empata no limite e vai rodar liso

2. Baixe os GGUFs do repositório certo

hf download unsloth/DeepSeek-V4-Flash-0731-GGUF

Repara na org: unsloth, e não deepseek-ai

É o repositório de GGUF indicado pelo guia da Unsloth, aquela separação que combinamos ali em cima: pesos oficiais na deepseek-ai, GGUF na unsloth

O erro comum deste passo: pegar o arquivo em uma org qualquer que apareceu no resultado de busca, fora dessas duas. Lembra do Vidar ali em cima?

3. Suba no llama.cpp ajustando os parâmetros de carga

Os três que importam aqui são --threads (número de threads de CPU), --ctx-size (tamanho do contexto) e --n-gpu-layers (quantas camadas vão pra GPU)

Os valores de exemplo do guia da Unsloth são:

--threads 32 --ctx-size 32768 --n-gpu-layers 2

Repara no --n-gpu-layers 2: pouquíssima camada na GPU, o grosso do modelo vive na RAM

O erro comum deste passo: abrir o --ctx-size no talo porque o modelo suporta 1 milhão de tokens de contexto. Suportar é uma coisa, ter memória pra materializar isso é outra bem diferente

4. Use os parâmetros de amostragem recomendados

--temp 1.0 --top-p 1.0 --min-p 0.0

O erro comum deste passo: chegar mexendo na temperatura por hábito de outro modelo e depois culpar o V4 pela saída estranha

O que esperar de velocidade na sua máquina

Vamos ser honestos aqui: depende muito de onde o modelo vai morar

Quem tem memória unificada grande é o perfil mais confortável, porque VRAM e RAM são a mesma piscina e o arquivo inteiro cabe sem malabarismo

Quem tem GPU pequena e muita RAM também joga, e é exatamente pra esse cenário que o --n-gpu-layers 2 do exemplo aponta: poucas camadas na placa, o resto na RAM do sistema

Quem não tem memória sobrando não vai fazer milagre com flag. Nesse caso o caminho sensato é consumir o modelo por API e seguir a vida

E quanto isso rende em tokens por segundo? Aqui eu não vou chutar

A referência que existe medida é de API, não local: a página viva do Artificial Analysis mede o DeepSeek V4 Flash 0731 em modo raciocínio máximo a 113,5 tokens por segundo, e a versão sem raciocínio a 103,7 tokens por segundo

Trata esses números como teto de infraestrutura dedicada, não como previsão da tua rodada local

Modelo com offload pra RAM anda em outro ritmo, e qualquer número que eu jogasse aqui seria achismo

Um panorama do lançamento, pra quem chegou direto no download

Se você baixou o arquivo antes de entender direito o que a DeepSeek soltou, esse vídeo do canal dá o panorama do V4 e do contexto do lançamento:

Conclusão

O caminho é curto quando você inverte a ordem: primeiro mede a memória, depois escolhe a quantização, e só então baixa

Somou VRAM e RAM e passou com folga dos 162 GB? O Q8 lossless é teu

Ficou na faixa dos 110 GB? Vai de 3 bits, que é onde o corte de memória realmente acontece

Não sobrou memória nenhuma? Fica na API sem culpa, é decisão de engenharia, não derrota 😀

E se a tentação for esperar o V4-Pro pra rodar local: ele segue em preview, sem data anunciada pra versão oficial, então o Flash é o que está na mesa hoje

Pra acompanhar o que muda no modelo, o lugar certo é a org deepseek-ai no Hugging Face, e pros GGUFs, a unsloth

até o próximo post!