DEV Community

Cover image for Como Executar o DeepSeek V4 Localmente?
Lucas
Lucas

Posted on • Originally published at apidog.com

Como Executar o DeepSeek V4 Localmente?

O DeepSeek V4 foi lançado em 23 de abril de 2026 com pesos licenciados pelo MIT no Hugging Face. Essa escolha de licença facilita para equipes que querem IA de ponta rodando em hardware próprio. O V4-Flash (284B total, 13B ativo) roda em dois H100s em FP8; o V4-Pro (1.6T total, 49B ativo) exige um cluster, mas compete com GPT-5.5 e Claude Opus 4.6 em tarefas de código e raciocínio.

Experimente o Apidog hoje

Este guia é um passo a passo para implantação local: requisitos de hardware, quantização, configurações de vLLM e SGLang, uso de ferramentas, e como validar seu servidor local usando o Apidog antes de redirecionar tráfego de produção.

Para uma visão geral do produto, veja o que é DeepSeek V4. Para integração via API hospedada, confira como usar a API DeepSeek V4. Para custos, veja preços da API DeepSeek V4.

TL;DR

  • V4-Flash roda em 2 × H100 80GB em FP8, ou 1 × H100 em INT4 (~500GB de pesos em FP8).
  • V4-Pro precisa de 16+ H100s em FP8 para produção; não recomendado para laptops.
  • vLLM é o caminho mais rápido para um servidor compatível com OpenAI (vllm>=0.9.0 já suporta o V4).
  • SGLang é a alternativa para equipes que focam em ferramentas e saída estruturada.
  • Quantização para AWQ INT4 ou GPTQ INT4 permite rodar o V4-Flash em uma única GPU de 80GB com ~5% de perda de qualidade.
  • Use o Apidog para testar seu endpoint local em http://localhost:8000/v1 usando a mesma coleção da API hospedada.

Quem deve hospedar por conta própria

Hospede o V4 localmente se sua equipe:

  1. Precisa de conformidade: setores como saúde, finanças, jurídico ou defesa, onde dados não podem sair da rede. Licença MIT → sem acordos extras ou transferência internacional de dados.
  2. Tem grandes cargas de trabalho estáveis: Acima de 200 bilhões de tokens/mês, hardware próprio compensa.
  3. Precisa de ajuste fino e pesquisa: Checkpoints Base servem para pré-treinamento contínuo e adaptação de domínio. MIT permite redistribuição comercial.

Quem não deve hospedar: prototipadores, equipes sem experiência em operações de GPU, ou workloads abaixo de US$ 200/mês em API hospedada.

Requisitos de hardware

O DeepSeek V4 usa precisão mista FP4 + FP8. Isso reduz o uso de memória real comparado ao número bruto de parâmetros.

Variante Total de parâmetros Parâmetros ativos VRAM FP8 VRAM INT4 Placas mínimas
V4-Flash 284B 13B ~500GB ~140GB 2 × H100 80GB (FP8) ou 1 × H100 (INT4)
V4-Pro 1.6T 49B ~2.4TB ~700GB 16 × H100 80GB (FP8) ou 8 × H100 (INT4)

Notas:

  • Memória MoE é o total, não apenas ativa.
  • H200 e MI300X são mais eficientes (mais VRAM/placa).
  • GPUs de consumidor não servem (nem RTX 5090).
  • Apple Silicon (M3/M4 Max) roda com quantização pesada, mas apenas para desenvolvimento/testes.

Etapa 1: Baixar os pesos

Repositórios oficiais:

Instale o CLI e baixe os pesos:

pip install -U "huggingface_hub[cli]"
huggingface-cli login

huggingface-cli download deepseek-ai/DeepSeek-V4-Flash \
  --local-dir ./models/deepseek-v4-flash \
  --local-dir-use-symlinks False
Enter fullscreen mode Exit fullscreen mode

Reserve ~500GB para o V4-Flash, vários TBs para o V4-Pro. Usuários na China: modelscope.cn é mais rápido.

Etapa 2: Escolha um mecanismo de serviço

  • vLLM: melhor taxa de transferência, interface compatível com OpenAI, comunidade maior. Recomendado.
  • SGLang: melhores recursos para ferramentas e saída estruturada; útil se depende de chamadas de funções.

Ambos já suportam DeepSeek V4.

Etapa 3: Sirva V4-Flash com vLLM 

pip install "vllm>=0.9.0"

vllm serve deepseek-ai/DeepSeek-V4-Flash \
  --tensor-parallel-size 2 \
  --max-model-len 1048576 \
  --dtype auto \
  --enable-prefix-caching \
  --port 8000
Enter fullscreen mode Exit fullscreen mode

Sinalizadores úteis:

  • --tensor-parallel-size 2: divide entre 2 H100s.
  • --max-model-len 1048576: ativa contexto de 1M tokens; reduza para liberar VRAM.
  • --enable-prefix-caching: ativa cache de prefixo, acelerando prompts repetidos.
  • --dtype auto: usa FP8 automaticamente.

Clientes OpenAI funcionam em http://localhost:8000/v1.

Etapa 4: Sirva V4-Pro com vLLM

V4-Pro exige cluster; ajuste os parâmetros de paralelismo:

vllm serve deepseek-ai/DeepSeek-V4-Pro \
  --tensor-parallel-size 8 \
  --pipeline-parallel-size 2 \
  --max-model-len 524288 \
  --enable-prefix-caching \
  --port 8000
Enter fullscreen mode Exit fullscreen mode

Ajuste --max-model-len conforme a VRAM disponível.

Etapa 5: Sirva com SGLang (alternativa para uso de ferramentas) 

