Configurar DeepSeek com Ollama: Guia de implantação complet

#Por que configurar DeepSeek com Ollama

Ollama cuida por você do download dos pesos, da distribuição entre GPU e CPU e da API local. Você obtém um servidor que escuta em http://localhost:11434 e um único comando para iniciar qualquer variante do DeepSeek. O restante — temperatura, tamanho do contexto, memória — é controlado por alguns parâmetros que é melhor entender do que sofrer com seus efeitos.

Uma boa configuração muda tudo: um DeepSeek R1 iniciado com a temperatura errada entra em loop ou interrompe seu raciocínio; um DeepSeek Coder com um contexto muito curto esquece metade do seu arquivo. O objetivo deste guia é definir esses ajustes uma vez por todas.

#DeepSeek Coder vs Chat vs R1: qual instalar

Três famílias coexistem sob o nome DeepSeek na biblioteca Ollama. Elas não são configuradas da mesma forma porque servem a usos diferentes.

deepseek-coder

Especializado em código: complementação de código, geração de funções, refatoração. Disponível em tamanhos pequenos (1,3B, 6,7B, 33B). Ideal quando conectado a um editor para autocompletar código localmente.

deepseek-v3 / deepseek-llm (Chat)

Modelo conversacional geral. Respostas diretas, sem exposição de cadeia de pensamento. Para um assistente polivalente em francês como em inglês.

deepseek-r1

Modelo de raciocínio: desenvolve uma cadeia de pensamento (tags <think>) antes de responder. Excelente em matemática, lógica e problemas em múltiplas etapas. Versões destiladas 1.5B / 7B / 8B / 14B / 32B / 70B para caber na memória da máquina local.

Regra simples: código à medida que você digita → Coder; um assistente que conversa → Chat/V3; um problema que exige reflexão → R1. Nada impede você de instalar os três; o Ollama os armazena lado a lado.

#Requisitos e VRAM por tamanho

Ollama deve estar instalado e seu serviço ativo. A quantização padrão dos modelos DeepSeek em Ollama é Q4_K_M, o melhor equilíbrio entre qualidade e memória para a maioria das placas. A seguir, a VRAM necessária em Q4, apenas com pesos — adicione entre 1 e 2 GB a mais para o contexto.

1,5B – 3B (R1 distilado)

≈ 2 GB · roda mesmo sem GPU dedicada, ou com muita facilidade em uma RTX 3060 de 12 GB.

7B – 8B

≈ 5 GB · RTX 3060 12 GB, RTX 4070 12 GB. Ponto de equilíbrio para uso diário.

14B

≈ 9 GB · Pouca folga na RTX 4070 de 12 GB, boa folga na RTX 4080 de 16 GB.

32B / 33B (Coder)

≈ 19 GB · RTX 4090 24 GB, ou Mac com memória unificada de 24-48 GB.

70B

≈ 40 GB · duas GPUs de 24 GB ou um Mac M4 Pro com 48 GB ou mais.

#Instalar e iniciar DeepSeek

1. 01
   Verificar se o Ollama está em execução

   O serviço deve estar em execução. `ollama --version` confirma a instalação; o servidor escuta na porta 11434.
2. 02
   Baixar o modelo

   Escolha a variante e o tamanho com `ollama pull`. O rótulo após o : define o tamanho (ex. :7b, :14b, :32b). Sem rótulo, Ollama usa o tamanho padrão.
3. 03
   Iniciar uma sessão

   `ollama run` baixa o modelo, se necessário, e depois abre um prompt interativo. Digite /bye para sair.
4. 04
   Testar a API

   O mesmo modelo fica imediatamente disponível na API REST local, pronta para ser conectada ao Open WebUI, a um editor ou aos seus scripts.

# Modèle de raisonnement, distillation 7B
ollama pull deepseek-r1:7b

# Modèle de code, 6.7B
ollama pull deepseek-coder:6.7b

# Lancer une session interactive
ollama run deepseek-r1:7b

# Voir ce qui est chargé et où (GPU/CPU)
ollama ps

curl http://localhost:11434/api/generate -d '{
  "model": "deepseek-r1:7b",
  "prompt": "Explique la récursivité en une phrase.",
  "stream": false
}'

#Ajustar temperatura e janela de contexto

Os dois parâmetros que mais afetam a qualidade são a temperatura (criatividade versus determinismo) e num_ctx (tamanho da janela de contexto). Os valores padrão de Ollama não são sempre ideais, especialmente para R1.

temperature (R1)

0,5 a 0,7. DeepSeek recomenda ~0,6 para R1: se o valor for muito baixo, o raciocínio trava; se for muito alto, ele divaga. Evite 0 em um modelo de raciocínio.

temperature (Coder)

0.1 a 0.3. Para código, queremos determinismo e reprodutibilidade, não criatividade.

num_ctx

Tamanho do contexto em tokens. Por padrão, geralmente 4096. Aumente para 8192 ou 16384 para arquivos longos ou cadeias de raciocínio longas — ao custo de mais VRAM.

top_p

Aproximadamente 0,95. Deixar como está na maioria dos casos; ajuste a temperatura primeiro.

repeat_penalty

