SÉANCE 2 / 8SESSION 2 / 8 ⏱ ≈ 90 min

Le paysage des modèles & la quantificationThe model landscape & quantization

Objectif du jour : ne plus jamais choisir un modèle « au feeling ». À la fin de cette séance, vous savez calculer sur un coin de table si un modèle donné tient dans une mémoire donnée, à quelle précision, avec quelle fenêtre de contexte utile — et vous savez pourquoi Q4_K_M est presque toujours le bon point de départ. Le gain du jour est un calculateur de budget mémoire et une table de décision que vous utiliserez à chaque projet. Today's goal: never pick a model "by feel" again. By the end of this session you can work out on the back of an envelope whether a given model fits in a given memory, at what precision, with what usable context window — and you know why Q4_K_M is almost always the right starting point. Today's win is a memory-budget calculator and a decision table you will use on every project.

Paramètres, précision, octets : l'arithmétique qui décideParameters, precision, bytes: the arithmetic that decides

≈ 20 min

Un paramètre est un nombre (un « poids ») dans le réseau. Un modèle « 8 B » en contient 8 milliards. Chaque poids occupe une certaine précision, exprimée en bits : c'est le seul levier vraiment libre de l'ingénieur, et il détermine à la fois la mémoire et la vitesse. A parameter is a number (a "weight") in the network. An "8 B" model holds 8 billion of them. Each weight occupies a given precision, expressed in bits: that is the engineer's one genuinely free lever, and it determines both memory and speed.

L'échelle des précisionsThe precision ladder

PrécisionPrecision	bits / poidsbits / weight	Poids d'un 8 BSize of an 8 B	UsageUse
FP32	32	~32 Go	Entraînement uniquement. Jamais en inférence.Training only. Never for inference.
FP16 / BF16	16	~16 Go	Référence « pleine précision » pour l'inférence et le fine-tuning.The "full precision" reference for inference and fine-tuning.
INT8 / Q8_0	8	~8 Go	Quasi sans perte. Quand la qualité prime sur le débit.Near-lossless. When quality beats throughput.
INT4 / Q4_K_M	~4,8	~4,9 Go	Le défaut raisonnable. Meilleur compromis qualité/taille/débit.The sensible default. Best quality/size/throughput trade-off.
Q3 / Q2 (INT3/INT2)	3 – 2	~3–2 Go	Dernier recours. Dégradation visible sur le code, le multilingue et le raisonnement.Last resort. Visible degradation on code, multilingual and reasoning.

La formule, et sa vérification sur le labThe formula, and its verification on the lab

taille_poids (Go)  ≈  paramètres × bits_par_poids / 8 / 1e9

bits_par_poids réel =  taille_octets × 8 / paramètres      # inversion, pour auditer

Cette formule n'est pas théorique : on la vérifie sur les modèles réellement installés sur le lab (relevé du 2026-09-18). This formula is not theoretical: we verify it against the models actually installed on the lab (reading of 2026-09-18).

ModèleModel	ParamètresParameters	Quantif. annoncéeDeclared quant	Taille sur disqueOn-disk size	bits/poids calculébits/weight computed
`granite-embedding`	30,15 M	F16	0,06 Go	15,9 ✅ (≈16 = F16)(≈16 = F16)
`mistral:7b`	7,2 B	Q4_K_M	4,37 Go	4,83
`llama3.1:8b`	8,0 B	Q4_K_M	4,92 Go	4,90
`qwen3.8:27b`	27,3 B	Q4_K_M	17,74 Go	5,20

🎯 Ce que la dernière colonne vous apprend : « Q4 » n'est pas une valeur unique. Elle vaut 4,83 bits/poids sur Mistral-7B et 5,20 sur le 27 B — parce que les variantes _K_M gardent certains tenseurs (attention, embeddings) à plus haute précision, et que la proportion de ces tenseurs varie d'une architecture à l'autre. Ne calculez jamais avec « 4 bits » ; auditez la taille réelle du fichier. C'est exactement ce que fait le script du lab. What that last column teaches you: "Q4" is not a single value. It is 4.83 bits/weight on Mistral-7B and 5.20 on the 27 B — because _K_M variants keep some tensors (attention, embeddings) at higher precision, and the proportion of those tensors varies by architecture. Never compute with "4 bits"; audit the real file size. That is exactly what the lab script does.

