Running a language model on your own machine used to be a project. You found weights, you worked out which format your inference library wanted, you converted them, you fought with a Python environment and CUDA versions, and somewhere in the second evening it either worked or you gave up. Ollama removed almost all of that, and the result is that anyone with a reasonably modern laptop can have a capable model running locally in the time it takes to make a coffee. That is a meaningful shift in who gets to experiment.
The quick start does what it should. Install, pull a model, run it, and you are talking to a local model in a terminal. No account, no key, no cloud, no per token cost, and nothing you type leaves your machine. For a lot of people the last part is the entire point, and the documentation gets you there without ceremony.
The model library is the thing that makes this work. Ollama maintains a catalogue of models already packaged and ready to pull, and that removes the step that used to defeat people. Browsing it also serves an incidental educational purpose, because seeing the same model available in several sizes and quantisations makes the tradeoffs concrete in a way that reading about them does not. The API documentation is solid.
There is a native HTTP interface, and there is compatibility with the widely used chat completion format, which means a great deal of existing code will point at a local instance with a changed base URL and nothing else. For prototyping, for testing, and for keeping sensitive data off third party infrastructure, that is genuinely valuable and it is documented well enough to just do. Modelfiles are the customisation mechanism and the concept is clean. A short file that sets a base model, a system prompt, generation parameters and a template, producing a named variant you can run like any other model.
The documentation covers the syntax adequately. What it does not do is show you why you would bother, and a few worked examples of useful custom models would teach the idea far better than the parameter list does. Now the significant gaps, and the first is the one that matters most. There is essentially no guidance on choosing a model.
The library lists what exists. Nothing tells you which model suits code generation versus summarisation versus structured extraction, how the sizes actually compare in practice, what you give up moving from a larger model to a smaller one, or how any of them compare to what you would get from a commercial API. A newcomer pulls whatever is at the top of the list and forms an impression of local models from one arbitrary choice. That is a real failure for a tool whose whole purpose is making local models accessible.
Quantisation is the second gap and it is worse, because it is unavoidable. Every model in the library comes in multiple quantisations, the choice determines whether it fits in your memory and how much quality you lose, and the documentation treats it as a detail you already understand. You do not, if you are the audience this tool was built for. A single page explaining what quantisation does, what the common levels mean in practice, and how to pick given your hardware would improve the experience of everyone using this more than any feature would.
Hardware guidance is vague. How much memory a given model needs, what performance to expect on a laptop versus a machine with a discrete graphics card, when a model will run but too slowly to be useful. People find this out by trying things and being disappointed, when a table would have told them. Structurally it is a reference rather than a course.
Command syntax, API endpoints, configuration options, all present and accurate, with no path through them and no sense of progression. That is a legitimate choice for documentation and it means the learning happens elsewhere, mostly on forums, which is a shame given how good the tool is. Security gets no treatment. You are downloading model weights from a registry and running them, the server binds to a port, and there are people who will expose that to a network without thinking about it.
None of this is discussed. It deserves a page. My three point nine is for a tool that genuinely changed who can run models locally, with documentation that handles the mechanics competently and skips every judgement call that determines whether the experience is good. Install it, ignore the gaps, and go elsewhere for the choices.
It is still the easiest way into local inference by a distance.