Zelfgehoste taalmodellen zijn niet zo krachtig als de topmodellen van Anthropic en OpenAI, maar toch nuttig. Met een eigen LLM-server en opensource software kunnen werkgroepen zich onafhankelijker maken van de grote aanbieders.
Minder afhankelijk van de cloud met een eigen AI-server
De richtlijn van de Amerikaanse regering van 12 juni 2026, waarin Anthropic werd opgedragen alle niet-Amerikanen de toegang tot het nieuwe AI-model Fable te ontzeggen, was een wake-upcall. Plotseling deed zich het scenario voor dat voorstanders van Europese digitale onafhankelijkheid al zo vaak hebben geschetst: de regering van een ander land draait de digitale kraan voor ons dicht.
Voor het eerst gold er een exportbeperking voor een wijdverbreide digitale dienst, al was het maar voor één versie van een taalmodel. Maar het zette veel mensen aan het denken die in hun werk of dagelijks leven volledig vertrouwen op taalmodellen van de grote aanbieders. Het is dan ook een schrale troost dat Anthropic het model gewoon voor iedereen uitschakelde, dus ook voor de Amerikanen, omdat op die manier alleen aan de richtlijn te voldoen was.
Dit geval laat heel duidelijk zien: je eigen werk of dat van een team volledig afhankelijk maken van andermans AI-infrastructuur is gevaarlijk. Als je deze gebeurtenis als aanleiding wilt nemen – of er al langer over nadenkt – om een eigen AI-server voor grote taalmodellen op te zetten, moet je je enerzijds vertrouwd maken met het beheer van dergelijke taalmodellen. Anderzijds moet je heel alledaagse beheertaken uitvoeren: installatie, updates, beveiliging, monitoring.
Dit artikel is bedoeld voor als je een beetje ervaring in systeembeheer hebt en laat zien hoe je – mits je over hardware met een krachtige GPU beschikt – een LLM-server voor een klein team kunt beheren – die desgewenst via internet bereikbaar is.
Maar eerst een waarschuwing: de meesten die ooit uit nieuwsgierigheid in het konijnenhol van lokale AI-modellen zijn gevallen, zijn er niet meer uitgekomen. Je verdiepen in lokale AI kan verslavend zijn.
Verwachtingsmanagement
GPT, Claude, Gemini zijn de modelfamilies van OpenAI, Anthropic en Google, waarvan de namen inmiddels zelfs bij absolute IT-leken bekend zijn. Die laten zien wat er technisch gezien vandaag de dag mogelijk is.
Als je zo’n antwoordkwaliteit en snelheid van een LLM verwacht en geen concessies kunt doen, is lokale AI op dit moment nog niet de juiste keuze. Die modellen kun je enerzijds niet downloaden en anderzijds is de hardware die nodig is om ze te laten draaien bij lange na niet betaalbaar.
Modelreeksen waarmee je op je eigen hardware aan de slag kunt, zijn bijvoorbeeld Qwen (van Alibaba Cloud), GPTOSS (van OpenAI), Gemma (van Google) en Mistral van het gelijknamige Franse bedrijf. Alle modellen uit die families zijn minder welbespraakt, minder deskundig en minder goed in het oplossen van problemen dan de betaalde topmodellen – maar ze leveren wel degelijk nuttige antwoorden, of het nu gaat om het schrijven van teksten, het samenvatten van inhoud of als hulp bij het programmeren.
En bovenal doen ze dat zonder vragen en antwoorden naar hun producenten door te sturen. Daardoor is een zelf beheerde server bij uitstek geschikt om ook gevoelige klantgegevens te verwerken, zonder risico’s op het gebied van gegevensbescherming.
Lokale AI heeft nog een voordeel dat je pas merkt als je er eenmaal mee gewerkt hebt: zonder de gedachte in je achterhoofd dat elke vraag tokens kost die betaald moeten worden of van je abonnementstegoed worden afgetrokken, stel je de modellen veel onbezorgder vragen en probeer je ook wel eens hoogstwaarschijnlijk doodlopende wegen uit.
Hardwarekeuze
Het succes van een eigen AI-server hangt grotendeels af van de keuze van de hardware – vooral van de grafische kaart of geïntegreerde GPU. Je kunt dat heel wetenschappelijk aanpakken en vergelijkingstabellen doorploegen die laten zien welk taalmodel met welke GPU hoeveel tokens per seconde oplevert. Dan kun je voor een specifiek taalmodel de beste kaart kopen.
Maar het landschap van taalmodellen is super dynamisch en morgen kan er alweer een uitkomen die op een andere kaart net iets sneller draait. Een investering in dé kaart die het beste bij één model past, is daarom niet duurzaam.
De absolute korte versie van het aankoopadvies luidt dan ook: het belangrijkste is veel grafisch geheugen! De modellen presteren het beste als ze volledig in het geheugen van de grafische kaart passen, het zogeheten video-RAM (VRAM).
Daarnaast is er nog wat ruimte nodig voor de key-value-cache, die vectoren bevat voor eerder gegenereerde tokens en het genereren van de volgende tokens enorm versnelt. Hoe meer gebruikers met grote contextvensters op de server werken, des te meer grafisch geheugen je moet reserveren.
Past een model niet helemaal in het geheugen van de grafische kaart, dan belanden delen ervan in het RAM – en ineens komen de antwoorden tergend traag.
De grafische kaart hoeft niet per se van Nvidia te zijn, ook hardware van AMD en Intel is geschikt voor het draaien van de modellen, de zogeheten inferencing. 20 GB grafisch geheugen is het minimum om redelijk bruikbare modellen te kunnen aanbieden, die op piekmomenten soms meerdere gebruikers kunnen bedienen.
Naar boven toe is het systeem natuurlijk open, maar voordat je een Nvidia H100 voor 33.000 euro voor je werkgever bestelt, kun je beter eerst een testopstelling bouwen met een grafische gamingkaart. Gamers die bijvoorbeeld vóór de recente prijsexplosie in een RTX 5090 met 32 GB hebben geïnvesteerd, zitten nu zonder twijfel in een gelukkige situatie.
Een andere optie is de Intel Arc Pro B70 met 32 GB RAM vanaf ongeveer 1200 euro. En voor 5500 euro koop je het miniworkstation Nvidia DGX Spark met maar liefst 128 GB LPDDR5X-RAM – voor varianten daarvan zie [1, 2]. We hebben lokaal geïnstalleerde AI-modellen ook getest op een HP Z2 Mini-workstation [3] en een eigen bouwvoorstel van eind 2025, dat prima draait op Linux [4].
Voor dit artikel hebben we gekozen voor een – in ieder geval volgens de maatstaven van beheerders van lokale AI – middenklasse-GPU. Voor alle andere toepassingen zou je hem als high-end hardware beschouwen: de Nvidia RTX 4000 SFF Ada Generation is een serverkaart en heeft 20 GB grafisch geheugen.
Als je zo’n kaart niet wilt kopen (vanaf 1800 euro), kun je die of vergelijkbare kaarten ook bij hostingproviders samen met een server huren. Dan ben je niet helemaal onafhankelijk, maar kun je wel aan de slag zonder hoge startinvestering.
Onze server draait op Ubuntu Server 24.04 en is via een statisch IP-adres bereikbaar vanaf het internet. Dat is handig als een team ook buiten de grenzen van een lokaal netwerk met de gezamenlijke AI-server moet werken, maar het is geen vereiste om de instructies uit dit artikel te kunnen volgen.
Hieronder beschrijven we het installeren voor Nvidia-hardware. Als je voor andere hardware kiest, moet je op zoek naar geschikte stuurprogramma’s.
Basissoftware: Ollama
In het verleden kon je om één bepaalde software bijna niet heen: Ollama heeft zich gevestigd als de gangbare manier om LLM’s te downloaden en te draaien. Het bedrijf achter Ollama heeft het wiel echter niet zelf uitgevonden: de kern van Ollama is llama.cpp en is bedacht door ontwikkelaar Georgi Gerganov om modellen lokaal uit te voeren.
Ollama heeft rond llama.cpp een systeem opgezet om modellen – bestaande uit gewichten, een systeemprompt en metadata uit een registry – te downloaden en uit te voeren.
Ollama ligt om meerdere redenen onder vuur bij gebruikers van lokale AI: Ollama heeft lang getreuzeld met het erkennen van de prestaties van de llama.cpp-ontwikkelaar. Om met het idee geld te verdienen, probeert Ollama gebruikers bovendien over te halen om naar de Ollama-cloud over te stappen. In plaats van de modellen echt lokaal op je eigen hardware uit te voeren, kun je ze ook rechtstreeks bij Ollama laten draaien. Dat komt niet overeen met het oorspronkelijke idee, maar is voor de durfkapitalisten natuurlijk wel een goed plan.
Afgezien van de kritiek doet Ollama echter ook veel goed en op dit moment biedt de software de meest comfortabele manier om met modellen om te gaan. Onze softwareconfiguratie, waar het hier om gaat, integreert Ollama vrij losjes, zodat je dat onderdeel later ook makkelijk kunt vervangen.
Dat kan omdat de llama-server die daarin draait een API aanbiedt die grotendeels overeenkomt met die van OpenAI – ook alternatieven voor Ollama spreken dezelfde taal.
Terug naar de hoofdfunctie van Ollama: als je de software via de commandline gebruikt, volstaat het om ollama run <modelnaam>:<variant> in te voeren om een model te downloaden en de serverdienst te starten. Op de achtergrond neemt het commandlineprogramma contact op met registry.ollama.ai en downloadt het model in de gekozen variant.
Net als bij containerimages gebeurt het downloaden in lagen, zodat modellen op andere modellen kunnen voortbouwen. Je kunt bijvoorbeeld een bestaand model uitbreiden met een zinvolle systeemprompt en het onder een nieuwe naam in de registry beschikbaar maken.
Dergelijke aanpassingen definieer je in een bestand met de naam Modelfile – de gelijkenis met Dockerfile is bewust.
Basissoftware: Open WebUI
Het tweede belangrijke onderdeel van ons voorstel voor een LLM-server waar meerdere gebruikers toegang toe hebben, is Open WebUI. Die opensource software vult aan wat de llama-server niet biedt.
Ten eerste is dat een behoorlijk uitgebreide webinterface die een chatfunctie biedt. Daarmee kun je in tekstvorm met modellen communiceren, maar dat is niet alles – in de interface kun je bijvoorbeeld ook afbeeldingen uploaden en het model de inhoud laten beschrijven.
Qua functionaliteit en gebruiksvriendelijkheid kan Open WebUI zich meten met de desktopapplicaties van OpenAI en Anthropic, en is het op sommige vlakken zelfs beter. Als beheerder van een team kun je gebruikers beheren, inloggegevens instellen en bepalen wie welk model mag gebruiken. Er is zelfs rekening gehouden met single-sign-on via OAuth en LDAP.
Op de achtergrond maakt de webinterface verbinding met een door Ollama gestarte serverdienst of een vergelijkbaar alternatief. Naar buiten toe biedt Open WebUI zelf een API aan, die is voorzien van gebruikersauthenticatie. Op die manier kun je de LLM-server, die op het internet of een intern netwerk draait, koppelen aan andere tools.
Installeren
Als dit alles je nog niet heeft afgeschrikt en je zo’n server wilt opzetten, begint het installatieproces in een SSH-commandline op de server. Alle commando’s en configuratiebestanden voor dit artikel staan in een GitHub-Gist, die je kunt vinden via de link bij dit artikel.
Eerst heeft de server de stuurprogramma’s voor de grafische kaart nodig. Onder Ubuntu is het installeren daarvan zo gedaan – pakketbronnen bijwerken en twee pakketten installeren:
sudo apt update
sudo apt upgrade
sudo apt install nvidia-utils-580 nvidia-driver-580Het getal 580 in de pakketnamen geeft de versie aan. Versie 580 werkt met Ubuntu 24.04 LTS – als je nieuwere versies van het besturingssysteem gebruikt, kun je ook nieuwere drivers installeren, zie de link.
Na een herstart is de installatie voltooid en moet het commando nvidia-smi de status van de GPU weergeven. Dat Nvidia-programma is echter niet echt handig, het wordt bijvoorbeeld niet bijgewerkt en geeft altijd alleen een statische momentopname weer.
Een goed alternatief is het opensource project nvitop, dat voor de GPU ongeveer hetzelfde doet als het standaard Linux-programma top voor RAM en CPU. Het laat live zien wat de grafische kaart op dat moment aan het doen is.
Tijdens onze experimenten draaide er altijd een sessie met nvitop. Dat kleine Python-programma start je het snelst met pipx:
apt install pipx
pipx run nvitop De volgende stap is het installeren van de containeromgeving Docker op het systeem. In Docker-containers moeten later Open WebUI, Ollama en een Ingress-router draaien, die inkomend verkeer via HTTPS doorstuurt naar de webinterface.
Je installeert Docker met:
curl -fsSL https://get.docker.com | sudo shAls je niet als rootgebruiker op de server werkt, voeg je de huidige gebruiker toe aan de groep docker, zodat hij containers mag starten:
sudo usermod -aG docker $USERDaarna moet je de sessie een keer opnieuw opstarten. Ga dan verder met de NVIDIA Container Toolkit, een uitbreiding voor Docker waarmee je de kracht van de GPU aan containers kunt doorgeven.
Voor het installeren moet je de repository van Nvidia in de pakketbeheerder toevoegen. Het commando daarvoor staat samen met alle commando’s en configuratiebestanden bij dit artikel in een repository – zie de link.
Daarna moeten de pakketbronnen worden bijgewerkt, waarna het installeren van de toolkit volgt:
sudo apt-get update
sudo apt install -y nvidia-container-toolkitAls dat klaar is, moet de toolkit nog worden opgenomen in het Docker-configuratiebestand /etc/docker/daemon.json. Dat lukt met nog een commando:
sudo nvidia-ctk runtime configure --runtime=docker Na een herstart van de Docker-daemon is de omgeving klaar voor gebruik:
sudo systemctl restart dockerEerste poging
Voor de allereerste functietest moet je twee SSH-sessies naast elkaar opzetten. In de ene draait nvitop continu om te controleren of het model ook daadwerkelijk op de GPU draait.
In de tweede sessie start je een Ollama-server:
docker run -d --gpus=all --name ollama-test ollama/ollamaMet het volgende commando start je een model in de container en ga je direct naar een commandlinevenster waarin je met het model kunt communiceren:
docker exec -it ollama-test ollama run qwen3.5:2b Als je dat model een vraag stelt, moet je in het tweede venster zien hoe de GPU het zwaar te verduren krijgt.
In tegenstelling tot modellen in de cloud zie je daar ook meteen dat het energieverbruik van de GPU bij elke vraag omhoogschiet.
Als je klaar bent met dat kleine experiment, sluit je de sessie af met /bye. Je verwijdert de testcontainer met:
docker stop ollama-testHet complete pakket
Na al die voorbereidingen kun je een complete server met grafische interface opzetten. Maak daarvoor een nieuwe map aan, ga daarheen en maak daarin weer een map aan voor de gegevens die permanent opgeslagen moeten worden:
mkdir llmserver
cd llmserver
mkdir dataIn die map heb je een bestand nodig met de naam docker-compose.yml. De inhoud van dat bestand staat in het kader en kun je downloaden via de link bij dit artikel.
services:
openwebui:
image: ghcr.io/open-webui/open-webui:main
ports:
- 8080:8080
volumes:
- ./data/open-webui:/app/backend/data
ollama:
image: ollama/ollama:latest
container_name: ollama
volumes:
- ./data/ollama:/root/.ollama
deploy:
resources:
reservations:
devices:
- driver: nvidia
count: all
capabilities: [gpu]
restart: unless-stoppedMet één commando start je die samenstelling:
docker compose up -d Vervolgens kun je de webinterface van Open WebUI in je browser openen via het adres http://:8080. Als je de server in het lokale netwerk draait en daar niets aan wilt veranderen, kun je het volgende gedeelte overslaan – lees dan verder bij het gedeelte Welkom bij Open WebUI.
De opstelling bestaat uit minimaal twee containers: Open WebUI zorgt voor de interface, terwijl Ollama op de achtergrond draait.
Met HTTPS op internet
Als je de server via een met TLS versleutelde verbinding vanaf internet bereikbaar wilt maken, moet je aan een paar voorwaarden voldoen en een reverse-proxy inschakelen die het verkeer beveiligt en doorstuurt naar Open WebUI.
Allereerst is portforwarding van de poorten 80 en 443 naar de server nodig. Als de server achter een internetverbinding met een dynamisch IP-adres staat, heb je een aanbieder voor dynamische DNS nodig, zodat je van buitenaf via een hostnaam bereikbaar bent.
Sluit eerst de containeropstelling af met docker compose down. Pas vervolgens het Docker Compose-bestand aan – een versie waarin we de reverse-proxy al hebben toegevoegd, kun je downloaden via de link. Vervang in het bestand de hostnaam ai.example.org door die van jou.
Vervolgens moet je een paar voorbereidende stappen uitvoeren voor de Ingress-router Traefik:
mkdir data/traefik
touch data/traefik/acme.json
chmod 600 data/traefik/acme.json
touch data/traefik/static.yml
touch data/traefik/dynamic.ymlAls alle bestanden zijn aangemaakt, start je de opstelling op met docker compose up -d. Na een paar minuten reageert de pagina met een geldig certificaat.
Welkom bij Open WebUI
Bij je eerste bezoek aan de webinterface moet je een eerste account aanmaken en daarvoor een naam, e-mailadres en wachtwoord instellen. Het e-mailadres is vervolgens je gebruikersnaam.
Je wordt meteen verwelkomd met een chatinterface die doet denken aan die van Claude. Linksboven moet je, voordat je gaat chatten, een model kiezen. Dat kan pas als Open WebUI weet waar het zijn Ollama-back-end kan vinden.
Open WebUI kan die modellen rechtstreeks uit de Ollama-registry laden, mits je de naam ervan kent. Maar welk model moet je kiezen en wat is de juiste naam? Handige tips vind je in het kader Geschikte modellen.
Zodra je een modelnaam hebt, type je naam daarvan in en klik je op het pijltje Pull Model. Bij pakketten van zo’n 20 gigabyte duurt het downloaden, afhankelijk van je internetverbinding, een paar minuten.
Nadat je een model gedownload hebt, kun je de mogelijkheden ervan en de functies van Open WebUI verkennen. Bij de eerste vraag aan een model dat nog niet geladen is, zul je merken dat je een paar seconden moet wachten.
In een nvitop-sessie kun je het systeem aan het werk zien: zodra het geheugen van de GPU vol is, komen de antwoorden. Als het antwoord klaar is, zie je eronder een klein rijtje met pictogrammen, waaronder een info-icoontje. Daarachter zitten details over het antwoord, onder andere het aantal tokens per seconde – een relevante indicatie als je de prestaties van modellen vergelijkt.
Afhankelijk van het model kun je via het plusteken naast de chat ook bestanden of websites invoeren en het model daarover vragen stellen.
Geschikte modellen
Zodra aan de voorwaarden voor een eigen LLM-server voldaan is, begint het leuke gedeelte: het downloaden en uitproberen van gratis beschikbare modellen.
Om te voorkomen dat je de weg kwijtraakt in de wirwar aan mogelijkheden, hebben we een paar tips op een rijtje gezet om geschikte modellen te vinden.
Voor Ollama-gebruikers ligt het voor de hand om in het Ollama-register te kijken. Maar daar staan de modellen gewoon allemaal achter elkaar in een lange lijst. Wat je zoekt, zijn modellen die in het RAM van je grafische kaart passen. Dat lukt bij LLM’s die zo slim zijn dat je er zinvol mee kunt werken, alleen met een paar wiskundige trucjes, met name kwantisering.
Daarbij blijft de structuur van een neuraal netwerk ongewijzigd; je bespaart opslagruimte en rekenkracht door de gewichten niet met een nauwkeurigheid van 32 bit op te slaan, maar ze om te zetten naar variabelen met een lagere resolutie: 16 bit, 8 bit of zelfs 4 bit. Die werkwijze hebben we al uitgebreid uitgelegd [5].
Daarnaast zijn er technieken die het netwerk uitdunnen en lagen verwijderen. Het model Qwen 3.6 met 27 miljard parameters neemt bijvoorbeeld met 32-bit floatingpoint-waarden meer dan 108 GB geheugen in beslag. In de kwantisatiefase Q4_K_M is 17 GB ineens genoeg – met ruimte voor de key-value-opslag past het model prima op een GPU met 20 GB.
Q4 is de naam van een kwantisatiemethode die betere resultaten oplevert dan modellen met Q3 in de naam.
In het register van Ollama is het best lastig om geschikte modellen te vinden. Handiger is de gratis site canitrun.dev. Daar selecteer je links je eigen GPU en de RAM-grootte en vind je modellen die mogelijk passen. Alle modellen met een groene stip passen volledig in het geheugen van de GPU, alle modellen met een gele stip moeten ook gebruikmaken van het RAM.
Achteraan in de lijst staat een schatting van hoeveel tokens per seconde realistisch zijn. Als je een model hebt gekozen, vind je een link naar Ollama, waar je de exacte naam uit de lijst met varianten kunt opzoeken – bijvoorbeeld qwen3.6:27b-q4_K_M.
Voor dit artikel hebben we onder meer de volgende modellen gebruikt, die in 20 GB geheugen passen: qwen3.6:27b-q4_K_M, qwen2.5-coder:32b (gespecialiseerd in programmeertaken), gemma4:26b en nemotron-3-nano_30b.
Instellingen voor een team
Veel functies van de interface spreken voor zich, alleen het beheergedeelte is wat ingewikkeld. Als je bruikbare modellen hebt gekozen en die met een team wilt delen, zijn er een paar klikken nodig. Linksonder achter je naam zit een menu, daarin zit het Admin Panel.
Als je meerdere gebruikers hebt, moet je hen rechten voor modellen toekennen. Gebruikers zonder beheerdersrechten kunnen alleen modellen gebruiken die jij vrijgeeft en geen modellen van Ollama downloaden.
Klik bij de instellingen links op Models vervolgens op het potlood naast een model en rechts bovenaan op Access. Daar kun je een model vrijgeven voor iedereen of voor bepaalde gebruikers. Als je het dialoogvenster sluit, kun je nog meer details van het model aanpassen – waaronder de weergavenaam, de geactiveerde mogelijkheden (Capabilities) en de systeemprompt (System Prompt).
Conclusie
Zelfstandig draaiende LLM’s op een eigen server is een optie! Met Open WebUI en Ollama bouw je binnen een redelijke tijd een server voor een klein team, die werk verricht waarvoor je elders tokens zou moeten afrekenen.
Als je als beheerder van de server meer inzicht nodig hebt in de belasting van de server over een langere periode, kijk dan eens in de documentatie van nvitop. Die tool kan belastinggegevens exporteren naar de datacollector Prometheus, zodat je alle waarden in Grafana-dashboards kunt weergeven.
Dit artikel behandelt slechts een greep uit de mogelijkheden van de geïnstalleerde software. Bij de instellingen en de documentatie valt nog veel te ontdekken: je kunt bijvoorbeeld MCP-servers ook rechtstreeks op de server draaien en koppelen aan de webinterface. Op die manier kun je handige hulpmiddelen opzetten voor zakelijke of privé-taken.
Jan Mahn en Noud van Kruysbergen
Literatuur
[1] Jan-Keno Janssen, Christof Windeck en Marco den Teuling, Compact AI-workstation: Gigabyte AI Top Atom (Nvidia DGX Spark), c’t 3/2026, p.92
[2] Noud van Kruysbergen, Asus Ascent GX10, c’t 10/2026, p.22
[3] Noud van Kruysbergen, Lenovo ThinkStation PGX, c’t 11/2026, p.24
[4] Carsten Spille en Alieke van Sommeren, AI-tools draaien op het high-end allround-pc bouwvoorstel, c’t 5/2026, p.142
[5] Andrea Trinkwalder en Alieke van Sommeren, Europese AI-scene: tussen Mistral en Lovable, c’t 6/2025, p.84
Links bij dit artikel
GitHub-gist met commando’s en configuratiebestanden
Nvidia-drivers voor Ubuntu
nvitop
Ollama-registry
Run LLMs on Your Own Hardware
Praat mee