Ollama: draai AI gratis op je eigen machine (developers guide)

Waarom lokale AI?

Je werkt voor een bedrijf met gevoelige klantdata. Of je bent een freelancer die miljarden ChatGPT-calls niet kan betalen. Of je wilt AI gebruiken op plekken zonder internet — in de trein, het vliegtuig, op locatie. De cloud-API’s van OpenAI, Anthropic en Google zijn krachtig, maar ze kosten geld per token. Ollama slaat een nieuwe route in: je downloadt een LLM eenmalig, draait het op je lokale machine, en bespaard voortaan alle API-kosten.

Dit tutorial leert je:

• Ollama installeren en je eerste model runnen
• De OpenAI-compatible API gebruiken in Python
• Dagelijkse taken automaten met cron jobs
• Hardware-keuze (welk model past in jouw RAM?)

Wat is Ollama?

Ollama is een open-source runtime die grote taalmodellen op je lokale machine draait. Het werkt als een soort Docker voor AI: je geeft één commando, het model downloadt, de runtime start, en je hebt meteen een API op localhost:11434. Geen subscriptie, geen usage limits, geen per-token-facturering. Volledig gratis, MIT-licentie.

Ondersteunde modellen (juli 2026):

• Mistral 7B — zeer snel, goed voor codegeneratie (4GB VRAM)
• Llama 2 / Llama 3 — sterke general-purpose modellen (7B tot 70B varianten)
• Qwen 2.5 — multilingual, goed voor Nederlands
• DeepSeek — nieuwe opkomers in quality/speed trade-off
• Phi 3 — micro-modellen voor edge devices
• Vision models — Llava, Moondream (afbeeldingen analyseren)

Over 100 modellen beschikbaar; check ollama.ai voor de volledige lijst.

Stap 1: Ollama installeren

macOS

# Download & install via Homebrew
brew install ollama

# Of direct DMG-installer: https://ollama.ai/download

Linux (Ubuntu/Debian)

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

Windows

Download de .exe van ollama.ai/download — installeert als Windows service.

Controleer installatie

ollama --version
# Output: ollama version 0.1.47 (of nieuwer)

Stap 2: Je eerste model runnen

Kies een model op basis van je hardware:

Model	VRAM	Speed	Best for
Mistral 7B	4GB	Snel	Code, snelle replies
Phi 3	2GB	Zeer snel	Embedded / edge
Llama 2 13B	8GB	Goed	Balanced
Qwen 2.5 14B	8GB	Goed	Nederlandse content
Llama 3 70B	40GB+	Langzaam	Beste kwaliteit

Regel: ± 0.6-0.7 GB VRAM per miljard parameters + overhead. Dus:

• 4B model ≈ 2.5GB
• 7B model ≈ 4-5GB
• 13B model ≈ 8-10GB

Run je model

# Start Mistral 7B interactief
ollama run mistral

# Of Qwen 2.5 voor Nederlands
ollama run qwen2.5

# Of Llama 3 voor high-quality
ollama run llama2

Je ziet:

>>> Send a message (/? for help)

Type een vraag en druk Enter. Het model genereert lokaal (geen internet-call). Eerste response duurt 5-20 seconden (afhankelijk van je CPU/GPU).

Interactief testen

>>> Schrijf een Python-functie die alle getallen van 1 tot n telt.

[Model genereert code...]

>>> Wat is de hoofdstad van Japan?
Tokyo

>>> /bye

Typ /bye om af te sluiten. Het model blijft op de achtergrond draaien.

Stap 3: REST API gebruiken (Python / Node)

Ollama serveert een OpenAI-compatible API op http://localhost:11434. Dit maakt integratie in scripts triviaal.

Ollama daemon starten (achtergrond)

# macOS / Linux
ollama serve

# Windows
# Start de Ollama-app; deze draait de daemon automatisch.

De API draait nu op :11434.

Python: eenvoudige chat-API

import requests
import json

def chat_with_ollama(message, model="mistral"):
    """
    Lokale chat via Ollama REST API.
    """
    url = "http://localhost:11434/api/chat"
    
    payload = {
        "model": model,
        "messages": [
            {"role": "user", "content": message}
        ],
        "stream": False  # Wachten op volledige response
    }
    
    response = requests.post(url, json=payload)
    data = response.json()
    
    return data["message"]["content"]