1.1 por padrão. Útil se R1 se repetir em loop na sua cadeia de pensamento.

ollama run deepseek-r1:7b
>>> /set parameter temperature 0.6
>>> /set parameter num_ctx 8192
>>> Résous : un train part à 60 km/h...
>>> /bye

{
  "model": "deepseek-coder:6.7b",
  "prompt": "Écris une fonction Python de tri fusion.",
  "options": {
    "temperature": 0.2,
    "num_ctx": 8192,
    "top_p": 0.95
  },
  "stream": false
}

#Fixar a configuração com um Modelfile

Ajustar os parâmetros em cada sessão é trabalhoso. Um Modelfile cria uma variante nomeada que inclui seus ajustes e um system prompt. Você obtém um modelo pronto para uso, invocado como qualquer outro.

FROM deepseek-coder:6.7b

PARAMETER temperature 0.2
PARAMETER num_ctx 8192
PARAMETER top_p 0.95

SYSTEM """Tu es un assistant de programmation.
Réponds en français, commente le code, et privilégie la clarté."""

# Créer le modèle à partir du fichier
ollama create deepseek-coder-fr -f ./Modelfile

# L'utiliser comme n'importe quel modèle
ollama run deepseek-coder-fr

A mesma abordagem se aplica ao R1: um Modelfile com temperature 0.6 e num_ctx 16384 fornece a você um modelo de raciocínio calibrado, sem precisar pensar nisso a cada inicialização.

#Otimizar a VRAM e a memória

Se um modelo exceder a capacidade da VRAM, o Ollama coloca as camadas excedentes na CPU — e a taxa de tokens por segundo despenca. Três formas de manter a execução inteiramente na GPU.

Reduzir a quantização

Q4_K_M por padrão. Permaneça nesse nível: ele já oferece um bom equilíbrio. Só passe para Q5_K_M ou Q8_0 se a VRAM permitir e você quiser um pouco mais de qualidade.

Escolher o tamanho certo

Um modelo de 14B executado inteiramente na GPU supera um de 32B que precisa transferir parte da execução para a CPU, tanto em velocidade quanto em conforto de uso. Busque o maior modelo que caiba inteiramente na VRAM.

Dominar num_ctx

O cache KV aumenta com o contexto. Um contexto razoável (8192) libera espaço para os pesos do modelo.

Descarregar da memória após o uso

OLLAMA_KEEP_ALIVE define por quanto tempo um modelo permanece na memória após a última requisição. Reduza esse valor para liberar a GPU mais rápido entre dois modelos.

# Garder les modèles chargés 2 minutes seulement (défaut : 5 min)
export OLLAMA_KEEP_ALIVE=2m

# Décharger immédiatement un modèle précis
ollama stop deepseek-r1:7b

#Execução em paralelo e concorrência

Ollama pode atender várias requisições simultaneamente e manter vários modelos carregados ao mesmo tempo. Útil para um assistente compartilhado, ou para rodar Coder e R1 ao mesmo tempo. Duas variáveis de ambiente controlam esse comportamento.

OLLAMA_NUM_PARALLEL

Quantidade de requisições tratadas em paralelo por um mesmo modelo. Cada requisição consome sua própria parte de contexto, portanto de VRAM. Aumente com cuidado (2, 4) de acordo com a placa.

OLLAMA_MAX_LOADED_MODELS

Número de modelos distintos mantidos em memória simultaneamente. Defina como 2 para manter Coder e R1 carregados e prontos para uso ao mesmo tempo, se houver VRAM suficiente.

# Servir 4 requêtes en parallèle, 2 modèles chargés
export OLLAMA_NUM_PARALLEL=4
export OLLAMA_MAX_LOADED_MODELS=2

# Redémarrer le service pour prendre en compte les variables
ollama serve

#Solução de problemas comuns

R1 fica em loop dentro de <think>

Temperatura muito baixa ou repeat_penalty ausente. Aumente temperature para 0.6 e adicione repeat_penalty 1.1.

Geração muito lenta

Parte do modelo está sendo executada na CPU. Verifique `ollama ps`: se PROCESSOR não indicar 100% GPU, reduza o tamanho, a quantização ou num_ctx.

Resposta truncada

num_predict (número máximo de tokens gerados) muito baixo, ou contexto saturado. Aumente num_ctx e deixe num_predict livre (-1).

O código sai com as tags de raciocínio

Você está usando R1 para código. Mude para deepseek-coder, que não gera uma cadeia de raciocínio.

#Para se aprofundar

Com o DeepSeek configurado e calibrado, os próximos passos naturais são: aprofundar seus conhecimentos sobre R1, refinar suas variantes e escolher a quantização de acordo com sua placa.

Instalar o DeepSeek R1 com Ollama

Guia dedicado ao modelo de raciocínio, versões destiladas e cadeia de pensamento, para ir além da configuração.

Personalizar um modelo com Ollama Modelfile

Sistema de templates, prompts de sistema e parâmetros — para industrializar as variantes vistas aqui.

Escolher sua quantização (Q4, Q5, Q8, FP16)

Entender os compromissos entre qualidade e VRAM para fazer caber na sua GPU o maior modelo DeepSeek possível.