Como executar o DeepSeek V4 localmente

TR

A forma prática de executar o DeepSeek V4 localmente é usar os pesos oficiais de código aberto com uma pilha de serving de alto desempenho como o vLLM e expor o modelo por meio de um endpoint local compatível com OpenAI. Os materiais públicos atuais da DeepSeek descrevem dois modelos na família V4: DeepSeek-V4-Pro com 1,6T de parâmetros totais / 49B ativos, e DeepSeek-V4-Flash com 284B de parâmetros totais / 13B ativos, ambos com contexto de 1M tokens e três modos de raciocínio. Os exemplos atuais de implantação local do vLLM visam 8× B200/B300 para o Pro e 4× B200/B300 para o Flash. Se você não tiver esse tipo de hardware, uma alternativa hospedada como a CometAPI é o caminho mais prático.

A DeepSeek AI causou grande impacto em 24 de abril de 2026 com o lançamento em prévia do DeepSeek-V4, apresentando dois poderosos modelos Mixture-of-Experts (MoE): DeepSeek-V4-Pro (1,6T de parâmetros totais, 49B ativos) e DeepSeek-V4-Flash (284B totais, 13B ativos). Ambos suportam nativamente uma janela de contexto de 1 milhão de tokens—um divisor de águas para análise de documentos longos, fluxos agentivos, programação sobre grandes bases de código e RAG (retrieval-augmented generation) em escala.

Treinado em mais de 32 trilhões de tokens com inovações arquiteturais como Compressed Sparse Attention (CSA) híbrida + Heavily Compressed Attention (HCA), hyper-connections com restrições em variedade (mHC) e manipulação de memória eficiente, o V4 alcança até 73% de redução em FLOPs de inferência e 90% menos pegada de cache KV para contextos de 1M em comparação com o V3.2. O desempenho rivaliza com os principais modelos de código fechado, permanecendo com pesos abertos (licença MIT) e extremamente econômico via API.

Executar esses modelos localmente oferece privacidade incomparável, custo recorrente zero de API (além do hardware), capacidade offline e personalização total. No entanto, sua escala apresenta desafios: os pesos completos do V4-Pro ultrapassam 800GB de download, e a inferência exige hardware significativo ou quantização agressiva.

O DeepSeek V4 realmente pode ser executado localmente?

Sim, mas “localmente” aqui significa algo muito diferente de rodar um modelo de 7B em um laptop. Os próprios materiais da DeepSeek e o post de suporte do vLLM apontam para grandes sistemas multi-GPU: o V4-Pro é um modelo com 1,6T de parâmetros e 49B de parâmetros ativos, enquanto o V4-Flash tem 284B totais / 13B ativos. Os exemplos oficiais de implantação do vLLM foram escritos para 8× B200/B300 no Pro e 4× B200/B300 no Flash. Esse é o sinal prático mais claro de que o DeepSeek V4 é uma implantação local de classe corporativa, não um experimento casual de desktop.

Há uma razão para essa escala. A DeepSeek afirma que o V4 suporta uma janela de contexto de 1M tokens, e o relatório técnico afirma que o V4-Pro usa apenas 27% dos FLOPs de inferência por token e 10% do cache KV em comparação com o DeepSeek-V3.2 em 1M de contexto. O vLLM explica ainda que, com bf16 KV cache, o DeepSeek V4 usa 9,62 GiB de cache KV por sequência em 1M de contexto, o que é cerca de 8,7× menor que os estimados 83,9 GiB para uma pilha comparável ao estilo DeepSeek-V3.2. Em outras palavras, o V4 é dramaticamente mais eficiente do que as gerações anteriores, mas um milhão de tokens ainda é um enorme problema de sistemas.

Tabela de Comparação de Arquiteturas: DeepSeek V4 vs V3 e Competidores

O design MoE do V4 ativa apenas uma fração dos parâmetros por token, mantendo o compute mais próximo de um modelo denso de 13B-49B ao mesmo tempo em que se beneficia do conhecimento de uma rede muito maior.

Qual modelo DeepSeek V4 você deve usar?

Para a maioria das implantações locais, o DeepSeek-V4-Flash é o melhor ponto de partida. O V4-Flash oferece raciocínio que se aproxima do Pro em tarefas agentivas mais simples, mantendo-se mais rápido e econômico.