📚 Sources : spécification GGUF (métadonnées et tenseurs) ; llama.cpp, quantize.cpp (liste des types) ; tailles et comptes de paramètres relevés via l'API Ollama du lab. Sources: GGUF specification (metadata and tensors); llama.cpp, quantize.cpp (type list); sizes and parameter counts read via the lab's Ollama API.

Lire un nom de quantification GGUFReading a GGUF quantization name

≈ 18 min

GGUF est le format de fichier standard de l'écosystème llama.cpp : un conteneur qui porte à la fois les métadonnées du modèle (architecture, nombre de couches, longueur de contexte, tokenizer) et les tenseurs quantifiés. C'est le format que vous trouverez partout — et celui que vous produirez vous-même en séance 8. GGUF is the standard file format of the llama.cpp ecosystem: a container carrying both the model's metadata (architecture, layer count, context length, tokenizer) and the quantized tensors. It is the format you will find everywhere — and the one you will produce yourself in session 8.

Décoder `Q4_K_M`Decoding `Q4_K_M`

FragmentFragment	SignificationMeaning
`Q4`	Environ 4 bits par poids. `Q8` ≈ 8 bits, `Q6` ≈ 6 bits.About 4 bits per weight. `Q8` ≈ 8 bits, `Q6` ≈ 6 bits.
`_K`	Schéma de quantification par blocs avec des échelles apprises (« k-quant »), plus efficace que l'ancien schéma plat.Block-wise quantization scheme with learned scales ("k-quant"), more efficient than the older flat scheme.
`_M`	Mélange « medium » : certains tenseurs sensibles restent à une précision plus élevée. Il existe `_S` (small), `_M`, `_L` (large)."Medium" mix: some sensitive tensors stay at higher precision. There is also `_S` (small), `_M`, `_L` (large).
`IQ*`	« i-quants » : quantification avec codebook, meilleure qualité à très basse précision, mais plus lente à produire et parfois plus lente à exécuter."i-quants": codebook-based quantization, better quality at very low precision, but slower to produce and sometimes slower to run.

✅ Ce que la quantification ne casse presque pasWhat quantization barely breaks Le style rédactionnel, la reformulation, le résumé, la traduction courante, le suivi d'instruction simple, la classification. En dessous de Q4, ces tâches tiennent encore. Writing style, rewriting, summarising, everyday translation, simple instruction following, classification. Even below Q4 these tasks still hold up.

⛔ Ce qui casse en premierWhat breaks first Le code (précision syntaxique), le raisonnement multi-étapes, les langues peu dotées, les faits rares (« long tail »), l'arithmétique, et l'appel d'outils au format strict. Code (syntactic precision), multi-step reasoning, low-resource languages, rare ("long tail") facts, arithmetic, and strict-format tool calling.

Pourquoi moins de bits = plus rapide (le lien avec la séance 1)Why fewer bits = faster (the link to session 1)

Rappelez-vous : le décodage est memory-bound. Pour produire un token, le moteur doit lire tous les poids du modèle. Diviser par deux la taille des poids divise par deux le temps de lecture — donc, à bande passante égale, double le débit. La quantification n'est pas seulement une astuce de mémoire : c'est l'optimisation de performance la plus rentable du domaine. Remember: decoding is memory-bound. To produce one token, the engine must read all the model's weights. Halving the weight size halves the read time — so at equal bandwidth it doubles throughput. Quantization is not just a memory trick: it is the highest-leverage performance optimisation in the field.

⚠️ Ne mesurez pas la qualité avec la perplexité seule. Un modèle quantifié peut avoir une perplexité quasi identique à la version F16 et échouer sur votre tâche (par exemple extraire un montant dans un JSON strict). La perplexité est un indicateur global ; votre évaluation doit être la vôtre, sur vos cas, avec vos critères — c'est tout l'objet de la séance 3. Do not measure quality with perplexity alone. A quantized model can have near-identical perplexity to the F16 version and still fail on your task (say, extracting an amount into strict JSON). Perplexity is a global indicator; your evaluation must be yours, on your cases, with your criteria — which is the whole point of session 3.

📚 Sources : llama.cpp, quantize.cpp ; Which Quantization Should I Use? A Unified Evaluation of llama.cpp — étude comparative indépendante et datée des compromis taille/qualité. Sources: llama.cpp, quantize.cpp; Which Quantization Should I Use? A Unified Evaluation of llama.cpp — an independent, dated comparison of size/quality trade-offs.

