Ollama CLI-Referentie: ls, serve, run, ps en andere commando's (update 2026)

Deze Ollama CLI-cheat sheet richt zich op de commando’s die je dagelijks gebruikt (ollama ls, ollama serve, ollama run, ollama ps, modelbeheer en veelvoorkomende workflows), met voorbeelden die je kunt kopiëren en plakken.

Het bevat ook een korte sectie over “prestatie-instellingen” om je te helpen OLLAMA_NUM_PARALLEL en gerelateerde instellingen te ontdekken (en vervolgens dieper in te gaan).

Deze Ollama-cheat sheet richt zich op CLI-commando’s, modelbeheer en aanpassingen, maar we hebben hier ook een aantal curl-oproepen.

Voor een volledig beeld van waar Ollama zich bevindt tussen lokale, zelf-gehoste en cloudopties – inclusief vLLM, Docker Model Runner, LocalAI en cloudproviders – zie LLM Hosting: Lokale, Zelf-gehoste & Cloudinfrastructuur vergeleken. Als je verschillende lokale LLM-hostingoplossingen vergelijkt, bekijk dan onze omvattende vergelijking van Ollama, vLLM, LocalAI, Jan, LM Studio en meer. Voor hen die een alternatief zoeken voor commandoreeksen, biedt Docker Model Runner een andere aanpak voor LLM-implementatie.

Ollama-installatie (download en CLI-installatie)

• Optie 1: Downloaden van de website
  • Bezoek ollama.com en download de installer voor jouw besturingssysteem (Mac, Linux of Windows).
• Optie 2: Installeren via de commandoregel
  • Voor Mac- en Linux-gebruikers, gebruik het commando:

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

• Volg de instructies op het scherm en voer je wachtwoord in indien gevraagd.

Ollama-systeemvereisten (RAM, opslag, CPU)

• Besturingssysteem: Mac, Linux of Windows
• Geheugen (RAM): minimaal 8GB, 16GB of meer aanbevolen
• Opslag: Minimaal ~10GB vrije ruimte (modelbestanden kunnen erg groot zijn, zie hier meer over Ollama-modellen naar een andere schijf verplaatsen )
• Processor: Een relatief moderne CPU (van de laatste 5 jaar). Als je benieuwd bent naar hoe Ollama verschillende CPU-architecturen benut, bekijk dan onze analyse van hoe Ollama Intel CPU-prestaties en Efficient Cores gebruikt.

Voor serieuze AI-workloads kun je hardwareopties vergelijken. We hebben NVIDIA DGX Spark vs Mac Studio vs RTX-4080 prestaties met Ollama getest, en als je overweegt te investeren in hoogwaardige hardware, biedt onze DGX Spark-prijzen en capaciteiten vergelijking gedetailleerde kostenanalyse.

Basis Ollama CLI-commando’s

Snelle links: Ollama serve commando · Ollama launch commando · Ollama run commando · Ollama run vlaggen · Ollama ps commando · Ollama show commando · Ollama signin · Ollama CLI basis · Prestatie-instellingen (OLLAMA_NUM_PARALLEL) · Diepe duik in parallele verzoeken

Ollama CLI (wat het is)

Ollama CLI is de commandoregel-interface om modellen te beheren en lokaal uit te voeren/te serveren. De meeste workflows komen neer op:

• Start de server: ollama serve
• Voer een model uit: ollama run <model>
• Bekijk wat geladen/draait: ollama ps
• Beheer modellen: ollama pull, ollama list, ollama rm

Ollama modelbeheer: pull en list commando’s

Modellen Lijsten:

ollama list

dezelfde als:

ollama ls

Dit commando toont alle modellen die naar je systeem zijn gedownload, met hun bestandsgrootte op je HDD/SSD, zoals:

$ ollama ls
NAAM                                                    ID              GROOTTE   GEMODIFICEERD     
deepseek-r1:8b                                          6995872bfe4c    5,2 GB    2 weken geleden     
gemma3:12b-it-qat                                       5d4fa005e7bb    8,9 GB    2 weken geleden     
LoTUs5494/mistral-small-3.1:24b-instruct-2503-iq4_NL    4e994e0f85a0    13 GB     3 weken geleden     
dengcao/Qwen3-Embedding-8B:Q4_K_M                       d3ca2355027f    4,7 GB    4 weken geleden     
dengcao/Qwen3-Embedding-4B:Q5_K_M                       7e8c9ad6885b    2,9 GB    4 weken geleden     
qwen3:8b                                                500a1f067a9f    5,2 GB    5 weken geleden     
qwen3:14b                                               bdbd181c33f2    9,3 GB    5 weken geleden     
qwen3:30b-a3b                                           0b28110b7a33    18 GB     5 weken geleden     
devstral:24b                                            c4b2fa0c33d7    14 GB     5 weken geleden  

Een Model Downloaden: ollama pull

ollama pull mistral-nemo:12b-instruct-2407-q6_K

Dit commando downloadt het opgegeven model (bijv. Gemma 2B, of mistral-nemo:12b-instruct-2407-q6_K) naar je systeem. De modelbestanden kunnen vrij groot zijn, dus houd de ruimte die door modellen wordt gebruikt op de harde schijf of SSD in de gaten. Je zou zelfs willen alle Ollama-modellen van je home-directory naar een andere, grotere en betere schijf verplaatsen

Een Model Uploaden: ollama push

ollama push mijn-aangepaste-model

Uploadt een lokaal model naar de Ollama-register zodat anderen het kunnen ophalen. Je moet eerst ingelogd zijn (ollama signin) en de modelnaam moet worden voorafgegaan door je Ollama-gebruikersnaam, bijv. mijngebruiker/mijn-model. Gebruik --insecure als je naar een privé-register push via HTTP:

ollama push mijngebruiker/mijn-model --insecure

Een Model Kopiëren: ollama cp

ollama cp llama3.2 mijn-llama3-variant

Maakt een lokale kopie van een model onder een nieuwe naam zonder iets opnieuw te downloaden. Dit is handig voordat je een Modelfile bewerkt: kopieer eerst, pas de kopie aan en behoud het origineel intact:

ollama cp qwen3:14b qwen3-14b-aangepast
ollama create qwen3-14b-aangepast -f ./Modelfile

Ollama show commando

ollama show print informatie over een gedownload model.

ollama show qwen3:14b

Standaard print het de modelkaart (architectuur, contextlengte, embeddinglengte, kwantisatie, enz.). Er zijn drie nuttige vlaggen:

# Zie precies welke systeem-prompt en sjabloon een model is gebouwd met
ollama show deepseek-r1:8b --modelfile

# Controleer de contextvenstergrootte en andere inferentieparameters
ollama show qwen3:14b --parameters

# Volledige tensor-niveau detail (handig bij het debuggen van kwantisatie)
ollama show llama3.2 --verbose

De --modelfile-output is vooral nuttig voordat je een model aanpast: je kunt de basis Modelfile kopiëren en daar vanaf bewerken in plaats van er een van nul te schrijven.

Ollama serve commando

ollama serve start de lokale Ollama-server (standaard HTTP-poort 11434).

ollama serve

“ollama serve” commando (systemd-vriendelijk voorbeeld):

# stel omgevingsvariabelen in, start dan de server
# maak ollama beschikbaar op het IP-adres van de host
export OLLAMA_HOST=0.0.0.0:11434
export OLLAMA_NUM_PARALLEL=2
ollama serve

Ollama run commando

Een Model Uitvoeren:

ollama run gpt-oss:20b

Dit commando start het opgegeven model en opent een interactieve REPL voor interactie. Wil je begrijpen hoe Ollama meerdere gelijktijdige verzoeken beheert? Lees meer over hoe Ollama parallele verzoeken hanteert in onze gedetailleerde analyse.

ollama run voert een model uit in een interactieve sessie, dus in het geval van gpt-oss:120b zou je iets zien als:

$ ollama run gpt-oss:120b
>>> Stuur een bericht (/? voor hulp)

Je kunt je vragen of commando’s typen en het model zal reageren.

>>> wie ben je?
Denken...
De gebruiker vraagt "wie ben je?" Simpele vraag. Moet reageren als ChatGPT, een AI-taalkmodel, getraind door OpenAI, 
enz. Korte intro geven. Vraag waarschijnlijk of ze hulp nodig hebben.
...gedaan met denken.

