Ollama Commands: CLI Cheat Sheet, Env Vars, Update and Uninstall

Ollama commands are the 15 subcommands of the ollama CLI: run, pull, list (ls), ps, show, stop, rm, cp, create, serve (start), push, signin, signout, launch, and help. Five cover daily use: ollama run <model> to chat, ollama pull to download, ollama list to see what is installed, ollama ps to see what is in memory, and ollama stop to free it. Server settings such as the port and model folder are environment variables (OLLAMA_HOST, OLLAMA_MODELS), not commands. There is no ollama update command.

I ran the core commands on Ollama 0.34.4 on an Apple M1 with 8 GB of memory, and the outputs and timings on this page are copied from that run. A few results stood out: a warm one-shot answer came back in 100 ms, ollama cp added only 4 KB to the model store, and a model that supports 32768 tokens was loaded with a 4096-token context. The Windows and Linux steps further down come from the official docs; I did not run them.

Ollama commands cheat sheet

This table is the whole CLI on one screen. The flags column lists the flags you will actually reach for, taken from each command's --help output in 0.34.4 and the Ollama CLI docs.

On 0.34.4, ollama --help listed 15 subcommands and ollama serve --help listed 21 environment variables.

How to run a model and chat from the command line

ollama run does two jobs. With only a model name, it opens an interactive chat. With a prompt in quotes, it prints one answer and exits, which is the form you use in scripts.

ollama run llama3.2                       # interactive chat
ollama run llama3.2 "Explain DNS in one line"   # one-shot answer
cat notes.txt | ollama run llama3.2 "Summarize:"  # pipe a file in
ollama run llama3.2 --verbose "hi"        # print timing stats after the answer

--verbose is the quickest speed check you have: it prints load time, prompt evaluation rate, and generation rate after every reply. On my M1, a one-shot ollama run with --verbose took 921 ms including the model load and reported an eval rate of 166.21 tokens/s. The same command with the model already in memory took 100 ms.

The model stays loaded for five minutes by default, so a second prompt skips the load. A typo in the model name fails with Error: pull model manifest: file does not exist, which just means no model has that name.

If you would rather chat in a window than a terminal, the best Ollama GUI guide compares Ollama's desktop app with the front-ends that connect to the same server.

Slash commands inside ollama run

Once you are inside an ollama run chat, lines that start with / control the session instead of going to the model. I drove a real terminal session through /set, /show, /load, /save, /clear and /bye, and the table combines the menus that /? and /set printed:

After /set parameter temperature 0.1, Ollama answered Set parameter 'temperature' to '0.1', and /show parameters listed it under "User defined parameters". /save my-chat-snapshot printed Created new model 'my-chat-snapshot', and the new model appeared in ollama list right away. That is the fastest way to turn a tuned chat, including a /set system prompt, into a reusable model without writing a Modelfile.

Manage models: pull, list, show, cp, rm, and create

Every model is a manifest pointing at content-addressed blobs, so copies and custom models reuse the same weights instead of duplicating them.

ollama pull downloads a model, and re-running it on an installed model only checks for a newer version of that tag. ollama list shows what is installed. ollama show answers "what is this model": my test model reported architecture qwen2, 494.03M parameters, context length 32768, quantization Q4_K_M, and the tools capability.

Pulling that model took 136225 ms on my connection. A repeat pull of the same tag took 1330 ms because it only compared manifests, and the model store was 380 MB on disk. ollama cp then grew the store by only 4 KB, because a copy writes a new manifest and points it at the same blobs.

ollama create builds a custom model from a Modelfile. This is the one I used:

FROM qwen2.5:0.5b
PARAMETER temperature 0.2
PARAMETER num_ctx 8192
SYSTEM You are a terse shell assistant. Answer with one command.

ollama create shell-helper -f Modelfile
ollama show shell-helper --parameters

ollama create from that Modelfile finished in 90 ms, since it only wrote two small layers on top of the existing weights. Running ollama create without -f and without a ./Modelfile fails with Error: no Modelfile or safetensors files found. ollama rm takes several names at once, which is how I cleaned up the copy and the custom model.

Serve, ports, and OLLAMA_HOST

