Lokale LLMs op macOS: Ollama, LM Studio, MLX, llama.cpp

Viacheslav Dubrov

2025-05-10 · Bijgewerkt 2026-08-10 · 6 min · Modelengineering · Ontwikkelaarstools

Automatische vertaling Dit artikel is automatisch vertaald vanuit de oorspronkelijke Engelse versie.

Engineers die lokale modellen op een Apple Silicon Mac draaien, moeten de volledige workload dimensioneren en niet alleen een model kiezen dat kan worden gedownload. Apple Silicon kan alledaagse prompts uitvoeren zonder remote API, omdat de CPU en GPU één unified memory pool delen. De model weights concurreren daar echter met de KV cache, runtime workspace en macOS.

Zodra het beoogde model, de context en de beschikbare geheugenruimte passen, kies je de control surface die bij de workflow hoort: Ollama voor een managed local service, LM Studio voor desktopinspectie, llama.cpp voor directe GGUF-execution of MLX-LM voor Apple-native Python. Zo houd je het testen van modelkwaliteit gescheiden van de keuze van tool en krijg je een eerlijke, memory-aware benchmark voor de stack die je gaat gebruiken.

TL;DR. Gebruik Ollama voor een managed local service, LM Studio voor desktopverkenning van modellen en de bijbehorende lokale APIs, llama.cpp voor directe controle over GGUF-execution en MLX-LM voor Apple-native Python-experimenten. Geen van deze tools is universeel het snelst. Benchmark het exacte model, de quantization, de context en de workload, met voldoende geheugenruimte.

Zie Local LLM Tools on macOS in 2026 voor de compacte decision table.

Begin met een memory envelope

De ruwe grootte van quantized weights is slechts de eerste term:

peak memory ≈ model weights
            + KV cache
            + runtime workspace
            + multimodal components
            + application and OS memory

Context length, cache dtype, parallelle requests en modelarchitectuur veranderen het resultaat. Een nominaal vier-bit 7B- of 8B-model kan op een Mac met 8 GB nog steeds problematisch zijn, omdat het besturingssysteem niet al het geïnstalleerde geheugen aan de runtime kan geven.

Gebruik Activity Monitor of de eigen metrics van de runtime tijdens het testen. Apple definieert memory pressure aan de hand van vrij geheugen, swap rate, wired memory en cached files. Houd voldoende headroom over om langdurige swap te voorkomen. Een model dat wel laadt maar het systeem in memory pressure brengt, is geen goede interactieve match.

Maak ook onderscheid tussen lokale inference en offline operation. Prompts kunnen op de machine blijven terwijl de applicatie toch het netwerk gebruikt voor modeldownloads, updates of optionele features. Ollama documenteert lokale execution, modeldownloads en optionele cloudfeatures afzonderlijk in de FAQ. Behandel offline operation als een workflowvereiste die je per applicatie moet verifiëren: download eerst de artifacts, verbreek daarna de netwerkverbinding en test de volledige workflow.

De vier tools lossen verschillende workflowproblemen op

Dit is een responsibility table, geen speed ranking. Verschillende tools kunnen vergelijkbare kernels of formats gebruiken en de performance verandert afhankelijk van model support en release.

Ollama: managed local service

Ollama beheert modeldownloads, templates, de process lifecycle en een localhost API. Het is nuttig wanneer applicatiecode een stabiele lokale service moet aanspreken in plaats van zelf inference-flags te beheren.

MODEL=llama3.2
ollama pull "$MODEL"
ollama run "$MODEL" "Explain unified memory."

curl http://localhost:11434/api/chat \
    -H 'Content-Type: application/json' \
    -d '{
      "model": "'"$MODEL"'",
      "messages": [{"role": "user", "content": "Explain unified memory."}],
      "stream": false
    }'

Inspecteer het modelmanifest en de contextconfiguratie in plaats van aan te nemen dat een korte library name een immutable checkpoint identificeert. Pin of registreer het exacte artifact voor evaluaties.

Ollama ruilt een deel van de low-level visibility in voor gemak rond de lifecycle. Stap over op llama.cpp of een andere runtime wanneer je een GGUF-file, chat template, cache setting of nieuwe backendfeature direct moet kunnen aansturen.

LM Studio: desktopverkenning en lokale APIs

LM Studio is nuttig wanneer model discovery, load configuration, chatinspectie en side-by-side human evaluation in één workflow thuishoren. Het biedt nu native Python- en TypeScript-SDKs, OpenAI-compatible endpoints, structured output, tool use en een headless daemon. Het is dus niet langer alleen een desktop-GUI.

De huidige Python SDK maakt verbinding met een model dat je al hebt gedownload:

import lmstudio as lms

MODEL_KEY = "ibm/granite-4-micro"

with lms.Client() as client:
    model = client.llm.model(MODEL_KEY)
    response = model.respond("Write one sentence about local inference.")
    print(response)

Start de lokale API vanuit het tabblad Developer of met:

