Audit de ma Consommation LLM : SQLite, OpenCode, Ollama Cloud, et Pourquoi Mon Abonnement Pro Éclate le Marché Mondial
Publié le 18 May 2026
- 1. Comprendre la Stack : Qui Fait Quoi ?
- 2. Introduction : Pourquoi un Audit ?
- 3. La Base de Données OpenCode : Une Mine d’Or
- 4. Les Résultats : 73 Jours de Consommation
- 5. Comparatif Tarifaire — Fournisseurs Occidentaux
- 6. Comparatif Tarifaire — Fournisseurs Chinois
- 7. Tableau Récapitulatif — Tous Providers
- 8. Le Coût Caché : Prompt Engineering et Itérations
- 9. Cumuler les Abonnements Ollama Cloud Pro : La Méthode Docker
- 10. Ce Que l’Audit Ne Mesure Pas
- 11. Conclusion : Le Verdict des Chiffres
- 12. Références
On me demande souvent combien coûte ma consommation d’IA. Je réponds « 20 balles par mois » et on me regarde avec des yeux ronds. Alors aujourd’hui, je vous ouvre la boîte noire. Cet article est l’audit complet de mes 73 jours de vibe coding : la méthodologie pour extraire les données depuis la base SQLite d’OpenCode, le code SQL pour interroger les tables, et la comparaison exhaustive avec tous les fournisseurs du marché — occidentaux comme chinois. Le résultat est tellement asymétrique que j’ai dû vérifier mes calculs trois fois.
1. Comprendre la Stack : Qui Fait Quoi ?
Avant de plonger dans les chiffres, clarifions l’architecture. Il y a trois acteurs distincts dans mon setup, et c’est important de ne pas les confondre :
|
OpenCode n’est PAS un fournisseur de modèles. C’est un CLI open source (github.com/anomalyco/opencode) qui orchestre des agents IA. Il ne vend pas d’abonnement, il ne fournit pas d’inférence. C’est l’équivalent de Ollama Cloud est le fournisseur d’inférence. Mon installation locale d’Ollama agit comme client — elle s’authentifie auprès des serveurs d’Ollama via une clé SSH unique (Device Key) et leur délègue l’exécution des modèles tagués |
2. Introduction : Pourquoi un Audit ?
Il y a deux mois, j’utilisais des modèles gratuitement sur mon installation locale d’Ollama. Puis j’ai souscrit un premier abonnement Ollama Cloud Pro à 20€/mois, qui me permet d’utiliser les modèles cloud (ceux avec le tag :cloud) via le provider ollama-cloud. Un deuxième abonnement a suivi un mois plus tard, sur une instance Docker séparée avec son propre compte et sa propre clé SSH — la méthode de cumul décrite dans mon article sur le cumul d’abonnements.
La question qui me taraudait : est-ce que ces 20€ par mois sont justifiés ? Pas au doigt mouillé. Avec des chiffres.
Pour répondre, j’avais besoin de données précises. Pas des estimations. Pas des moyennes. Ma consommation réelle, token par token, modèle par modèle, session par session.
Et OpenCode — le CLI — stocke tout ça dans une base SQLite.
3. La Base de Données OpenCode : Une Mine d’Or
OpenCode persiste l’intégralité de l’historique de ses sessions dans un fichier SQLite situé à ~/.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.db3.1. Le Schéma
La base contient une vingtaine de tables, mais trois d’entre elles sont cruciales pour notre audit :
La table session est parfaite pour un audit global : chaque session a son décompte de tokens agrégé, son modèle utilisé, et son coût. Le champ model est du JSON brut :
{
"id": "deepseek-v4-pro:cloud",
"providerID": "ollama-cloud",
"variant": "default"
}|
Le champ |
3.2. Le Code d’Extraction
Pas besoin d’installer quoi que ce soit. Node.js 22+ intègre un module SQLite expérimental (node:sqlite) qui fonctionne parfaitement. Voici le script qui m’a tout donné :
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();|
Le flag |
4. Les Résultats : 73 Jours de Consommation
4.1. Vue Globale
| Métrique | Valeur | Contexte |
|---|---|---|
Sessions OpenCode |
1 022 |
~14 sessions/jour en moyenne |
Tokens Input |
2,62 milliards |
Dont 94,5M en cache hit |
Tokens Output |
21 millions |
Ratio input/output ~125:1 |
Tokens Reasoning |
141 000 |
Négligeable — quasi pas de thinking |
Coût API externe |
\$0,22 |
Frais hors abonnement (Gemini + free tiers) |
Ce chiffre de \$0,22 est crucial : il représente tout ce que j’ai payé en plus de mon abonnement Ollama Cloud Pro. C’est-à-dire quasiment rien. L’abonnement couvre l’essentiel.
Le décollage entre mars et avril est spectaculaire : ×35 en un mois. C’est la transition de l’usage « test » à l’usage « production » — quand j’ai commencé à faire tourner des agents OpenCode en continu pour mes plugins Gradle.
4.2. Ventilation par Modèle et Fournisseur
Le champ model de la table session étant du JSON, json_extract() permet de ventiler proprement :
| Modèle × Provider | Sessions | Input | Output | Coût |
|---|---|---|---|---|
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 |
|
Trois providers différents pour exactement le même modèle DeepSeek V4 Pro :
La somme des trois donne 936M input, 8,4M output — c’est ma conso totale DeepSeek V4 Pro, tous providers confondus. Seul |
4.3. Les Modèles Intra-Session : Ce Que la Table Session Ne Voit Pas
La table session ne capture que le modèle principal de la session. Mais pendant une même session, un agent OpenCode peut basculer entre plusieurs modèles. La table message le révèle :
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%)|
Je n’utilise plus Qwen, GLM, Kimi ni les autres modèles. Ils apparaissent dans l’historique parce que j’ai testé pas mal de choses en avril. Depuis mi-mai, je suis verrouillé sur DeepSeek V4 Pro — c’est le seul qui tient la charge sur du long contexte avec gouvernance agent (cf. ma comparaison Kimi/GLM/DeepSeek). Les 32% de messages deepseek dans l’historique sont trompeurs : aujourd’hui c’est 100%. |
5. Comparatif Tarifaire — Fournisseurs Occidentaux
La question qui fâche : combien coûterait cette même consommation chez les fournisseurs traditionnels ?
Ma base de calcul pour le comparatif : 220M tokens input + 1,9M tokens output — uniquement le volume passé par ollama-cloud (le seul qui correspond à mon abonnement payant). Les 716M restants sont gratuits (Ollama local et instance Docker B).
| Fournisseur | Modèle | Input \$/M | Output \$/M | Coût/mois | × mon abonnement |
|---|---|---|---|---|---|
Mon setup |
DeepSeek V4 Pro |
0 |
0 |
\~20€ |
1× |
5.1. Anthropic — Claude
| Modèle | Input \$/M | Output \$/M | Coût/mois | × mon abonnement |
|---|---|---|---|---|
Opus 4.7 |
\$5 |
\$25 |
\$1 148 |
57× |
Sonnet 4.6 |
\$3 |
\$15 |
\$689 |
34× |
Haiku 4.5 |
\$1 |
\$5 |
\$230 |
11× |
Même Haiku 4.5, le modèle le plus « économique » de Claude, coûte 11× mon abonnement. Et il ne connaît rien de mon codebase, ne génère pas dans mon style, et hallucine sur les APIs Gradle Kotlin DSL.
5.2. OpenAI — GPT
| Modèle | Input \$/M | Output \$/M | Coût/mois | × mon abonnement |
|---|---|---|---|---|
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× |
5.3. Google — Gemini
| Modèle | Input \$/M | Output \$/M | Coût/mois | × mon abonnement |
|---|---|---|---|---|
Gemini 3.1 Pro |
\$2,00 |
\$10 |
\$459 |
23× |
Gemini 3 Flash |
\$0,30 |
\$1,50 |
\$69 |
3,5× |
Gemini 3 Flash à 69€ est le seul concurrent « proche » en prix pur — mais c’est un modèle dense léger, pas un MoE 1.6T comme DeepSeek V4 Pro. La qualité du code généré n’a rien à voir.
5.4. HuggingFace Inference Providers
HuggingFace ne fait pas d’inférence lui-même — il agrège des providers tiers (Novita, Together, DeepInfra, Cerebras, SambaNova, Fireworks, Groq…) via une API unifiée. On choisit le provider le moins cher ou le plus rapide. Voici les tarifs relevés en mai 2026 pour DeepSeek V4 Pro :
| Provider HF | Input \$/M | Output \$/M | Coût/mois | × mon abonnement |
|---|---|---|---|---|
Novita (le moins cher) |
\$1,67 |
\$3,38 |
\$374 |
19× |
DeepInfra |
\$1,74 |
\$3,48 |
\$389 |
19× |
Together |
\$2,10 |
\$4,40 |
\$470 |
23× |
Fireworks |
tarif non public |
— |
— |
— |
Même le provider le moins cher sur HuggingFace (Novita) facture 19× le prix de mon abonnement. Et contrairement à Ollama Cloud, HuggingFace facture en plus les frais de plateforme si vous n’avez pas d’abonnement PRO HF (\$9/mois).
5.5. Groq
Groq n’a aucun des modèles que j’utilise — leur catalogue se limite à GPT-OSS, Llama et Qwen 32B. Impossible de comparer.
6. Comparatif Tarifaire — Fournisseurs Chinois
Le vrai test, c’est le marché chinois. Si DeepSeek est un modèle chinois, son API native devrait être moins chère, non ?
6.1. DeepSeek API Direct (platform.deepseek.com)
| Période | Input \$/M | Output \$/M | Coût/mois |
|---|---|---|---|
Promo -75% (fin 31 mai) |
\$0,435 |
\$0,87 |
\$98 |
Plein tarif (à partir de juin) |
\$1,74 |
\$3,48 |
\$390 |
Même avec la promo agressive de DeepSeek (-75% prolongée), l’API directe coûte 5× plus cher. Au tarif normal, 20×. Et c’est uniquement DeepSeek — pas d’accès à d’autres modèles.
6.2. Kimi Moonshot (platform.kimi.com)
Kimi ne propose que ses propres modèles. Pas de DeepSeek.
6.3. Alibaba Bailian (bailian.aliyun.com)
Seul fournisseur qui agrège tous les modèles chinois — mais via revente avec marge. Les prix sont chargés dynamiquement en JavaScript, rendant le scraping impossible.
7. Tableau Récapitulatif — Tous Providers
| Fournisseur | Modèle | Input \$/M | Output \$/M | Coût/mois | × mon abonnement |
|---|---|---|---|---|---|
Ollama Cloud Pro |
DeepSeek V4 Pro |
0 |
0 |
~20€ |
1× |
Gemini 3 Flash |
Gemini 3 Flash |
\$0,30 |
\$1,50 |
\$69 |
3,5× |
DeepSeek API (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× |
8. Le Coût Caché : Prompt Engineering et Itérations
Le coût token n’est qu’une partie de l’équation. Le vrai coût, c’est le temps développeur.
Avec OpenCode + Ollama Cloud Pro + ma gouvernance agent (EAGER/LAZY/Hot/Warm/Cold, décrite dans l’article sur la gouvernance), j’obtiens : * 0 prompt engineering répétitif : le contexte est injecté automatiquement * 90%+ first-shot correct : le code compile du premier coup * Zéro hallucination deepseek sur 8 sessions consécutives (documenté dans la comparaison Kimi/GLM/DeepSeek)
Avec Claude ou GPT sans fine-tune ni gouvernance : * 2-3 itérations par tâche en moyenne * Prompt engineering systématique * Hallucinations sur les APIs Kotlin/Gradle dès que le contexte dépasse 30K tokens
Le coût « effectif » mensuel — tokens × itérations × temps de correction — est de 27× à 54× celui de ma solution, comme je l’ai démontré dans l’article sur le ratio d’efficacité.
Ce n’est pas juste une histoire de prix au token. Un Claude Opus à 57× le prix qui nécessite 3× plus d’itérations, c’est un coût effectif ~170× supérieur. Pour le dire crûment : payer un stagiaire le salaire d’un partner McKinsey.
9. Cumuler les Abonnements Ollama Cloud Pro : La Méthode Docker
Si un seul abonnement ne suffit pas, on en cumule. Le principe est d’isoler chaque abonnement dans sa propre installation Ollama, avec sa propre clé SSH d’authentification. Docker rend ça trivial.
La méthode complète est détaillée dans l’article sur le cumul Docker, voici le principe :
Le pattern est simple :
. Créer un volume ~/ollama-b-data
. Lancer un conteneur Docker ollama/ollama:0.20.2 mappé sur 11435:11434
. Récupérer la clé SSH du conteneur → l’enregistrer sur ollama.com
. Faire ollama signin avec un deuxième email
. Configurer OpenCode avec deux providers (ollama sur :11434, ollama-b sur :11435)
Deux comptes, une carte bleue, zéro conflit.
10. Ce Que l’Audit Ne Mesure Pas
| Angle mort | Impact |
|---|---|
Qualité du code produit |
2,6 milliards de tokens ne disent pas si le code compile. Mes 8 sessions DeepSeek V4 Pro ont un taux de first-shot >90%. |
Écosystème OpenCode |
Le CLI est gratuit, mais sa valeur (agents, sandboxes, historique, prompt caching) est immense. Il n’est pas inclus dans le prix de l’abonnement — c’est un outil séparé. |
Coût d’opportunité |
Passer 2h/jour à debugger des hallucinations d’un modèle inférieur coûte plus cher que 20€/mois. |
Tranquillité d’esprit |
Forfait fixe = pas de surprise. Avec du per-token, un pic d’activité peut faire très mal. |
|
Les prix cités sont ceux de mai 2026. Dans six mois, tout aura baissé. Mais le rapport de force structurel — abonnement fixe vs paiement à l’usage — restera favorable à l’abonnement pour les gros consommateurs. |
11. Conclusion : Le Verdict des Chiffres
Après 73 jours, 1 022 sessions OpenCode, et 2,6 milliards de tokens :
| Métrique | Verdict |
|---|---|
Coût API externe cumulé |
\$0,22 (quasi nul) |
Coût abonnement Ollama Cloud Pro |
~20€/mois |
Équivalent Claude Opus |
\$1 148/mois — 57× plus cher |
Équivalent GPT 5.5 |
\$1 157/mois — 58× plus cher |
Équivalent HuggingFace/Novita |
\$374/mois — 19× plus cher |
Équivalent DeepSeek API direct |
\$390/mois — 20× plus cher |
Équivalent le moins cher (Gemini Flash) |
\$69/mois — 3,5× plus cher, modèle inférieur |
Meilleure offre du marché |
Ollama Cloud Pro à 20€/mois — imbattable |
À 20€ par mois pour accéder à DeepSeek V4 Pro (1.6T params, MoE, CSA+HCA, 1M contexte) via Ollama Cloud, j’ai le meilleur rapport qualité/prix du marché mondial. Même les fournisseurs chinois en direct sont 5× à 20× plus chers. Même HuggingFace, avec son agrégation de providers low-cost, est 19× plus cher. Le marché occidental (Claude, GPT) est à 50-60× — une autre planète.
Ce ratio est tellement déséquilibré qu’il ne peut pas durer éternellement. Profitez-en tant que ça existe.
Alors oui, mes 20 balles par mois, c’est le meilleur investissement technique de ma vie de développeur. Et maintenant vous avez les chiffres pour le prouver.