tempo de leitura : 22 minutes

Muitas vezes me perguntam quanto custa meu consumo de IA. Eu respondo « 20 euros por mês » e eles me olham com os olhos arregalados. Então hoje, eu abro a caixa preta para vocês. Este artigo é a auditoria completa dos meus 73 dias de vibe coding : a metodologia para extrair os dados da base SQLite d’OpenCode, o código SQL para consultar as tabelas, e a comparação exaustiva com todos os fornecedores do mercado — ocidentais como chineses. O resultado é tão assimétrico que tive que verificar meus cálculos três vezes.

Compreender a Stack: Quem Faz o Que?

Antes de mergulhar nos números, vamos esclarecer a arquitetura. Há três atores distintos no meu setup, e é importante não confundir os três :

@startuml
skinparam backgroundColor #FEFEFE
skinparam defaultFontSize 12

title Os Três Atores da Minha PilhaLLM
left to right direction

actor "Eu (Desenvolvedor)" as Dev

package "OpenCode\n(github.com/anomalyco/opencode)" as OC {
  rectangle "CLI de programação vibe\nCódigo aberto, gratuito" as CLI
  note right of CLI
É a ferramenta que eu utilizo
para codificar com agentes de IA
Ele não fornece AUCUN modelo
É um terminal + um orquestrador
  end note
}

package "Ollama (Instalação Local)" as OL {
  rectangle "Cliente de inferência\nInstalado na minha máquina" as Client
  note right of Client
É o software que executa os modelos. Pode executá‑los localmente ou delegar à nuvem conforme a tag (:cloud). Ele se autentica usando a chave SSH.
  end note
}

package "Ollama Cloud\n(ollama.com)" as OCloud {
  rectangle "Service d'inférence cloud\nAssinatura Pro: 20€/mois" as Cloud
  note right of Cloud
É o fornecedor de inferência.
Meus modelos com a tag :cloud
são executados nos servidores LEURS.
A assinatura Pro dá acesso
às quotas superiores.
  end note
}

Dev --> CLI : "Eu digito prompts"
CLI --> Client : "Chama este modelo"
Client --> Cloud : "Chave SSH + requisição\n(modelos :cloud)"
Client --> Client : "Execução local\n(modelos sem :cloud)"

@enduml

OpenCode NÃO é um fornecedor de modelos.É um CLI de código aberto (github.com/anomalyco/opencode) que orquestra agentes de IA. Ele não vende assinatura, ele não fornece inferência. É o equivalente de`git`para versionamento: uma ferramenta, não um serviço. Ollama Cloud é o fornecedor da inferência.Minha instalação local do Ollama atua como client — ela se autentica nos servidores do Ollama por meio de uma chave SSH única (Device Key) e delega a execução dos modelos marcados a eles`:cloud`. A assinatura Pro (20€/mês) desbloqueia quotas superiores e permite acumular várias contas na mesma máquina via Docker.

Introdução : Por que realizar uma auditoria ?

Há dois meses, estava usando modelos gratuitamente na minha instalação local do Ollama. Então assinei um primeiro plano Ollama Cloud Pro de 20€/mês, que me permite usar os modelos em nuvem (aqueles com a tag`:cloud`) via o provider`ollama-cloud`. Uma segunda assinatura ocorreu um mês depois, em uma instância Docker separada com sua própria conta e chave SSH — o método de acumulação descrito em meu artigo sobre a acumulação de assinaturas

A pergunta que me atormentava : será que esses 20€ por mês são justificados ? Não de bate-pronto. Com números.

Para responder, eu precisava de dados precisos. Não eram estimativas. Não eram médias. Meu consumo real, token por token, modelo por modelo, sessão por sessão.

E OpenCode — a CLI — armazena tudo isso em um banco de dados SQLite.

A Base de Dados OpenCode : Uma Mina de Ouro

OpenCode persiste a integralidade do histórico de suas sessões em um arquivo SQLite localizado em`~/.local/share/opencode/opencode.db`. La mienne pèse 660 Mo pour 73 jours d’utilisation — une base de données de production tout à fait respectable.

$ ls -lh ~/.local/share/opencode/opencode.db
-rw-r--r-- 1 cheroliv cheroliv 660M mai 18 12:25 opencode.db