lms server start

LM Studio kan op localhost of een lokaal netwerk serven en ondersteunt API-tokens in de API authentication settings. Laat de service op loopback luisteren tenzij remote access bewust vereist is. Als je de service op een LAN exposeert, vereis dan de gedocumenteerde API-tokenoptie, pas een host-firewallregel toe en controleer de toegang tot tools en integrations.

llama.cpp: directe GGUF-execution

llama.cpp is de reference path wanneer het artifact GGUF is en je de runtime boundary direct wilt zien. Het ondersteunt Apple Metal en daarnaast CPU- en andere hardware-backends.

brew install llama.cpp

# Download through the Hugging Face integration and select a quantization.
MODEL_REPO=ggml-org/gemma-3-1b-it-GGUF
QUANT=Q4_K_M
llama-cli -hf "$MODEL_REPO:$QUANT"

# Or start an OpenAI-compatible local server.
llama-server -hf "$MODEL_REPO:$QUANT"

Het huidige -hf-pad in de repository kan, wanneer beschikbaar, een bijpassende multimodal projector downloaden. Model support, templates en CLI-flags veranderen snel. Pin daarom een bekende build en bewaar het launch command bij het evaluatierecord.

Kies llama.cpp wanneer directe controle het doel is, niet omdat “lower-level” automatisch sneller betekent. Een managed tool kan goede defaults kiezen; directe flags kunnen de performance ook verslechteren.

MLX-LM: Apple-native Python-werk

MLX-LM bouwt voort op Apple’s MLX array framework. Het ondersteunt generation, chat, conversion, quantization en parameter-efficient fine-tuning voor compatibele modellen.

MODEL=mlx-community/Llama-3.2-3B-Instruct-4bit
uv add mlx-lm
uv run mlx_lm.generate \
    --model "$MODEL" \
    --prompt "Explain Metal acceleration in one paragraph."

Python geeft direct toegang tot het model en de tokenizer:

from mlx_lm import generate, load

MODEL = "mlx-community/Llama-3.2-3B-Instruct-4bit"

model, tokenizer = load(MODEL)
messages = [{"role": "user", "content": "Give one local-LLM benchmark rule."}]
prompt = tokenizer.apply_chat_template(
    messages,
    tokenize=False,
    add_generation_prompt=True,
)
print(generate(model, tokenizer, prompt=prompt, max_tokens=80))

De HTTP-server van MLX-LM wordt gedocumenteerd als een development server met basale security checks, niet als een production service. Gebruik deze voor lokale experimenten of plaats er een gecontroleerde application boundary voor.

Een eerlijke benchmark kost minder tijd dan een verkeerde download

Test dezelfde checkpoint family en, waar de formats dat toestaan, een vergelijkbare quantization. Gebruik een kleine promptset met:

• één korte interactieve prompt
• één lange prompt die dicht bij de beoogde context ligt
• structured output of tool calls als de applicatie die nodig heeft
• een representatieve generation length
• één herhaald request om cold load te onderscheiden van warm inference

Leg het volgende vast:

Vergelijk niet het 4-bit model van de ene tool met het full-precision model van een andere tool om het verschil vervolgens aan de runtime toe te schrijven.

Checklist voor security en privacy

1. Bind APIs aan loopback tenzij network access vereist is.
2. Als LAN-access vereist is, gebruik dan een host-firewall en óf de gedocumenteerde authentication van de tool óf een authenticated reverse proxy vóór de service. Ondersteuning voor API-tokens is tool-specifiek: LM Studio documenteert API-tokens, terwijl Ollama’s gedocumenteerde exposure path host binding en proxying gebruikt.
3. Behandel modelfiles als third-party artifacts; registreer source, revision, license en hash.
4. Vermijd het uitvoeren van niet-gecontroleerde custom model code.
5. Controleer of optionele document-, tool-, update- of analyticsfeatures netwerkcalls uitvoeren.
6. Ga er niet van uit dat lokale generation ervoor zorgt dat retrieved documents, logs of side effects van tools veilig zijn.

Belangrijkste conclusies

1. Kies eerst de workflow boundary: managed service, desktop- en headless development, directe GGUF-control of Apple-native Python.
2. Zowel Ollama als LM Studio bieden lokale APIs. Vergelijk lifecycle control, SDKs, structured output, tools en runtime visibility.
3. Model weights vormen slechts een deel van het memory budget. Neem ook KV cache, workspace, multimodal components, de applicatie en de beschikbare ruimte voor macOS mee.
4. Lokale inference is niet automatisch offline of private. Verifieer network calls, binding, authentication, artifacts, logs en tool side effects.
5. Benchmark dezelfde task, checkpoint family, context en vergelijkbare quantization voordat je een resultaat aan de runtime toeschrijft.

References

• Ollama documentation and source
• LM Studio developer documentation en Python SDK
• llama.cpp documentation and source
• MLX-LM documentation and source
• Apple MLX documentation