Use o DeepSeek-V4-Pro quando você priorizar capacidade absoluta em vez de eficiência. O Pro é mais forte para raciocínio difícil, programação e tarefas agentivas. As tabelas de benchmark mostram o porquê: na comparação oficial, o V4-Pro-Base atinge 90,1 em MMLU, 76,8 em HumanEval e 51,5 em LongBench-V2, enquanto o V4-Flash-Base marca 88,7, 69,5 e 44,7, respectivamente. Ambos são fortes; o Pro vai mais longe quando você precisa do melhor resultado possível.

Uma leitura simples da tabela é suficiente para o planejamento de produto. O Flash não é um modelo simplificado; é um assistente sério de longo contexto com menor custo. O Pro é o modelo a testar primeiro quando o problema é difícil, com estado ou próximo a um fluxo de trabalho de conhecimento em produção.

Pilha local recomendada

1) vLLM para serving em estilo de produção

A opção oficial mais forte hoje é o vLLM. A equipe do vLLM diz que agora suporta a família DeepSeek V4 e fornece comandos concretos de lançamento de nó único para ambos os modelos. O post enquadra o V4 como uma família de modelos de longo contexto projetada para tarefas de até um milhão de tokens e descreve o trabalho de implementação necessário para cache KV híbrido, fusão de kernels e serving desagregado.

Para o V4-Pro, o exemplo do vLLM visa 8× B200 ou 8× B300. Para o V4-Flash, o exemplo visa 4× B200 ou 4× B300. Os comandos também usam --kv-cache-dtype fp8, --block-size 256, --enable-expert-parallel e flags específicas da DeepSeek, como --tokenizer-mode deepseek_v4, --tool-call-parser deepseek_v4 e --reasoning-parser deepseek_v4. Essa combinação é um forte indício de como a DeepSeek espera que hospedagens sérias sejam feitas.

# DeepSeek-V4-Flash on a supported multi-GPU hostdocker run --gpus all \  --ipc=host -p 8000:8000 \  -v ~/.cache/huggingface:/root/.cache/huggingface \  vllm/vllm-openai:deepseekv4-cu130 deepseek-ai/DeepSeek-V4-Flash \  --trust-remote-code \  --kv-cache-dtype fp8 \  --block-size 256 \  --enable-expert-parallel \  --data-parallel-size 4 \  --compilation-config '{"cudagraph_mode":"FULL_AND_PIECEWISE", "custom_ops":["all"]}' \  --attention_config.use_fp4_indexer_cache=True \  --tokenizer-mode deepseek_v4 \  --tool-call-parser deepseek_v4 \  --enable-auto-tool-choice \  --reasoning-parser deepseek_v4

Para alternar para o V4-Pro, mantenha o mesmo padrão e altere o modelo para deepseek-ai/DeepSeek-V4-Pro, com o tamanho de paralelismo de dados ajustado conforme o exemplo do Pro no post do vLLM. Esse é o jeito mais simples de começar a testar localmente sem reinventar a pilha de serving.

2) Auxiliares de inferência do repositório da DeepSeek

O DeepSeek V4 não inclui um template de chat em formato Jinja. Em vez disso, fornece uma pasta dedicada encoding com scripts Python e casos de teste para converter mensagens no estilo OpenAI em strings de entrada do modelo e analisar a saída. A mesma página diz para consultar a pasta inference para detalhes de implantação local, incluindo conversão de pesos e demos interativas de chat. Isso é útil se você quiser construir um front-end personalizado ou controlar rigidamente a formatação do prompt.

3) CometAPI como plano de backup prático

Se você não possui hardware da classe B200/B300, uma rota hospedada é a escolha sensata. A CometAPI diz que oferece uma única chave de API para tudo, acesso a 500+ modelos de IA e preços 20–40% mais baratos do que as tarifas oficiais dos fornecedores. Ela também publica páginas dedicadas ao DeepSeek V4, incluindo DeepSeek-V4-Pro e DeepSeek-V4-Flash, com exemplos de integração compatíveis com OpenAI.

Passo a passo: Como executar o DeepSeek V4 localmente

1. Pré-requisitos

• SO: Linux preferencial (Ubuntu 22.04/24.04) para melhor suporte a CUDA/ROCm. Windows via WSL2 ou nativo. macOS com Metal (limitado para os maiores modelos).
• Drivers: NVIDIA CUDA 12.4+ (ou mais recente). AMD ROCm para placas Radeon.
• Python 3.11+, Git e espaço em disco suficiente.
• Conta no Hugging Face para modelos restritos (se aplicável): huggingface-cli login.

