Skip to content
Français
Account: not signed in, sync available My learning
Select theme
Français
Lire en français

Which Ollama model to choose in 2026? Llama 4, Qwen 3, Gemma 4 cheat sheet

17 min read
Improve this page

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 ps and ollama 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 tools capability (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.

ParametersOllama tagFile size
4 Bqwen3:4b2.5 GB
8 Bqwen3:8b5.2 GB
14 Bqwen3:14b9.3 GB
30-32 Bqwen3:30b, qwen3:32b19 GB, 20 GB
70 Bllama3.3:70b43 GB
MoE, 17 B active per tokenllama4:16x17b67 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.

LicenseLibrary models concerned
Apache 2.0mistral, granite-embedding
MITphi3, deepseek-r1 (DeepSeek R1 weights; the distilled variants keep the license of their base model)
Llama 3.3 Community Licensellama3.3
Llama 4 Community Licensellama4

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.

ModelOllama tagFile sizeNote
Qwen 3qwen35.2 GBThe guide's compromise; tools and thinking capabilities
Gemma 4gemma46.6 GB (latest tag)Vision, tools and thinking, maximum context of 131072 tokens
Llama 4 (MoE)llama4:16x17b67 GB17 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.

ModelOllama tagFile sizeNote
DeepSeek Coder V2deepseek-coder-v28.9 GB (16b tag)Code-specialized model
Qwen 3.6 27Bqwen3.6:27b18 GBtools, thinking and vision capabilities
Kimi K2.6kimi-k2.6:cloudnone1 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.

ModelOllama tagFile sizeNote
Qwen 3qwen35.2 GBtools capability declared, used in Tool calling
Gemma 4gemma46.6 GBtools capability declared, along with vision
Llama 4llama4:16x17b67 GBtools 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.

ModelOllama tagFile sizeNote
Gemma 4gemma46.6 GB (latest tag)Vision and tools on the same page
Llama 3.2 Vision 11Bllama3.2-vision7.8 GBThe page declares English only for requests with an image
Llama 3.2 Vision 90Bllama3.2-vision:90b55 GBFor 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.

ModelOllama tagFile sizeDimensions
nomic-embed-textnomic-embed-text274 MB768 (measured)
mxbai-embed-largemxbai-embed-large670 MB1024 (measured)
granite-embeddinggranite-embedding63 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 memoryChatCodeVision
4 GBphi3 (2.2 GB), gemma:2b (1.7 GB)qwen2.5-coder:1.5b (986 MB)qwen2.5vl:3b (3.2 GB), no margin
8 GBqwen3 (5.2 GB)qwen2.5-coder:7b (4.7 GB)gemma4:e2b (4.6 GB)
12 GBgemma4 (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.

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.

Terminal window
ollama pull qwen3 # chat + agents + structured
ollama pull nomic-embed-text # embeddings pour RAG

DevOps 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.

Terminal window
ollama pull qwen3 # chat / agents
ollama pull qwen3.6:27b # code (utilisation alternée)
ollama pull gemma4 # vision
ollama pull nomic-embed-text # RAG

Production 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.

Terminal window
ollama pull qwen3 # défaut
ollama pull gemma4 # vision + tools
ollama pull llama3.3 # chat généraliste de 70 B
ollama pull mxbai-embed-large # RAG, 1024 dimensions

Key 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 ps and ollama run --verbose.
  • An MoE model activates only part of its weights, but all of them stay in memory: llama4:16x17b weighs 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, latest tag).
  • The default context depends on the VRAM (4k tokens under 24 GiB): fix OLLAMA_CONTEXT_LENGTH or num_ctx rather 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

6 questions
6 min
70% to pass

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

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.