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

Ollama is a free, open-source tool for running open 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 tools such as Claude Code can call it too. Besides models that run on your machine, it now also runs cloud models, whose names end in :cloud, with the same commands.

This guide sticks to how to use Ollama itself, checked against the original text of the official GitHub repo (including the source code), the official docs, and the pricing page (as of November 12, 2026). For local LLMs in general, see how to run a local LLM; for which model to pick, our best local LLM models comparison; for working out the VRAM you need, the hardware requirements article; and for wiring a model into your editor, the Ollama + Cline article.

1. What is Ollama? Two ways to run models: local and cloud

Ollama is a free, open-source tool for running open models (Gemma, Qwen, gpt-oss and others) easily on your own PC. It handles the tedious parts in the background (downloading models, dealing with quantization formats, configuring GPU use), so all you do is "name a model and run it". Inference is built on llama.cpp, and on Apple silicon Macs some models also come in versions that run on Apple's MLX.

There are two ways to run a model, and which one you choose completely changes the PC you need and what you pay.

A similar tool is LM Studio. Roughly: Ollama = built around commands and the API, suited to developers, automation and connecting agents; LM Studio = built around a GUI, for people who want to go from finding a model to chatting without leaving the window. Both are free. The differences between local and cloud themselves (cost, performance, privacy) are covered in our local vs. cloud LLM comparison.

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

The official download page and the README on GitHub offer two routes for each OS: a one-liner you paste into a terminal, or a manual installer. Both give the same result.

Windows

If you'd rather not use a command, get OllamaSetup.exe from the download page and run it. According to the official Windows page, it installs into your home folder by default, and models can take tens to hundreds of GB on top. If drive C: is short on space, change the install location with OllamaSetup.exe /DIR="d:\some\location" and the model location with the OLLAMA_MODELS environment variable (section 9). After installation Ollama runs in the background, and the ollama command works in both cmd and PowerShell.

macOS

To install manually, open Ollama.dmg and drag the app into the Applications folder. On first launch, if the ollama command isn't on your PATH, the app asks permission to create a link in /usr/local/bin (official macOS page).

Linux

Manual installation without the script and the extra package for AMD GPUs are described on the official Linux page. Linux has no app like Windows and macOS do; you use it through commands and the API.

Docker

The official image ollama/ollama is on Docker Hub. A minimal CPU-only start looks like this. For NVIDIA GPUs, install the NVIDIA Container Toolkit and add --gpus=all; for AMD GPUs, use the ollama/ollama:rocm image (official Docker page). Docker Desktop on macOS can't use the GPU (official FAQ), so on a Mac installing the app directly is faster.

docker run -d -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama
docker exec -it ollama ollama run gemma4:e2b

3. Will it run fast on your GPU? (supported GPUs at a glance)

If Ollama can't use your GPU it falls back to the CPU, so you won't see an error, but it becomes several times slower. Before installing, check whether your GPU is listed on the official Hardware support page. Here are the key points.

To see whether a model actually landed on the GPU, run ollama ps while it's loaded. If the PROCESSOR column says 100% GPU, it's entirely on the GPU; a split such as 48%/52% CPU/GPU means it overflowed VRAM (official FAQ). What to dial down when it's split is covered in the table in section 9. VRAM estimates per GPU are in our hardware requirements article.

4. Ollama command list

This table covers the commands in the official CLI reference and those defined in the source code (cmd/cmd.go). Day to day, you'll mostly use the first six.

ollama run has some handy options. With --verbose, it prints the elapsed time and tokens per second (eval rate) after each answer, so you can compare speed in numbers when you switch models or tags. --think=false stops models that show their reasoning from doing so, --format json makes the answer come back as JSON, and --keepalive 30m changes how long the model stays in memory. For models that can read images, just include the file path in your prompt, as in ollama run gemma4 "What's in this image? ./photo.png".