2. Caminho mais fácil: Ollama ou LM Studio (amigável para iniciantes)

O Ollama fornece a experiência CLI e WebUI mais simples. No fim de abril de 2026, o suporte completo ao V4 pode exigir Modelfiles personalizados ou tags da comunidade, mas versões quantizadas do V4-Flash estão surgindo rapidamente.

Instalar o Ollama (Linux/macOS):

curl -fsSL https://ollama.com/install.sh | sh
ollama --version

Executar um modelo compatível (comece com menores ou verifique por tags V4):

ollama pull deepseek-v4-flash:q4_0   # Example quantized tag; check ollama.com/library or community
ollama run deepseek-v4-flash:q4_0

Para customizar: criar um Modelfile (texto):

FROM ./DeepSeek-V4-Flash-GGUF-Q4.gguf
TEMPLATE """{{ .Prompt }}"""
PARAMETER num_ctx 32768  # Start conservative; increase as hardware allows up to 1M with sufficient RAM/VRAM

Depois execute: ollama create my-v4-flash -f Modelfile.

LM Studio: alternativa GUI. Baixe em lmstudio.ai, procure/explore no HF por quantizações GGUF do DeepSeek-V4 (estilo TheBloke ou oficial), carregue e converse. Excelente para experimentação com sliders de contexto e offloading para GPU.

Open WebUI: camada sobre o Ollama para uma interface estilo ChatGPT (Bash):

docker run -d -p 8080:8080 --add-host=host.docker.internal:host-gateway -v open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:main

Acesse em http://localhost:8080.

3. Avançado: Hugging Face + vLLM ou SGLang (alto desempenho)

Para máxima velocidade e suporte a 1M de contexto, use o vLLM (excelente suporte a MoE e PagedAttention):

Passo 1: Preparar o ambiente

Comece instalando a pilha vLLM atual e garantindo que sua CUDA, drivers e topologia de GPU correspondam ao modelo que você deseja executar. recommending temperature = 1.0 and top_p = 1.0 for local deployment, and for Think Max it recommends a context window of at least 384K tokens. That is a useful starting point whether you are building a chat app, a coding assistant, or an agent workflow.

Instalação:

Bash
pip install -U "vllm>=0.9.0"  # Check latest for V4 compatibility

Baixar o modelo (use CLI para arquivos grandes):

Bash
pip install -U "huggingface_hub[cli]"
huggingface-cli download deepseek-ai/DeepSeek-V4-Flash --local-dir ./DeepSeek-V4-Flash

Servir com vLLM (exemplo para Flash em 2 GPUs):

Passo 2: Iniciar o servidor do modelo

Quando o contêiner estiver ativo, exponha o modelo como um endpoint local compatível com OpenAI. Isso facilita o reuso do seu código de aplicativo existente e a troca de backends sem mudar a arquitetura do app.

Servir com vLLM (exemplo para Flash em 2 GPUs):

Python
from vllm import LLM, SamplingParams

llm = LLM(
    model="deepseek-ai/DeepSeek-V4-Flash",
    tensor_parallel_size=2,      # Adjust to your GPU count
    max_model_len=1048576,       # 1M context (hardware permitting)
    dtype="auto",                # or "fp8" / "bfloat16"
    quantization="gptq" if using quantized weights else None,
    gpu_memory_utilization=0.9
)

sampling_params = SamplingParams(temperature=0.7, top_p=0.95, max_tokens=4096)

outputs = llm.generate(["Explain the architecture of DeepSeek V4 in detail."], sampling_params)
for output in outputs:
    print(output.outputs[0].text)

Para modo servidor (API compatível com OpenAI):

Bash
vllm serve deepseek-ai/DeepSeek-V4-Flash \
  --tensor-parallel-size 2 \
  --max-model-len 1048576 \
  --port 8000

Depois, consulte via cliente OpenAI definindo base_url="http://localhost:8000/v1".

SGLang como alternativa, possivelmente melhor para longos contextos:

Bash
pip install "sglang[all]>=0.4.0"
python -m sglang.launch_server --model-path deepseek-ai/DeepSeek-V4-Flash --port 30000

Passo 3: Consultar o endpoint local a partir do Python

from openai import OpenAI
# Adjust the base URL if your vLLM server is bound differently.