O esquema

A base contém cerca de vinte tabelas, mas três delas são cruciais para nossa auditoria:

@startuml
skinparam backgroundColor #FEFEFE
skinparam defaultFontSize 12

title Esquema Simplificado — OpenCode SQLite
entity "sessão" as S {
  * id : TEXT
  --
  * model : TEXT (JSON)
  * cost : REAL
  * tokens_input : INTEGER
  * tokens_output : INTEGER
  * tokens_reasoning : INTEGER
  * tokens_cache_read : INTEGER
  * tokens_cache_write : INTEGER
  * time_created : INTEGER
  * project_id : TEXT
}

entity "mensagem" as M {
  * id : TEXT
  --
  * session_id : TEXT <<FK>>
  * data : TEXT (JSON)
  * time_created : INTEGER
}

entity "projeto" as P {
  * id : TEXT
  --
  * worktree : TEXT
  * name : TEXT
}

S ||--o{ M : "session_id"
S }o--|| P : "project_id"

note right of S
A tabela session agrega
tokens + custo + modelo.
Este é nosso ponto de entrada
principal.
end note

note right of M
As mensagens individuais.
O campo dados contém
o modelo utilizado (formato JSON)
mesmo que a sessão mude de modelo no caminho.
end note

@enduml

A mesa`session`é perfeita para uma auditoria global: cada sessão tem sua contagem agregada de tokens, o modelo utilizado e seu custo. O campo`model`é JSON bruto:

{
  "id": "deepseek-v4-pro:cloud",
  "providerID": "ollama-cloud",
  "variant": "default"
}

o campo`cost`na base OpenCode reflete apenas as taxas de API externas pagas por consumo via chave de API (Google Gemini, OpenAI, etc.). As chamadas via Ollama — seja localmente ou via Ollama Cloud Pro — são marcadas`cost=0`Porque o custo é fixo (assinatura), não por token. O verdadeiro custo dessas chamadas é a assinatura mensal.

O Código de Extração

Não é preciso instalar nada. Node.js 22+ inclui um módulo SQLite experimental (node:sqlite) que funciona perfeitamente. Aqui está o script que me deu tudo:

const { DatabaseSync } = require('node:sqlite');
const db = new DatabaseSync(
  `${process.env.HOME}/.local/share/opencode/opencode.db`,
  { readonly: true }
);

// 1. Statistiques globales
const global = db.prepare(`
  SELECT
    COUNT(*) as sessions,
    SUM(tokens_input) as total_input,
    SUM(tokens_output) as total_output,
    SUM(tokens_reasoning) as total_reasoning,
    SUM(tokens_cache_read) as total_cache_read,
    SUM(cost) as total_cost
  FROM session
`).get();

// 2. Ventilation par modèle et fournisseur
const byModel = db.prepare(`
  SELECT
    json_extract(model, '$.id') as model_id,
    json_extract(model, '$.providerID') as provider,
    COUNT(*) as sessions,
    SUM(tokens_input) as total_input,
    SUM(tokens_output) as total_output,
    SUM(cost) as total_cost
  FROM session
  WHERE model IS NOT NULL
  GROUP BY model_id, provider
  ORDER BY SUM(tokens_input) DESC
`).all();

// 3. Par mois
const monthly = db.prepare(`
  SELECT
    strftime('%Y-%m', datetime(time_created/1000, 'unixepoch')) as month,
    COUNT(*) as sessions,
    SUM(tokens_input) as total_input,
    SUM(tokens_output) as total_output,
    SUM(cost) as total_cost
  FROM session
  WHERE time_created IS NOT NULL
  GROUP BY month
  ORDER BY month
`).all();

// 4. Messages par modèle (détection des changements intra-session)
const msgByModel = db.prepare(`
  SELECT
    json_extract(m.data, '$.model.providerID') as provider,
    json_extract(m.data, '$.model.modelID') as model_id,
    COUNT(*) as messages
  FROM message m
  WHERE json_extract(m.data, '$.model') IS NOT NULL
  GROUP BY provider, model_id
  ORDER BY COUNT(*) DESC
`).all();

console.log({ global, byModel, monthly, msgByModel });
db.close();