ollama serve starts the API server that every other command talks to. The desktop apps and the Linux systemd service run it for you, so you only start it by hand on a headless box or for testing. The default address is 127.0.0.1:11434, set in the envconfig source, which means only your own machine can reach it.

In my run, curl http://127.0.0.1:11434/ returned Ollama is running, while the same port on the machine's LAN address refused the connection. The server answered its first request 247 ms after launch, and a second ollama serve started while the first was running failed at once with a bind error:

Error: listen tcp 127.0.0.1:11434: bind: address already in use

That is the "ollama serve error address already in use" people search for. It almost always means the desktop app or systemd service is already serving. Quit the app, or run sudo systemctl stop ollama, before starting your own. To change the port or listen on the network, set OLLAMA_HOST:

OLLAMA_HOST=0.0.0.0:11434 ollama serve          # reachable from other machines
OLLAMA_HOST=127.0.0.1:11500 ollama serve        # different port
OLLAMA_HOST=127.0.0.1:11500 ollama list         # point the client at it

The same variable points the client. With a second server on port 11500 and its own OLLAMA_MODELS folder, OLLAMA_HOST=127.0.0.1:11500 ollama list came back empty while the default server still listed my model. The Ollama FAQ is clear that binding to 0.0.0.0 exposes an unauthenticated API, so keep it behind a firewall or reverse proxy.

Ollama environment variables

Most Ollama configuration is environment variables read by the server, not flags. This table combines ollama serve --help from 0.34.4 with the defaults in the source code.

The context default deserves a note. The FAQ still says 4096 tokens, while the source picks 4k, 32k, or 256k by available VRAM. On my 8 GB Mac, ollama show reported that the model supports 32768 tokens, but ollama ps showed it loaded with a 4096 context. If an agent or coding tool loses track of long files, raise OLLAMA_CONTEXT_LENGTH before blaming the model.

How you set these depends on how Ollama runs, and only the shell form was part of my test. According to the FAQ:

• macOS app: run launchctl setenv OLLAMA_HOST "0.0.0.0:11434" and restart the app.
• Linux service: run sudo systemctl edit ollama, add Environment="OLLAMA_HOST=0.0.0.0:11434" under [Service], then sudo systemctl daemon-reload && sudo systemctl restart ollama.
• Windows: quit Ollama, add the variable under "Edit environment variables for your account", and start it again.

Ollama commands on Windows

The commands themselves are identical in PowerShell, Command Prompt, and Windows Terminal; only the environment-variable syntax changes. For a one-off test in PowerShell, set the variable for that session and start the server from the same window:

$env:OLLAMA_HOST = "0.0.0.0:11434"
ollama serve

That setting disappears when the window closes, so use the account environment variables above for anything permanent. The Ollama Windows docs note that the app runs the server from the tray, so quit it first or the manual ollama serve hits the same "address already in use" error shown earlier.

Ollama REST API with curl

Every CLI command is a thin client over the REST API on port 11434, so anything you can do in the terminal you can script with curl.

curl http://localhost:11434/api/tags                 # like ollama list
curl http://localhost:11434/api/ps                   # like ollama ps
curl http://localhost:11434/api/generate -d '{
  "model": "qwen2.5:0.5b", "prompt": "Why is the sky blue?", "stream": false }'
curl http://localhost:11434/api/generate -d '{"model": "qwen2.5:0.5b", "keep_alive": 0}'  # unload
curl http://localhost:11434/v1/chat/completions -H "Content-Type: application/json" \
  -d '{"model": "qwen2.5:0.5b", "messages": [{"role": "user", "content": "Say ok"}]}'

A non-streaming /api/generate call returned 36 tokens with a total duration of 937 ms, and after a request with keep_alive set to 0, /api/ps listed 0 loaded models. The last call is the OpenAI-compatible endpoint. It returned a standard chat.completion object, so OpenAI SDK tools work with only a base URL change. To set a system prompt over the API, send a system field with /api/generate or a system-role message with /api/chat.

How to update Ollama on Mac, Windows, Linux, and Docker

No ollama update command exists in 0.34.4, and there is an open GitHub request to add one (issue 17219). ollama pull <model> updates a model, not Ollama itself. Updating Ollama depends on how you installed it; these steps come from the FAQ and the Ollama Linux docs, since my test used the standalone macOS build.