client = OpenAI(
base_url="http://localhost:8000/v1",
api_key="EMPTY",
)

response = client.chat.completions.create(
model="deepseek-ai/DeepSeek-V4-Flash",
messages=[
{"role": "system", "content": "You are a precise, technical assistant."},
{"role": "user", "content": "Explain the difference between V4-Pro and V4-Flash."},
],
temperature=1.0,
top_p=1.0,
)

print(response.choices[0].message.content)

Expectativas de desempenho e dicas de otimização

• Tokens/s: Em uma RTX 4090 com Q4 Flash: 15–40+ t/s em contexto de 8K–32K (varia com a implementação). Cai em 128K+ devido à atenção/cache KV, mas as eficiências do V4 ajudam. Multi-GPU escala bem com paralelismo de tensor/pipeline.
• Otimizações:
• Use FlashAttention-3 ou PagedAttention do vLLM.
• Decodificação especulativa para aceleração de 1,5–2×.
• Técnicas de poda ou compressão de contexto.
• Monitore com nvidia-smi; utilize gpu_memory_utilization.
• Para CPU: llama.cpp com --n-gpu-layers -1 (offload total se possível) ou CPU pura com muita RAM.

Avalie seu setup com ferramentas como llama-bench ou scripts simples de medição. A vazão real depende do tamanho do prompt, do tamanho da geração e do hardware.

Desafios e limitações da implantação local do V4

• Intensidade de recursos: Mesmo o Flash requer hardware decente para velocidades confortáveis em contextos longos.
• Trade-offs da quantização: Bits menores podem reduzir a qualidade de raciocínio, especialmente em tarefas complexas—valide com benchmarks como SWE-Bench, MMLU ou avaliações específicas do seu domínio.
• Maturidade do software: Como uma prévia (abril de 2026), o suporte totalmente otimizado em todos os backends está sendo lançado gradualmente. Verifique Issues do GitHub para vLLM, llama.cpp e HF.
• Download/armazenamento: Modelos em escala de terabytes exigem internet rápida e armazenamento.
• Energia e calor: Setups de ponta consomem eletricidade significativa.

Para muitos usuários, abordagens híbridas funcionam melhor: rode tarefas menores localmente, faça offload para a nuvem quando precisar de raciocínio com 1M de contexto.

Quando local não basta: Integração sem atrito com CometAPI

Para muitas equipes, a decisão mais inteligente é não forçar uma implantação local. Enquanto a implantação local é excelente para privacidade e controle, escalar para produção, lidar com picos de carga ou acessar desempenho pleno sem quantização e sem grande investimento em hardware muitas vezes favorece uma API confiável.

CometAPI fornece um gateway unificado, compatível com OpenAI, para modelos DeepSeek—including the latest Deeppseek V4 series—junto com dezenas de outros LLMs de ponta (Claude, GPT, Llama, Qwen, Grok etc.).

Onde a API supera a implantação local

Os modelos atuais do DeepSeek V4 estão disponíveis por endpoints no estilo OpenAI e Anthropic, com URLs base estáveis enquanto o nome do modelo muda. A documentação também diz que os nomes de modelo deepseek-chat e deepseek-reasoner eventualmente serão descontinuados e mapeados para o comportamento do V4-Flash durante a transição.

Isso é importante porque a implantação local tem custo operacional. Se a carga de trabalho não for sensível à residência de dados ou se sua equipe quiser mais rapidez para gerar valor, a rota da API geralmente é a escolha racional. O V4-Flash a $0,14 por 1M de tokens de entrada em cache miss, $0,0028 por 1M de tokens de entrada em cache hit e $0,28 por 1M de tokens de saída. A mesma página diz que o V4-Pro está atualmente com desconto de 75% até 31 de maio de 2026, em $0,435 por 1M de tokens de entrada em cache miss e $0,87 por 1M de tokens de saída.

A melhor alternativa ao DeepSeek: onde a CometAPI se encaixa

A CometAPI é útil quando o objetivo não é apenas chamar o DeepSeek V4 uma vez, mas construir uma pilha que pode trocar de modelo rapidamente. A CometAPI afirma fornecer uma chave de API para 500+ modelos, uma API compatível com OpenAI, análises de uso e preços mais baixos do que as tarifas oficiais dos fornecedores. Também se posiciona como uma forma de evitar lock-in de fornecedor e gerenciar gastos entre vários provedores.

