DeepSeek em Tudo Quanto É Lugar: Ligando um Cérebro de Nuvem Barato ao Claude Code e a um Stack Local de Agentes

O DeepSeek agora sustenta três coisas diferentes na minha casa: o cérebro do meu stack de agentes, a CLI do Claude Code, e o degrau de nuvem de uma escada de fallback. O esforço total de ligação foi um pouco de JSON, algumas variáveis de ambiente e um bug de escape do systemd que consumiu uma noite inteira.

O que você acaba tendo

Antes do passo a passo, o formato da coisa. Eu rodo o OpenClaw, um gateway de agentes, com oito agentes nomeados por trás de uma interface de chat, mais a CLI do Claude Code que esses agentes disparam para trabalho real de codificação. O DeepSeek sustenta os dois.

Padrão	O que faz	Custo
1. Cérebro do agente	DeepSeek como provedor na configuração do gateway; qualquer agente pode escolhê-lo como principal ou fallback	US$ 0,14–US$ 0,87 / milhão de tokens
2. Backend do Claude Code	Um drop-in do systemd redireciona a CLI para o endpoint compatível com Anthropic do DeepSeek, sem reinstalar nada	o mesmo preço por token
3. Escada de fallback	Uma lista de decisão para quando um trabalho vai para o DeepSeek ou para um modelo local	US$ 0 quando fica local

A linha que torna tudo isso possível: o DeepSeek disponibiliza um endpoint compatível com Anthropic em https://api.deepseek.com/anthropic. Qualquer coisa feita para conversar com a Claude — incluindo a própria CLI do Claude Code — pode ser apontada para lá usando apenas variáveis de ambiente. Sem script intermediário, sem fork.

Padrão 1: DeepSeek como cérebro de agente

Um bloco de provedor na configuração do gateway. Coisa real, chave ocultada:

"deepseek": {
  "baseUrl": "https://api.deepseek.com/v1",
  "api": "openai-completions",
  "apiKey": "CHANGE_ME",
  "timeoutSeconds": 450,
  "models": [
    {
      "id": "deepseek-v4-pro",
      "name": "deepseek-v4-pro",
      "reasoning": true,
      "input": ["text"],
      "cost": { "input": 0.435, "output": 0.87,
                "cacheRead": 0.003625, "cacheWrite": 0.435 },
      "contextWindow": 1000000,
      "maxTokens": 384000
    },
    {
      "id": "deepseek-v4-flash",
      "name": "deepseek-v4-flash",
      "reasoning": true,
      "input": ["text"],
      "cost": { "input": 0.14, "output": 0.28,
                "cacheRead": 0.0028, "cacheWrite": 0.14 },
      "contextWindow": 1000000,
      "maxTokens": 384000
    }
  ]
}

Cada agente então escolhe um modelo principal e uma cadeia de fallback:

"model": {
  "primary": "deepseek/deepseek-v4-flash",
  "fallbacks": ["deepseek/deepseek-v4-pro", "vllm/google/gemma-4-31b"]
}

Veja o que acontece quando uma mensagem chega nesse roteamento:

Meu elenco real. A maioria dos agentes começa com o DeepSeek e recua para o local; o Doxy faz o inverso de propósito:

Agente	Principal	Fallbacks
Bits (chat principal)	DeepSeek flash	DeepSeek pro → gemma-4-31b local
Brains	DeepSeek pro	gemma-4-31b local
Flash	DeepSeek flash	DeepSeek pro → local
Hermes (agente de deploy)	DeepSeek pro	DeepSeek flash → local
Alpha (seguro para a família)	DeepSeek flash	DeepSeek pro → local
Doxy (força de trabalho local)	120B local	DeepSeek flash (inverso — o local vem primeiro)
beta	local	DeepSeek flash → DeepSeek pro
Charley (visão)	gemma-31b local	DeepSeek pro → DeepSeek flash

O Charley importa aqui: essas entradas do DeepSeek são somente texto ("input": ["text"]), então trabalho de imagem fica local não importa o que a cadeia diga. Os apelidos (ds-flash, ds-brain) me deixam trocar de modelo no meio da conversa sem editar configuração.

