Een lokale LLM-server bouwen: hardware + Ollama + OpenWebUI

Je eigen LLM-server bouwen hoeft niet te beginnen bij een rack vol Tesla-kaarten. Met de juiste hardware, Ollama en OpenWebUI draai je een volwaardige AI-assistent die volledig offline werkt — van een compacte budgetbuild voor €600 tot een dual-GPU workstation dat 70B-modellen soepel aankan. Het lastigste deel is niet de installatie, maar de keuzes erna.

Drie build-niveaus: wat past bij welk gebruik?

Lokale AI-hardware valt grofweg in drie categorieën uiteen. De eerste is de instapbuild — een bestaande pc of mini-pc met een GPU van 8–12 GB VRAM. Dat is genoeg voor de gangbare 7B- en 8B-modellen die anno 2026 behoorlijk capabel zijn. Llama 3.1 8B Instruct in Q4_K_M-kwantisatie past in 5,5 GB VRAM en haalt op een RTX 4070 (12 GB) typisch 55–70 tokens per seconde — snel genoeg om de output bijna sneller te lezen dan die gegenereerd wordt.

Populaire modellen voor dit niveau:

Llama 3.2 3B (Q4_K_M, ~2,0 GB) — extreem snel, 100+ tok/s, verrassend nuttig voor eenvoudige taken
Llama 3.1 8B Instruct (Q4_K_M, ~5,5 GB) — solide allesronder voor schrijven en samenvatten
Qwen 2.5 7B Instruct (Q4_K_M, ~5,2 GB) — opvallend sterk in meertalige taken, inclusief Nederlands
Mistral 7B v0.3 (Q4_K_M, ~5,1 GB) — bewezen sterk op code en instructietaken

De tweede categorie is de middenklasse workstation met 16–24 GB VRAM. Een RTX 4080 (16 GB) of RTX 4090 (24 GB) draait modellen tot 32B parameters volledig in GPU-geheugen. Qwen 2.5 32B Instruct past in Q4_K_M net op een 4090 (~22 GB) en haalt daar 30–43 tok/s — een significante sprong in redeneervermogen ten opzichte van 7B, zonder dat je het aan de snelheid merkt.

De derde categorie is de dual-GPU of workstation-GPU build, ontworpen om 70B-modellen volledig in VRAM te houden. Twee RTX 4090's geven 48 GB gecombineerd geheugen en draaien Llama 3.3 70B Q4_K_M op 25–35 tok/s. De nieuwere RTX 5090 brengt 32 GB GDDR7 met 1,79 TB/s bandbreedte en haalt 213 tok/s op 8B-modellen en 61 tok/s op 32B — een verbetering van 67% ten opzichte van de 4090 voor dezelfde modelklasse.

Build-varianten op een rij

Build	GPU	VRAM	Beste model	Snelheid	Prijs indicatie
Instap	RTX 4070 / RX 7900 GRE	12 GB	Llama 3.1 8B Q4_K_M	55–70 tok/s	±€350–500 (GPU)
Middenklasse	RTX 4090 / RX 7900 XTX	24 GB	Qwen 2.5 32B Q4_K_M	30–43 tok/s	±€900–1.400 (GPU)
High-end	RTX 5090 of 2× RTX 4090	32 / 48 GB	Llama 3.3 70B Q4_K_M	35–60 tok/s	±€2.000–4.500 (GPU)

Een aantrekkelijk AMD-alternatief voor de middenklasse is de RX 7900 XTX (24 GB GDDR6). Met de maturatie van ROCm 7.x en officiële Ollama-ondersteuning is dit een volwaardige optie op Linux, doorgaans €200–400 goedkoper dan een RTX 4090.

Ollama installeren in vijf minuten

Ollama is de eenvoudigste ingang naar lokale LLM's. Het is een Go-wrapper rond llama.cpp die modeldownloads, GPU-detectie en een OpenAI-compatibele REST API ineen combineert. Installatie op Linux is één commando:

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