O flag`--experimental-sqlite`É necessário no Node.js 22.x. No Node.js 24+, o módulo é estável e não requer mais nenhum sinalizador.

Os Resultados: 73 Dias de Consumo

Visão Global

Métrica Valor Contexto

Sessões OpenCode

1 022

~14 sessões por dia em média

tokens de entrada

2,62 bilhões

Dont 94,5M em acertos de cache

Tokens Output

21 milhões

Ratio input/output ~125:1

Tokens Reasoning

141 000

Negligível — quase nenhum pensamento

Custo da API externa

\$0,22

Custos fora da assinatura (Gemini + free tiers)

Este número de $0,22 é crucial: representa tudo o que eu paguei além da minha assinatura Ollama Cloud Pro. Ou seja, praticamente nada. A assinatura cobre o essencial.

@startuml
skinparam backgroundColor #FEFEFE
skinparam defaultFontSize 12

title Evolução Mensual — Entrada de tokens
rectangle "Março 2026\n9 sessões\n37,7M tokens" as MARS #FFE082
rectangle "Abril 2026\n486 sessões\n1,33 Md tokens" as AVR #81C784
rectangle "Maio 2026\n527 sessões\n1,25 Md tokens" as MAI #64B5F6

MARS -right-> AVR : (No text provided for translation.)
AVR -right-> MAI : estável (período em curso)

note bottom of MAI
Maio contabilizado até o dia 18.
Projeção do mês completo: ~2,1 Md tokens
se a tendência se manter.
end note
@enduml

O decolagem entre março e abril é espetacular: ×35 em um mês. É a transição do uso « teste » para o uso « produção » — quando comecei a fazer rodar agentes OpenCode continuamente para meus plugins Gradle.

Ventilação por Modelo e Fornecedor

O campo`model`da mesa`session`sendo JSON,`json_extract()`permite ventilar adequadamente :

Modelo × Provider Sessões [No output, as no French text was provided for translation] Output Custo

deepseek-v4-pro @ ollama-cloud

63

220 M

1,94 M

\$0

deepseek-v4-pro @ ollama-b

124

463 M

4,15 M

\$0

deepseek-v4-pro @ ollama

100

252 M

2,25 M

\$0

deepseek-v4-flash-free @ opencode

16

1,3 M

279 K

\$0

qwen3.6-plus-free @ opencode

1

369 K

25 K

\$0

gemini-2.5-flash @ google

1

211 K

19 K

\$0,04

Três provedores diferentes para exatamente o mesmo modelo DeepSeek V4 Pro : * ollama-cloud→ via assinatura Pro paga (cloud gerenciado por Ollama) * ollama-b→ segunda assinatura Pro, isolado em um contêiner Docker separado * ollama→ instance native locale, gratuita (executa diretamente na minha máquina) O somatório das três dá 936M de entrada, 8,4M de saída — é o meu consumo total DeepSeek V4 Pro, todos os provedores combinados. Só`ollama-cloud`(220M input) custa uma assinatura. Os 716M restantes são gratuitos (local ou acúmulo de assinaturas).

Os Modelos Intra-Sessão: O Que a Tabela de Sessão Não Vê

A mesa`session`Captura apenas o modelo principal da sessão. Mas durante a mesma sessão, um agente OpenCode pode alternar entre vários modelos. A tabela`message`o revela :

Modèles utilisés dans les messages (ollama-cloud provider) :
├─ deepseek-v4-pro      1 441 msgs  (32%)
├─ qwen3.5:397b         1 217 msgs  (27%)
├─ glm-5.1                712 msgs  (16%)
├─ kimi-k2.6:cloud        634 msgs  (14%)
├─ qwen3-coder:480b       414 msgs   (9%)
├─ gpt-oss:20b             34 msgs  (0,8%)
├─ qwen3-coder-next        27 msgs  (0,6%)
└─ gemma4:31b               7 msgs  (0,2%)

Não uso mais Qwen, GLM, Kimi nem os outros modelos. Eles aparecem no histórico porque testei muitas coisas em abril. Desde meados de maio, estou bloqueado no DeepSeek V4 Pro — é o único que sustenta a carga em contextos longos com governança de agente (cf. minha comparação Kimi/GLM/DeepSeek). Os 32% de mensagens deepseek no histórico são enganosos: hoje é 100%.

