How to start an interactive Ollama chat<\/strong><\/h3>An interactive Ollama chat starts when you run a model without a prompt. The session keeps the conversation context, so you can ask follow-up questions.<\/p>
ollama run gemma3<\/pre>Inside the session, type a prompt and press Enter<\/strong>. For example, you can ask the model to explain a command before you run it:<\/p>Explain what the command find . -name \"*.log\" -mtime +7 -delete does.<\/pre>\n\t\t\t\n\t\t\t\t<\/path>\n\t\t\t<\/svg>\n\t\t<\/button><\/figure>A few slash commands help you manage the session:<\/p>
\n\/bye<\/strong> ends the session and returns you to the terminal.<\/li>\n\n\n\n\/clear<\/strong> clears the current context, so the model forgets the conversation so far.<\/li>\n\n\n\n\/help<\/strong> lists the available session commands.<\/li>\n<\/ul>The model remembers the conversation only while the session is open. If you exit then start a new session, it has no memory of the previous chat.<\/p>
If you want consistent behavior across sessions, define it in a Modelfile instead of relying on chat history.<\/p>
How to use multiline prompts<\/strong><\/h3>Multiline prompts let you send long or structured input at once, such as a pasted log, a configuration block, or multi-step instructions. Inside a session, wrap the text in triple quotes:<\/p>
>>> \"\"\"\n... Review this NGINX location block and flag any problem:\n... location \/api {\n... proxy_pass http:\/\/localhost:3000;\n... }\n... \"\"\"<\/pre>The model treats everything between the opening and closing triple quotes as a single prompt. This is cleaner than forcing a long instruction onto one line.<\/p>
How to use multimodal models in Ollama CLI<\/strong><\/h3>The Ollama CLI supports multimodal prompts with vision-capable models, so you can ask about an image directly from the terminal. Add the image file path to the prompt, and the model reads it as input:<\/p>
ollama run gemma3 “Describe what is shown in this screenshot: \/home\/user\/screenshot.png”<\/p>
The default gemma3<\/strong> model handles images, while the smaller gemma3:1b<\/strong> model supports text only. Pull the 4B<\/strong> model or a larger version for visual tasks.<\/p>A graphical interface often works better for repeated image tasks, but the CLI handles one-off image prompts well.<\/p>
How to manage local Ollama models<\/strong><\/h2>The Ollama CLI manages local models with commands that list, inspect, stop, and remove model files on your machine. You’ll use these commands after running a model when you need to check storage or free up memory.<\/p>
Each command works with models already downloaded to your system.<\/p>
How to list installed models<\/strong><\/h3>List installed models with ollama list<\/strong> or its shorter alias, ollama ls<\/strong>. Both commands print the same table:<\/p>ollama list<\/pre>\n\t\t\t\n\t\t\t\t<\/path>\n\t\t\t<\/svg>\n\t\t<\/button><\/figure>The output shows each model’s name, size on disk, and last modified date. Check the size column when disk space runs low because larger models can take up several gigabytes each.<\/p>
How to inspect model details<\/strong><\/h3>Inspect a model’s details with ollama show<\/strong>. It prints the model’s architecture, parameters, context length, and license:<\/p>ollama show gemma3<\/pre>\n\t\t\t\n\t\t\t\t<\/path>\n\t\t\t<\/svg>\n\t\t<\/button><\/figure>To see the exact recipe behind a model, add the –modelfile<\/strong> flag:<\/p>ollama show --modelfile gemma3<\/pre>Use this before customizing or deleting a model, so you know its template and parameters first. The –modelfile<\/strong> output also gives you a useful starting point when you build your own model.<\/p>How to stop or remove models<\/strong><\/h3>Stop a running model with ollama stop<\/strong>, and delete a downloaded model with ollama rm<\/strong>. Check what’s currently running first:<\/p>ollama ps<\/pre>Stopping unloads the model from memory but keeps it on disk:<\/p>
ollama stop gemma3<\/pre>Removing deletes the model files from disk:<\/p>
ollama rm gemma3<\/pre>Deleting a model frees disk space, but you’ll need to download it again before the next run. Stop a model when you only want to free memory, and remove it when you no longer need the files.<\/p>
How to use files, outputs, and embeddings in the Ollama CLI<\/strong><\/h2>The Ollama CLI reads prompt input from files, writes responses to files, and generates embeddings through standard terminal redirection and pipes.<\/p>
The model reads from standard input and writes to standard output, so the usual shell operators work without extra setup.<\/p>
Four shell features cover most file and output workflows:<\/p>
\n< input.txt<\/strong> sends a file’s contents to the model as input.<\/li>\n\n\n\n> output.txt<\/strong> writes the response to a file and overwrites anything already there.<\/li>\n\n\n\n>> output.txt<\/strong> appends the response to the end of an existing file.<\/li>\n\n\n\n|<\/strong> pipes the output of another command straight into Ollama.<\/li>\n<\/ul>How to prompt Ollama with a local file<\/strong><\/h3>Prompt Ollama with a local file by redirecting the file into the command with <<\/strong>. The model reads the file and acts on it, so you don’t need to paste long text into the terminal:<\/p>ollama run gemma3 \"Summarize this server log and list the three most frequent errors:\" < error.log<\/pre>This works well for long documents, configuration files, and log files. The instruction in quotes tells the model what to do, and the file after <<\/strong> supplies the content.<\/p>How to save Ollama responses to a file<\/strong><\/h3>Save Ollama responses to a file by redirecting the output with ><\/strong> or >><\/strong>. The first operator overwrites the file, while the second appends to it:<\/p>ollama run gemma3 \"List three common Linux server hardening steps.\" > hardening-notes.txt<\/pre>\n\t\t\t\n\t\t\t\t<\/path>\n\t\t\t<\/svg>\n\t\t<\/button><\/figure>Use >><\/strong> when you want to keep adding to the same file across several runs:<\/p>ollama run gemma3 \"Add three more hardening steps for SSH.\" >> hardening-notes.txt<\/pre>How to generate embeddings from the terminal<\/strong><\/h3>Generate embeddings from the terminal by running an embedding model, which returns a numerical vector instead of text.<\/p>
Embeddings turn text into numbers that capture meaning. They power semantic search, clustering, and retrieval-augmented generation (RAG).<\/p>
Run an embedding model and pass it some text. Ollama pulls the model automatically on the first run:<\/p>
ollama run embeddinggemma \"How do I reset a user password on Linux?\"<\/pre>The output is a JSON array of numbers instead of a sentence. For larger or repeated workloads, use the \/api\/embed<\/strong> endpoint or the Python library, which is faster than the interactive command.<\/p>How to customize Ollama models with a Modelfile<\/strong><\/h2>A Modelfile is the blueprint for building and sharing a customized Ollama model. It combines a base model with a system message, parameters, and a prompt template into a new model you can run by name.<\/p>
A Modelfile customizes how a model behaves. It doesn’t train the model on new data. Real fine-tuning trains LoRA adapters with external tools such as llama.cpp or Unsloth.<\/p>
The ADAPTER<\/strong> instruction in a Modelfile applies those pre-trained adapters to a base model. That’s a separate workflow beyond system prompts and parameters.<\/p>The value of a Modelfile is persistence. Settings you’d otherwise retype in every session become part of a reusable model instead.<\/p>
![\"Terminal](\"https:\/\/imagedelivery.net\/LqiWLm-3MGbYHtFuUbcBtA\/wp-content\/uploads\/sites\/2\/2024\/10\/ollama-cli-verify-version.png\/w=1024,h=1024,fit=scale-down\")