Ollama Complete Guide [2026]: Install, Commands & API Usage

Ollama is a free, open-source tool for running LLMs (large language models) on your own computer. It installs on Windows, macOS, and Linux, and a single line, ollama run model-name, takes you from downloading a model to chatting with it. While it runs, an API server listens on localhost:11434, so your own apps and other tools can call it too.

This guide sticks to how to use Ollama itself: the install command for each OS, the full command list, Modelfiles, environment variables, and minimal API examples, all checked against the official GitHub repo and the official docs (as of September 29, 2026). For local LLMs in general, see how to run a local LLM; for which model to pick, our best local LLM models comparison; and for wiring a model into your editor, the Ollama + Cline article.

1. What is Ollama? The go-to local-LLM runtime

Ollama is a free, open-source tool for running local LLMs easily on your own PC. It handles the hassle—downloading models, dealing with quantization formats, configuring GPU use—behind the scenes, so all you do is "name a model and run it."

A similar tool is LM Studio. Roughly: Ollama = CLI-first, for developers, APIs, and automation; LM Studio = GUI-first, for non-engineers getting started. Both are free and install in minutes. This article centers on Ollama (which also covers APIs and embedding); if you want a GUI, jump to Section 5.

2. How to install (Windows / macOS / Linux)

The official download page and the GitHub README offer two routes for each OS: a one-line command you paste into a terminal, or a manual installer. Either one gets you to the same place.

Windows

Open PowerShell and run this line (exactly as the official page gives it):

irm https://ollama.com/install.ps1 | iex

If you'd rather not use a command, click "Download for Windows" on the download page and run OllamaSetup.exe. Per the official Windows page, you need Windows 10 22H2 or newer (Home or Pro). No administrator rights are required; by default it installs into your home folder. The binaries alone need at least 4 GB of free space, and models can add tens to hundreds of GB. After installing, Ollama runs in the background and the ollama command works in both cmd and PowerShell.

macOS

Run this line in Terminal:

curl -fsSL https://ollama.com/install.sh | sh

To install by hand, open Ollama.dmg and drag the app into your Applications folder. On first launch, if the ollama command isn't on your PATH, the app asks for permission to create a link in /usr/local/bin. You need macOS 14 Sonoma or later; Apple M-series Macs use both CPU and GPU, while Intel (x86) Macs run on the CPU only (official macOS page).

Linux

One line installs it. To update later, run the same command again.

curl -fsSL https://ollama.com/install.sh | sh

Manual install steps without the script, and the extra package for AMD GPUs, are on the official Linux page.

Docker

The official image ollama/ollama is on Docker Hub. Here is the minimal CPU-only setup (for NVIDIA GPUs, install the NVIDIA Container Toolkit and add --gpus=all; details on the official Docker page):

docker run -d -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama
docker exec -it ollama ollama run gemma3:4b

3. Ollama command list

This table covers the commands listed by the current ollama --help, matched against the official CLI reference and the definitions in the source code. Day to day, you'll mostly use the first five.

Inside a chat (after the >>> prompt), commands starting with / are available. /bye exits, /? lists them, /clear wipes the conversation context, and /set parameter num_ctx 8192 changes the context length on the spot. To type several lines at once, wrap them in """.

4. Getting and choosing models

Specify a model by name + size tag. If you omit the tag, the default latest is used. For example, llama3.2 is the same as llama3.2:latest, which is the 3B build llama3.2:3b (the official tag list shows they are the same version). If you want the smaller 1B build, ask for llama3.2:1b explicitly. Which size latest points to differs from model to model, so check the tag list before you pull. The rule of thumb: pick a size that fits in your VRAM.

Sizes are as shown for each tag in the official library (as of September 29, 2026). With some models, such as qwen3-coder, leaving off the tag pulls a large build, so check the tag list first on a machine with little disk or memory. Once a model is installed, ollama show qwen3 shows its parameter count, quantization, context length, and more.

5. Using a GUI (Open WebUI and more)

Not a fan of the terminal? No problem—you can put a chat screen (GUI) on top of Ollama.

6. Using the API (embed it in apps)

Ollama's real strength is its local API. By default the server listens on 127.0.0.1:11434, and by sending requests there, your own apps, scripts, and tools can use a local LLM. There are two main entry points.

/api/generate (a single answer)

curl http://localhost:11434/api/generate -d '{
  "model": "qwen3",
  "prompt": "Why is the sky blue?",
  "stream": false
}'

Drop "stream": false and the answer comes back bit by bit as lines of JSON (streaming is the default).

/api/chat (pass the conversation history)

curl http://localhost:11434/api/chat -d '{
  "model": "qwen3",
  "messages": [{
    "role": "user",
    "content": "Why is the sky blue?"
  }],
  "stream": false
}'

Those two are written for macOS and Linux shells. Windows PowerShell handles quotes differently, so use this form from the official Windows page:

(Invoke-WebRequest -method POST -Body '{"model":"qwen3", "prompt":"Why is the sky blue?", "stream": false}' -uri http://localhost:11434/api/generate ).Content | ConvertFrom-json

OpenAI-compatible (/v1)

With the official OpenAI library, pointing base_url at Ollama is all it takes. According to the official docs, the API key is "required but ignored," so any string will do.

from openai import OpenAI

client = OpenAI(
    base_url='http://localhost:11434/v1/',
    api_key='ollama',  # required but ignored
)

chat_completion = client.chat.completions.create(
    messages=[{'role': 'user', 'content': 'Say this is a test'}],
    model='qwen3',
)
print(chat_completion.choices[0].message.content)

7. Customizing (Modelfile, env vars)

Modelfile: build your own model

A Modelfile is a config file much like a Dockerfile. Start from a base model (FROM, required), add parameters (PARAMETER) and a system prompt (SYSTEM), and you get "your own model" that always behaves the same way. A minimal example:

FROM qwen3
PARAMETER temperature 0.7
PARAMETER num_ctx 8192
SYSTEM """You are a concise assistant. Lead with the key point and keep answers short."""

Save it as a file named Modelfile, then run this in the same folder:

ollama create my-assistant -f Modelfile
ollama run my-assistant

To see the Modelfile behind an existing model, run ollama show --modelfile qwen3. Copying and editing that is the quickest way to start.

Key environment variables

You change how the server behaves with environment variables. ollama serve --help prints the full list. Here are the common ones, with the defaults written in the source code.

How you set them depends on the OS (official FAQ). On Windows, quit Ollama from the taskbar, add a user variable in the environment variables settings, and start Ollama again from the Start menu. On macOS, set it with something like launchctl setenv OLLAMA_HOST "0.0.0.0:11434" and restart the app. On Linux (when running under systemd), do this:

systemctl edit ollama.service
# add one line per variable under [Service]
# Environment="OLLAMA_HOST=0.0.0.0:11434"
systemctl daemon-reload
systemctl restart ollama

8. Troubleshooting

Here are the common snags and fixes, up front.

Summary

Ollama is the fastest way to get into local LLMs. Three takeaways:

• Set up in minutes: install from the official site, then just ollama run <model>. Very few commands to learn.
• Choose models by size: stay within your VRAM. When unsure, start at the 7B class and pick a lineage by use case.
• The API is the real value: the OpenAI-compatible API at localhost:11434 lets you embed it in your own apps and chat UIs—and serve as a cloud fallback.

Start by typing ollama run qwen3. The best way to learn is to run it while checking the differences from the cloud and how to choose a model.

From there, if you want to go on to wiring a model into your editor and having it write code, coding with a local LLM covers configuring Cline and Continue, along with the context length that makes an agent break without ever raising an error.

FAQ