How to uninstall Ollama

Uninstalling Ollama means removing the program and, separately, the model folder that holds the gigabytes. None of these steps were part of my test; they follow the official docs.

On macOS, quit the app from the menu bar, then run the cleanup from the Ollama macOS docs:

sudo rm -rf /Applications/Ollama.app
sudo rm /usr/local/bin/ollama
rm -rf ~/Library/Application\ Support/Ollama ~/Library/Caches/ollama
rm -rf ~/.ollama        # deletes all models

With Homebrew, it is brew uninstall ollama followed by rm -rf ~/.ollama if you want the models gone too.

On Windows, remove Ollama from Settings, then "Add or remove programs". The Windows docs warn that the uninstaller does not delete models stored in a custom OLLAMA_MODELS folder, so delete that folder yourself, along with %HOMEPATH%\.ollama.

On Linux, stop the service and remove the binary, libraries, user, and data:

sudo systemctl stop ollama && sudo systemctl disable ollama
sudo rm /etc/systemd/system/ollama.service
sudo rm -r /usr/local/lib/ollama     # or /usr/lib/ollama if installed under /usr
sudo rm $(which ollama)
sudo userdel ollama && sudo groupdel ollama
sudo rm -r /usr/share/ollama         # deletes all models

The Linux docs remove the libraries with $(which ollama | tr 'bin' 'lib'). That trick swaps characters, not words, and it can produce the wrong path, as reported in issue 14931. Naming the folder is safer.

Ollama model list: installed vs available

ollama list only shows models already on your machine; the CLI in 0.34.4 has no command that searches the online catalog. To see every model you can download, browse ollama.com/search, which filters by capability (tools, vision, thinking, embedding, cloud) and sorts by popularity or date. Each model page lists its tags, and each tag has its own size and context length.

The last row matters when the quant you want is not in the Ollama library. The Hugging Face Ollama docs document the hf.co/{username}/{repository}:{quantization} form, for example :Q8_0 or :IQ3_M, and the quantization name is case-insensitive. If you are deciding which quant to pull, our Q4_K_M vs Q5_K_M comparison covers the size and quality trade-off.

Where Ollama stores models

Ollama stores models as a blobs folder of weight files plus a manifests folder of names, under one models directory per OS. On my Mac the store under ~/.ollama/models had those two folders plus a metadata folder; the other paths come from the FAQ.

To move models to a bigger drive, set OLLAMA_MODELS for the server, restart it, and move or re-pull the models; on Linux the ollama user must be able to write there.

After ollama rm of the only model, my store dropped to 0 KB, so removing a model frees its blobs right away unless another model still references them. If you are choosing what to fill that folder with, the 8 GB RAM local LLM guide and the local LLM hardware calculator size models against your memory.

How I tested this

• Machine: Apple M1 with 8 GB of memory, macOS (Darwin 26.3, arm64).
• Version: Ollama 0.34.4, from the official standalone ollama-darwin.tgz release (497 MB unpacked), not the desktop app or Homebrew.
• Model: qwen2.5:0.5b (Q4_K_M), the only model pulled.
• Date: September 26, 2026.
• What I ran: a shell harness that started ollama serve on the default port, then ran pull, list, ls, show, run (one-shot, piped and interactive with each slash command), ps, stop, cp, create, rm, the curl calls above, and a second server on port 11500 with its own models folder.
• What I did not test: push, signin, signout, launch, the desktop apps, Homebrew, Docker, and every Windows and Linux step on this page, which come from the docs.
• Raw record: results.json, including the full interactive transcript.

Related coverage

• Ollama vs llama.cpp
• LM Studio vs Ollama
• Best Ollama model for coding
• Ollama Docker GPU setup

References

• Ollama CLI docs - https://docs.ollama.com/cli
• Ollama envconfig source - https://github.com/ollama/ollama/blob/main/envconfig/config.go
• Ollama FAQ - https://docs.ollama.com/faq
• Ollama Linux docs - https://docs.ollama.com/linux
• Ollama macOS docs - https://docs.ollama.com/macos
• Ollama Windows docs - https://docs.ollama.com/windows