DeepSeek-V3.1 é um modelo de bate-papo híbrido Mixture-of-Experts (MoE) lançado pela DeepSeek em agosto de 2025 que oferece suporte dois modos de inferência — um modo rápido "sem pensar" e um modo "pensante" deliberado — a partir do mesmo ponto de verificação. O modelo está disponível no Hugging Face e pode ser executado localmente por meio de vários caminhos (vLLM, Ollama/llama.cpp, GGUFs no estilo Ollama ou configurações multi-GPU em larga escala). Abaixo, explico os requisitos, como o modo pensante funciona, diversas opções de execução local (com trechos de código executáveis) e uma receita passo a passo de "implantação no Modo Pensante" com exemplos de chamadas de ferramentas e modelos de token.
O que é DeepSeek-V3.1 e por que isso é importante?
DeepSeek-V3.1 é a atualização da família v3 do DeepSeek que apresenta um design de inferência híbrida: o mesmo modelo pode ser executado em pensando (deliberativo, multietapas) ou não-pensante (resposta direta, mais rápida) alterando o modelo de chat. Em termos de arquitetura, trata-se de uma grande família MoE (ponto de verificação base com cerca de 671 bilhões de parâmetros no total, ~37 bilhões ativados por token), com treinamento de longo contexto estendido para 128 mil tokens e suporte para microescala FP8. O DeepSeek posicionou a V3.1 como uma versão pronta para agentes: melhor chamada de ferramentas, habilidades aprimoradas para agentes e maior eficiência de raciocínio em comparação com as versões R1 anteriores. A versão foi anunciada em agosto de 2025 e foi integrada ao Hugging Face, às ferramentas CFD/OSS e aos guias de implantação em nuvem.
Como funciona o modelo híbrido (conciso)
- Um ponto de verificação, dois modelos: Os modos de pensar e não pensar são controlados pelo modelo de bate-papo e uma
<think>/</think>convenção de token no prompt. O cartão do modelo documenta os prefixos exatos. - Melhorias no agente/ferramenta: Os reforços pós-treinamento permitem chamadas de ferramentas mais inteligentes — o modelo espera um formato JSON de chamada de ferramenta estrito para execução segura e determinística da ferramenta.
- Compensações de desempenho: O modo de pensamento gasta fichas em raciocínios internos baseados em cadeia de pensamento e pode ser mais lento/exigir mais fichas; o modo não-pensamento é mais rápido e mais barato. Os benchmarks no cartão de modelo mostram melhorias substanciais nos benchmarks de raciocínio e código para a V3.1.
Como o modelo é estruturado
- espinha dorsal do MoE: grande contagem total de parâmetros com um subconjunto ativado menor por token (inferência econômica).
- Treinamento de contexto longo: A versão 3.1 estende significativamente as fases de contexto longo (32 mil → treinamento maior em documentos longos) para oferecer suporte a mais de 128 mil janelas em algumas compilações.
- Fluxo de trabalho nativo do FP8: O DeepSeek usa extensivamente os formatos FP8 (w8a8 / UE8M0) para eficiência de peso/ativação; existem scripts de conversão da comunidade se você preferir BF16/FP16.
Quais são os requisitos para executar o DeepSeek-V3.1 localmente? (Hardware, armazenamento e software)
Executando o completa O modelo V3.1 (não quantizado) é um projeto grande. Abaixo estão categorias realistas de configurações e o que elas normalmente exigem.
Baldes práticos
- Cluster / laboratório de pesquisa (modelo completo): várias GPUs de alta memória (classe H100/H800 ou muitas GPUs Ada/Hopper), vários nós com dezenas de GPUs, muito armazenamento NVMe (centenas de GBs) e estruturas de inferência especializadas (SGLang, vLLM, LMDeploy, TRT-LLM).
- Servidor único de ponta (quantizado): possível com quantização pesada (INT4/AWQ/AWQ2/gguf) e frameworks como Ollama (pré-empacotado) ou GGUFs comunitários — ainda requer ~dezenas a centenas de GB de RAM de GPU ou descarregamento inteligente de CPU+GPU.
- Laptop de desenvolvedor / caixa de desenvolvimento: não é viável para o modelo completo; use variantes pequenas, destiladas/ajustadas ou conecte-se ao servidor local/instância do Ollama.
Lista de verificação de hardware (prática)
- GPUs: Para inferência real de todo o V3.1: clusters multi-GPU (H100 / H800 / Ada Lovelace+). Para execução do FP8, são necessárias GPUs com capacidade de computação e suporte a drivers.
- RAM e armazenamento: Espere centenas de GB de espaço livre em disco para os arquivos de modelo (as páginas de modelo listam algumas centenas de GB dependendo do formato/quantização), além de espaço de trabalho para formatos convertidos. Os metadados do Ollama listam um espaço de ~400 GB para um pacote DeepSeek V3.1 Ollama na biblioteca.
- Network:Para inferência de vários nós, você precisa de interconexões de baixa latência (NVLink / InfiniBand) e ferramentas de orquestração para configurações tensor-paralelas.
Lista de verificação de software
- OS: Linux é recomendado para ferramentas de inferência da comunidade (a demonstração do DeepSeek-Infer lista Linux/Python).
- Python: 3.10+ (em muitos exemplos do DeepSeek). Versões típicas de pacotes são fixadas no repositório
requirements.txt. - Estruturas e ferramentas (escolha um ou mais): SGLang, vLLM, LMDeploy, TRT-LLM/TensorRT-LLM, LightLLM ou Ollama para instalações locais mais simples. Cada um possui instruções e suporte a precisão/quantização diferentes.
Nota prática: Se você tiver apenas uma GPU de consumidor (por exemplo, 24–48 GB), provavelmente usará GGUFs quantizados ou inferência remota; se tiver uma estação de trabalho com >128 GB de RAM mais um cluster de GPU de classe H100/H200, você pode atingir inferência FP8/FP16 de maior fidelidade com vLLM.
Como executo o DeepSeek-V3.1 localmente?
Abaixo estão vários caminhos práticos que você pode usar, desde o mais manual/flexível até o caminho mais fácil para uma única caixa de desenvolvedor. Fornecerei tutoriais passo a passo e exemplos de código
Opção A — Demonstração oficial do DeepSeek-Infer (caminho de desenvolvimento/cluster)
Este é o exemplo/demonstração do repositório para inferência FP8/BF16. Use-o se você planeja multi-nós ou deseja experimentar o código de inferência oficial.
- Clonar, preparar ambiente
git clone https://github.com/deepseek-ai/DeepSeek-V3.git
cd DeepSeek-V3/inference
# Create a dedicated venv / conda env
python -m venv venv && source venv/bin/activate
pip install -r requirements.txt
(Repositório inference/requirements.txt lista as versões fixadas de tocha/triton/transformers recomendadas pela equipe.)
- Baixar pesos do modelo
- Baixe na página do modelo Hugging Face (
deepseek-ai/DeepSeek-V3.1) e coloque-os sob/path/to/DeepSeek-V3. O cartão do modelo e o repositório observam os links oficiais de armazenamento do Hugging Face.
- Converter pesos para demonstração
# example conversion command shown in the repo
python convert.py --hf-ckpt-path /path/to/DeepSeek-V3 --save-path /path/to/DeepSeek-V3-Demo --n-experts 256 --model-parallel 16
- Executar geração interativa (distribuída)
torchrun --nnodes 2 --nproc-per-node 8 --node-rank $RANK --master-addr $ADDR \
generate.py --ckpt-path /path/to/DeepSeek-V3-Demo --config configs/config_671B.json \
--interactive --temperature 0.7 --max-new-tokens 200
Este é o exemplo canônico do repositório DeepSeek para execuções em estilo cluster.
Opção B — vLLM (recomendado para implantações de servidor e API compatível com OpenAI)
O vLLM suporta DeepSeek nos modos FP8/BF16 e oferece um servidor compatível com OpenAI. É um caminho de produção popular para modelos grandes devido às otimizações de memória e compatibilidade de API.
Inicie um servidor vLLM que buscará o modelo do Hugging Face (padrão de exemplo):
# this will download/serve the model (replace with exact model id if needed)
vllm serve deepseek-ai/DeepSeek-V3.1 --host 0.0.0.0 --port 8000
Em seguida, solicite conclusões com curl ou um cliente compatível com OpenAI:
curl -s -X POST "http://localhost:8000/v1/completions" \
-H "Content-Type: application/json" \
-d '{"model":"DeepSeek-V3.1","prompt":"Explain the QuickSort algorithm", "max_tokens":200}'
As receitas e a documentação do vLLM incluem exemplos do DeepSeek e notas sobre compatibilidade com FP8 e paralelismo multi-GPU/pipeline. Para modelos pesados, você ainda precisará de múltiplas GPUs ou de uma variante quantizada.
Opção C — LMDeploy / SGLang / LightLLM e TensorRT-LLM (alto desempenho)
O repositório DeepSeek recomenda explicitamente SGLang, Implantação LM e TensorRT-LLM como mecanismos otimizados para o DeepSeek V3. Eles oferecem latência de inferência, taxa de transferência e kernels FP8 aprimorados.
Uma invocação típica do LMDeploy (consulte a documentação do LMDeploy para obter a CLI exata):
# pseudo-example; refer to LMDeploy docs for exact options
lmdeploy serve --model /path/to/deepseek_v3.1 --precision fp8 --port 8080
Os benchmarks e receitas de lançamento do SGLang estão disponíveis no repositório e no projeto SGLang benchmark/deepseek_v3 pasta. Use essas pilhas quando controlar um cluster de GPU e desejar obter rendimento de produção.
Opção D — Ollama (a rota de desenvolvimento local mais fácil, geralmente em uma única máquina)
Se você quiser a maneira mais fácil de executar o DeepSeek localmente (e puder poupar o disco), Ollama fornece modelos empacotados e uma CLI simples (ollama pull, ollama run). O DeepSeek-V3.1 aparece na biblioteca Ollama e pode ser executado localmente (o Ollama pode exigir uma versão recente/pré-lançamento para alguns recursos).
Exemplo (Ollama CLI):
# Pull the model (downloads the model artifacts to your disk)
ollama pull deepseek-v3.1
# Start an interactive session:
ollama run deepseek-v3.1
# Or run as a local API server (Ollama supports a local API)
# Example: POSTing to Ollama's local API (adjust host/port to your setup)
curl -X POST http://localhost:11434/api/generate \
-H 'Content-Type: application/json' \
-d '{"model":"deepseek-v3.1","prompt":"Summarize the following paper: ..."}'
O Ollama abstrai muitos detalhes de distribuição/quantização e pode ser uma ótima maneira de testar o comportamento do modelo em um único host. Observação: a página do modelo lista um tamanho de pacote de ~404 GB para a entrada do Ollama, portanto, planeje o disco e a RAM de acordo.
O que é o Modo de Pensamento e como usá-lo
DeepSeek-V3.1 implementa um token de pensamento híbrido abordagem: o mesmo ponto de verificação pode ser executado em pensando modo (tokens internos de “cadeia de pensamento”) ou não-pensante modo alternando o modelo de chat/prompt. O modelo usa tokens explícitos como <think> (e fechando </think> (em alguns modelos) para sinalizar a cadeia interna de pensamento versus a geração de respostas diretas. O cartão modelo documenta prefixos de pensamento e não pensamento e mostra como os modelos diferem.
Exemplo: construindo uma mensagem em Python (auxiliar tokenizador)
O cartão modelo Hugging Face inclui um trecho útil que mostra como aplicar o modelo de bate-papo por meio do tokenizador. Este é o padrão recomendado para gerar pensando or não-pensante prompts formatados:
import transformers
tokenizer = transformers.AutoTokenizer.from_pretrained("deepseek-ai/DeepSeek-V3.1")
messages = [
{"role": "system", "content": "You are a helpful assistant"},
{"role": "user", "content": "Who are you?"},
{"role": "assistant", "content": "<think>Hmm</think>I am DeepSeek"},
{"role": "user", "content": "1+1=?"}
]
# Thinking mode
tokenizer.apply_chat_template(messages, tokenize=False, thinking=True, add_generation_prompt=True)
# Non-thinking mode
tokenizer.apply_chat_template(messages, tokenize=False, thinking=False, add_generation_prompt=True)
Interruptor thinking=True para produzir um prompt que use o <think> prefixo; thinking=False produz o modelo não pensante. O modelo se comportará de forma diferente (deliberação interna vs. resposta imediata) dependendo deste sinalizador.
Referência rápida — pequenas soluções de problemas e práticas recomendadas
Se você ficar sem memória da GPU: Experimente compilações quantizadas (AWQ/q4/INT4) ou GGUFs comunitários; muitos espaços comunitários publicam quantizações para uso local. Ollama/vLLM também pode oferecer compilações quantizadas menores.
Se você precisar que o modelo chame ferramentas externas: Adote o Chamada de ferramenta esquema no modelo de bate-papo exatamente. Teste o formato JSON da ferramenta offline e verifique se o seu código de orquestração (a parte que executa a ferramenta) retorna JSON digitado e higienizado de volta ao modelo.
Se você precisar de um contexto longo: Use vLLM ou SGLang com plugins de contexto longo; o DeepSeek foi explicitamente treinado/estendido para contextos de 32K/128K e ferramentas relacionadas suportam essa janela. Espere compensações de memória.
Posso realmente executar o DeepSeek-V3.1 em um laptop ou servidor pequeno?
Resposta curta: Sim, mas com ressalvas. Quantizações comunitárias (AWQ/GGUF/dinâmicas de 1 bit) reduzem drasticamente o consumo de armazenamento e memória e permitiram que amadores executassem variantes da V3.1 em desktops de última geração (afirma-se um conjunto de trabalho de ~170 GB). No entanto:
- Fidelidade versus compensação de tamanho: A quantização agressiva reduz a memória, mas pode afetar o raciocínio/desempenho do código. Teste em suas cargas de trabalho.
- Legal e licenciamento: o modelo é licenciado pelo MIT de acordo com o cartão do modelo, mas quantizações de terceiros podem ter suas próprias licenças; revise-as antes do uso em produção.
Considerações finais
O DeepSeek-V3.1 é um passo significativo em direção a modelos híbridos de "agentes", com comportamento de pensamento/não pensamento explícito e uso aprimorado de ferramentas. Se você quiser executá-lo localmente, escolha um caminho que corresponda ao seu hardware e tolerância a riscos:
Para pesquisa: transformers + safetensors quantizados e acelerar.
Para produção e rendimento: vLLM + multi-GPU (H100/H200).
Para experimentos locais: Ollama/llama.cpp + GGUFs da comunidade (mesclar + executar).
Começando a jornada
A CometAPI é uma plataforma de API unificada que agrega mais de 500 modelos de IA de provedores líderes — como a série GPT da OpenAI, a Gemini do Google, a Claude da Anthropic, a Midjourney e a Suno, entre outros — em uma interface única e amigável ao desenvolvedor. Ao oferecer autenticação, formatação de solicitações e tratamento de respostas consistentes, a CometAPI simplifica drasticamente a integração de recursos de IA em seus aplicativos. Seja para criar chatbots, geradores de imagens, compositores musicais ou pipelines de análise baseados em dados, a CometAPI permite iterar mais rapidamente, controlar custos e permanecer independente de fornecedores — tudo isso enquanto aproveita os avanços mais recentes em todo o ecossistema de IA.
Os desenvolvedores podem acessar DeepSeek-V3.1 Por meio do CometAPI, as versões mais recentes dos modelos listados são as da data de publicação do artigo. Para começar, explore os recursos do modelo no Playground e consulte o Guia de API para obter instruções detalhadas. Antes de acessar, certifique-se de ter feito login no CometAPI e obtido a chave da API. CometAPI oferecem um preço muito mais baixo que o preço oficial para ajudar você a se integrar.