Comparativo Tarifário — Fornecedores Ocidentais

A questão que fere : quanto custaria esse mesmo consumo junto aos fornecedores tradicionais?

Minha base de cálculo para o comparativo :220M tokens de entrada + 1,9M tokens de saída— apenas o volume passado por`ollama-cloud`(o único que corresponde ao meu plano pago). Os 716M restantes são gratuitos (Ollama local e instância Docker B).

fornecedor Modelo \$/M Output \$/M Custo/mês × minha assinatura

Minha configuração

DeepSeek V4 Pro

0

0

\~20€

1×

Anthropic — Claude

Modelo $/M Saída \$/M Custo/mês × minha assinatura

Opus 4.7

\$5

\$25

\$1 148

57×

Soneto 4.6

\$3

\$15

\$689

34×

Haiku 4.5

\$1

\$5

\$230

11×

Mesmo o Haiku 4.5, o modelo mais « econômico » da Claude, custa 11× a minha assinatura. E ele não sabe nada do meu código base, não gera nada no meu estilo e alucina nas APIs Gradle Kotlin DSL.

OpenAI — GPT

Modelo $/M Sortie \$/M Custo/mês × minha assinatura

GPT 5.5

\$5

\$30

\$1 157

58×

GPT 5.4

\$2,50

\$15

\$579

29×

GPT 5.4 Mini

\$0,75

\$4,50

\$174

9×

Google — Gemini

Modelo $/M Saída \$/M Custo/mês minha assinatura

Gemini 3.1 Pro

\$2,00

\$10

\$459

23×

Gemini 3 Flash

\$0,30

\$1,50

\$69

3,5×

Gemini 3 Flash a 69€ é o único concorrente « próximo » em preço puro — mas é um modelo denso leve, não um MoE 1.6T como o DeepSeek V4 Pro. A qualidade do código gerado não tem nada a ver.

Provedores de Inferência HuggingFace

HuggingFace não realiza inferência por conta própria — ele agrega fornecedores terceiros (Novita, Together, DeepInfra, Cerebras, SambaNova, Fireworks, Groq…) via uma API unificada. Escolhe-se o fornecedor mais barato ou o mais rápido. Os tarifos coletados em maio de 2026 para DeepSeek V4 Pro são os seguintes:

Provedor HF $/M Preservar TODO os spans de código entre crases (…​) exatamente como estão — nunca modifique o conteúdo, o espaçamento ou a posição das crases. Este texto pode ser um fragmento de uma frase maior — traduza o fragmento sem solicitar mais contexto. Apresente apenas o texto traduzido — sem explicação, sem comentário, sem introdução, sem alternativas, sem opções. Saída \$/M Custo/mês × minha assinatura

Novita (o mais barato)

\$1,67

\$3,38

$374

19×

DeepInfra

\$1,74

\$3,48

$389

19×

junto

\$2,10

\$4,40

$470

23×

Fogos de artifício

tarifa não pública

—

(Empty)

—

Mesmo o provedor mais barato na HuggingFace (Novita) cobra 19× o preço da minha assinatura. E, ao contrário do Ollama Cloud, a HuggingFace também cobra em mais as tarifas de plataforma se você não tiver uma assinatura PRO HF ($9/mês).

Groq

Groq não tem nenhum dos modelos que eu uso — o catálogo deles se limita a GPT-OSS, Llama e Qwen 32B. Impossível de comparar.

Comparativo Tarifário — Fornecedores Chineses

O verdadeiro teste é o mercado chinês. Se o DeepSeek é um modelo chinês, a sua API nativa deveria ser mais barata, não é?

DeepSeek API Direct (platform.deepseek.com)

Período $/M Saída \$/M Custo/mês

Promo -75% (fim 31 de maio)

\$0,435

\$0,87

$98

Tarifa cheia (a partir de junho)

\$1,74

\$3,48

\$390

Mesmo com a promo agressiva da DeepSeek (-75% prolongada), a API direta custa5 vezesmais caro. À tarifa normal,20×. E isso é apenas DeepSeek — sem acesso a outros modelos.

Kimi Moonshot (platform.kimi.com)