# Gebruik
reply = chat_with_ollama("Wat zijn de top 3 voordelen van lokale AI?")
print(reply)

OpenAI Python library (drop-in replacement)

Omdat Ollama OpenAI-compatible is, kun je direct openai-python gebruiken:

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"  # Dummy key; Ollama checkt het niet
)

response = client.chat.completions.create(
    model="mistral",
    messages=[
        {"role": "user", "content": "Leg uit hoe quantum computing werkt"}
    ],
    temperature=0.7
)

print(response.choices[0].message.content)

Node.js / JavaScript

const fetch = require('node-fetch');

async function chatWithOllama(message, model = 'mistral') {
    const response = await fetch('http://localhost:11434/api/chat', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
            model,
            messages: [{ role: 'user', content: message }],
            stream: false
        })
    });
    
    const data = await response.json();
    return data.message.content;
}

// Gebruik
chatWithOllama('Hoeveel maanden zijn er in een jaar?').then(console.log);

Stap 4: Dagelijkse taken automaten (Cron + Ollama)

Het echte kracht van lokale AI: 24/7 automation zonder API-kosten.

Use-case: dagelijkse samenvatting van een lokale logfile

#!/usr/bin/env python3
# ~/projects/daily_log_summary.py

import json
import subprocess
from datetime import datetime

def run_ollama(prompt, model="mistral"):
    """Run Ollama model via subprocess."""
    result = subprocess.run(
        ["ollama", "run", model, prompt],
        capture_output=True,
        text=True,
        timeout=120
    )
    return result.stdout.strip()

def summarize_logs():
    """Lees vandaag's logs, genereer samenvatting."""
    
    # Lees logs
    with open("/var/log/myapp.log", "r") as f:
        logs = f.read()[-2000:]  # Laatste 2000 chars
    
    # Stuur naar Ollama
    prompt = f"""Maak een korte samenvatting (3-5 regels) van deze logs, 
focus op fouten en waarschuwingen:

{logs}"""
    
    summary = run_ollama(prompt, model="mistral")
    
    # Sla op
    timestamp = datetime.now().isoformat()
    with open("/home/user/log_summaries.jsonl", "a") as f:
        f.write(json.dumps({
            "date": timestamp,
            "summary": summary
        }) + "\n")
    
    print(f"Samenvatting opgeslagen: {summary[:80]}...")

if __name__ == "__main__":
    summarize_logs()

Cron job instellen

# Edit crontab
crontab -e

# Voeg toe:
0 8 * * * /usr/bin/python3 /home/user/daily_log_summary.py

# Uitleggen: elke dag om 8 uur (0 8) script runnen

Resultaat: dagelijks, zonder handwerk, krijg je een AI-samenvatting van je logs.

Use-case 2: wekelijkse “monitoring assistant”

#!/usr/bin/env python3
# Wekelijks: vergelijk CPU/mem-stats met vorige week

import requests
import psutil
from datetime import datetime

def monitor_system():
    """
    Lees system stats, vraag Ollama wat te doen.
    """
    cpu_percent = psutil.cpu_percent(interval=1)
    memory = psutil.virtual_memory()
    
    prompt = f"""
Dit is de system-status van deze week:
- CPU gemiddeld: {cpu_percent}%
- RAM in gebruik: {memory.percent}%
- Beschikbaar: {memory.available / (1024**3):.1f}GB

Wat moet ik checken of optimaliseren? Geef 2-3 acties.
"""
    
    # Via REST API
    url = "http://localhost:11434/api/generate"
    response = requests.post(url, json={
        "model": "mistral",
        "prompt": prompt,
        "stream": False
    })
    
    advice = response.json()["response"]
    
    print("Wekelijks monitoring advies:")
    print(advice)
    
    # Log to Telegram / Email / Slack
    # send_telegram(advice)

if __name__ == "__main__":
    monitor_system()

# Cron: elke maandag 9 uur
0 9 * * 1 /usr/bin/python3 /home/user/monitor_system.py