Op Windows download je de installer van ollama.com; op macOS volstaat brew install ollama. Na installatie trek je een model binnen met:

ollama pull llama3.1:8b
ollama run llama3.1:8b

Ollama detecteert automatisch beschikbare GPU's en laadt het model volledig in VRAM als dat past. Past het niet, dan offloadt het het resterende deel automatisch naar CPU-RAM — al gaat dat ten koste van de snelheid. In versie 0.6.x (2026) voegde Ollama Flash Attention v2.7 toe, activeerbaar met de omgevingsvariabele OLLAMA_FLASH_ATTENTION=1. Dat levert 15–20% snelheidswinst en tot 30% minder VRAM-gebruik op toepasselijke modellen zoals Llama 3.1 en Gemma 3.

De ingebouwde API luistert standaard op poort 11434. Wil je die extern bereikbaar maken, stel dan OLLAMA_HOST=0.0.0.0 in voor je de service start. Dat is genoeg om andere apparaten in je netwerk er gebruik van te laten maken.

"Ollama's kracht zit niet in rauwe snelheid, maar in hoe weinig je hoeft te weten om een model te draaien. Eén commando, en je hebt een werkende API."

OpenWebUI en gebruikersbeheer

De commandoregel is prima voor testen, maar voor dagelijks gebruik — zeker als meerdere mensen op dezelfde server werken — is OpenWebUI de standaardkeuze. Het biedt een ChatGPT-achtige interface die verbindt met je lokale Ollama-instantie (of een andere OpenAI-compatibele API). Via Docker draait het in twee commando's:

docker pull ghcr.io/open-webui/open-webui:main
docker run -d -p 3000:8080 \
  -e OLLAMA_BASE_URL=http://host.docker.internal:11434 \
  -v open-webui:/app/backend/data \
  ghcr.io/open-webui/open-webui:main

Surf daarna naar http://localhost:3000 en maak een beheerdersaccount aan. OpenWebUI heeft uitgebreid gebruikersbeheer: nieuwe gebruikers kunnen als pending, user of admin worden ingedeeld. Je bepaalt zelf of registratie open staat of uitnodiging vereist. Voor grotere teams biedt de tool LDAP-integratie, SSO via OIDC en SCIM 2.0-provisioning voor koppelingen met Okta of Azure AD.

Andere nuttige features:

Modelselectie per gesprek — wissel tussen lokale en externe modellen (OpenAI, Anthropic) in dezelfde interface
Document RAG — upload PDF's die automatisch via embedding-modellen in de context landen
Active Users Indicator — live zicht op welke modellen worden belast, handig voor capaciteitsplanning
Pipelines — koppel web search, Python of externe API's aan gesprekken

OpenWebUI slaat gesprekken lokaal op in een SQLite-database. Wil je back-ups automatiseren, verwijs de Docker-volume dan naar een pad op je host en neem dat mee in je reguliere back-upschema.

Waarom multi-GPU lastiger is dan je denkt

Twee GPU's klinkt als twee keer zo krachtig. De realiteit is genuanceerder. Ollama verdeelt modellagen standaard over beschikbare GPU's via llama.cpp, maar ondersteunt geen echte tensor-parallellisme zoals vLLM dat doet. Dat betekent dat beide GPU's los van elkaar aan dezelfde taken werken in plaats van samen te werken aan één token. In de praktijk werkt dit prima voor model offloading — de 70B past in het gecombineerde VRAM — maar de snelheidswinst per GPU is beperkt.

Een beproefde meting: twee RTX 4090's over PCIe 4.0 presteren op circa 85–90% van NVLink-gekoppelde A100's met hetzelfde totale VRAM. NVLink (~600 GB/s) tegenover PCIe 4.0 (~32 GB/s) merk je pas bij grote contextvensters of hoge parallelle belasting — bij normaal conversatiegebruik is het verschil marginaal.