Kimi apenas oferece seus próprios modelos. Sem DeepSeek.

Alibaba Bailian (bailian.aliyun.com)

Somente fornecedor que agrega todos os modelos chineses — mas por meio de revenda com margem. Os preços são carregados dinamicamente em JavaScript, tornando o scraping impossível.

Tabela Resumo — Todos Providers

Fornecedor Modelo $/M Saída \$/M Custo/mês × minha assinatura

Ollama Nuvem Pro

DeepSeek V4 Pro

0

0

~20€

1×

Gemini 3 Flash

Gemini 3 Flash

\$0,30

\$1,50

\$69

3,5×

API DeepSeek (promo)

DeepSeek V4 Pro

\$0,44

\$0,87

\$98

5×

GPT 5.4 Mini

GPT 5.4 Mini

\$0,75

\$4,50

\$174

9×

Claude Haiku 4.5

Claude Haiku 4.5

\$1

\$5

\$230

11×

HuggingFace/Novita

DeepSeek V4 Pro

\$1,67

\$3,38

\$374

19×

DeepSeek API (normal)

DeepSeek V4 Pro

\$1,74

\$3,48

\$390

20×

Together AI

DeepSeek V4 Pro

\$2,10

\$4,40

\$470

23×

GPT 5.4

GPT 5.4

\$2,50

\$15

\$579

29×

Claude Sonnet 4.6

Claude Sonnet 4.6

\$3

\$15

\$689

34×

Claude Opus 4.7

Claude Opus 4.7

\$5

\$25

\$1 148

57×

GPT 5.5

GPT 5.5

\$5

\$30

\$1 157

58×

@startuml
skinparam backgroundColor #FEFEFE
skinparam defaultFontSize 11

title Custo Mensal Projetado — 220M Input + 1,9M Output
rectangle "Ollama Cloud Pro\n~20€" as OC #4CAF50
rectangle "Gemini Flash\n\$69" as GF #8BC34A
rectangle "DeepSeek promo\n\$98" as DSP #FFC107
rectangle "GPT Mini\n\$174" as GM #FF9800
rectangle "Claude Haiku\n\$230" as CH #FF5722
rectangle "HF/Novita\n\$374" as HF #F44336
rectangle "DeepSeek normal\n\$390" as DSN #F44336
rectangle "GPT 5.4\n\$579" as G4 #D32F2F
rectangle "Claude Sonnet\n\$689" as CS #D32F2F
rectangle "Claude Opus\n\$1 148" as CO #B71C1C
rectangle "GPT 5.5\n\$1 157" as G5 #880E4F

note bottom of OC
DeepSeek V4 Pro 1.6T MoE
+ acesso a todo o catálogo
Ollama Cloud (Qwen, GLM, Kimi...)
Incluído na assinatura
end note
@enduml

O Custo Oculto : Engenharia de Prompts e Iterações

O custo do token é apenas uma parte da equação. O verdadeiro custo é o tempo do desenvolvedor.

Com o OpenCode + Ollama Cloud Pro + meu agente de governança (EAGER/LAZY/Hot/Warm/Cold, descrito em o artigo sobre governança), obtenho:

  • 0 prompt engineering repetitivo: o contexto é injetado automaticamente

  • 90%+ de acerto na primeira tentativa: o código compila de primeira

  • Zero alucinação deepseek em 8 sessões consecutivas(documentado em la comparaison Kimi/GLM/DeepSeek)

Com Claude ou GPT sem ajuste fino nem governança:

  • 2-3 iterações por tarefa em média

  • Prompt engineering sistemática

  • Alucinações nas APIs Kotlin/Gradle assim que o contexto ultrapassar 30K tokens

O custo « efetivo » mensal — tokens × iterações × tempo de correção — é de 27× a 54× o da minha solução, como eu demonstrei no artigo sobre a relação de eficiência.

_ Não é apenas uma questão de preço por token. Um Claude Opus a 57× o preço que requer 3× mais iterações, resultando em um custo efetivo ~170× maior. Para falar francamente: pagar a um estagiário o salário de um parceiro da McKinsey. _

Acumular as Assinaturas Ollama Cloud Pro: O Método Docker

