Audit van mijn LLM‑consumptie : SQLite, OpenCode, Ollama Cloud, en waarom mijn pro‑abonnement de wereldwijde markt opschudt
Gepubliceerd op 18 May 2026
- De stack begrijpen: Wie doet wat?
- Inleiding: Waarom een audit?
- De OpenCode-database: Een goudmijn
- De Resultaten : 73 Dagen van Consumptie
- Tariefvergelijking — Westerse leveranciers
- Tariefvergelijking — Chinese leveranciers
- Samenvattende tabel — Alle Providers
- De Verborgen Kosten : Prompt Engineering en Iteraties
- De Ollama Cloud Pro-abonnementen combineren: de Docker-methode
- Wat de audit niet meet
- Conclusie: Het verdict van de cijfers
- Referenties
Men vraagt me vaak hoeveel mijn AI-gebruik kost. Ik antwoord: '20 ballen per maand' en men kijkt me aan met grote ogen. Dus vandaag open ik voor jullie de zwarte doos. Dit artikel is het volledige audit van mijn 73 dagen vibe coding: de methodologie om de gegevens te extraheren uit de SQLite-database van OpenCode, de SQL-code om de tabellen te bevragen, en de uitgebreide vergelijking met alle leveranciers op de markt — westers als Chinees. Het resultaat is zo asymmetrisch dat ik mijn berekeningen drie keer moest controleren.
De stack begrijpen: Wie doet wat?
Voordat we in de cijfers duiken, laten we de architectuur verduidelijken. Er zijn drie verschillende actoren in mijn setup, en het is belangrijk om ze niet te verwarren:
@startuml
skinparam backgroundColor #FEFEFE
skinparam defaultFontSize 12
title De Drie Actoren van Mijn Stack LLM
left to right direction
actor "Ik (Ontwikkelaar)" as Dev
package "OpenCode\n(github.com/anomalyco/opencode)" as OC {
rectangle "CLI van vibe coding\nOpen source, gratis" as CLI
note right of CLI
Dit is het hulpmiddel dat ik gebruik
voor te coderen met AI‑agents.
Het biedt geen AUCUN model.
Dat is een terminal + een orchestrator
end note
}
package "Ollama (Lokale installatie)" as OL {
rectangle "Inferentieclient\nGeïnstalleerd op mijn machine" as Client
note right of Client
Het is de software die draait
Modellen. Hij kan ze uitvoeren
lokaal OF delegeren naar de cloud
op basis van het tag (:cloud).
Hij authentiseert met behulp van sleutel SSH
end note
}
package "Ollama Cloud\n(ollama.com)" as OCloud {
rectangle "Cloud-inferentieservice\nPro-abonnement : 20€/mois" as Cloud
note right of Cloud
Dit is de inferentieaanbieder.
Mijn modellen met de tag :cloud
worden uitgevoerd op LEURS servers.
Het Pro-abonnement geeft toegang
aan hogere quota.
end note
}
Dev --> CLI : "Ik typ prompts"
CLI --> Client : "Roep dit model aan"
Client --> Cloud : "Sleutel SSH + vraag\n(modellen :cloud)"
Client --> Client : "Lokale uitvoering\n(modellen zonder :cloud)"
@enduml
|
OpenCode is NIET een leverancier van modellen.Dit is een open source CLI (github.com/anomalyco/opencode) die AI-agents orchestreert. Hij verkoopt geen abonnement en levert geen inferentie. Dit is het equivalent van`git`voor versiebeheer: een hulpmiddel, geen dienst. Ollama Cloud is de inferentieprovider.Mijn lokale Ollama-installatie fungeert als client — ze authenticeren bij de Ollama-servers via een unieke SSH-sleutel (Device Key) en delegeert de uitvoering van de gelabelde modellen aan hen. |
Inleiding: Waarom een audit?
Twee maanden geleden gebruikte ik gratis modellen op mijn lokale Ollama-installatie. Daarna sloot ik een eerste abonnement af op Ollama Cloud Pro van 20 euro per maand, waardoor ik de cloudmodellen kan gebruiken (die met de tag`:cloud`) via de provider`ollama-cloud`. Een tweede abonnement volgde een maand later op een gescheiden Docker-instantie met zijn eigen account en eigen SSH-sleutel — de cumulatieve methode beschreven in mijn artikel over het stapelen van abonnementen
De vraag die me bezighield : Zijn deze 20 € per maand gerechtvaardigd? Niet op gevoel. Met cijfers.
Om te antwoorden, had ik precieze gegevens nodig. Geen schattingen. Geen gemiddelden. Mijn echte consumptie, token per token, model per model, sessie per sessie.
En OpenCode — de CLI — slaat dit alles op in een SQLite-database.
De OpenCode-database: Een goudmijn
OpenCode slaat de volledige geschiedenis van zijn sessies op in een SQLite-bestand dat zich bevindt op`~/.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
Het schema
De database bevat ongeveer twintig tabellen, maar drie daarvan zijn cruciaal voor onze audit :
@startuml
skinparam backgroundColor #FEFEFE
skinparam defaultFontSize 12
title Vereenvoudigd schema — OpenCode SQLite
entity "sessie" 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 "bericht" as M {
* id : TEXT
--
* session_id : TEXT <<FK>>
* data : TEXT (JSON)
* time_created : INTEGER
}
entity "project" as P {
* id : TEXT
--
* worktree : TEXT
* name : TEXT
}
S ||--o{ M : "session_id"
S }o--|| P : "project_id"
note right of S
De sessietabel aggregeert tokens + kosten + model.
Dit is ons belangrijkste ingangspunt.
end note
note right of M
De individuele berichten.
Het data‑veld bevat het gebruikte model (format JSON)
zelfs als de sessie van model verandert onderweg
end note
@enduml
De tafel`session`is perfect voor een globale audit: elke sessie heeft zijn geaggregeerde aantal tokens, zijn gebruikte model en zijn kosten. Het veld`model`is ruwe JSON :
{
"id": "deepseek-v4-pro:cloud",
"providerID": "ollama-cloud",
"variant": "default"
}
|
Het veld`cost`in de OpenCode-database weerspiegelt alleen de externe API-kosten betaald per gebruik via API-sleutel (Google Gemini, OpenAI, enz.). De aanroepen via Ollama — zowel lokaal als via Ollama Cloud Pro — zijn gemarkeerd`cost=0`omdat de kosten vastliggen (abonnement), niet per-token. De echte kosten van deze gesprekken zijn het maandelijkse abonnement. |
De extractiecode
Je hoeft niets te installeren. Node.js 22+ bevat een experimenteel SQLite-module (node:sqlite) die perfect werkt. Dit is het script dat mij alles heeft gegeven:
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();
|
De vlag`--experimental-sqlite`Op Node.js 22.x is vereist. Op Node.js 24+ is het module stabiel en vereist geen vlag meer. |
De Resultaten : 73 Dagen van Consumptie
Globale weergave
| metriek | Waarde | Context |
|---|---|---|
Sessions OpenCode |
1 022 |
~14 sessies/dag gemiddeld |
Tokens invoer |
2,62 miljard |
Waarvan 94,5M cache-hit |
Tokens Output |
21 miljoen |
Ratio input/output ~125:1 |
Tokens Reasoning |
141 000 |
Verwaarloosbaar — bijna geen thinking |
Kosten externe API |
$0,22 |
Kosten buiten abonnement (Gemini + gratis niveaus) |
Dit bedrag van \$0,22 is cruciaal: het vertegenwoordigt alles wat ik heb betaald naast mijn Ollama Cloud Pro-abonnement. Dat wil zeggen, bijna niets. Het abonnement dekt het essentiële.
@startuml skinparam backgroundColor #FEFEFE skinparam defaultFontSize 12 title Maandelijkse evolutie — invoer tokens rectangle "Maart 2026\n9 sessies\n37,7M tokens" as MARS #FFE082 rectangle "April 2026\n486 sessies\n1,33 Md tokens" as AVR #81C784 rectangle "Mei 2026\n527 sessies\n1,25 Md tokens" as MAI #64B5F6 MARS -right-> AVR : ×35 AVR -right-> MAI : stable (huidige periode) note bottom of MAI Mei geteld tot en met de 18e. Projectie volledige maand: ~2,1 Md tokens als de trend zich voortzet. end note @enduml
De lancering tussen maart en april is spectaculair: ×35 in één maand. Dit is de overgang van gebruik « test » naar gebruik « productie » — toen ik begon om OpenCode-agents continu te laten draaien voor mijn Gradle-plugins.
Ventilatie per model en leverancier
Het veld`model`van de tafel`session`zijnde JSON,`json_extract()`maakt het mogelijk om schoon te ventileren:
| Model × Provider | Sessies | Input | Output | Kosten |
|---|---|---|---|---|
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 |
|
Drie verschillende providers voor exact hetzelfde model DeepSeek V4 Pro:
* |
Intra-Sessie-modellen: Wat de Sessietabel niet ziet
De tafel`session`ne vangt alleen het hoofdmodel van de sessie. Maar tijdens dezelfde sessie kan een OpenCode-agent schakelen tussen meerdere modellen. De tabel`message`het onthult:
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%)
|
Ik gebruik niet meer Qwen, GLM, Kimi noch de andere modellen. Ze verschijnen in de geschiedenis omdat ik heel wat dingen heb getest in april. Sinds half mei ben ik geblokkeerd op DeepSeek V4 Pro — het is het enige dat de belasting aankan bij lange contexte met agent governance (cf. mijn vergelijking Kimi/GLM/DeepSeek). De 32% deepseek-berichten in de geschiedenis zijn misleidend: vandaag is het 100%. |
Tariefvergelijking — Westerse leveranciers
De brandende vraag: hoeveel zou dezezelfde consumptie kosten bij traditionele leveranciers?
Mijn berekeningsbasis voor de vergelijking:220M tokens invoer + 1,9M tokens uitvoer— alleen het volume dat is gepasseerd`ollama-cloud`(de enige die overeenkomt met mijn betaalde abonnement). De resterende 716M zijn gratis (lokale Ollama en Docker B-instantie).
| leverancier | model | \$/M | $/M | Kosten/maand | × mijn abonnement |
|---|---|---|---|---|---|
Mijn setup |
DeepSeek V4 Pro |
0 |
0 |
\~20€ |
1× |
Anthropic — Claude
| Model | $/M | Uitvoer $/M | Kosten/maand | × mijn abonnement |
|---|---|---|---|---|
Opus 4.7 |
\$5 |
\$25 |
\$1 148 |
57 keer |
Sonnet 4.6 |
\$3 |
\$15 |
\$689 |
34 keer |
Haiku 4.5 |
\$1 |
\$5 |
\$230 |
11× |
Zelfs Haiku 4.5, het meest 'kostenefficiënte' model van Claude, kost 11× mijn abonnement. En het kent niets van mijn codebase, genereert niet in mijn stijl, en hallucineert over de Gradle Kotlin DSL-APIs.
OpenAI — GPT
| Model | $/M | Output $/M | Kosten/maand | × mijn 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 keer |
Google — Gemini
| Model | \$/M | Uitvoer \$/M | Kosten/maand | mijn abonnement |
|---|---|---|---|---|
Gemini 3.1 Pro |
\$2,00 |
\$10 |
\$459 |
23× |
Gemini 3 Flash |
\$0,30 |
\$1,50 |
\$69 |
3,5× |
Gemini 3 Flash van 69€ is de enige « dichtbij » concurrent in puur prijs — maar het is een lichtgewicht dicht model, geen MoE 1.6T zoals DeepSeek V4 Pro. De kwaliteit van de gegenereerde code heeft niets te maken.
HuggingFace Inferentie-aanbieders
HuggingFace voert zelf geen inferentie uit — het agregateert externe providers (Novita, Together, DeepInfra, Cerebras, SambaNova, Fireworks, Groq…) via een geïntegreerde API. Men kiest de provider die het goedkoopst of het snelst is. Hier zijn de tarieven die in mei 2026 zijn vastgelegd voor DeepSeek V4 Pro :
| Leverancier HF | $/M | Uitvoer \$/M | Kosten/maand | × mijn abonnement |
|---|---|---|---|---|
Novita (het goedkoopst) |
\$1,67 |
\$3,38 |
\$374 |
19× |
DeepInfra |
\$1,74 |
\$3,48 |
$389 |
19× |
Samen |
\$2,10 |
\$4,40 |
$470 |
23× |
vuurwerk |
niet openbaar tarief |
— |
— |
— |
Zelfs de goedkoopste provider op HuggingFace (Novita) vraagt 19× de prijs van mijn abonnement. En in tegenstelling tot Ollama Cloud rekent HuggingFace ook de platformkosten als je geen PRO HF-abonnement hebt ($9/maand).
Groq
Groq heeft geen van de modellen die ik gebruik — hun catalogus beperkt zich tot GPT-OSS, Llama en Qwen 32B. Onmogelijk te vergelijken.
Tariefvergelijking — Chinese leveranciers
De echte test is de Chinese markt. Als DeepSeek een Chinees model is, zou zijn native API goedkoper moeten zijn, niet?
DeepSeek API Direct (platform.deepseek.com)
| periode | \$/M | Uitvoer \$/M | Kosten/maand |
|---|---|---|---|
Promo -75% (eind 31 mei) |
\$0,435 |
\$0,87 |
\$98 |
Vol tarief (vanaf juni) |
\$1,74 |
\$3,48 |
\$390 |
Zelfs met de agressieve promotie van DeepSeek (-75% verlengd), kost de directe API5×duurder. Bij het normale tarief,20 keer. En het is alleen DeepSeek — geen toegang tot andere modellen.
Kimi Moonshot (platform.kimi.com)
Kimi biedt alleen zijn eigen modellen aan. Geen DeepSeek.
Alibaba Bailian (bailian.aliyun.com)
Enkele leverancier die alle Chinese modellen aggregeert — maar via doorverkoop met marge. De prijzen worden dynamisch geladen in JavaScript, waardoor scraping onmogelijk is.
Samenvattende tabel — Alle Providers
| Leverancier | model | $/M | Output $/M | Kosten per maand | × mijn 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 (promotie) |
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 (normaal) |
DeepSeek V4 Pro |
\$1,74 |
\$3,48 |
\$390 |
20× |
Samen 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 Verwachte Maandelijkse Kosten — 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 + toegang tot de volledige catalogus Ollama Cloud (Qwen, GLM, Kimi...) Inbegrepen in het abonnement end note @enduml
De Verborgen Kosten : Prompt Engineering en Iteraties
De tokenkosten zijn slechts een deel van de vergelijking. De echte kosten zijn de ontwikkelertijd.
Met OpenCode + Ollama Cloud Pro + mijn bestuur agent (EAGER/LAZY/Hot/Warm/Cold, beschreven in het artikel over de bestuur), ik krijg :
-
0 prompt engineering repetitief: de context wordt automatisch geïnjecteerd
-
90%+ correct bij eerste pogingde code compileert in één keer
-
Nul hallucinatie deepseek bij 8 opeenvolgende sessies(gedocumenteerd in de vergelijking Kimi/GLM/DeepSeek)
Met Claude of GPT zonder fine-tuning of governance :
-
2-3 iteraties per taak gemiddeld
-
Systematisch prompt engineering
-
Hallucinaties over de Kotlin/Gradle API’s zodra de context 30K tokens overschrijdt
De effectieve maandelijkse kosten — tokens × iteraties × correctietijd — zijn 27× tot 54× die van mijn oplossing, zoals ik heb aangetoond in het artikel over de efficiëntieratio.
_ Het is niet alleen een kwestie van prijs per token. Een Claude Opus die 57× duurder is en 3× meer iteraties vereist, heeft een effectieve kosten die ~170× hoger is. Om het ronduit te zeggen: een stagiaire betalen met het salaris van een McKinsey-partner. _
De Ollama Cloud Pro-abonnementen combineren: de Docker-methode
Als één abonnement niet voldoende is, combineren we ze. Het principe is om elk abonnement te isoleren in zijn eigen Ollama-installatie, met zijn eigen SSH-authenticatiesleutel. Docker maakt het triviaal.
De volledige methode wordt gedetailleerd beschreven in het artikel over het combineren van Docker, hier is het principe :
@startuml
skinparam backgroundColor #FEFEFE
skinparam defaultFontSize 12
title Architectuur — Twee Ollama Cloud Pro-abonnementen op Eén Machine
left to right direction
node "Mijn Fysieke Machine" {
frame "Ollama Instantie A (native)\npoort :11434" as Native {
database "Identiteit A\n/usr/share/ollama/.ollama/id_ed25519"
}
frame "Ollama Instantie B (Docker)\npoort :11435" as Docker {
database "Identiteit B\n~/ollama-b-data/id_ed25519"
}
}
cloud "Ollama Cloud" {
actor "Pro Account A\n(email 1)" as A
actor "Pro Account B\n(email 2)" as B
}
Native --> A : "Device Key A"
Docker --> B : "Device Key B"
note bottom of Docker
Geïsoleerde Docker-container:
- Afzonderlijke SSH-sleutel
- Afzonderlijke netwerkpoort (11435)
- Persistent volume (~/ollama-b-data)
- restart: always
end note
@enduml
Het patroon is simpel:
-
Een volume maken`~/ollama-b-data`
-
Een Docker-container starten`ollama/ollama:0.20.2`gemapt op`11435:11434`
-
Ophalen van de SSH-sleutel van de container → opslaan op ollama.com
-
doen`ollama signin`met een tweede e-mail
-
OpenCode configureren met twee providers (`ollama`op :11434,`ollama-b`op :11435)
Twee rekeningen, één blauwe kaart, geen conflicten.
Wat de audit niet meet
| dode hoek | impact |
|---|---|
Kwaliteit van de geproduceerde code |
2,6 miljard tokens zeggen niet of de code compileert. Mijn 8 sessies DeepSeek V4 Pro hebben een first-shot slagingspercentage >90%. |
ecosysteem OpenCode |
De CLI is gratis, maar de waarde (agents, sandboxes, geschiedenis, prompt caching) is enorm. Het is niet inbegrepen in de prijs van het abonnement — het is een apart hulpmiddel. |
alternatieve kosten |
2 uur per dag besteden aan het debuggen van hallucinaties van een inferieur model kost meer dan €20 per maand. |
Gemoedsrust |
Vast tarief = geen verrassing. Met per-token kan een piek in activiteit ernstig pijn doen. |
|
De genoemde prijzen zijn die van mei 2026. Over zes maanden zal alles zijn gedaald. Maar de structurele krachtverhouding — vast abonnement versus betalen naar gebruik — blijft gunstig voor het abonnement voor grote verbruikers. |
Conclusie: Het verdict van de cijfers
Na 73 dagen, 1.022 OpenCode-sessies, en 2,6 miljard tokens :
| Metrisch | vonnis |
|---|---|
Cumulatieve externe API-kosten |
$0,22(bijna nul) |
Abonnementskosten Ollama Cloud Pro |
~20€/maand |
Claude Opus-equivalent |
\$1 148/maand— 57× duurder |
Equivalent GPT 5.5 |
$1 157/maand— 58 keer duurder |
Gelijkwaardig HuggingFace/Novita |
\$374/maand— 19× duurder |
Direct DeepSeek API-equivalent |
$390 per maand— 20× duurder |
Goedkoopste equivalent |
$69/maand— 3,5× duurder, lager model |
beste aanbod op de markt |
Ollama Cloud Pro voor 20€/maand— onverslaanbaar |
__ Voor 20€ per maand om toegang te krijgen tot DeepSeek V4 Pro (1.6T params, MoE, CSA+HCA, 1M context) via Ollama Cloud, heb ik de beste prijs-kwaliteitverhouding op de wereldwijde markt. Zelfs de rechtstreekse Chinese leveranciers zijn 5× tot 20× duurder. Zelfs HuggingFace, met zijn aggregatie van low-cost providers, is 19× duurder. De westerse markt (Claude, GPT) ligt op 50-60× — een hele andere wereld.
Deze verhouding is zo ongebalanceerd dat hij niet eeuwig kan duren. Geniet ervan zolang het bestaat. __
Dus ja, mijn 20 euro per maand, dat is de beste technische investering in mijn leven als ontwikkelaar. En nu heb je de cijfers om dat te bewijzen.
Referenties
-
Artikel 0119 — Benchmark DGX Spark vs Cloud vs Abonnementen LLM
-
Artikel 0120 — Twee abonnementen combineren voor Ollama Cloud Pro met Docker
-
Artikel 0121 — Gradle-plugin voor het besturen van twee Ollama-instanties