Hardwarevereisten voor probleemloos gebruik van Ollama

Informatic Digital » Middelen » Hardwarevereisten voor probleemloos gebruik van Ollama

Als je overweegt om kunstmatige intelligentiemodellen op je eigen computer te draaien, kom je vroeg of laat onvermijdelijk Ollama tegen. En dat is waar de grote vraag opduikt: welke hardwarevereisten heb ik nodig om de modellen soepel en zonder haperingen te laten draaien? Het is niet voldoende dat ze gewoon opstarten; het belangrijkste is dat ze comfortabel te gebruiken zijn bij dagelijkse taken, en inzicht in de verschillende soorten computerhardware is essentieel.

In dit artikel zullen we in detail bekijken wat Llama doet, wat de verschillende modellen (7B, 13B, 70B, enz.) vereisen, hoe de CPU, GPU, RAM en schijf de prestaties beïnvloeden en welke configuraties geschikt zijn, afhankelijk van uw situatie : of u nu een eenvoudige tekstassistent wilt of juist krachtige programma's zoals Llama 3 met tientallen miljarden parameters, of beeldherkennings- en OCR-modellen wilt draaien.

Wat is Ollama en waarom maakt de hardware zo'n verschil?

Ollama is in essentie een client voor taalmodellen waarmee je LLM's lokaal op je computer kunt uitvoeren, zonder afhankelijk te zijn van de cloud. Het maakt gebruik van engines zoals llama.cpp voor inferentie en verpakt alle complexiteit in een eenvoudige tool met een CLI en REST API, die je ook helpt de concepten van de kunstmatige neurale netwerken achter de modellen te begrijpen.

De functie ervan is die van "commandocentrum" van waaruit u modellen zoals Llama 3, Mistral, Gemma, Phi, Qwen, DeepSeek of multimodale modellen zoals Llava kunt downloaden, beheren en uitvoeren . Het mooie is dat u ze volledig offline kunt gebruiken, waardoor uw gegevens lokaal blijven en u niet voor elk token hoeft te betalen, zoals bij cloud-API's het geval is.

Hoewel Ollama zelf lichtgewicht en niet veeleisend is, zijn de modellen die het uitvoert zeer resource-intensief . Elk LLM bestaat uit miljoenen of miljarden parameters, wat zich vertaalt in gigabytes aan geheugen en opslag, en een zware belasting voor de CPU en, indien aanwezig, de GPU.

Daarom is het zo dat wanneer iemand een groot model (bijvoorbeeld een 70B Llama) probeert te draaien op een systeem met een krachtige CPU, maar een aparte GPU en net genoeg RAM, het resultaat meestal is dat "het wel werkt", maar zo traag is dat het praktisch nutteloos is . De sleutel is om de juiste balans te vinden tussen CPU, GPU, RAM, harde schijf en modeltype.

Soorten modellen in Ollama en hoe deze de vereisten beïnvloeden

In de Ollama-bibliotheek vindt u modellen georganiseerd per familie en grootte: 1B, 2B, 4B, 7B, 13B, 30B, 65B, 70B, 405B… . Dat getal (B staat voor miljarden) geeft het geschatte aantal parameters aan en is een van de belangrijkste factoren die de benodigde hardware bepalen.

We kunnen ze in grote lijnen indelen in vier categorieën , wat enorm helpt bij het inschatten welke machine je nodig hebt om vertrouwd te raken met elke groep modellen en kwantificeringen:

• Mini-modellen (270M – 4B): ontworpen voor bescheiden apparaten (eenvoudige laptops, zelfs sommige mobiele telefoons of mini-pc's). Snel, maar met minder redeneervermogen.
• Kleine modellen (4B – 14B): ideaal als evenwichtige “binnenlandse” modellenGeschikt voor algemene gesprekken, kantoortaken, lichte programmeerhulp, enz.
• Middelgrote modellen (14B – 70B)Ze spelen al in een andere competitie; Ze hebben krachtige hardware nodig., voldoende RAM-geheugen en, indien mogelijk, een grafische kaart met veel VRAM.
• Grote modellen (> 70B)Het zijn beesten die ontworpen zijn voor zeer serieuze infrastructuren (Hoogwaardige GPU's, meerdere grafische kaarten, dedicated servers, goed benutte high-end Macs, enz.).

Naast de grootte speelt ook kwantisering een rol : in Ollama zie je achtervoegsels zoals q4_K_M, q5_1, q3_K_S, q8_0, f16 , enz. Deze formaten geven aan hoe sterk de gewichten van het model gecomprimeerd zijn.

• FP16 / FP32 (f16, f32): nauwelijks samengeperst, topkwaliteit, maar een enorm geheugenverbruik.Een 7B in FP16 kan tot meer dan 20 GB VRAM gaan.
• Q4 (q4_0, q4_K_M…): 4-bits kwantisering, grote volumeverkleining met een matige impact op de kwaliteit.Dat is meestal de ideale situatie.
• Q3, Q2 (q3_K_S, q2_K…): agressievere kwantiseringen, zeer klein formaat in ruil voor een gering verlies aan precisieBruikbaar op hardware met zeer beperkte mogelijkheden.
• K5, K6, K8: tussenstappen tussen sterke compressie en FP16; Hogere kwaliteit, hogere consumptie.

Het praktische gevolg is duidelijk: hetzelfde 7B-model kan ongeveer 26 GB in beslag nemen in FP16 of ongeveer 4 GB in Q4 . Dit vertaalt zich direct naar de benodigde GPU VRAM en de hoeveelheid RAM die de werklast moet ondersteunen.

Minimale en aanbevolen hardwarevereisten voor Ollama op het lokale netwerk.

Als je je afvraagt ​​of je computer Ollama wel aankan, is het antwoord meestal ja; de vraag is welk model het spel soepel kan draaien . Laten we het per component bekijken: RAM, CPU, GPU en harde schijf, met realistische aanbevelingen gebaseerd op praktijkervaring en documentatie uit diverse gespecialiseerde handleidingen.

RAM: de ultieme kritieke bron

RAM is het grootste knelpunt bij het bespreken van lokale LLM's. Over het algemeen kunnen we de volgende bereiken aanhouden:

• 8 GB RAM-geheugen: de praktische basis. Het maakt kleine modellen mogelijk (1B, 3B, een sterk gekwantiseerde variant van 7B).Je zult echter wel beperkingen ondervinden, vooral als het systeem en de browser al veel geheugen gebruiken. De kans is groot dat alles wat trager en met meer vertraging zal werken.
• 16 GB RAM-geheugen: de redelijke norm van vandaag. Ideaal voor 7B- en zelfs 13B-modellen die in Q4 zijn gekwantiseerd.Vooral als je GPU's gebruikt. Je kunt met complexe chats werken zonder dat het systeem trager wordt.
• 32 GB RAM of meerAanbevolen als je wilt middelgrote modellen (30B, 40B, 70B) Of voer complexere taken uit, zoals zeer lange contexten, meerdere modellen parallel, servers voor meerdere gebruikers of grafische tools van het type Open WebUI op Ollama.

Houd er rekening mee dat RAM niet alleen door het apparaat zelf wordt gebruikt: het besturingssysteem, de browser, IDE, Docker, Open WebUI en andere applicaties verbruiken het ook . Als u in specifieke situaties geheugen wilt vrijmaken, kunt u leren hoe u het RAM-gebruik in applicaties zoals uw browser kunt verminderen. Voor intensief gebruik is 16 GB momenteel het minimum dat wordt aanbevolen, en 32 GB is meer dan voldoende.

CPU: Moderne instructies en aantal cores

Ollama kan op een CPU alleen draaien, maar de ervaring verschilt sterk afhankelijk van de processor. Belangrijker dan het aantal cores is de ondersteuning voor geavanceerde instructies zoals AVX2 en, nog beter, AVX-512 , die matrix- en vectorbewerkingen versnellen die veelvuldig worden gebruikt in LLM's.

Een redelijke richtlijn zou zijn:

• Minimaal aanvaardbaarEen moderne quad-core CPU (bijvoorbeeld een Intel i5 van de nieuwste generatie of een gelijkwaardige Ryzen-processor) met AVX2-ondersteuning. Hiermee kunt u Voer 7B-modellen geduldig uit, vooral als ze goed gekwantiseerd zijn..
• Recomendado: nieuwste processortype Intel 11e generatie of nieuwer of AMD Zen4met 8 kernen of meer en waar mogelijk AVX-512-ondersteuning. Zo krijgt u Verbeterde reactietijden en minder knelpunten, zelfs met GPU's..

Als je van plan bent om zeer grote modellen te gebruiken (bijvoorbeeld een Llama 3 van 70 miljard met een bescheiden CPU en GPU), zal de CPU het moeilijk hebben en zul je merken dat het genereren van tokens erg lang duurt . In dergelijke gevallen is het verstandiger om te kiezen voor kleinere modellen of te investeren in een geschikte GPU.

GPU en VRAM: wanneer is het essentieel en hoeveel heb je nodig?

Een goede GPU is niet verplicht, maar het maakt wel een wereld van verschil. Een degelijke GPU met voldoende VRAM kan een trage ervaring omtoveren tot iets perfect bruikbaars , vooral bij modellen met 7 tot 13 bits.

Als zeer nuttige referentie kan voor gekwantiseerde modellen (ongeveer Q4) iets als dit worden geschat:

• 7B → ~4 GB VRAM
• 13B → ~8 GB VRAM
• 30B → ~16 GB VRAM
• 65-70B → ~32 GB VRAM

Dit zijn benaderende waarden, maar ze laten duidelijk zien dat een RTX 2060 SUPER GPU met 8 GB VRAM meer dan capabel is voor 7B en 13B aankan, maar tekortschiet bij 70B, zelfs met een i9 en 64 GB RAM. In dat geval zal het systeem een ​​groot deel van de belasting moeten verdelen tussen RAM en CPU, waardoor de latentie enorm zal toenemen.

In de praktijk :

• met 4-6 GB VRAM: focus op goed gekwantificeerde 7B-modellenZe zijn zeer geschikt voor chatten, schrijven en algemene taken.
• met 8-12 GB VRAMJe kunt comfortabel werken met 7B en 13B En zelfs een 30B als je bereid bent om wat langzamer te rijden.
• met 20-24 GB VRAMJe betreedt nu het terrein van 30B-40B modellen met aanzienlijke waardigheidEn een aantal sterk gekwantiseerde 70B-bestanden, vooral als je dat ondersteunt met goed RAM-geheugen.
• met 32 GB VRAM of meer: is wanneer 70 miljard begint er ineens heel redelijk uit te zien. Voor interactief gebruik, mits de rest van het team meedoet.

Voor een OCR-model of andere gespecialiseerde modellen (bijv. computervisie) is een GPU met 20-24 GB VRAM een zeer solide basis voor soepele prestaties , vooral als het model tientallen miljarden parameters bevat. Voor lichtere (2B-7B) OCR- of computervisievarianten is 8-12 GB doorgaans meer dan voldoende.

Schijfopslag: hoeveel ruimte nemen de modellen in beslag?

Wat betreft schijfruimte: de Ollama-applicatie zelf neemt heel weinig ruimte in beslag; de modellen nemen echt veel ruimte in beslag. In een basis- of testomgeving is ongeveer 50 GB voldoende , maar als je modellen gaat verzamelen, loopt de benodigde ruimte snel op.

Als grove richtlijn voor gekwantiseerde modellen:

• Kleine modellen (1B-4B) → rondom 2 GB per model.
• Middelgrote modellen (7B-13B) → normaal 4-8 GB per model, afhankelijk van de kwantificering.
• Grote modellen (30B-70B) → gemakkelijk 16-40 GB een ieder
• Zeer grote modellen (> 100B) → kan overschrijden 200 GB per model en in sommige extreme gevallen zelfs meer dan terabytes.

Gebruik idealiter een snelle SSD (bij voorkeur NVMe) voor een snellere initiële modellading. Daarnaast kunt u in Ollama de opslaglocatie van het model wijzigen met behulp van de omgevingsvariabele OLLAMA_MODELS , zodat u een grote secundaire schijf kunt gebruiken en ruimte vrijmaakt op uw primaire schijf. Zie de handleiding voor opslaghardware voor meer informatie over opslagcapaciteit en schijftypen.

Specifieke vereisten voor het uitvoeren van specifieke modellen met Ollama

Hoewel elk model zijn eigen nuances heeft, kunnen er binnen het huidige Ollama-ecosysteem enkele duidelijke richtlijnen worden gegeven voor typische gebruikscategorieën: algemene chat, codering, beeldherkenning/OCR-modellen en gigantische 70B-achtige modellen.

Algemene chattemplates (Llama, Mistral, Gemma, Qwen…)

Voor typisch "lokaal ChatGPT"-gebruik met middelgrote modellen zoals de Llama 3.x 7B/8B, Mistral 7B, Gemma 2B/7B of Qwen , zou een redelijke configuratie er vandaag de dag ongeveer zo uitzien:

• Minimum aanbevolen:
  • Moderne quad-core CPU met AVX2.
  • 16 GB RAM-geheugen.
  • Geen GPU of een basis-GPU met 4-6 GB VRAM.
  • Minimaal 50 GB SSD voor het systeem + één of twee modellen.
• Optimale configuratie voor voldoende hoofdruimte met 7B-13B:
  • CPU met 8 of meer kernen (moderne i7/i9 of Ryzen 7/9).
  • 32 GB RAM-geheugen als je veel dingen open wilt houden.
  • GPU met 8-12 GB VRAM (RTX 3060/3070 of equivalent, AMD RX 6700 of hoger, of een Mac met een goed benut M1/M2/M3-geheugen).
  • Een SSD van 1 TB is aan te raden als je van plan bent modellen te verzamelen.

In deze scenario's presteren 7B-modellen met Q4_K_M- of Q5_K_M-kwantisering zeer goed en bieden ze meer dan voldoende kwaliteit voor persoonlijk gebruik, technische documentatie, studietaken of schrijfondersteuning.

Codeermodellen (DeepSeek, CodeLlama, Code-georiënteerde Phi)

Modellen die gespecialiseerd zijn in programmeren hebben doorgaans vergelijkbare behoeften als algemene chatmodellen van dezelfde omvang , maar het is raadzaam om wat meer RAM en VRAM te reserveren als je ze gaat gebruiken in combinatie met een zware IDE en veel open projecten.

Om bijvoorbeeld DeepSeek-Coder (7B-8B) of een CodeLlama van vergelijkbare grootte onder de juiste omstandigheden te gebruiken , zou een zeer redelijke combinatie er als volgt uitzien:

• CPU moderne processoren met 6-8 kernen.
• 32 GB RAM-geheugen als je met meerdere tools tegelijk werkt (IDE, browser met tabbladen, Docker, enz.).
• GPU met minimaal 8 GB VRAM om het model soepel te verplaatsen.

Het werkt ook op minder krachtige hardware, maar je zult merken dat de reactietijd trager is bij het genereren van lange stukken code of het uitvoeren van complexe analyses . Voor compacte modellen zoals de Phi-4 Mini zijn de vereisten veel lager en presteren ze goed, zelfs op systemen met 16 GB RAM en een lichte GPU.

Visie- en OCR-modellen (Legenda, OCR-modellen, multimodaal)

Modellen met beeldverwerkingsmogelijkheden (visie/OCR), zoals Llama of de multimodale varianten van Llama 3.x, evenals specifieke OCR-modellen, voegen een extra laag complexiteit toe. Op hardwareniveau benaderen ze de vereisten van een tekstmodel van dezelfde omvang, maar met het grotere voordeel van het gebruik van een GPU.

Als we het hebben over een middelgroot OCR-model (laten we zeggen in de 7B-13B-reeks) en je wilt het lokaal comfortabel gebruiken voor documentherkenning, gescande afbeeldingen, enz., dan is het zinvol om iets als het volgende te overwegen:

• GPU met 20-24 GB VRAM Of het nu gaat om een ​​zeer groot model of om de wens om vrijwel alle verwerking op de grafische kaart te laten plaatsvinden.
• GPU met 8-12 GB VRAM Als je kiest voor lichtere en goed gekwantiseerde varianten, blijft het goed werken zolang je de afbeeldingsgrootte of gigantische contexten niet overdrijft.
• Minimaal 16 GB RAM, hoewel 32 GB een zeer comfortabele marge biedt voor intensief gebruik.
• moderne CPU, zodat deze geen knelpunt vormt wanneer de GPU zwaar belast wordt.

Het directe antwoord op de veelgestelde vraag "kan ik een OCR-model draaien op een GPU met 20-24 GB VRAM?" is ja, dat is een uitstekend bereik voor middelgrote tot grote beeldverwerkings-/OCR-modellen in Ollama , mits je ook over voldoende RAM en een degelijke processor beschikt.

Gigantische modellen (Llama 3:70B en vergelijkbare modellen)

Het proberen om een ​​70KB Llama 3-model te draaien op Windows met een zeer krachtige CPU (bijvoorbeeld een 11e generatie i9) en 64 GB RAM, maar een GPU zoals een 8 GB RTX 2060 SUPER, is een perfect voorbeeld van "ja, maar nee". Het model laadt misschien uiteindelijk wel, maar:

• Een deel van het model past niet in het VRAM en is sterk afhankelijk van het RAM-geheugen.
• De CPU moet een groot deel van het inferentiewerk op zich nemen.
• De tijd per token loopt enorm op en de ervaring wordt praktisch onbruikbaar..

Om een ​​70B zinvol te laten zijn in een thuisomgeving of semi-professionele omgeving, heb je minimaal het volgende nodig:

• 32 GB RAM als basis, 64 GB als je extra geheugen wilt..
• GPU met minimaal 24-32 GB VRAM om het grootste deel van het model te laden met een redelijke kwantisering (Q4_K_M of iets dergelijks).
• Krachtige high-end CPU met 8-16 kernen.

Als je deze cijfers niet haalt, is het veel praktischer om goed gekwantiseerde 7B-13B-modellen te gebruiken of, als je echt 70B nodig hebt voor kwaliteit, een gespecialiseerde server (lokaal of in de cloud), een zeer krachtige Mac of meerdere GPU's die parallel werken te overwegen.

Vereisten voor het installeren van Ollama op een VPS of server

Een andere veelvoorkomende optie is om Ollama te installeren op een VPS of dedicated server en er toegang toe te krijgen via een API of webinterface (bijvoorbeeld met Open WebUI). Dit brengt niet alleen resources met zich mee, maar ook het besturingssysteem en de benodigde machtigingen.

In handleidingen van providers zoals Hostinger worden de volgende minimale vereisten aanbevolen voor een VPS die geschikt is voor Ollama:

• RAM: minimaal 16 GB zodat kleine/middelgrote modellen het systeem niet overbelasten.
• CPU: 4-8 vCoresafhankelijk van de grootte van de modellen en het aantal gelijktijdige gebruikers.
• Opslag: minimaal 12 GBIn de praktijk is het echter raadzaam om een ​​grotere opslagcapaciteit te kiezen (50-100 GB) als je meerdere modellen wilt uitproberen.
• Sistema operativo: bovenal Linux, met voorkeur voor Ubuntu 22.04 of hoger, of een recente stabiele versie van Debian..
• Root-toegang of sudo-rechten om afhankelijkheden te installeren, systemd te configureren, enz.

Als uw VPS een NVIDIA GPU bevat, moet u CUDA of de NVIDIA Container Toolkit installeren en configureren als u Docker gebruikt. Bij AMD wordt doorgaans ROCm gebruikt op Linux en de bijbehorende Adrenalin-stuurprogramma's op Windows. In omgevingen zonder GPU zal de server afhankelijk zijn van de CPU en het RAM-geheugen, dus bezuinig niet op deze resources; u kunt de server ook op afstand beheren via Remote Desktop als u een grafische interface nodig hebt.

Specifieke hardwarescenario's en welke modellen te gebruiken

Om ervoor te zorgen dat het bovenstaande niet louter theoretisch blijft, kan het nuttig zijn om met behulp van Ollama te kijken naar enkele typische hardwarecombinaties en welke modellen in elk geval goed passen .

Een bescheiden desktopcomputer of een middelgrote laptop.

Laten we een typisch team eens bekijken :

• i5- of Ryzen 5-processor van een paar jaar geleden (4-6 kernen).
• 16 GB RAM-geheugen.
• Geïntegreerde of aparte GPU van 4 GB.
• 512 GB SSD.

In dit scenario is het verstandig om te streven naar :

• Gekwantiseerde 1B-3B-modellen (Gemma 2B, Phi-4 Mini, Llama 3.x 1B) voor maximale vloeiendheid.
• 7B-modellen in het vierde kwartaal als u een iets langere reactietijd accepteert.
• Gebruik Ollama via de terminal en, als je een webinterface wilt, open WebUI dan voorzichtig om het RAM-geheugen niet te overbelasten.

Je kunt je lokale tekstassistent gebruiken, samenvattingen maken, analyses uitvoeren en lichte programmeertaken verrichten, maar het is niet de ideale omgeving voor 13B-modellen en hoger.

Middel- tot hoogwaardige apparatuur gericht op lokale AI

Hier hebben we het over een pc-type :

• Moderne i7/i9 of Ryzen 7/9 CPU, 8-16 kernen.
• 32 GB RAM-geheugen.
• GPU met 12-24 GB VRAM (RTX 4070/4080, 3090, 4090, AMD-equivalenten of vergelijkbaar).
• 1-2 TB SSD.

Deze configuratie vergroot de mogelijkheden aanzienlijk :

• Modellen 7B-13B in Q4/Q5 Voor chatten, coderen, data-analyse… met zeer goede reactietijden.
• 30B-modellen en wat 70B gekwantiseerd als je een iets langere latentie voor lief neemt.
• Modellen van visie/OCR middelgrote bedrijven die de GPU intensief gebruiken.

Het is het soort machine waarmee je een serieuze lokale AI-omgeving kunt opzetten , met meerdere modellen, een webinterface, integratie via REST API en een professionele workflow, zonder afhankelijk te zijn van externe diensten.

"Beast" server of werkstation

Aan de bovenkant bevinden zich omgevingen met:

• Meerdere GPU's met elk 24-48 GB VRAM, of één krachtige GPU.
• 64-128 GB RAM.
• CPU's met veel kernen, zoals recente Threadripper- of Xeon-modellen.

Dit is waar gigantische modellen (>70 miljard, MoE, veel visuele input, enz.) realistisch beginnen te worden, zelfs met meerdere gelijktijdige gebruikers of complexe integraties. Het is uiteraard een kostbaar scenario, maar het biedt ook mogelijkheden die vergelijkbaar zijn met sommige commerciële API's, met volledige controle over de gegevens binnen uw eigen infrastructuur.

Praktische tips om het meeste uit uw Ollama-hardware te halen

Naast het aanschaffen van meer RAM of een betere GPU, zijn er verschillende methoden die je helpen om het maximale uit je bestaande apparatuur te halen en verrassingen te voorkomen bij het uitvoeren van grote modellen met Ollama.

Om te beginnen is het belangrijk om het juiste model te kiezen op basis van je beoogde gebruik : het heeft geen zin om een ​​70B te gebruiken voor het schrijven van simpele e-mails als een goed afgestelde 7B perfect volstaat. Evenzo is een 30B niet zinvol als je GPU slechts 6 GB VRAM heeft; een 7B is in het vierde kwartaal een betere keuze.

Een andere belangrijke maatregel is experimenteren met runtime-parameters (temperatuur, num_ctx, num_predict, enz.), hetzij in het modelbestand of via de CLI/API. Het gebruik van extreem grote contexten ( num_ctx van 32k of meer ) met weinig RAM of VRAM zal het hele systeem vertragen zonder in veel gevallen veel voordeel op te leveren.

Het is ook raadzaam controleren welke modellen geladen zijn en op welke processor. gebruik ollama psDaar zie je of het model daadwerkelijk op de GPU of CPU draait, en hoe groot het geladen is. Pas de variabele aan. OLLAMA_KEEP_ALIVE Het helpt modellen om geheugen vrij te maken wanneer het niet in gebruik is, waardoor resources vrijkomen.

Vergeet tot slot niet dat kwantisering je bondgenoot is : door Q4_K_M- of Q5_K_M-varianten van een origineel FP16-model te creëren, kun je profiteren van veel bescheidener hardware met een kwaliteitsverlies dat in de praktijk vaak nauwelijks merkbaar is.

Na dit alles te hebben overwogen, is de duidelijkste conclusie dat Ollama zelf niet het lastige onderdeel is; de modellen zijn dat wel . Inzicht in de relatie tussen grootte, kwantisering, RAM en VRAM stelt je in staat de juiste hardware- en LLM-combinatie voor jouw behoeften te kiezen: van een laptop met 16 GB RAM waarop een lichtgewicht 7B-model draait tot een werkstation met een GPU van 24 GB die robuuste beeldherkenning en OCR-modellen aankan. Door de verwachtingen en parameters zorgvuldig aan te passen, is het perfect mogelijk om een ​​krachtige, persoonlijke AI op je eigen computer te draaien zonder maandelijkse kosten.