Ollama CLI commands: ollama ps, run, pull and more

This page is a reference for the ollama command line tool on a Linux server. It lists every command, the flags that matter in practice, the environment variables of the background service and the REST API calls that do the same work over HTTP. The commands and flags were checked against the Ollama source code and documentation for release v0.40.14.

If Ollama is not installed yet, follow how to run Ollama on a CPU only VPS first. The examples below use the small gemma3:1b model. Replace it with any model name from the Ollama library.

All commands at a glance

Command	What it does
ollama serve	Start the Ollama server in the foreground (alias ollama start)
ollama run MODEL [PROMPT]	Chat with a model, or answer one prompt and exit
ollama pull MODEL	Download a model or update it to the latest version
ollama push MODEL	Upload your own model to ollama.com
ollama list / ollama ls	Show models stored on disk
ollama ps	Show models currently loaded in memory
ollama stop MODEL	Unload a running model from memory
ollama show MODEL	Print model details, parameters, template or license
ollama create NAME -f Modelfile	Build a custom model from a Modelfile
ollama cp SOURCE DESTINATION	Copy a model under a new name
ollama rm MODEL [MODEL...]	Delete one or more models from disk
ollama signin / ollama signout	Connect or disconnect the server from an ollama.com account (aliases login, logout)
ollama launch	Configure a coding tool such as Claude Code, Codex or OpenCode to use Ollama
ollama -v	Print the client and server version

Every command accepts --help, for example ollama run --help. The CLI is a client: apart from serve, each command talks to the server on 127.0.0.1:11434, so the ollama service must be running.

ollama run

Start an interactive chat. The model is downloaded first if it is not on disk yet:

ollama run gemma3:1b

Pass a prompt to get one answer and return to the shell. This form works in scripts and cron jobs:

ollama run gemma3:1b "Summarize the benefits of NVMe storage in two sentences."

Text from a pipe is added to the prompt, which is handy for log files and documents:

cat /var/log/nginx/error.log | tail -n 50 | ollama run gemma3:1b "Explain these errors briefly:"

Flags of ollama run that are useful on a server:

Flag	Effect
--verbose	After each answer, print timings: load time, prompt evaluation rate and generation speed in tokens per second
--format json	Force the answer to be valid JSON
--keepalive 30m	Keep the model in memory for this long after the last request, instead of the server default
--nowordwrap	Do not wrap long lines, useful when the output goes to a file
--think / --think=false	Turn the reasoning phase on or off for models that support it (high, medium and low work on some models)
--hidethinking	Keep reasoning on but print only the final answer
--insecure	Allow pulling from a registry without valid TLS

--verbose is the quickest benchmark you have. The eval rate line shows how many tokens per second the model generates on your CPU:

ollama run gemma3:1b --verbose "Write a haiku about servers."

A JSON example for scripts:

ollama run gemma3:1b --format json "List three Linux distributions as a JSON array named distros."

Commands inside the chat

At the >>> prompt these commands are available:

Command	Effect
/? or /help	List all chat commands
/set parameter num_ctx 8192	Change a parameter for this session, here the context length
/set system "You are a terse assistant."	Set a system message
/set verbose	Show timings after every answer
/show info	Print model details
/clear	Clear the conversation context
/save NAME	Save the current session as a new model
/load NAME	Switch to another model
/bye	Exit