Calculer son budget mémoire (poids + cache KV)Computing your memory budget (weights + KV cache)

≈ 22 min

Erreur classique : ne compter que la taille du fichier. La mémoire réellement consommée, c'est trois termes : les poids, le cache KV (la mémoire de l'attention), et le surcoût du runtime. Le cache KV est le terme que tout le monde oublie — et c'est celui qui explose avec la fenêtre de contexte. Classic mistake: counting only the file size. Actual memory use is three terms: the weights, the KV cache (the attention memory), and the runtime overhead. The KV cache is the term everyone forgets — and the one that explodes with the context window.

mémoire_totale ≈ poids + cache_KV + surcoût_runtime(≈5–10 %)

cache_KV (octets) = 2 × n_couches × n_têtes_KV × dim_tête × contexte × octets_par_élément
                    ↑                                        ↑
              (clé ET valeur)                    (2 en FP16, 1 en q8_0, 0.5 en q4_0)

dim_tête = dim_embedding / n_têtes          # souvent 128 ; 256 sur certains modèles récents

-- Avec GQA (grouped-query attention), n_têtes_KV < n_têtes.
   C'est ce qui rend le contexte long abordable. Toujours prendre n_têtes_KV,
   PAS n_têtes, sinon vous surestimez le cache d'un facteur 4 à 8.

Application aux modèles du lab (chiffres réels)Applied to the lab models (real figures)

Valeurs d'architecture relevées via api/show le 2026-09-18 : Architecture values read via api/show on 2026-09-18:

ModèleModel	CouchesLayers	Têtes / Têtes KVHeads / KV heads	dim têtehead dim	cache KV / tokenKV cache / token	8 k	32 k	128 k
`llama3.1:8b`	32	32 / 8	128	128 Kio	1,07 Go	4,29 Go	17,18 Go
`qwen3.8:27b`	65	24 / 4	256	260 Kio	2,18 Go	8,72 Go	34,90 Go

Deux budgets calculés de bout en boutTwo budgets computed end to end

llama3.1:8b — Q4_K_M — contexte 8 k

poids      :  4,92 Go
cache KV   :  1,07 Go
surcoût    :  0,39 Go
-----------------------------
TOTAL      :  6,39 Go

Tient sur une seule RTX 3060 (12 Go), marge de 5,6 Go. C'est le modèle de travail du lab. Fits on a single RTX 3060 (12 GB), with 5.6 GB to spare. This is the lab's workhorse.

qwen3.8:27b — Q4_K_M — contexte 8 k

poids      : 17,74 Go
cache KV   :  2,18 Go
surcoût    :  1,42 Go
-----------------------------
TOTAL      : 21,34 Go

Exige les deux RTX 3060 (24 Go cumulés), marge de 2,7 Go seulement. Passer à 32 k déborderait (27,9 Go). Requires both RTX 3060s (24 GB total), with only 2.7 GB to spare. Going to 32 k would overflow (27.9 GB).

⛔ Le piège de la fenêtre annoncéeThe advertised-window trap qwen3.8:27b annonce 262 144 tokens de contexte. Pour l'utiliser réellement : 17,74 Go de poids + 34,90 Go de cache KV à 128 k = 54,06 Go. Le lab n'a que 24 Go de VRAM. La fenêtre annoncée est donc inutilisable telle quelle. Trois issues, dans l'ordre : (1) réduire la fenêtre au besoin réel, (2) quantifier le cache KV en q8_0 ou q4_0 (divise par 2 ou 4 le cache — à 128 k en q8_0, le cache retombe à 17,45 Go, ce qui reste insuffisant, mais à 32 k il passe de 8,72 à 4,36 Go et le total rentre enfin sur 2×3060), (3) changer de modèle. Notez que llama3.1:8b, qui annonce 131 k, a le même problème : 4,92 + 17,18 = 22,49 Go, soit tout juste la capacité des deux cartes — sans marge pour le traitement du prompt. qwen3.8:27b advertises 262,144 tokens of context. To actually use it: 17.74 GB of weights + 34.90 GB of KV cache at 128 k = 54.06 GB. The lab has only 24 GB of VRAM. The advertised window is therefore unusable as-is. Three ways out, in order: (1) reduce the window to what you actually need, (2) quantize the KV cache to q8_0 or q4_0 (halves or quarters the cache — at 128 k in q8_0 the cache drops to 17.45 GB, still not enough, but at 32 k it goes from 8.72 to 4.36 GB and the total finally fits on 2×3060), (3) change model. Note that llama3.1:8b, advertising 131 k, has the same problem: 4.92 + 17.18 = 22.49 GB, i.e. exactly the two cards' capacity — with no headroom for prompt processing.