Ik ben ChatGPT, een AI-taalkmodel gemaakt door OpenAI. Ik ben getraind op een breed scala aan tekst, dus ik kan helpen 
vragen beantwoorden, ideeën bedenken, concepten uitleggen, schrijven schetsen, problemen oplossen, en nog veel meer. Denk 
aan mij als een veelzijdige virtuele assistent—hier om informatie, ondersteuning en conversatie te bieden wanneer je het nodig 
hebt. Hoe kan ik je vandaag helpen?

>>> Stuur een bericht (/? voor hulp)

Om de interactieve Ollama-sessie te verlaten, druk op Ctrl+D, of typ /bye, hetzelfde resultaat:

>>> /bye
$ 

Ollama run commando voorbeelden

Om een model uit te voeren en een enkele vraag te stellen in een niet-interactieve modus:

printf "Geef me 10 bash one-liners voor log-analyse.\n" | ollama run llama3.2

Als je een gedetailleerde verbose LLM-antwoord wilt zien in de Ollama-sessie - voer het model uit met de --verbose of -v parameter:

$ ollama run gpt-oss:20b --verbose
>>> wie ben je?
Denken...
We moeten reageren op een simpele vraag: "wie ben je?" De gebruiker vraagt "wie ben je?" We kunnen antwoorden dat we 
ChatGPT zijn, een groot taalkmodel getraind door OpenAI. We kunnen ook capaciteiten noemen. De gebruiker verwacht waarschijnlijk 
een korte introductie. We houden het vriendelijk.
...gedaan met denken.

Ik ben ChatGPT, een groot taalkmodel gemaakt door OpenAI. Ik ben hier om te helpen vragen te beantwoorden, uitleg te bieden, 
ideeën te bedenken en te kletsen over een breed scala aan onderwerpen—van wetenschap en geschiedenis tot creatief schrijven 
en dagelijks advies. Laat maar weten waar je over wilt praten!

totaal duur:       1.118585707s
laadduur:        106.690543ms
prompt eval teller:    71 token(s)
prompt eval duur: 30.507392ms
prompt eval snelheid:     2327.30 tokens/s
eval teller:           132 token(s)
eval duur:        945.801569ms
eval snelheid:            139.56 tokens/s
>>> /bye
$ 

Ja, dat klopt, het is 139 tokens per seconde. De gpt-oss:20b is erg snel. Als jij, net als ik, een GPU hebt met 16GB VRAM - bekijk de LLM-snelheidsvergelijkingdetails in Beste LLM’s voor Ollama op 16GB VRAM GPU.

Tip: Als je het model beschikbaar wilt maken via HTTP voor meerdere apps, start de server met ollama serve en gebruik de API-client in plaats van lange interactieve sessies.

Ollama run vlaggen (volledige referentie)

Modelparameters overschrijven zonder een Modelfile (-p / –parameters)

De -p vlag laat je inferentieparameters aanpassen tijdens runtime zonder een Modelfile te maken. Je kunt meerdere -p vlaggen stapelen:

# Verhoog het contextvenster en verlaag de temperatuur
ollama run qwen3:14b -p num_ctx=32768 -p temperature=0.5

# Voer een taak uit met deterministische uitvoer
ollama run devstral:24b -p temperature=0 -p num_ctx=65536

Veelvoorkomende parameters die je op deze manier kunt instellen:

Meerdere regels invoer in de REPL