Duas configurações vão te morder se você pular:

• "reasoning": true é obrigatório para modelos de raciocínio. Eles transmitem reasoning_content antes da resposta de fato; com a flag desligada, o gateway ouve silêncio, decide que o modelo travou e mata a rodada por volta dos 390 segundos. Não pergunte como eu sei.
• Aumente o timeoutSeconds. O timeout padrão de requisição era 120 segundos; execuções longas de raciocínio estouram isso e "falham" de forma aleatória. 450 resolveu aqui, e as configurações de provedor recarregam a quente — sem precisar reiniciar o gateway.

Padrão 2: a CLI do Claude Code no DeepSeek

A CLI do Claude Code lê ANTHROPIC_BASE_URL, ANTHROPIC_MODEL e ANTHROPIC_AUTH_TOKEN/ANTHROPIC_API_KEY do seu ambiente, e o endpoint /anthropic do DeepSeek fala o mesmo formato de fio que a Claude fala. Então redirecionar a CLI é só mudar o ambiente que o gateway entrega a cada subprocesso do Claude Code que ele dispara — a CLI continua sendo uma instalação padrão.

O arquivo é um drop-in de usuário do systemd. O meu é gerado por um pequeno aplicativo GTK que construí, que alterna entre quatro modos (Local LM Studio / DeepSeek / Anthropic Cloud / Off), mas é curto o suficiente para escrever à mão:

# ~/.config/systemd/user/openclaw-gateway.service.d/60-subagent-routing.conf
[Service]
# Routes Claude Code CLI sub-processes to DeepSeek's Anthropic-compatible
# endpoint. The key is NOT copied here: $$DEEPSEEK_API_KEY is systemd's escape
# for a literal $DEEPSEEK_API_KEY, which bash expands at runtime from the
# gateway EnvironmentFile -- the secret never enters the unit or the argv.
Environment="ANTHROPIC_BASE_URL=https://api.deepseek.com/anthropic"
Environment="ANTHROPIC_MODEL=deepseek-v4-pro"
ExecStart=
ExecStart=/usr/bin/bash -c 'export ANTHROPIC_AUTH_TOKEN="$$DEEPSEEK_API_KEY"; export ANTHROPIC_API_KEY="$$DEEPSEEK_API_KEY"; exec node /path/to/openclaw/dist/index.js gateway --port 18789'

A chave em si mora em exatamente um lugar: o EnvironmentFile do serviço (~/.openclaw/gateway.systemd.env, chmod 600), que só contém DEEPSEEK_API_KEY=CHANGE_ME.

A pegadinha do $$ (a razão de este post existir)

Minha primeira tentativa usou um único $. Não foi bem. Dentro de um arquivo de unidade, $VAR é expandido pelo próprio systemd no momento em que o processo é disparado, o que embute a chave direto na linha de comando — visível no ps, em /proc/<pid>/cmdline e no systemctl show. Não exatamente onde você quer que um segredo fique.

$$VAR é o escape do systemd para um $VAR literal: o systemd repassa a string sem tocar nela, e o bash a expande em tempo de execução, a partir do ambiente que o EnvironmentFile já tinha carregado. Efeito líquido: o segredo existe em um único arquivo chmod 600 e em nenhum outro lugar — nunca aparece no arquivo de unidade, no systemctl show ou em qualquer argv. Um gerenciador de segredos "pobre" montado com systemd e bash, e funciona.

Mais pegadinhas de quem realmente rodou isso:

• Configure as duas variáveis de autenticação. Versões diferentes da CLI leem ANTHROPIC_AUTH_TOKEN ou ANTHROPIC_API_KEY; configurar só uma é jogar cara ou coroa.
• Fixe o ANTHROPIC_MODEL, ou os apelidos costumeiros sonnet/opus da CLI acabam enviados para o endpoint do DeepSeek e retornam 404.
• O drop-in ofusca qualquer chave real da Anthropic. Um único ambiente domina toda a CLI — eu descobri isso quando ele quebrou em silêncio meus apelidos de "rotear para a Claude de verdade".
• Deixe o ExecStart= vazio primeiro — a linha em branco antes da sobrescrita — ou o systemd vai anexar o seu comando em vez de substituir o original.
• Atualizações de pacote podem deixar o wrapper órfão. Ele fixa o comando de execução como texto, então uma atualização que muda o ExecStart real significa regenerar o drop-in. Meu gerador lê o comando canônico a partir do FragmentPath da unidade e se recusa a envolver qualquer coisa que já contenha $$DEEPSEEK_API_KEY.
• Depois recarregue: systemctl --user daemon-reload && systemctl --user restart <service>.

Para provar o caminho inteiro de ponta a ponta, pule a CLI e use curl:

curl https://api.deepseek.com/anthropic/v1/messages \
  -H "x-api-key: $DEEPSEEK_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{"model":"deepseek-v4-pro","max_tokens":16,"messages":[{"role":"user","content":"ping"}]}'

Uma resposta "type":"message" de volta significa que o caminho compatível com Anthropic inteiro realmente funciona.

Padrão 3: quando realmente usar DeepSeek em vez de local

Ter os dois disponíveis não significa que todo trabalho vai para a nuvem. Por milhão de tokens, com os preços de tabela da Claude para efeito de comparação (Opus US$ 5/US$ 25, Sonnet US$ 3/US$ 15, Haiku US$ 1/US$ 5):

Opção	Entrada	Saída	Notas
DeepSeek flash	US$ 0,14	US$ 0,28	leitura de cache US$ 0,0028 — o expediente de agente de chat custa centavos por dia
DeepSeek pro	US$ 0,435	US$ 0,87	o nível "pensante", ainda assim 7 a 17 vezes mais barato que o Sonnet
Local (mesma máquina)	US$ 0	US$ 0	só a conta de luz

Velocidade foi a surpresa maior. Modelos locais de classe 100B me obrigaram a aumentar os timeouts de rodada para 20–30 minutos, e dois agentes dividindo uma única máquina com GPU travam um ao outro. O DeepSeek responde em segundos; o teto de 450 segundos só importou mesmo nos piores casos de execuções de raciocínio. Contexto é a outra diferença — uma janela de 1 milhão de tokens contra cerca de 128 mil nos modelos locais — então sessões longas de agente e trabalhos de codificação em bases de código grandes vão por padrão para o DeepSeek. Visão vai na direção oposta: minhas entradas do DeepSeek são somente texto, então "olhe esta imagem" continua com um modelo de visão local.

A regra de bolso de privacidade que eu realmente uso: não mande para a nuvem nada que você não colocaria num e-mail.

Cadeias de fallback funcionam nos dois sentidos, que é a minha parte favorita. Agentes com prioridade na nuvem caem para um modelo local quando a internet ou a API morre; a força de trabalho com prioridade local recua para o DeepSeek flash quando o servidor local está ocupado ou fora do ar. Ninguém fica totalmente no escuro.

Pegadinhas, a lista curta

A flag reasoning: true, o timeout de 120 segundos, o escape $$ e o drop-in ofuscando sua chave real da Anthropic já foram todos cobertos nos Padrões 1 e 2. Mais duas:

• Uma allowlist de plugins não vazia é rígida. No OpenClaw, uma entrada de provedor habilitada mas ausente de plugins.allow nunca carrega. Sem erro, sem aviso, só silêncio.
• O DeepSeek aqui é somente texto. Confira o "input" na entrada do modelo antes de rotear trabalhos de visão para ele.

Quer tudo totalmente local em vez disso — sem chave de API, sem conta na nuvem? Eu também escrevi sobre isso: DeepSeek: Rodando Localmente — um Guia de 4 Passos, com destilados do DeepSeek na sua própria GPU usando Ollama, Docker e Open WebUI. Esse é o caminho para iniciantes; este aqui é para quando os trabalhos difíceis crescem além da sua GPU, mas o que é privado continua em casa.