📚 Sources : métadonnées d'architecture relevées via l'API Ollama (api/show) ; paramètres de cache KV et de contexte documentés dans le README de llama-server et la spécification GGUF. Sources: architecture metadata read via the Ollama API (api/show); KV-cache and context parameters documented in the llama-server README and the GGUF specification.

Choisir un modèle : la procédureChoosing a model: the procedure

≈ 18 min

Les familles que vous croiserezThe families you will meet

FamilleFamily	Sur le labOn the lab	Points fortsStrengths
Llama	`llama3.1:8b`	Écosystème énorme, outils d'inférence et de fine-tuning les mieux supportés, contexte long (131 k).Huge ecosystem, best-supported inference and fine-tuning tooling, long context (131 k).
Qwen	`qwen3.6:27b`, `qwen3.8:27b`	Excellent multilingue, support vision et thinking, très bon rapport taille/qualité. Attention : vocabulaire plus large.Excellent multilingual, vision and thinking support, very good size/quality ratio. Note: larger vocabulary.
Mistral	`mistral:7b`	Léger, rapide, licences permissives. Bon point de départ CPU.Light, fast, permissive licences. A good CPU starting point.
Gemma	`gemma4:26b`	Compact et solide, mais conditions d'utilisation spécifiques à lire avant usage commercial.Compact and solid, but read the specific terms of use before commercial deployment.
GLM / Nemotron	`glm-4.7-flash`, `nemotron-3.5-lightning`	Générations récentes, orientées efficacité et agents. À évaluer sur vos cas.Recent generations, efficiency- and agent-oriented. Evaluate on your cases.
EmbeddingsEmbeddings	`granite-embedding`	Rôle différent : ne génère pas de texte, produit des vecteurs. 384 dimensions, contexte 512, F16.Different role: does not generate text, produces vectors. 384 dimensions, 512 context, F16.

Trois axes de décisionThree decision axes

Dense vs MoEDense vs MoE Un modèle dense active tous ses poids à chaque token. Un MoE (mixture of experts) n'en active qu'une fraction : mémoire de stockage élevée, mais décodage rapide. nemotron-3.5-lightning (32,9 B, 25,4 Go) est de cette famille : gros sur disque, économe en calcul par token. A dense model activates all its weights per token. A MoE (mixture of experts) activates only a fraction: high storage memory, but fast decoding. nemotron-3.5-lightning (32.9 B, 25.4 GB) is of that family: big on disk, cheap in compute per token.

Capacités déclaréesDeclared capabilities Interrogez-les, ne les supposez pas. Le lab répond : llama3.1:8b → completion, tools · qwen3.8:27b → completion, vision, tools, thinking · granite-embedding → embedding. Si tools est absent, votre agent ne fonctionnera pas, quelle que soit la qualité du modèle. Query them, do not assume. The lab answers: llama3.1:8b → completion, tools · qwen3.8:27b → completion, vision, tools, thinking · granite-embedding → embedding. If tools is missing, your agent will not work, however good the model is.

🎯 La procédure en cinq questions, dans cet ordre : (1) Quelle tâche exactement, et faut-il des outils ou de la vision ? (2) Quelle langue de sortie — et avez-vous mesuré son coût en tokens ? (3) Quel budget mémoire réel (calculez-le, section 3) ? (4) Quelle licence pour votre usage (commercial, redistribution) ? (5) Évaluez deux candidats sur votre propre jeu de cas avant de trancher. Les questions 1, 3 et 5 éliminent 90 % des mauvais choix. The procedure in five questions, in this order: (1) Which exact task, and do you need tools or vision? (2) Which output language — and have you measured its token cost? (3) Which real memory budget (compute it, section 3)? (4) Which licence for your use (commercial, redistribution)? (5) Evaluate two candidates on your own case set before deciding. Questions 1, 3 and 5 eliminate 90 % of bad choices.