pip install "sglang[all]>=0.4.0"

python -m sglang.launch_server \
  --model-path deepseek-ai/DeepSeek-V4-Flash \
  --tp 2 \
  --context-length 1048576 \
  --port 30000
Enter fullscreen mode Exit fullscreen mode

SGLang expõe /v1 compatível com OpenAI em http://localhost:30000/v1. O DSL lang facilita chamadas de função e saída JSON.

Etapa 6: Quantize para uma GPU única

Quantização INT4 permite rodar o V4-Flash em uma H100 de 80GB com perda mínima de qualidade.

AWQ (recomendado) 

pip install autoawq

python -c "
from awq import AutoAWQForCausalLM
from transformers import AutoTokenizer

model_path = './models/deepseek-v4-flash'
out_path = './models/deepseek-v4-flash-awq'
model = AutoAWQForCausalLM.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.quantize(tokenizer, quant_config={'w_bit': 4, 'q_group_size': 128})
model.save_quantized(out_path)
tokenizer.save_pretrained(out_path)
"
Enter fullscreen mode Exit fullscreen mode

GPTQ 

pip install auto-gptq
# Siga a receita de quantização GPTQ; processo semelhante ao AWQ.
Enter fullscreen mode Exit fullscreen mode

Sirva o checkpoint quantizado com vLLM usando --quantization awq ou --quantization gptq.

Etapa 7: Teste com Apidog

Não envie produção direto para o novo servidor. Valide antes.

Captura de tela do Apidog mostrando como testar a API DeepSeek V4 localmente.

  1. Baixe o Apidog.
  2. Crie uma coleção apontando para http://localhost:8000/v1/chat/completions.
  3. Use o mesmo prompt de teste que na API hospedada e compare as respostas.
  4. Faça teste com contexto de 500K tokens para validar o cache KV.
  5. Execute um fluxo de chamada de ferramentas antes de conectar automações.

A coleção usada na API hospedada DeepSeek V4 funciona localmente mudando só o URL base.

Observabilidade e monitoramento

Monitore estas métricas desde o início:

  1. Tokens por segundo (prompt e geração) — vLLM expõe em /metrics formato Prometheus.
  2. Utilização da GPU — nvidia-smi ou DCGM; taxa <70% indica batch size subótimo.
  3. Taxa de acerto do cache KV — vLLM mostra; queda sinaliza prompts não otimizados.
  4. Latência p50/p95/p99 — rastreamento padrão; p99 alto com p50 estável indica requisições problemáticas.

Envie todas para Grafana ou sua stack de observabilidade.

Ajuste fino dos checkpoints Base do V4

Checkpoints Base servem para pré-treinamento contínuo e SFT (fine-tuning supervisionado):

pip install "torch>=2.6" transformers accelerate peft trl

# SFT padrão com LoRA no V4-Flash-Base
python -m trl sft \
  --model_name_or_path deepseek-ai/DeepSeek-V4-Flash-Base \
  --dataset_name your-org/your-sft-set \
  --output_dir ./models/v4-flash-custom \
  --per_device_train_batch_size 1 \
  --gradient_accumulation_steps 16 \
  --learning_rate 2e-5 \
  --bf16 true \
  --use_peft true \
  --lora_r 64 \
  --lora_alpha 128
Enter fullscreen mode Exit fullscreen mode

Full fine-tuning no V4-Pro é tarefa de pesquisa. LoRA adapters no V4-Flash-Base são o caminho prático para a maioria.

Armadilhas comuns

  1. OOM (Out Of Memory) na inicialização: contexto alto demais ou paralelismo baixo. Diminua --max-model-len ou aumente --tensor-parallel-size.
  2. Primeira requisição lenta: vLLM compila kernels sob demanda; aqueça com request dummy.
  3. Erros de parsing em uso de ferramentas: DeepSeek difere levemente do OpenAI; use SDKs com suporte explícito ao V4.
  4. Erros FP8 em GPUs antigas: A100 não suporta FP8. Use BF16 e espere dobrar a necessidade de VRAM.

Quando a hospedagem própria compensa

Cálculo de breakeven, usando os preços da API DeepSeek V4:

  • V4-Flash com 200B tokens in / 20B out/mês: ~$33,6K pela API. Uma máquina com 8 × H100 custa ~$20K/mês. Economia de ~40%.
  • V4-Pro com 500B in / 50B out/mês: ~$1,04M na API. Cluster de 16 × H100 sai por ~$35K/mês. Economia >95%.

O ponto crítico para V4-Flash é em ~100B tokens/mês. Abaixo disso, a API hospedada é mais barata.

FAQ

Posso executar V4-Flash em uma A100?

Com quantização pesada e contexto reduzido, sim, mas é lento (5-15 tok/s). H100 é o hardware ideal.

O V4 suporta fine-tuning com LoRA?

Sim. Use checkpoints Base e pipelines TRL ou Axolotl. MoE não afeta o LoRA.

O servidor local é compatível com OpenAI?

Sim. vLLM e SGLang expõem /v1/chat/completions e /v1/completions. O guia da API hospedada funciona com localhost.

Como habilito modo de pensamento ("thinking mode")?

Inclua thinking_mode: "thinking" ou "thinking_max" na requisição. vLLM e SGLang encaminham ao modelo.

Consigo fazer streaming do servidor V4 local?

Sim. Use stream: true igual ao OpenAI ou API DeepSeek.

Forma mais barata de testar antes de comprar hardware?

Alugue uma H100 no RunPod ou Lambda, rode V4-Flash em INT4 e meça throughput real. Teste de $10–$30 resolve rápido.

Top comments (0)