Stap 5: Image-analyse (Vision models)

Ollama voegt sinds januari 2026 native image-support toe. Met Llava kun je screenshots, foto’s en documenten analyseren — allemaal lokaal.

import base64
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"
)

# Lees afbeelding
with open("/path/to/image.jpg", "rb") as f:
    image_b64 = base64.b64encode(f.read()).decode()

# Analyseer
response = client.chat.completions.create(
    model="llava",
    messages=[{
        "role": "user",
        "content": "Wat zie je op deze screenshot? Fokus op tekstdelen.",
        "image_url": {
            "url": f"data:image/jpeg;base64,{image_b64}"
        }
    }]
)

print(response.choices[0].message.content)

Llava installeren

ollama pull llava
ollama run llava

Stap 6: Performance & troubleshooting

Model niet snel genoeg?

Oorzaken & fixes:

1. CPU-only run → NVIDIA GPU toevoegen (ollama run --gpu / CUDA installeren)
2. Model te groot → Kleinere versie proberen (Mistral 7B i.p.v. Llama 70B)
3. VRAM vol → Ander model uit-cachen: ollama rm llama2 en ollama pull mistral

Out-of-Memory (OOM)?

# Controleer beschikbare VRAM
nvidia-smi  # (GPU)
free -h     # (RAM)

# Quantization-hint in URL (Ollama kiest automatisch):
ollama run mistral:7b-q4_0  # Q4 = meer compressie, sneller
ollama run mistral:7b-q2_0  # Q2 = nog sneller, lagere quality

API niet bereikbaar?

# Controleer of daemon draait
ps aux | grep ollama

# Herstart
ollama serve

# Test API
curl http://localhost:11434/api/generate -d '{
  "model": "mistral",
  "prompt": "hello",
  "stream": false
}'

Productiehints

1. Achtergrond-daemon (systemd)

# /etc/systemd/system/ollama.service
[Unit]
Description=Ollama
After=network.target

[Service]
Type=simple
User=ollama
ExecStart=/usr/local/bin/ollama serve
Restart=always

[Install]
WantedBy=multi-user.target

sudo systemctl enable ollama
sudo systemctl start ollama
systemctl status ollama

2. Reverse proxy (Nginx)

Gooi Ollama achter Nginx om extra beveiliging/logging toe te voegen:

server {
    listen 80;
    server_name ai.mycompany.local;
    
    location / {
        proxy_pass http://localhost:11434;
        proxy_buffering off;
        proxy_request_buffering off;
    }
}

3. Model-caching

Models blijven in RAM nadat je ze draait (sneller bij hergebruik). Controleer geheugengebruik:

ollama ps
# NAME    ID      SIZE    PROCESSOR
# mistral abc...  3.8GB   GPU

Verwijder ongebruikte models:

ollama rm mistral
ollama rm llama2

4. Meerdere workers (load balancing)

Voor productie-setups: draai Ollama op meerdere machines / containers. Use case: voorkomen dat één zwaar request alles blokkeert.

Volgende stappen

• RAG (Retrieval Augmented Generation): combineer Ollama met LangChain + vector DB (Chroma, Pinecone) voor documentzoeken
• Multi-agent systemen: bouw samenwerkende AI-assistenten die elkaar roepen — onze gids multi-agent AI lokaal bouwen met Ollama zet de basis op in vier stappen
• Agents testen: gebruik je lokale model als rechter — AI-agents evalueren met een LLM-as-a-judge bouwt een herhaalbare testbank met Ollama en Qwen
• Cloudflare Workers: publiceer je Ollama-API via Cloudflare voor remote access (zónder het internet in)
• Fine-tuning: train Ollama-modellen op je eigen data (advanced)

Samenvatting

Ollama geeft je volledige controle: geen facturering per token, geen data naar de cloud, volledige privacy, 24/7 offline beschikbaar. Het kost je alleen eenmalig een model te downloaden en — afhankelijk van je model-keuze — wat hardware. Voor developers die lokale AI willen, is dit de standaard geworden in 2026.

Begin vandaag: ollama run mistral en je bent in 30 seconden klaar.