Lab 2 — Le calculateur de budgetLab 2 — The budget calculator

≈ 20 min

🔬 Objectif : répondre à « est-ce que ça rentre ? » sans lancer le modèleGoal: answer "will it fit?" without loading the model

Étape 1 — Calculer un budgetStep 1 — Compute a budget

# Interroge le modèle via l'API, récupère son architecture réelle,
# puis calcule poids + cache KV + surcoût pour plusieurs contextes.
python3 labs/lab2_memory_budget.py --endpoint http://172.16.8.81:11434 \
        --model qwen3.8:27b --contexts 4096 8192 32768 131072

# Auditer la quantification réelle d'un modèle :
python3 labs/lab2_memory_budget.py --endpoint http://172.16.8.81:11434 \
        --model llama3.1:8b --audit

Étape 2 — Confronter au matérielStep 2 — Confront it with the hardware

# Le script compare automatiquement aux profils du lab :
#   1x RTX 3060 (12 Go) · 2x RTX 3060 (24 Go) · poste CPU 64 Go RAM
python3 labs/lab2_memory_budget.py --endpoint http://172.16.8.81:11434 \
        --model qwen3.8:27b --contexts 8192 32768 --hardware

Étape 3 — Comparer deux quantifications du même modèleStep 3 — Compare two quantizations of the same model

Sur le lab, mistral:7b et llama3.1:8b sont tous deux en Q4_K_M. Pour comparer des quantifications, téléchargez deux variantes du même modèle : On the lab, mistral:7b and llama3.1:8b are both Q4_K_M. To compare quantizations, pull two variants of the same model:

ollama pull llama3.1:8b-instruct-q8_0     # ~8,5 Go, quasi sans perte
ollama pull llama3.1:8b-instruct-q3_K_S   # ~3,5 Go, dégradé

# puis, pour chaque variante :
python3 labs/lab2_memory_budget.py --endpoint http://172.16.8.81:11434 \
        --model llama3.1:8b-instruct-q8_0 --audit

🎯 Ce que vous devez produire : un tableau de 4 lignes (modèle × quantification × contexte → mémoire totale → verdict « rentre / ne rentre pas » sur 1×3060, 2×3060, CPU). C'est votre table de décision de la journée. Gardez-la : elle servira en séance 4 (servir) et en séance 5 (régler). What you must produce: a 4-row table (model × quantization × context → total memory → verdict "fits / does not fit" on 1×3060, 2×3060, CPU). That is your decision table for today. Keep it: it will be used in session 4 (serving) and session 5 (tuning).

Quiz — 5 questionsQuiz — 5 questions

≈ 8 min

1. Un modèle 8 B en Q4_K_M pèse 4,92 Go. Combien de bits par poids cela fait-il ?1. An 8 B model in Q4_K_M weighs 4.92 GB. How many bits per weight is that?

4,92 Go × 8 / 8,0 B = 4,90 bits/poids. Les variantes _K_M gardent certains tenseurs sensibles en précision plus élevée, ce qui pousse le total au-dessus de 4. Sur qwen3.8:27b on mesure même 5,20. Toujours auditer la taille réelle du fichier.4.92 GB × 8 / 8.0 B = 4.90 bits/weight. The _K_M variants keep some sensitive tensors at higher precision, pushing the total above 4. On qwen3.8:27b we measure 5.20. Always audit the real file size.

2. Pourquoi quantifier accélère-t-il le décodage ?2. Why does quantizing speed up decoding?

Le nombre de paramètres ne change pas. Ce qui change, c'est le nombre d'octets déplacés pour produire chaque token. À bande passante constante, diviser la taille par deux double le débit. C'est l'optimisation la plus rentable du domaine.The parameter count does not change. What changes is the number of bytes moved to produce each token. At constant bandwidth, halving the size doubles throughput. It is the highest-leverage optimisation in the field.

3. Pour le cache KV, faut-il utiliser le nombre de têtes d'attention ou le nombre de têtes KV ?3. For the KV cache, should you use the number of attention heads or the number of KV heads?

