You open ollama.com/library and you see Llama 4, Qwen 3, Gemma 4, Kimi K2, DeepSeek-R1, Mistral, Phi, GLM-5, and many more. Which one fits your case? Which one fits in your memory? Which one writes French correctly? This guide proposes a selection of models by use case, with the file sizes read on ollama.com/library on November 11, 2026. It also explains how to measure, on your own machine, the memory a model uses and the speed at which it answers.
What you will learn
- Apply the 4 criteria for choosing an Ollama model: use case, memory, license, multilingual support
- Pick three models per use case (chat, code, agents, vision, RAG), with the verifiable criterion that retains them
- Read a cheat sheet by amount of available memory
- Measure the memory used and the speed on your machine with
ollama psandollama run --verbose
4 criteria to choose a model
Four questions are enough to eliminate most of the catalog, and they come in this order. The use case rules out unsuitable families (an embeddings model does not chat), the memory sets the maximum size, the license decides whether you can use it commercially, and the quality in French separates what is left. Reversing this order wastes time: a model that is perfect in French but does not fit in your machine remains unusable.
1. The target use case
A model is trained for a family of tasks and degrades sharply outside its domain. Embeddings models generate no text, and "thinking" models produce a long chain of reasoning before answering, which makes them poorly suited to an interactive chat. Hybrid models, such as qwen3 and gemma4 whose page declares thinking, are an exception: their reasoning can be switched off request by request, with think=False in the Python SDK or /set nothink in an ollama run session.
- General chat: balanced models (Llama 4, Qwen 3, Gemma 4)
- Code (generation, completion): dedicated models (Qwen 2.5 Coder, DeepSeek Coder V2) or large general-purpose ones (Qwen 3.6)
- Agents (tool calling): models whose page declares the
toolscapability (Qwen 3, Gemma 4) - Vision: multimodal models (Gemma 4, Llama 3.2 Vision)
- RAG (embeddings): embeddings models (nomic-embed-text, mxbai-embed-large)
- Complex reasoning: "thinking" models (DeepSeek-R1, Kimi K2.6, the latter in the cloud only)
2. The available memory
Ollama's models are quantized: their weights are stored with a reduced precision to take up less space. The default tags in the library are often Q4_K_M, a quantization that stores each weight on a little under 5 bits on average, about 0.6 byte (some blocks of weights keep more precision). This is not guaranteed: ollama show <model> displays the quantization actually installed.
Take qwen3: 8.2 billion parameters for a 5.2 GB file, about 0.6 byte per parameter. Unquantized 16-bit (FP16) weights need 2 bytes per parameter. The file size is read on the model's page, and the tag gives the number of parameters: qwen3:8b has 8 billion.
An MoE (Mixture of Experts) model is split into blocks called experts, of which only a part works on each token (a token is a piece of a word). llama4:16x17b activates 17 billion parameters per token, but all the weights must stay in memory: the file weighs 67 GB, and 245 GB for llama4:128x17b. The last row of the table gives an example.
| Parameters | Ollama tag | File size |
|---|---|---|
| 4 B | qwen3:4b | 2.5 GB |
| 8 B | qwen3:8b | 5.2 GB |
| 14 B | qwen3:14b | 9.3 GB |
| 30-32 B | qwen3:30b, qwen3:32b | 19 GB, 20 GB |
| 70 B | llama3.3:70b | 43 GB |
| MoE, 17 B active per token | llama4:16x17b | 67 GB |
The file size is not the memory used: you must add the context, that is, the text the model keeps in view during the exchange, which takes up memory in proportion to its length. The measurement section, further down, shows how to read the actual value on your machine.
3. The license
A model's license covers the weights, not Ollama's code: being able to download a model says nothing about the right to use it in production. The library pages display the license when it is declared, and the two points to check before settling on a choice are the user threshold of the Llama Community License and the attribution clauses.
| License | Library models concerned |
|---|---|
| Apache 2.0 | mistral, granite-embedding |
| MIT | phi3, deepseek-r1 (DeepSeek R1 weights; the distilled variants keep the license of their base model) |
| Llama 3.3 Community License | llama3.3 |
| Llama 4 Community License | llama4 |
For Qwen 3, Gemma 4 and Kimi K2, the library page displays no license: read the one in the weights repository before any commercial use. On Hugging Face, the Qwen3-8B page states Apache 2.0, the Gemma 4 31B page states Apache 2.0 and points to Google's terms of use, and the Kimi K2 Instruct page states a Modified MIT License. The Llama Community License requires you to request a license from Meta beyond 700 million monthly active users. For a company project, have the license validated before going to production.
4. Multilingual support (French in particular)
Not all models are equal in French, and the library pages publish no language score: the only way to decide is to test your own texts on two or three candidates, for example Qwen 3, Gemma 4 and Mistral. Llama 3.2 Vision officially declares English only for requests with an image.
Which models to choose by use case?
Five selections, for the chat, code, agents, vision and RAG use cases. This is not a quality ranking: no measurement in this guide separates these models. Each selection retains models whose page declares the desired capabilities, sorted from the smallest file to the largest (except embeddings). The size column gives the file to download, not the actual memory use: allow for more. The tags are those of ollama.com/library as of November 11, 2026; a tag can be renamed or point to a different quantization after an update.
General chat
For a chat in French, compare the quality of the answers and the time to first word on your own questions. The first two models fit in a mainstream machine, the third needs 67 GB.
| Model | Ollama tag | File size | Note |
|---|---|---|---|
| Qwen 3 | qwen3 | 5.2 GB | The guide's compromise; tools and thinking capabilities |
| Gemma 4 | gemma4 | 6.6 GB (latest tag) | Vision, tools and thinking, maximum context of 131072 tokens |
| Llama 4 (MoE) | llama4:16x17b | 67 GB | 17 B active per token; tools and vision |
Code
For code, the file size weighs on memory: qwen2.5-coder:7b (see the cheat sheet below) is 4.7 GB, qwen3.6:27b 18 GB. The models in the table are sorted by increasing file size, the cloud model last.
| Model | Ollama tag | File size | Note |
|---|---|---|---|
| DeepSeek Coder V2 | deepseek-coder-v2 | 8.9 GB (16b tag) | Code-specialized model |
| Qwen 3.6 27B | qwen3.6:27b | 18 GB | tools, thinking and vision capabilities |
| Kimi K2.6 | kimi-k2.6:cloud | none | 1 T-parameter model run in Ollama's cloud, with no local download, with tools, thinking and vision; your requests leave your machine |
Agents (tool calling)
For an agent, what matters is not the quality of the prose but the consistency of the format: a model that invents an argument name one time in twenty breaks the execution loop. Check that the model's Ollama page declares the tools capability, and test it on your own tools.
| Model | Ollama tag | File size | Note |
|---|---|---|---|
| Qwen 3 | qwen3 | 5.2 GB | tools capability declared, used in Tool calling |
| Gemma 4 | gemma4 | 6.6 GB | tools capability declared, along with vision |
| Llama 4 | llama4:16x17b | 67 GB | tools capability declared |
Vision
Multimodal models accept an image as input in addition to text. Several pages declare both vision and tools, which avoids running two models. The gap between the 11 B and the 90 B of Llama 3.2 Vision is large: 7.8 GB against 55 GB.
| Model | Ollama tag | File size | Note |
|---|---|---|---|
| Gemma 4 | gemma4 | 6.6 GB (latest tag) | Vision and tools on the same page |
| Llama 3.2 Vision 11B | llama3.2-vision | 7.8 GB | The page declares English only for requests with an image |
| Llama 3.2 Vision 90B | llama3.2-vision:90b | 55 GB | For machines with very large memory |
Details in Vision with Ollama.
RAG / embeddings
An embeddings model turns a text into a vector, it answers no question. It weighs a few tens to a few hundred megabytes, and therefore fits in memory next to the chat model. The number of dimensions is structural: it sets the size of your vector database, and changing models forces you to reindex the whole corpus.
| Model | Ollama tag | File size | Dimensions |
|---|---|---|---|
| nomic-embed-text | nomic-embed-text | 274 MB | 768 (measured) |
| mxbai-embed-large | mxbai-embed-large | 670 MB | 1024 (measured) |
| granite-embedding | granite-embedding | 63 MB (30m) or 563 MB (278m) | not measured |
The dimensions of nomic-embed-text and mxbai-embed-large were measured with len(client.embed(model=..., input="bonjour")["embeddings"][0]). Measure those of granite-embedding the same way before sizing a database. Details in Embeddings with Ollama (in French).
Cheat sheet by memory size
This table crosses the available memory with the three main uses. The values in parentheses are the file size: the remaining margin goes to the context and the compute buffers, and you must plan for it. Each row assumes a modest context, yet Ollama chooses its own length from the VRAM, the graphics card's memory: 4k tokens under 24 GiB (the gibibyte, 1 GiB = 1.07 GB), 32k from 24 to 48 GiB, 256k from 48 GiB. A longer context needs more memory, hence the "context fixed" mention on the 24 and 80 GB rows, where a long context can make the model spill over onto the processor: fix it with OLLAMA_CONTEXT_LENGTH (for example 8192). Read the actual value with ollama ps, CONTEXT column. On 4 GB, only small models fit, with a reduced context.
| Available memory | Chat | Code | Vision |
|---|---|---|---|
| 4 GB | phi3 (2.2 GB), gemma:2b (1.7 GB) | qwen2.5-coder:1.5b (986 MB) | qwen2.5vl:3b (3.2 GB), no margin |
| 8 GB | qwen3 (5.2 GB) | qwen2.5-coder:7b (4.7 GB) | gemma4:e2b (4.6 GB) |
| 12 GB | gemma4 (6.6 GB), qwen3:14b (9.3 GB) | qwen2.5-coder:14b (9.0 GB) | gemma4, llama3.2-vision (7.8 GB) |
| 24 GB (context fixed) | qwen3:30b (19 GB) | qwen3.6:27b (18 GB), deepseek-coder-v2 (8.9 GB) | gemma4:26b (16 GB) |
| 80 GB (context fixed) | llama3.3 (43 GB), llama4:16x17b (67 GB) | qwen3.6:27b (18 GB) | llama3.2-vision:90b (55 GB) |
How do you measure size and speed on your machine?
The file sizes in this guide come from the Ollama library, but neither the memory used nor the speed can be read there: they depend on your hardware, the context size and the quantization. Two commands are enough to read them. ollama ps, run while a model is loaded, displays the memory used (SIZE column), the split between processor and GPU (PROCESSOR column) and the context (CONTEXT column). ollama run --verbose <model> "<question>" displays statistics at the end of the answer, including eval rate, the writing speed in tokens per second.
On Ollama 0.40.16, CPU only, qwen3 loaded with a 4096 context used 5.9 GB for a 5.2 GB file. For speed, the Ollama lesson shows an eval rate of 14.56 tokens per second for llama3.2 on an Intel Core i7-12650H with no GPU. Your result will be different: read it for each model you compare. If ollama ps says the model spills over onto the processor, the Ollama: troubleshooting and configuration lesson explains how to react.
Which model should you install by default?
For a single model that covers chat, agents and structured outputs, the choice proposed here rests on three verifiable criteria: the capabilities declared on the page (tools, vision), the file size, and the room it leaves for an embeddings model in the same memory. Quality in French is not one of them, since no page publishes it: test it yourself (criterion 4). The three models below answer three profiles.
First choice: qwen3, the default all-rounder
qwen3 covers chat, tools (tools) and structured outputs for a 5.2 GB file, which leaves room for the rest of the stack (see Structured outputs). No accuracy measurement backs this choice: it rests on its declared capabilities (tools and thinking) and on its size. Its drawback is that it does not accept images, which gemma4 provides.
Second choice: gemma4, if you want multimodal
gemma4 accepts images and declares tools on the same page, which avoids running two models in parallel. The latest tag weighs 1.4 GB more than qwen3 (6.6 GB against 5.2 GB) and its maximum context is 131072 tokens. Its size ranges from 4.6 to 19 GB depending on the tag, and 6.6 GB only holds for latest: check the tag you download.
Third choice: llama4:16x17b, if you have very large memory
Its MoE architecture activates only 17 B parameters per token, but the file weighs 67 GB: you need a machine with very large memory. The page declares the vision and tools capabilities. Its Llama 4 Community License calls for a check before any commercial use.
Recommended stack by profile
Ollama keeps a model in memory for a limited time after the last call, then unloads it; the keep_alive parameter sets that duration. You can therefore install more models than your machine holds at the same time, as long as they are not used together. Each stack below is designed for the memory indicated.
Solo developer, MacBook M3/M4 16 GB
Memory is unified on Apple Silicon, so it is shared with the system: plan to leave part of the total to the system and the applications.
ollama pull qwen3 # chat + agents + structuredollama pull nomic-embed-text # embeddings pour RAGDevOps team, 24 GB GPU server
The code model and the chat model do not coexist in 24 GB: Ollama unloads one to load the other, which adds a few seconds to the first call after a switch.
ollama pull qwen3 # chat / agentsollama pull qwen3.6:27b # code (utilisation alternée)ollama pull gemma4 # visionollama pull nomic-embed-text # RAGProduction with 80 GB of GPU memory
With 80 GB, the weights are no longer the main constraint: the loading time and the context matter more. From 48 GiB of VRAM, the default context is 256k tokens, and its cache adds to the 43 GB of llama3.3 weights: fix OLLAMA_CONTEXT_LENGTH or num_ctx, as in the cheat sheet. For loading, keep the default model in memory by lengthening keep_alive, and accept the switching latency on the specialized models.
ollama pull qwen3 # défautollama pull gemma4 # vision + toolsollama pull llama3.3 # chat généraliste de 70 Bollama pull mxbai-embed-large # RAG, 1024 dimensionsKey takeaways
- Four criteria, in this order: use case, memory, license, quality in French.
- The file size is read on ollama.com/library; the memory used and the speed are measured with
ollama psandollama run --verbose. - An MoE model activates only part of its weights, but all of them stay in memory:
llama4:16x17bweighs 67 GB. - The selections by use case are not rankings: they rest on declared capabilities and file size, not on a benchmark.
- The proposed default choice is
qwen3(5.2 GB); for vision,gemma4(6.6 GB,latesttag). - The default context depends on the VRAM (4k tokens under 24 GiB): fix
OLLAMA_CONTEXT_LENGTHornum_ctxrather than put up with it. - Check the license on the model's page, and read the one of the weights when the page displays none.
Knowledge check
Check that you have the essentials of this guide. The questions cover only what was just explained here.
Knowledge check
Check what you have learned with this interactive quiz
How it works
- The timer starts when you click Start
- Multiple choice, true/false and short answer questions
- You can move between questions
- Detailed results are shown at the end
Starts the quiz and the timer
Review
(0/0)Score by domain
A domain groups several guides and gets several questions, so its score is more reliable than a per-topic score, which often rests on a single question.
Summary
Strengths
No topic passed at 80% on at least two questions yet.
Weak areas
No topic below the pass mark.
Recommended next
Hints before you try again?
A new full quiz with random questions
Work again only on the questions you missed
FAQ
These five questions cover choosing and getting started with a model. Two of them concern quantization, which largely decides whether a model fits in the GPU's memory (the VRAM) or must move to the processor.
ollama run --verbose <model> displays its speed, and ollama ps the memory it uses.ollama show <model> command displays a Capabilities section that lists what the model can do. It is the most reliable source, because it covers the model actually installed on your machine. Before downloading, the model's page on ollama.com gives the same information. As a last resort, test it: if tool_calls stays empty from the very first question, the model does not handle tools.qwen3:8b weighs 5.2 GB, against about 16 GB in 16 bits), for a quality loss that is often small, to be checked on your own tasks. Q8_0 only divides by two and stays more faithful. Q4_K_M is a good starting point: the VRAM saved often matters more than the quality gap, but if your answers degrade, try Q8_0.llama3.2:1b comes in Q8_0 and qwen2:0.5b in Q4_0, because an aggressive quantization would degrade an already small model too much.So do not assume, look:ollama show llama3.2:1b
parameters 1.2B
context length 131072
quantization Q8_0
To force a specific format, add a suffix to the tag, provided it is published: ollama pull qwen3:8b-q8_0. Mind the sizes actually available: qwen3 exists in several sizes, from 0.6b to 235b, but not in 7b.ollama ps command shows it in its PROCESSOR column:NAME ID SIZE PROCESSOR CONTEXT RUNNER UNTIL
llama3.2:latest a80c4f17acd5 2.6 GB 100% CPU 4096 llamacpp 4 minutes from now
Two levers: reduce the context size (num_ctx for one request, OLLAMA_CONTEXT_LENGTH for the whole server), which Ollama chooses by default from the VRAM and which consumes memory in proportion to its length, or choose a smaller or more heavily quantized model.The second cause is a missing driver or an unsupported card: Ollama then detects no GPU, even though the model would have fit in its memory. Restart the server with OLLAMA_DEBUG=1 to read the GPU detection, as described in the Ollama: troubleshooting and configuration lesson.