Isso torna a CometAPI uma recomendação forte para equipes que estão avaliando o V4-Pro em relação ao V4-Flash ou comparando a DeepSeek com outros modelos de fronteira na mesma aplicação. Em vez de criar uma nova integração toda vez que o modelo muda, o aplicativo pode manter um cliente estável no estilo OpenAI e trocar apenas o valor de model e a URL base. O guia do V4 da CometAPI mostra exatamente esse padrão.

Quick Start com CometAPI para DeepSeek V4:

• Use o SDK OpenAI:
• Registre-se/entre em CometAPI.com.
• Gere uma chave de API no console.

Aqui está a versão hospedada do mesmo padrão de integração:

from openai import OpenAIclient = OpenAI(    base_url="https://api.cometapi.com",    api_key="YOUR_COMETAPI_KEY",)response = client.chat.completions.create(    model="deepseek-v4-pro",    messages=[        {"role": "system", "content": "You are a senior coding assistant."},        {"role": "user", "content": "Review this architecture for bottlenecks."}    ],    stream=False,    extra_body={        "thinking": {"type": "enabled"},        "reasoning_effort": "high"    })print(response.choices[0].message.content)

O valor dessa rota é operacional, não retórico. Ela remove trabalho de infraestrutura, mantém o código do cliente portátil e oferece à equipe um único lugar para testar custo, latência e qualidade entre vários modelos. A CometAPI também diz que rastreia gastos, latência e volume de chamadas, o que é útil quando o protótipo se torna uma carga de trabalho de produção.

Quando escolher local, API ou CometAPI

O caminho local é justificado quando o controle importa mais do que a conveniência. O caminho via API é justificado quando velocidade e simplicidade importam mais do que propriedade. A CometAPI é a camada intermediária quando a equipe quer portabilidade e controle de custos sem refazer a integração toda vez que o modelo muda.

FAQ

O DeepSeek V4 pode rodar em um laptop?

Não no sentido prático implícito por tutoriais de inferência local. Os materiais oficiais apontam para implantação multi-GPU e multinó, e os tamanhos dos modelos vão muito além dos orçamentos de memória de consumidores comuns. Um laptop é adequado para acesso via API, mas não para auto-hospedagem significativa do V4-Pro ou mesmo um V4-Flash confortável.

Qual é melhor: V4-Pro ou V4-Flash?

O V4-Pro é mais forte para raciocínio, programação e pesquisa. O V4-Flash é a melhor opção padrão para velocidade, throughput e menor custo. O lançamento oficial e a tabela de benchmarks apontam para a mesma conclusão.

A CometAPI é obrigatória na implantação local?

Não. É uma camada opcional de produção. A própria API da DeepSeek funciona diretamente, e a auto-hospedagem local é possível pelo caminho oficial de inferência. A CometAPI se torna atraente quando você quer um único caminho de código entre muitos provedores de modelos, rastreamento de custos e uma troca mais fácil entre famílias de modelos.

Conclusão

O DeepSeek V4 não é apenas mais um lançamento de modelo. É um sistema de longo contexto com foco em agentes, com pesos abertos, acesso via API oficial e divisão clara entre um modelo de raciocínio de alto nível e um modelo de throughput de menor custo. As últimas novidades oficiais importam porque mudam a árvore de decisão: a implantação local é possível, mas apenas para equipes com infraestrutura séria de GPU; o acesso via API está disponível imediatamente; e a CometAPI é uma recomendação sensata quando portabilidade e disciplina de custos importam mais do que possuir a pilha de inferência.

Se a carga de trabalho é complexa e o hardware existe, comece com o V4-Pro. Se a carga de trabalho é guiada por volume, comece com o V4-Flash. Se o objetivo é lançar rapidamente e manter as opções de modelo em aberto, use a camada de API e mantenha seu código portátil. Essa é a estratégia de produção mais defensável no momento.

Próximos passos acionáveis:

1. Avalie seu hardware e comece com o V4-Flash quantizado via Ollama ou LM Studio.
2. Experimente com os exemplos de código acima e faça benchmarks contra suas cargas de trabalho.
3. Explore quantizações GGUF e otimizações da comunidade à medida que amadurecem após o lançamento.
4. Para produção ou tarefas pesadas, integre a CometAPI para acesso confiável e econômico ao V4-Pro/Flash completo sem gerenciar hardware.