Avec la GQA (grouped-query attention), plusieurs têtes d'attention partagent une même tête KV. llama3.1:8b a 32 têtes mais seulement 8 têtes KV ; qwen3.8:27b en a 24 pour 4 têtes KV. Utiliser le mauvais nombre surestime le cache d'un facteur 4 à 8 — et vous fait renoncer à un modèle qui rentrait.With GQA (grouped-query attention), several attention heads share one KV head. llama3.1:8b has 32 heads but only 8 KV heads; qwen3.8:27b has 24 for 4 KV heads. Using the wrong number overestimates the cache by 4–8× — and makes you give up on a model that would have fitted.

4. Un modèle annonce 262 k de contexte. Que devez-vous vérifier avant de compter dessus ?4. A model advertises 262 k context. What must you check before relying on it?

À 128 k, qwen3.8:27b demande 32,5 Go de cache KV en plus des 17,74 Go de poids : 50 Go, contre 24 Go disponibles. Solutions : réduire la fenêtre, quantifier le cache KV (q8_0/q4_0), ou changer de modèle.At 128 k, qwen3.8:27b needs 32.5 GB of KV cache on top of 17.74 GB of weights: 50 GB against 24 GB available. Fixes: shrink the window, quantize the KV cache (q8_0/q4_0), or change model.

5. Vous voulez construire un agent qui appelle des fonctions. Quel critère est éliminatoire ?5. You want to build an agent that calls functions. Which criterion is disqualifying?

Si le modèle n'expose pas tools, l'appel d'outil ne sera pas fiable, quelle que soit sa qualité rédactionnelle. Interrogez les capacités : qwen3.8:27b déclare vision, tools et thinking ; granite-embedding ne déclare que embedding. On ne devine pas, on lit.If the model does not expose tools, tool calling will not be reliable, however good its prose. Query the capabilities: qwen3.8:27b declares vision, tools and thinking; granite-embedding declares only embedding. You do not guess, you read.

Score : 0 / 5Score: 0 / 5

🏁 À retenirKey takeaways

Mémoire = poids + cache KV + surcoût. Le cache KV est le terme qu'on oublie, et celui qui explose avec le contexte.Memory = weights + KV cache + overhead. The KV cache is the term people forget, and the one that explodes with context.
Utilisez les têtes KV (GQA), pas les têtes d'attention, dans la formule du cache.Use the KV heads (GQA), not the attention heads, in the cache formula.
Q4_K_M est le défaut raisonnable (~4,8–5,2 bits/poids). Q8_0 si la qualité prime, Q3 et en dessous en dernier recours.Q4_K_M is the sensible default (~4.8–5.2 bits/weight). Q8_0 if quality dominates, Q3 and below as a last resort.
Moins de bits = plus de débit, parce que le décodage est memory-bound.Fewer bits = more throughput, because decoding is memory-bound.
La fenêtre annoncée n'est pas la fenêtre utilisable. Calculez, puis réduisez, quantifiez le cache KV, ou changez de modèle.The advertised window is not the usable window. Compute, then shrink, quantize the KV cache, or change model.
Lisez les capacités déclarées (tools, vision, thinking) : elles sont éliminatoires, pas indicatives.Read the declared capabilities (tools, vision, thinking): they are disqualifying, not indicative.

🏆 Votre gain du jourToday's win
Un calculateur de budget mémoire exécutable, qui interroge l'architecture réelle d'un modèle et vous dit s'il rentre — et une table de décision (modèle × quantification × contexte → mémoire → verdict matériel) que vous emportez. Vous ne choisirez plus un modèle au feeling, vous le calculerez. A runnable memory-budget calculator that reads a model's real architecture and tells you whether it fits — plus a decision table (model × quantization × context → memory → hardware verdict) you take away. You will no longer pick a model by feel, you will compute it.

Sources de la séance : ggml, GGUF specification · llama.cpp, quantize.cpp et llama-server README · Which Quantization Should I Use? A Unified Evaluation of llama.cpp, arXiv:2601.14277 · HF blog, Llama 3.1. Relevés d'architecture et tailles : API Ollama du lab, 2026-09-18 (RESOURCES.md §8). Session sources: ggml, GGUF specification · llama.cpp, quantize.cpp and llama-server README · Which Quantization Should I Use? A Unified Evaluation of llama.cpp, arXiv:2601.14277 · HF blog, Llama 3.1. Architecture readings and sizes: lab Ollama API, 2026-09-18 (RESOURCES.md §8).