Inside a chat (after the >>> prompt) you can use special commands that start with /. /bye exits, /? lists them all, /clear wipes the conversation context, and /set parameter num_ctx 8192 changes the context length on the spot. To enter several lines at once, wrap them in """.

5. Getting models and reading tags

You specify a model by name + tag. Leave out the tag and latest is used, but which size latest points to differs from model to model. Install without checking and you may get a much bigger version than you expected. Using the official gemma4 tag list as an example, here is how to read tags (as displayed on November 12, 2026).

The sizes come as ranges because one tag contains several formats, and the one that suits your machine is chosen. For gemma4's latest, the lower bound of 6.6 GB matches e4b-it-q4_K_M and the upper bound of 9.5 GB matches e4b-mlx. When in doubt, pick a tag without a suffix (such as gemma4:e4b) and Ollama chooses the right format for your machine. Quantization formats themselves (how to read GGUF's Q4_K_M and so on) are covered in our quantization formats article.

The VRAM figures are a rough guide: the model size plus headroom for the conversation (the context). The official quickstart likewise recommends "8 GB of VRAM (or unified memory on a Mac)" for gemma4:e2b (about 7.2 GB in the format installed by default). Once installed, ollama show gemma4 shows the parameter count, quantization and context length.

6. Using a GUI (the Ollama app, Open WebUI and more)

If you'd rather avoid the terminal, start by opening Ollama's own app. The Windows and macOS versions include a window where you pick a model and chat (official blog post "Ollama's new app"). Linux has no app, so use one of the other interfaces below.

7. Cloud models and pricing

When your own GPU can't run a large model, you can use cloud models that run on Ollama's servers, with the same workflow. Sign in to ollama.com with ollama signin, then give a name ending in :cloud, such as ollama run gemma4:cloud. No download is needed (official Cloud page). The plans are as follows (pricing page, as of November 12, 2026).

Usage is counted at each model's price per million tokens. The cloud version of gemma4, for example, costs $0.14 for input and $0.40 for output. Using 1 million input tokens and 200,000 output tokens comes to 0.14 + 0.40 × 0.2 = about $0.22. At that ratio, Pro's $60 a month covers about 270 such rounds (60 ÷ 0.22). Included usage doesn't roll over to the next month. Models running on your own machine are unlimited and free on every plan.

8. Using the API (OpenAI- and Anthropic-compatible)

Ollama's real strength is its local API. By default the server listens on 127.0.0.1:11434; send requests there and your apps, scripts and tools can use a local LLM. There are three request formats.

/api/chat (send the conversation history)

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

The answer is in message.content. Drop "stream": false and the answer arrives bit by bit as lines of JSON (streaming is the default). For a single answer, you can also send a "prompt" to /api/generate. The example above is written for macOS and Linux shells; Windows PowerShell handles quotes differently, so use this form from the official Windows page (only the model name changed).

(Invoke-WebRequest -method POST -Body '{"model":"gemma4", "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, on a local server 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='gemma4',
)
print(chat_completion.choices[0].message.content)

Anthropic-compatible (connecting Claude Code)

The official Anthropic compatibility page has you set these two environment variables for tools built around Anthropic's API. Even without setting them yourself, ollama launch claude starts Claude Code already connected.

export ANTHROPIC_AUTH_TOKEN=ollama  # required but ignored
export ANTHROPIC_BASE_URL=http://localhost:11434

Both compatibility layers support only part of the original APIs. The Responses format, for example, is stateless, so you have to send the conversation history every time. When you use a local model with a coding agent, the context length in the next section is the key.

9. Customizing (Modelfile, environment variables, memory tuning)

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 gemma4
PARAMETER temperature 0.7
PARAMETER num_ctx 16384
SYSTEM """You are a concise assistant. Lead with the key point and keep answers short."""

Save it as a file named Modelfile and run the following in the same folder. Putting num_ctx in the Modelfile extends the context length for this model only, without changing the server-wide default.

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

ollama show --modelfile gemma4 shows the Modelfile behind an existing model. Copying and editing it is the quickest way in.

Key environment variables

You control the server's behavior with environment variables. ollama serve --help prints the full list. Here are the most common ones, with the defaults written in the source code (envconfig/config.go) and the official FAQ.

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 restart Ollama 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 (running under systemd), do this:

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

Tuning for low memory or long context

With less than 24 GiB of VRAM, the default context length is only 4k (about 4,000 tokens). The official Context length page recommends at least 64,000 tokens for web search, agents and coding tools. When it's too short, the model silently forgets earlier content, so this table lists the setting for each goal, letting you work back from the symptom.

After changing settings, check with ollama ps that the CONTEXT column shows the length you wanted and PROCESSOR still says 100% GPU. How context length translates into memory is worked out in our hardware requirements article, and the symptoms of an agent breaking when it runs out of context are covered in the Ollama + Cline article.

10. Troubleshooting

Common sticking points and the fixes given in the official FAQ and Troubleshooting page.

Summary

Ollama runs open models on your own machine or in the cloud with the same workflow. Four takeaways:

• Check your GPU before installing: NVIDIA needs Compute Capability 5.0 or higher, AMD the ROCm v7 list or Vulkan, Macs an Apple M-series chip. Once running, confirm 100% GPU in ollama ps.
• Read the tag before you pick: what latest contains differs by model. Look at the size number (e2b, 12b, 31b), and when in doubt choose a tag without a suffix.
• Set the context length yourself: the default under 24 GiB of VRAM is 4k. At least 64k is recommended for agents; win back memory by quantizing the K/V cache.
• Connect tools with the API and launch: the OpenAI- and Anthropic-compatible APIs and ollama launch let your own apps and Claude Code use it. Run heavy models with :cloud.

Start by opening the app or typing ollama run gemma4:e2b. The best way to learn is to keep it running while you explore the differences from the cloud and how to choose a model. If you want to go further and wire a model into your editor to write code, coding with a local LLM covers the Cline and Continue setup.

FAQ