Wrap text in """ to type a prompt that spans several lines.

ollama pull, list, cp and rm

Download a model without starting it:

ollama pull gemma3:1b

Running pull again on a model you already have updates it. Only the changed layers are downloaded.

List what is stored on disk:

ollama list

The table has four columns: NAME (model and tag), ID (the first 12 characters of the digest), SIZE (space on disk) and MODIFIED (when it was pulled or created). ollama ls is the same command.

Copy a model under another name. No data is duplicated, both names point to the same files:

ollama cp gemma3:1b my-assistant

Delete models. You can pass several names at once, and a model that is loaded is stopped first:

ollama rm my-assistant gemma3:1b

ollama ps

ollama ps lists the models that are loaded in memory right now. A model that is only on disk does not appear here. On a CPU server the output looks like this:

NAME         ID              SIZE      PROCESSOR    CONTEXT    RUNNER    UNTIL
gemma3:1b    97558784bdc9    1.9 GB    100% CPU     4096       ggml      4 minutes from now

The numbers on your server will differ with the model, the context length and the Ollama version. What each column means:

Column	Meaning
NAME	The model and tag that is loaded
ID	Short digest, the same as in ollama list
SIZE	Memory the loaded model takes, including the context cache. This is usually larger than the size on disk
PROCESSOR	Where the model lives: 100% CPU means fully in system RAM, 100% GPU means fully in video memory, and a split like 48%/52% CPU/GPU means it is divided
CONTEXT	Context length in tokens that the model was loaded with
RUNNER	The inference engine that serves the model, for example ggml or llamacpp
UNTIL	When the model will be unloaded if no new requests arrive. Forever means it never expires, Stopping... means it is being unloaded

Older Ollama versions print only NAME, ID, SIZE, PROCESSOR and UNTIL. To see a single model, add part of its name: ollama ps gemma3.

On a DataPasa VPS there is no GPU, so PROCESSOR always shows 100% CPU. That is expected and not an error.

ollama stop

Unload a model right away and free its memory. The files stay on disk:

ollama stop gemma3:1b

The next request loads the model again, which takes a few seconds on a CPU.

ollama show

Print a summary of a model: architecture, parameter count, context length, quantization, capabilities and default parameters.

ollama show gemma3:1b

Flags print one part only:

Flag	Prints
--modelfile	The full Modelfile, a good starting point for your own model
--parameters	Default parameters such as temperature, top_k and stop tokens
--template	The prompt template
--system	The built in system message, if there is one
--license	The license text
-v, --verbose	Detailed metadata of the model file

ollama create with a Modelfile

A Modelfile describes a new model on top of an existing one: a fixed system prompt, different defaults, a longer context. Create a working folder and a file named Modelfile:

mkdir -p ~/models/support-bot && cd ~/models/support-bot
nano Modelfile

FROM gemma3:1b
PARAMETER temperature 0.3
PARAMETER num_ctx 8192
SYSTEM """
You answer customer questions about web hosting. Keep answers short and polite.
"""

Build and run it:

ollama create support-bot -f Modelfile
ollama run support-bot

Common Modelfile instructions:

Instruction	Purpose
FROM	Base model name, or a path to a GGUF or Safetensors file
PARAMETER	Default option, for example temperature, num_ctx, top_p, stop
SYSTEM	System message used for every chat
TEMPLATE	Prompt template, only needed for imported models
ADAPTER	A LoRA adapter to apply on top of the base model
MESSAGE	Example dialogue to prime the model
LICENSE	License text stored with the model

The new model shares layers with its base, so it takes almost no extra disk space. ollama create -q can quantize a model while importing it from Safetensors weights.

ollama push, signin and launch

To publish a model on ollama.com, create an account, run ollama signin on the server and follow the link it prints. Then copy the model into your namespace and push it:

ollama cp support-bot YOUR_USERNAME/support-bot
ollama push YOUR_USERNAME/support-bot

ollama signout disconnects the server from the account. ollama launch sets up a coding assistant such as Claude Code, Codex, OpenCode or Droid to use your Ollama models. It is aimed at desktops and is rarely needed on a server.

ollama serve and server settings

With the official installer the server already runs as the ollama systemd service, so you do not start ollama serve yourself. Run it in the foreground only for debugging, after stopping the service:

systemctl stop ollama
OLLAMA_DEBUG=1 ollama serve

The server is configured with environment variables. These are the ones that matter on a VPS:

Variable	Default	What it controls
OLLAMA_HOST	127.0.0.1:11434	Address and port the API listens on
OLLAMA_KEEP_ALIVE	5m	How long an idle model stays in memory. 0 unloads at once, a negative value such as -1 keeps it loaded
OLLAMA_MODELS	/usr/share/ollama/.ollama/models	Folder where models are stored
OLLAMA_NUM_PARALLEL	1	How many requests one model processes at the same time
OLLAMA_MAX_LOADED_MODELS	3 without a GPU	How many different models can be in memory at once
OLLAMA_MAX_QUEUE	512	Requests that may wait before the server answers with HTTP 503
OLLAMA_CONTEXT_LENGTH	4096 without a GPU	Default context length when a request does not set one
OLLAMA_ORIGINS	local origins	Extra browser origins allowed to call the API
OLLAMA_DEBUG	off	Verbose logging, set to 1

ollama serve --help prints the full list for your version.

Set variables with a systemd override

Do not edit the unit file the installer created, because an update overwrites it. Use an override instead:

systemctl edit ollama.service

Add the variables under [Service], one Environment line each:

[Service]
Environment="OLLAMA_KEEP_ALIVE=30m"
Environment="OLLAMA_MAX_LOADED_MODELS=1"
Environment="OLLAMA_NUM_PARALLEL=1"

Apply and check:

systemctl daemon-reload
systemctl restart ollama
systemctl show ollama --property=Environment

If you move models with OLLAMA_MODELS, the new folder must belong to the ollama user, for example chown -R ollama:ollama /data/ollama.

REST API equivalents

Everything the CLI does goes through the HTTP API on port 11434. You can call it with curl from the server or from apps running on it.

CLI	API call
ollama run (one prompt)	POST /api/generate
ollama run (chat)	POST /api/chat
ollama list	GET /api/tags
ollama ps	GET /api/ps
ollama show	POST /api/show
ollama pull	POST /api/pull
ollama cp	POST /api/copy
ollama rm	DELETE /api/delete
ollama stop	POST /api/generate with "keep_alive": 0
ollama -v	GET /api/version

Generate a single answer. "stream": false returns one JSON object instead of a stream of chunks:

curl http://localhost:11434/api/generate -d '{
  "model": "gemma3:1b",
  "prompt": "Name three uses of a VPS.",
  "stream": false
}'

A chat with history and a system message:

curl http://localhost:11434/api/chat -d '{
  "model": "gemma3:1b",
  "messages": [
    { "role": "system", "content": "Answer in one sentence." },
    { "role": "user", "content": "What is KVM virtualization?" }
  ],
  "stream": false,
  "options": { "temperature": 0.2, "num_ctx": 4096 }
}'

List downloaded and loaded models:

curl http://localhost:11434/api/tags
curl http://localhost:11434/api/ps

/api/ps returns the same data as ollama ps in JSON: size is the memory in bytes, size_vram is the part in video memory (always 0 on a CPU server), context_length and expires_at match the CONTEXT and UNTIL columns.

Load a model in advance, or unload it, by sending a request with no prompt:

curl http://localhost:11434/api/generate -d '{"model": "gemma3:1b", "keep_alive": -1}'
curl http://localhost:11434/api/generate -d '{"model": "gemma3:1b", "keep_alive": 0}'

The first keeps the model in memory until the service restarts, the second unloads it at once.

Reading ollama ps on a CPU VPS

On a server without a GPU, models are loaded into the same RAM that the system and your other apps use. A few habits keep memory under control:

• Compare SIZE with free memory. Run ollama ps and free -h side by side. The model SIZE must fit in available RAM with room left for the system. Our guide on how much RAM your VPS needs helps with sizing.
• Watch the context. A bigger CONTEXT means a bigger SIZE. Memory for the context also grows with OLLAMA_NUM_PARALLEL, because each parallel slot gets its own cache. On 4 to 8 GB plans keep parallel requests at 1.
• Allow one model at a time on small plans. With the default of three loaded models, a request to a second model can push the first one into swap or make the kernel kill the process. OLLAMA_MAX_LOADED_MODELS=1 makes Ollama unload the old model before loading a new one.
• Unload when you are done. ollama stop MODEL frees memory immediately. If a model is used rarely, a short OLLAMA_KEEP_ALIVE such as 2m returns RAM quickly. If it is used all the time, a long keep alive saves the reload delay on every request.
• Check the logs when a model fails to load. journalctl -u ollama -n 100 shows memory errors and load times.

As a guide, 1B to 4B models fit on VPS-3 (2 vCPU, 4 GB) and VPS-4 (4 vCPU, 8 GB), and 12B to 14B models need VPS-6 (6 vCPU, 16 GB). DataPasa servers run on NVMe in Falkenstein, Germany, and are billed by the hour from a prepaid balance, so you can test a larger plan for a day and delete it. Plans for language models are on the Ollama VPS page and all prices are on the pricing page.

Never expose port 11434 to the internet

The Ollama API has no authentication. Anyone who reaches it can run your models, pull new ones to fill your disk and delete the ones you have. Keep OLLAMA_HOST on 127.0.0.1 and reach the API through an SSH tunnel or a reverse proxy with a password, as shown in the Ollama setup guide. If you ever change OLLAMA_HOST to 0.0.0.0, block the port with a firewall, see how to secure your VPS with UFW and Fail2ban.

Summary

ollama run, pull, list and rm cover daily work with models, ollama ps and ollama stop show and free the memory they use, and ollama show and ollama create let you inspect and customize them. Server behavior is set with environment variables in a systemd override, and every command has a REST API counterpart on localhost. To run these models around the clock, pick a plan on the Ollama VPS page.