Se uma única assinatura não for suficiente, acumulamos‑nas. O princípio é isolar cada assinatura em sua própria instalação Ollama, com sua própria chave SSH de autenticação. Docker torna isso trivial.

O método completo está detalhado em o artigo sobre o cumul Docker, aqui está o princípio :

@startuml
skinparam backgroundColor #FEFEFE
skinparam defaultFontSize 12

title Arquitetura — Duas Assinaturas Ollama Cloud Pro em Uma Máquina
left to right direction

node "Minha Máquina Física" {
  frame "Instância Ollama A (nativa)\nporta :11434" as Native {
    database "Identidade A\n/usr/share/ollama/.ollama/id_ed25519"
  }
  frame "Instância Ollama B (Docker)\nporta :11435" as Docker {
    database "Identidade B\n~/ollama-b-data/id_ed25519"
  }
}

cloud "Ollama Cloud" {
  actor "Conta Pro A\n(email 1)" as A
  actor "Conta Pro B\n(email 2)" as B
}

Native --> A : "Device Key A"
Docker --> B : "Device Key B"

note bottom of Docker
Contentor Docker isolado:
- Chave SSH distinta
- Porta de rede distinta (11435)
- Volume persistente (~/ollama-b-data)
- restart: always
end note
@enduml

O padrão é simples :

  1. Criar um volume`~/ollama-b-data`

  2. Iniciar um contêiner Docker`ollama/ollama:0.20.2`mapeado em`11435:11434`

  3. Recuperar a chave SSH do contêiner → registrá‑la em ollama.com

  4. fazer`ollama signin`com um segundo e-mail

  5. Configurar OpenCode com dois providers (`ollama`em :11434,`ollama-b`em :11435)

Duas contas, um cartão azul, zero conflito.

O Que a Auditoria Não Mede

Ponto cego Impacto

Qualidade do código produzido

2,6 bilhões de tokens não dizem se o código compila. As minhas 8 sessões DeepSeek V4 Pro têm uma taxa de first-shot >90%.

Ecossistema OpenCode

O CLI é gratuito, mas o seu valor (agentes, sandboxes, histórico, caching de prompt) é imenso. Não está incluído no preço da assinatura — é uma ferramenta separada.

Custo de oportunidade

Passar 2h/dia depurando as alucinações de um modelo inferior custa mais caro do que 20€/mês.

Tranquilidade de espírito

Tarifa fixa = sem surpresa. Com o modelo de preço por token, um pico de atividade pode fazer muito mal.

Os preços citados são os de maio de 2026. Daqui a seis meses, tudo terá baixado. Mas a relação de força estrutural — assinatura fixa vs pagamento por uso — permanecerá favorável à assinatura para os grandes consumidores.

Conclusão: O Veredito dos Números

Depois de 73 dias, 1 022 sessões OpenCode e 2,6 bilhões de tokens:

Métrica veredicto

Custo acumulado da API externa

$0,22(quase nulo)

Custo assinatura Ollama Cloud Pro

~20€/mês

Equivalente Claude Opus

\$1 148/mês— 57 vezes mais caro

Equivalente GPT 5.5

$1 157/mês— 58 vezes mais caro

Equivalente HuggingFace/Novita

$374/mês— 19× mais caro

Equivalente direto da API DeepSeek

\$390/mês— 20 vezes mais caro

Equivalente mais barato (Gemini Flash)

\$69/mês— 3,5× mais caro, modelo inferior

Melhor oferta do mercado

Ollama Cloud Pro por 20€/mês— invencível

__ A 20€ por mês para acessar o DeepSeek V4 Pro (1.6T params, MoE, CSA+HCA, 1M contexto) via Ollama Cloud, tenho a melhor relação custo-benefício do mercado mundial. Mesmo os fornecedores chineses diretos são 5× a 20× mais caros. Mesmo o HuggingFace, com sua agregação de providers low-cost, é 19× mais caro. O mercado ocidental (Claude, GPT) está em 50-60× — outro planeta.

Esta razão é tão desequilibrada que não pode durar para sempre. Aproveite enquanto isso existir. __

Então sim, meus 20 reais por mês, é o melhor investimento técnico da minha vida de desenvolvedor. E agora você tem os números para provar isso.


Artigos relacionados