Voor wie meerdere gebruikers tegelijk bedient of productie-niveau throughput nastreeft, is vLLM de betere keuze boven Ollama. vLLM implementeert tensor-parallellisme correct, waardoor twee GPU's echt samen één inferentie-run uitvoeren in plaats van apart. De keerzijde: installatie en configuratie zijn aanzienlijk complexer, en model-hot-swapping vereist een herstart van de service.

De eerlijke conclusie: twee GPU's zijn zinvol als je daarmee een model volledig in VRAM houdt dat anders deels naar RAM offloadt. De sprong van CPU-offload (3–8 tok/s) naar volledig-in-VRAM (25–35 tok/s) is enorm. Twee GPU's kopen voor betere snelheid bij een model dat al in één GPU past, loont nauwelijks.

llama.cpp of Ollama: wanneer kies je wat?

Technisch is Ollama een Go-wrapper rondom llama.cpp. Die extra laag kost iets: directe llama.cpp-aanroepen halen 15–30% meer tokens per seconde met 20% minder VRAM-gebruik. Onder gelijktijdige belasting kan dat verschil oplopen tot een factor drie, omdat llama.cpp geheugen efficiënter beheert. Toch is Ollama voor de meeste gebruikers de betere keuze: installatie duurt drie minuten, modellen downloaden met één commando, en je hebt direct een werkende OpenAI-compatibele API. Bijkomend voordeel: Ollama wisselt automatisch van actief model en verwijdert het vorige netjes uit VRAM.

Kies llama.cpp als je elke procent snelheid wilt benutten, grote contextvensters nodig hebt (32.768 tokens vs. Ollama's 11.288 op dezelfde hardware), of zelf modellen quantiseert vanuit FP16-brongewichten. Kies Ollama als je snel wilt starten en een stabiele plug-and-play API wilt voor lokale apps.

De hosting-puzzel: alleen thuis of ook buiten de deur?

Een lokale LLM-server werkt goed op het thuisnetwerk. Wil je hem ook bereiken van buiten — onderweg, op kantoor — dan komen er complicaties bij. De simpelste optie is een VPN naar huis (WireGuard of Tailscale), zodat je van elke locatie op de Ollama-API komt alsof je thuis bent. Tailscale heeft een gratis tier voor persoonlijk gebruik en werkt ook achter dubbele NAT.

Wil je de interface via een gewone URL bereikbaar maken, dan heb je een reverse proxy nodig — Caddy of Nginx — en een geldig TLS-certificaat. Stel ook authenticatie in op Ollama zelf, want standaard heeft de API geen toegangsbeveiliging. Een alternatief is Cloudflare Tunnel: een kleine daemon die een beveiligde tunnel opzet zonder poorten te openen, met automatisch TLS. Handig als je provider geen vast IP biedt.

FAQ

Kan ik Ollama ook zonder GPU draaien?: Ja, maar de snelheid valt sterk terug. Op een moderne Ryzen 9 of Core Ultra haal je 3–8 tok/s op een 7B-model — bruikbaar voor incidenteel gebruik, niet voor interactieve gesprekken.
Werkt Ollama op Windows?: Ja, er is een native installer. NVIDIA-ondersteuning werkt stabiel; AMD vereist extra configuratie op Windows. Linux met ROCm is voor AMD de meest volwassen omgeving.
Hoeveel RAM heb ik nodig naast VRAM?: Als het model volledig in VRAM past, nauwelijks. Bij CPU-offload (70B op een enkele 4090) is 64 GB aanbevolen. Voor pure GPU-builds volstaat 32 GB ruimschoots.
Is een NVMe-drive belangrijk voor modelsnelheid?: Alleen bij het laden. Eenmaal in VRAM speelt schijfsnelheid geen rol. Een model van 10 GB laad je van PCIe 4.0 NVMe in 5–8 seconden; daarna is het verschil nul.
Kan ik Ollama koppelen aan eigen applicaties?: Ja. Ollama biedt een OpenAI-compatibele API op http://localhost:11434/v1. Elke bibliotheek die de OpenAI-SDK gebruikt werkt zonder aanpassing door simpelweg het base-URL te wijzigen.