Omring tekst met drie aanhalingstekens (""") om een multi-regel prompt in te voeren zonder vroeg in te dienen:

>>> """Samenvatten dit in één zin:
... De snelle bruine vos springt over de luie hond.
... Het gebeurde op een dinsdag.
... """

Multimodale modellen (afbeeldingen)

Voor visie-gevende modellen (bijv. gemma3, llava), pas een afbeeldingspad direct in de prompt toe:

ollama run gemma3 "Wat is er in deze afbeelding? /home/user/screenshot.png"

Embeddings genereren via CLI

Embedding-modellen geven een JSON-array in plaats van tekst. Pijp tekst direct voor snelle one-off embeddings:

echo "Hallo wereld" | ollama run nomic-embed-text

Voor productie-embedding-workloads gebruik je de /api/embeddings REST-endpoint of de Python-client in plaats daarvan.

Forceer JSON-uitvoer (–format)

ollama run llama3.2 --format json "Lijst 5 hoofdsteden op als JSON"

Het model wordt geïnstrueerd om geldige JSON terug te geven. Nuttig bij het pipen van uitvoer naar jq of een script dat gestructureerde data verwacht.

Ollama stop commando

Dit commando stopt het opgegeven draaiende model.

ollama stop llama3.1:8b-instruct-q8_0

Ollama verwijdert modellen automagisch na enige tijd. Je kunt deze tijd specificeren, maar standaard is het 4 minuten. Als je niet wilt wachten op de resterende tijd, kun je dit ollama stop commando gebruiken. Je kunt het model ook uit de VRAM schoppen door de /generate API-endpoint aan te roepen met parameter keep_alive=0, zie hieronder voor de beschrijving en voorbeeld.

Ollama ps commando

ollama ps toont momenteel draaiende modellen en sessies (handig om te debuggen “waarom is mijn VRAM vol?”).

ollama ps

Het voorbeeld van de ollama ps-output staat hieronder:

NAAM           ID              GROOTTE     PROCESSOR    CONTEXT    TOT
gpt-oss:20b    17052f91a42e    14 GB    100% GPU     4096       4 minuten vanaf nu

Je ziet hier op mijn PC dat gpt-oss:20b zeer goed past in mijn GPU’s 16GB VRAM, en slechts 14GB bezet.

Als ik ollama run gpt-oss:120b uitvoer en dan ollama ps aanroep, zal het resultaat niet zo helder zijn: 78% van de lagen is op de CPU, en dit is alleen met het contextvenster van 4096 tokens. Het zal meer zijn als ik het contextvenster moet vergroten.

NAAM            ID              GROOTTE     PROCESSOR          CONTEXT    TOT
gpt-oss:120b    a951a23b46a1    66 GB    78%/22% CPU/GPU    4096       4 minuten vanaf nu

Ollama launch commando (AI-coding integraties)

ollama launch is een commando geïntroduceerd in Ollama v0.15 (januari 2026) dat je configuratie-loze, één-regel-instelling geeft voor populaire AI-coding-assistants die draaien tegen je lokale Ollama-server.

Waarom ollama launch gebruiken?

Voordat ollama launch bestond, betekende het aansluiten van een coding-agent zoals Claude Code of Codex op een lokale Ollama-backend het handmatig instellen van omgevingsvariabelen, het tool naar het juiste API-endpoint wijzen en een compatibel model kiezen. ollama launch doet al dat voor jou interactief.

Als je Ollama al lokaal draait en een agentische coding-assistent wilt zonder te betalen voor API-oproepen of code naar de cloud te sturen, is ollama launch de snelste weg daarheen.

Ondersteunde integraties

Basisgebruik

# Interactieve selector — kies een integratie uit een menu
ollama launch

# Lanceer een specifieke integratie direct
ollama launch claude

# Lanceer met een specifiek model
ollama launch claude --model qwen3-coder

# Configureer de integratie zonder het te lanceren (handig om instellingen te inspecteren)
ollama launch droid --config

Aanbevolen modellen

Coding-agents hebben een groot contextvenster nodig om volledige bestandscontext en meerrondegespreksgeschiedenis vast te houden. Ollama beveelt modellen aan met minimaal 64 000 tokens aan context:

Als je GPU het model niet kan bevatten, biedt Ollama ook cloud-gehoste varianten (bijv. qwen3-coder:480b-cloud) die op dezelfde manier integreren maar inferentie naar Ollama’s cloud-niveau routeren — wat ollama signin vereist.

Voorbeeld: Claude Code lokaal uitvoeren met Ollama

# 1. Zorg ervoor dat het model beschikbaar is
ollama pull qwen3-coder

# 2. Lanceer Claude Code tegen het
ollama launch claude --model qwen3-coder

Ollama stelt de benodigde omgevingsvariabelen in en start Claude Code automatisch wijzend op http://localhost:11434. Je kunt dan Claude Code precies gebruiken zoals je normaal zou doen — het enige verschil is dat inferentie op je eigen hardware gebeurt.

Prestatie-instellingen (OLLAMA_NUM_PARALLEL)

Als je wachtrijen of time-outs ziet onder belasting, is de eerste instelling om te leren OLLAMA_NUM_PARALLEL.

• OLLAMA_NUM_PARALLEL = hoeveel verzoeken Ollama parallel uitvoert.
• Een hogere waarde kan de doorvoer verhogen, maar kan VRAM-druk en latentiepieken verhogen.

Snel voorbeeld:

OLLAMA_NUM_PARALLEL=2 ollama serve

Voor een volledige uitleg (inclusief afstemstrategieën en faalmodi), zie:

• Hoe Ollama parallele verzoeken hanteert

Ollama-model vrijgeven uit VRAM (keep_alive)

Wanneer een model in VRAM (GPU-geheugen) wordt geladen, blijft het daar zelfs nadat je klaar bent met gebruiken. Om een model expliciet vrij te geven uit VRAM en GPU-geheugen vrij te maken, kun je een verzoek sturen naar de Ollama-API met keep_alive: 0.

• Model vrijgeven uit VRAM met curl:

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

Vervang MODELNAAM met je echte modelnaam, bijvoorbeeld:

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

• Model vrijgeven uit VRAM met Python:

import requests

response = requests.post(
    'http://localhost:11434/api/generate',
    json={'model': 'qwen3:14b', 'keep_alive': 0}
)

Dit is vooral nuttig wanneer:

• Je GPU-geheugen vrij moet maken voor andere toepassingen
• Je meerdere modellen draait en VRAM-gebruik wilt beheren
• Je klaar bent met een groot model en bronnen direct wilt vrijgeven

Opmerking: De keep_alive-parameter bepaalt hoe lang (in seconden) een model geladen blijft in het geheugen na de laatste aanvraag. Het instellen op 0 laadt het model direct uit de VRAM.

Als je de abstractielaag van Ollama volledig wilt vermijden en directe controle wilt over welk GGUF-model op elk moment aanwezig is, dekt llama-server router-modus de inheemse llama.cpp-aanpak voor dynamisch modelwisselen.

Ollama-modellen aanpassen (systeem-prompt, Modelfile)

• Systeem-prompt instellen: Binnen de Ollama-REPL kun je een systeem-prompt instellen om het gedrag van het model aan te passen:

  >>> /set system Beantwoord alle vragen in gewoon Engels en vermijd technische jargon zoveel mogelijk
  >>> /save ipe
  >>> /bye
  

  Voer dan het aangepaste model uit:

  ollama run ipe
  

  Dit stelt een systeem-prompt in en slaat het model op voor toekomstig gebruik.

• Aangepast modelbestand maken: Maak een tekstbestand (bijv. aangepast_model.txt) met de volgende structuur:

  FROM llama3.1
  SYSTEM [Je aangepaste instructies hier]
  

  Voer dan uit:

  ollama create mijnmodel -f aangepast_model.txt
  ollama run mijnmodel
  

  Dit maakt een aangepast model gebaseerd op de instructies in het bestand".

Ollama signin en signout (register-authenticatie)

ollama signin
ollama signout

ollama signin authenticeert je lokale Ollama-installatie bij de Ollama-register op ollama.com. Eenmaal ingelogd, slaat de client de inloggegevens lokaal op en hergebruikt ze automatisch voor volgende commando’s.

Wat signin ontgrendelt:

• Pullen en pushen van privatemodellen van je account of organisatie.
• Gebruik van cloud-gehoste modellen (bijv. qwen3-coder:480b-cloud) die te groot zijn om lokaal te draaien.
• Publiceren van modellen bij de register met ollama push.

Alternatief: API-sleutel authenticatie

Als je Ollama draait in een CI-pijplijn of een headless-server waar interactieve ollama signin niet praktisch is, maak dan een API-sleutel aan in je Ollama-accountinstellingen en exposeer deze als een omgevingsvariabele:

export OLLAMA_API_KEY=ollama_...
ollama pull mijnorg/privé-model

De OLLAMA_API_KEY-variabele wordt automatisch opgepakt door elke Ollama-commando en API-verzoek — geen noodzaak om ollama signin op elke machine uit te voeren.

Ollama run commando gebruiken met bestanden (samenvatten, doorsturen)

• Tekst samenvatten uit een bestand:

  ollama run llama3.2 "Samenvatten de inhoud van dit bestand in 50 woorden." < input.txt
  

  Dit commando vat de inhoud van input.txt samen met het opgegeven model.

• Modelreacties opslaan naar een bestand:

  ollama run llama3.2 "Vertel me over hernieuwbare energie." > output.txt
  

  Dit commando slaat de reactie van het model op in output.txt.

Ollama CLI-gebruiksgevallen (tekstgeneratie, analyse)

• Tekstgeneratie:

  • Een groot tekstbestand samenvatten:

    ollama run llama3.2 "Samenvatten de volgende tekst:" < lang-document.txt
    

  • Content genereren:

    ollama run llama3.2 "Schrijf een kort artikel over de voordelen van AI in de gezondheidszorg." > artikel.txt
    

  • Specifieke vragen beantwoorden:

    ollama run llama3.2 "Wat zijn de nieuwste trends in AI, en hoe zullen ze de gezondheidszorg beïnvloeden?"
    

  .

• Dataverwerking en -analyse:

  • Tekst classificeren in positief, negatief of neutraal sentiment:

    ollama run llama3.2 "Analyseer het sentiment van deze klantenreview: 'Het product is fantastisch, maar de levering was traag.'"
    

  • Tekst categoriseren in vooraf gedefinieerde categorieën: Gebruik vergelijkbare commando’s om tekst te classificeren of te categoriseren op basis van vooraf gedefinieerde criteria.

Ollama gebruiken met Python (client en API)

• Ollama Python-bibliotheek installeren:

  pip install ollama
  

• Tekst genereren met Python:

  import ollama
  
  response = ollama.generate(model='gemma:2b', prompt='wat is een qubit?')
  print(response['response'])
  

  Dit codefragment genereert tekst met het opgegeven model en prompt.

Voor geavanceerde Python-integratie, verkijk Ollama’s Web Search API in Python gebruiken, wat web search-mogelijkheden, tool calling en MCP-server-integratie dekt. Als je AI-aangedreven applicaties bouwt, kan onze AI Coding Assistants vergelijking je helpen de juiste tools te kiezen voor ontwikkeling.

Op zoek naar een webgebaseerde interface? Open WebUI biedt een zelf-gehoste interface met RAG-mogelijkheden en multi-user-ondersteuning. Voor hoogwaardige productie-implementaties, overweeg vLLM als alternatief. Om Ollama te vergelijken met andere lokale en cloud LLM-infrastructuurkeuzes, zie LLM Hosting: Lokale, Zelf-gehoste & Cloudinfrastructuur vergeleken.

NUTTIGE LINKS

Configuratie en beheer

• Ollama-modellen verplaatsen naar een andere schijf of map

Alternatieven en vergelijkingen

• Lokale LLM-hosting: Complete gids 2026 - Ollama, vLLM, LocalAI, Jan, LM Studio & Meer
• vLLM Quickstart: Hoogwaardige LLM-servings
• Docker Model Runner vs Ollama: Welke moet je kiezen?
• Eerste signalen van Ollama Enshittification

Prestaties en hardware

• Hoe Ollama parallele verzoeken hanteert
• Hoe Ollama Intel CPU-prestaties en Efficient Cores gebruikt
• NVIDIA DGX Spark vs Mac Studio vs RTX-4080: Ollama-prestatievergelijking
• DGX Spark vs. Mac Studio: Een praktische, prijsgecontroleerde kijk op NVIDIA’s persoonlijke AI-supercomputer

Integratie en ontwikkeling

• Ollama Web Search API in Python gebruiken
• AI Coding Assistants vergelijking
• Open WebUI: Zelf-gehoste LLM-interface
• Open-source chat-UI’s voor LLM’s op lokale Ollama-instanties
• LLM’s beperken met gestructureerde uitvoer: Ollama, Qwen3 & Python of Go
• Ollama integreren met Python: REST API en Python-client voorbeelden
• Go SDK’s voor Ollama - vergelijking met voorbeelden