Een lokale LLM op een thuis-NAS implementeren is niet lastig omdat het eerste commando moeilijk is. Het is lastig omdat het model, de cache, de container, de API-server en achtergrondtaken allemaal dezelfde opslag en systeembronnen gebruiken die je NAS al nodig heeft voor bestanden, back-ups, media, databases en apps.
Het veiligste doel is niet om de LLM vanaf dag één zo snel mogelijk te maken. Het is veiliger om een bekend opslagpad te gebruiken, harde grenzen aan resources te stellen, parallelle verwerking te beperken en een verificatieroutine in te voeren. Een iets trager lokaal model is meestal beter dan een snel model dat de systeemschijf vult, geheugendruk veroorzaakt of andere zelfgehoste apps onbetrouwbaar maakt.
Kort gezegd: geef de LLM eigen opslagruimte en limieten
Een lokale LLM moet een eigen plek hebben voordat het eerste model wordt geïnstalleerd. Dat betekent dat je moet weten waar modelbestanden, caches, indexen, logbestanden en appgegevens komen te staan voordat je een model downloadt of een WebUI koppelt. Als die bestanden in een verborgen Docker-pad of op een kleine opstartschijf terechtkomen, kan de implementatie succesvol lijken terwijl ze ongemerkt ruimte innemen die de NAS zelf nodig heeft.
Er zijn ook limieten nodig. LLM-runtimes kunnen veel RAM, VRAM, CPU-threads en contextgeheugen gebruiken, vooral wanneer meerdere modellen of parallelle aanvragen zijn ingeschakeld. De resourcebeperkingen van Docker leggen uit dat containers anders de hostbronnen kunnen gebruiken die door de kernelscheduler worden toegestaan. Geheugendruk kan bovendien leiden tot een out-of-memory-situatie die andere processen beïnvloedt.
Voor een gedeelde NAS is dat belangrijker dan piekscores in benchmarks. Plex, Jellyfin, Home Assistant, databases, synchronisatietaken, back-ups en bestandsdeling mogen niet instabiel worden doordat een modelserver één lange prompt probeert te beantwoorden. Een veilige lokale LLM-implementatie begint met het toewijzen van opslag, resourcebeperkingen, modelkeuze en verificatie.
Wat je moet controleren voordat je het eerste model binnenhaalt
Bepaal voordat je het eerste model downloadt wat de eerste taak is. Een lokale LLM voor licht chatgebruik stelt andere eisen dan een RAG-assistent, een embeddingworker, een programmeerhulp of een automatiseringsagent die bestanden kan lezen en schrijven. Als je de gebruikssituatie niet eerst bepaalt, is het makkelijk om een model binnen te halen dat te groot of te traag is, of de server te zwaar belast.
Begin met deze controles:
- Gebruikssituatie: chatten, RAG, embeddings, samenvattingen, automatisering, programmeren of zoekhulp.
- Modelgrootte: hoe groot het modelbestand is en of je meerdere varianten wilt bewaren.
- Kwantisatie: of het model voldoende is gecomprimeerd voor de server.
- Opslagpad: waar modelbestanden en cache op de host worden opgeslagen.
- Containerpad: hoe het hostpad aan de container wordt gekoppeld.
- RAM en VRAM: hoeveel geheugen beschikbaar blijft voor andere apps.
- CPU-reservecapaciteit: hoeveel threads het model kan gebruiken zonder de NAS te overbelasten.
- Parallelisme: hoeveel verzoeken of geladen modellen tegelijk kunnen worden uitgevoerd.
- Bestaande werklast: back-ups, mediastreaming, databases, synchronisatie en bestanden delen.
- Verificatieplan: hoe je achteraf controleert of de NAS nog steeds goed functioneert.
Deze voorbereidende stap is geen overbodige moeite. Hij voorkomt het meest voorkomende probleem bij de implementatie van een lokale LLM op een NAS: het model reageert, maar de rest van het systeem wordt minder betrouwbaar.
Houd modelbestanden van de systeemschijf af
Modelbestanden kunnen sneller groeien dan verwacht. Eén model is misschien nog goed te beheren, maar meerdere modellen, kwantisatievarianten, embeddings, indexen, WebUI-gegevens en logboeken kunnen al snel tientallen of honderden gigabytes in beslag nemen. Als die bestanden op de systeemschijf of in de Docker-root terechtkomen, kan de NAS te weinig kritieke opslagruimte overhouden, zelfs als de hoofdopslagpool nog in orde lijkt.
In de veelgestelde vragen van Ollama staan de standaardlocaties voor modellen voor verschillende besturingssystemen. Ook wordt uitgelegd dat de modelopslagmap kan worden gewijzigd met de omgevingsvariabele OLLAMA_MODELS. Op een NAS of homeserver is dit belangrijk, omdat het standaardpad misschien niet de juiste plek is voor modelbestanden die je langdurig wilt bewaren.
Als je Ollama of een andere modelrunner in Docker uitvoert, houd er dan rekening mee dat een containerpad niet hetzelfde is als een hostpad. Een map zoals /root/.ollama in de container moet aan een geschikte locatie op de host worden gekoppeld als je voorspelbare opslag wilt. Zonder volumekoppeling kunnen modelbestanden in door Docker beheerde opslag blijven staan, waardoor het moeilijker wordt om de groei te zien en op te ruimen.
Een veiliger aanpak is om vóór de implementatie een aparte modelmap aan te maken, bijvoorbeeld een AI-opslagmap op een datapool of app-opslagvolume. Houd deze gescheiden van back-updoelen, kritieke databases en onvervangbare appgegevens. De modelmap moet groot genoeg zijn, gemakkelijk te controleren en gedocumenteerd zijn, zodat je later oude modellen kunt verwijderen.
Bepaal ook waar gerelateerde bestanden komen te staan. RAG-indexen, embeddings, vectordatabases, logboeken en geüploade documenten kunnen elk extra opslagruimte verbruiken. Als je alleen rekening houdt met het modelbestand, kan de rest van de AI-stack je alsnog verrassen.
Stel grenzen in voor geheugen, CPU en gelijktijdigheid
Geheugenlimieten
Lokale LLM's gebruiken veel geheugen. Ze hebben geheugen nodig voor modelgewichten, context, runtime-overhead en soms meerdere geladen modellen. Als de server ook databases, mediaservices, bestandssynchronisatie, containers en back-uptaken uitvoert, mag het LLM niet zomaar al het beschikbare geheugen kunnen gebruiken.
Docker ondersteunt geheugenlimieten voor containers die kunnen voorkomen dat één container alle bronnen van de host opeist. Op een gedeelde NAS draait het hierbij minder om het model sneller te maken en meer om de rest van het systeem te beschermen. Als het LLM zijn eigen limiet bereikt, is dat meestal beter dan het hele systeem onder geheugendruk te laten komen.
Houd ruimte vrij voor kernservices. Als de NAS 32 GB RAM heeft en normale apps tijdens drukke periodes 8 GB tot 12 GB gebruiken, wijs de rest dan niet toe aan het LLM. Houd ruimte over voor de bestandssysteemcache, back-uptaken, databases en korte piekbelastingen. Een model dat alleen werkt als er verder niets draait, is geen veilige standaardkeuze voor een gedeelde homeserver.
VRAM is ook belangrijk bij GPU-inferentie. In de veelgestelde vragen van Ollama staat dat inferentie via de CPU systeemgeheugen gebruikt, terwijl GPU-inferentie VRAM gebruikt, en dat het gelijktijdig laden van modellen afhangt van het beschikbare geheugen of VRAM. Een GPU kan dus veel helpen, maar de noodzaak van een geheugenplan verdwijnt niet.
CPU-limieten
CPU-limieten zorgen ervoor dat het systeem responsief blijft. Een lokaal LLM kan tijdens het verwerken van prompts of het genereren van tokens veel threads gebruiken. Als het de CPU volledig belast, kan het NAS-dashboard traag reageren, kunnen mediastreams bufferen, kunnen automatiseringen vertraging oplopen en kunnen databases traag reageren.
Docker biedt CPU-regelaars zoals --cpus, --cpu-quota en --cpuset-cpus. Je hebt niet altijd strenge limieten nodig, maar je moet wel bepalen hoeveel CPU het LLM tijdens normaal NAS-gebruik mag verbruiken. Een model dat iets langer over een antwoord doet maar de server responsief houdt, past meestal beter dan een model dat alle threads benut.
Inferentie die alleen de CPU gebruikt is bijzonder gevoelig voor limieten. Zonder GPU of NPU concurreert het LLM rechtstreeks met alle andere services die de CPU gebruiken. Als de NAS al media transcodeert, indexeert, comprimeert, back-ups maakt of databases uitvoert, moet het LLM tijdens piekuren niet onbeperkt draaien.
Modelaantal en parallelle verzoeken
Parallelisme wordt makkelijk over het hoofd gezien. Eén model dat één prompt beantwoordt, kan prima werken. Meerdere gebruikers, een WebUI, een automatiseringsworkflow en een RAG-tool kunnen al snel verzoeken opstapelen. Elk verzoek kan extra contextgeheugen en CPU-belasting veroorzaken.
In de veelgestelde vragen van Ollama worden gelijktijdige verzoeken en het gedrag van geladen modellen beschreven, waaronder instellingen zoals OLLAMA_MAX_LOADED_MODELS, OLLAMA_NUM_PARALLEL en OLLAMA_MAX_QUEUE. Deze instellingen zijn van belang op een NAS, omdat gelijktijdig gebruik een stabiele implementatie voor één gebruiker kan veranderen in een piekbelasting.
Begin voor een gedeelde thuisserver met conservatieve limieten. Eén geladen model en één actief verzoek vormen een veiliger uitgangspunt. Verhoog de limieten pas nadat je hebt gecontroleerd of de opslag, het geheugen, de CPU en andere services stabiel blijven.
Kies een model dat bij de server past, niet bij de hype
Het juiste eerste model is niet het grootste model dat je kunt downloaden. Het is het kleinste model dat de taak met aanvaardbare kwaliteit kan uitvoeren. Op een NAS maakt de modelkeuze deel uit van de systeembeveiliging.
Gekwantiseerde modellen zijn vaak een praktisch startpunt. llama.cpp legt uit hoe gekwantiseerde modellen de precisie van modelgewichten verlagen, bijvoorbeeld door GGUF-modelbestanden met een hogere precisie om te zetten naar kleinere formaten. Dat kan de modelgrootte verkleinen en inferentie in de praktijk verbeteren, maar kan ook ten koste gaan van de kwaliteit.
Die afweging is voor veel toepassingen op een thuis-NAS meestal aanvaardbaar: eenvoudige chat, samenvattingen, embeddings, hulp bij RAG, bestandsorganisatie en kleine automatiseringshulpmiddelen. Ze is minder aanvaardbaar als de taak diepgaand redeneren, een lange context, prestaties voor meerdere gebruikers of hoge nauwkeurigheid bij programmeren vereist.
Gebruik de serverstatus als uitgangspunt:
| Serverstatus | Veiliger startpunt | Vermijd in eerste instantie |
|---|---|---|
| 8GB–16GB RAM, alleen CPU | Klein gekwantiseerd model, embeddings, lichte chat | Grote modellen, lange context, meerdere gebruikers |
| 16GB–32GB RAM, iGPU / NPU | Kleine chat, RAG, zoekassistent | Afbeeldingen genereren, zware programmeerassistent |
| GPU met voldoende VRAM | Groter model of snellere inferentie | Onbeperkt modellen stapelen |
| Gedeelde NAS met veel apps | Geplande AI-taken, één model, één gebruiker | Altijd zware inferentie uitvoeren |
| NAS plus aparte GPU-machine | NAS slaat gegevens op; de AI-machine voert inferentie uit | Alle rekenkracht op de NAS afdwingen |
Een veilige implementatie begint klein, omdat je zo een stabiele basis creëert. Daarna kun je een groter model, een langere context of een WebUI-integratie testen. Als het systeem trager wordt, weet je door welke wijziging dat komt.
Houd de LLM uit de buurt van kritieke apps en back-ups
Een lokale LLM mag geen storingsdomeinen delen met de services waarvan je het meest afhankelijk bent. Als AI-modelopslag, back-ups, appdatabases en tijdelijke bestanden allemaal op dezelfde slecht geplande locatie staan, kan één workload problemen veroorzaken voor de rest.
Houd de modelcache en tijdelijke AI-gegevens uit de buurt van back-updoelen. Een modelmap kan meestal opnieuw worden aangemaakt; een back-upopslagplaats niet. Als een back-upbestemming volloopt met modelbestanden of tijdelijke AI-gegevens, kunnen back-ups worden overgeslagen, synchronisatietaken mislukken of herstelpunten onduidelijk worden.
Houd appdatabases indien mogelijk gescheiden. Home Assistant, mediaservers, fotobibliotheken, wachtwoordmanagers en andere zelfgehoste apps kunnen afhankelijk zijn van kleine databases die slecht tegen plotselinge I/O-druk of weinig schijfruimte kunnen. Laat een grote modeldownload of RAG-indexering niet zonder planning dezelfde opslagruimte in beslag nemen.
Houd ook rekening met de timing. Als back-ups 's nachts worden uitgevoerd, plan dan geen zware indexering in hetzelfde tijdsvenster. Als er 's avonds media wordt gestreamd, voer dan op dat moment geen inferentie met lange context uit die alleen CPU gebruikt. Een NAS heeft vaak genoeg capaciteit voor meerdere taken, maar niet voor alle taken op hun piekmoment.
Voeg voor LLM-workflows die bestanden kunnen schrijven of tools kunnen aanroepen beveiligingsmaatregelen toe. Gebruik afgeschermde paden, bevestigingsstappen en logboeken. Laat het model acties voorstellen, maar gebruik deterministische code of bevestiging van de gebruiker voor schrijven, verwijderen, verplaatsen en wijzigingen aan apps. Een veilige LLM-implementatie beschermt niet alleen systeemresources, maar ook de gegevens waartoe de LLM toegang heeft.
Waarschuwingssignalen dat de LLM andere services tekortdoet
Een slechte implementatie loopt niet altijd meteen vast. Vaker veroorzaakt die symptomen die op het eerste gezicht niets met elkaar te maken lijken te hebben.
Een waarschuwingssignaal is een plotselinge toename van schijfgebruik. Als de systeemschijf, de Docker-hoofdmap of de app-opslag snel groeit nadat je modellen hebt opgehaald, is het modelpad mogelijk niet gekoppeld aan de locatie die je verwachtte. Controleer het echte pad op de host, niet alleen het pad in de container.
Herstarts van containers zijn een ander signaal. Als de LLM-container, database, Home Assistant, mediaserver of webinterface steeds opnieuw wordt gestart, controleer dan de geheugendruk, OOM-logboeken en CPU-belasting. De LLM blijft mogelijk actief terwijl andere services onvoldoende resources krijgen.
Een traag NAS-dashboard is ook van belang. Als de webinterface traag wordt tijdens prompts, gebruikt de lokale LLM mogelijk te veel CPU-threads, te veel geheugen of te veel schijfactiviteit. Dat het model correct antwoordt, betekent niet dat de implementatie goed functioneert.
Bufferproblemen bij media, vertraagde automatiseringen, trage bestandsdeling en gemiste back-upvensters zijn duidelijkere signalen. Dit zijn kerntaken van een NAS. Als die na de implementatie van de LLM minder goed werken, heeft de LLM een kleiner model, strengere limieten, een betere planning of een aparte computehost nodig.
Houd ook het API-gedrag in de gaten. Als de LLM-API vastloopt, verzoeken eindeloos in de wachtrij blijven staan of de API onbetrouwbaar wordt wanneer een WebUI, RAG-tool of automatiseringssysteem verbinding maakt, kan de server te veel gelijktijdige taken verwerken. Beperk het aantal geladen modellen, actieve verzoeken en de wachtrijlengte voordat je meer integraties toevoegt.
Een veiligere implementatievolgorde voor een lokale LLM op een NAS
Begin niet met het installeren van alle AI-tools tegelijk. Begin met één lokale LLM-service, één model, één opslagpad en één testtoepassing. Zo is de implementatie makkelijker te begrijpen en veiliger op te lossen.
Een veiligere implementatievolgorde ziet er als volgt uit:
- Kies één toepassing, zoals eenvoudige chat, embeddings of RAG-tests.
- Kies het kleinste model dat de taak aankan.
- Maak een aparte map voor modellen op een bekend opslagpad.
- Koppel die map aan de container of stel de runner zo in dat die de map gebruikt.
- Stel limieten in voor geheugen en CPU.
- Beperk het aantal gelijktijdige verzoeken en geladen modellen.
- Begin met één testprompt of één kleine RAG-index.
- Houd tijdens het gebruik de schijf, het RAM-geheugen, de CPU, de GPU, de logs en de reactietijd in de gaten.
- Controleer of bestaande apps en back-ups nog normaal werken.
- Voeg pas daarna integraties toe, zoals Open WebUI, RAG-tools of automatiseringsworkflows.
Deze volgorde lijkt misschien trager dan een snelle installatiehandleiding, maar voorkomt verrassingen. Als er iets misgaat, weet je of het probleem door het model, het pad, de resourcelimieten, de WebUI, de RAG-index of een andere integratie komt.
Opslag en apps veilig houden: zo controleer je dat
Bij verificatie mag het niet blijven bij “het model heeft gereageerd”. Een lokale LLM kan een prompt beantwoorden en ondertussen toch de verkeerde schijf vullen, andere containers van middelen beroven of back-uptaken vertragen.
Begin met opslagverificatie. Controleer of de modelbestanden op het verwachte hostpad staan. Controleer of er nog vrije ruimte op de systeemschijf is. Controleer of de Docker-hoofdmap niet onverwacht is gegroeid. Zorg ervoor dat de modelcache, logs, indexen en appgegevens niet vermengd zijn met kritieke back-ups of databases.
Controleer vervolgens de resources. De CPU moet na prompts of indexeren weer normaal worden belast. Het geheugengebruik moet onder de geplande limiet blijven. Het swapgebruik mag bij normaal gebruik niet toenemen. Als GPU-inferentie is ingeschakeld, controleer dan of het model daadwerkelijk de GPU gebruikt en of de VRAM-belasting acceptabel is.
Controleer daarna de stabiliteit van apps. Open gedeelde bestanden, stream media, activeer een Home Assistant-automatisering, bekijk het NAS-dashboard en controleer of databases en appdashboards nog reageren. Als deze diensten alleen vertragen wanneer de LLM actief is, zijn strengere grenzen voor CPU, geheugen of planning nodig.
Controleer de logboeken. Let op herstartlussen, OOM-meldingen, mislukte modelladingen, toestemmingsfouten, ontbrekende GPU-toegang, mislukte volumekoppelingen en herhaalde API-time-outs. Vaak blijkt uit de logboeken dat een implementatie die ‘werkt’ nauwelijks stabiel is.
Controleer tot slot de grens van het eindpunt. Als de modelserver een API beschikbaar stelt, weet dan waar die bereikbaar is. Een lokaal LLM-eindpunt mag niet per ongeluk openbaar toegankelijk worden. Houd het intern, tenzij je het bewust achter authenticatie, regels voor een reverse proxy, VPN-toegang of een andere gecontroleerde grens hebt geplaatst.
Hoe ZimaOS AI Search een gecontroleerd AI-implementatiepatroon laat zien
Een gecontroleerde AI-workflow op een NAS moet een vastgelegd modelpad, resourcevereisten, verwachtingen voor de uitvoering en een verificatiepad hebben. De workflow hoort zich niet te gedragen als een onbeperkte achtergronddienst die modellen downloadt, GPU-tijd verbruikt en gegevens opslaat waar het maar wil.
ZimaOS-AI is een nuttig voorbeeld van dit gecontroleerde patroon. De ZimaSpace-handleiding voor AI Search legt uit dat de module is ontworpen om ZimaOS Search te ondersteunen door een lokale LLM te gebruiken om kenmerken uit afbeeldingen, audio en video te halen. Die insteek is belangrijk: de AI-werklast ondersteunt het zoeken en het extraheren van kenmerken, in plaats van de NAS om te vormen tot een onbeperkte chatserver.
Dezelfde handleiding maakt de grens voor hulpbronnen duidelijk. Er worden afzonderlijke installatiepaden beschreven voor systemen met een discrete NVIDIA-GPU en systemen met een geïntegreerde Intel-GPU. Het NVIDIA-pad is afhankelijk van CUDA-compatibele GPU-ondersteuning, terwijl het pad voor Intel-systemen met geïntegreerde GPU minimaal 8 GB vrij RAM-geheugen vereist en een CPU van i5-1235U of hoger met geïntegreerde grafische kaart aanbeveelt. Er is ook minimaal 20 GB vrije systeemruimte nodig; modelbestanden worden opgeslagen in /media/ZimaOS-HD/AppData/.models, tenzij AppData is verplaatst.
Dat is de informatie die nodig is voordat een veilige LLM-implementatie van start gaat. Een privécloudapparaat zoals ZimaCube 2 AI NAS kan uitgebreidere lokale AI-workflows ondersteunen wanneer het modelpad, de GPU- of iGPU-ondersteuning, het RAM-geheugen, de opslagruimte en de planning aansluiten op de werklast. Maar de belangrijkste les gaat over de grenzen, niet over de merknaam: weet waar het model draait, welk hardwarepad het gebruikt en wanneer het bronnen mag verbruiken.
De details voor probleemoplossing laten ook zien hoe je de implementatie controleert. Als AI-zoeken geen AI-gerelateerde resultaten oplevert, kan het model nog worden gedownload, kan de functie-extractie nog bezig zijn, is Hugging Face mogelijk niet bereikbaar of kan het VRAM te beperkt zijn, waardoor wordt teruggeschakeld naar CPU-/geheugengebruik. De handleiding verwijst gebruikers ook naar Call-History, netwerkverkeer en journalctl -xef -u zimaos-ai om de status te controleren.
Dat is een handige aanpak voor elke lokale LLM-implementatie op een NAS: bepaal het pad en de resources, houd de logs in de gaten, controleer of de functie echt werkt en plan intensieve activiteiten zo dat de NAS bruikbaar blijft.
Veelgestelde vragen
Waar moet ik lokale LLM-modelbestanden op een NAS opslaan?
Bewaar modelbestanden in een aparte, gedocumenteerde modelmap op een gegevensvolume of opslaglocatie voor apps met voldoende ruimte. Voorkom dat modellen ongemerkt op de opstartschijf, in de Docker-hoofdmap of op een back-updoel terechtkomen. Het pad moet gemakkelijk te controleren, op te schonen en te migreren zijn.
Moet ik Ollama rechtstreeks uitvoeren of in Docker?
Beide kunnen werken. Docker maakt isolatie en implementatie eenvoudiger, maar je moet de modelopslag correct koppelen en resourcelimieten instellen. Een rechtstreekse installatie kan op sommige systemen eenvoudiger zijn, maar je moet nog steeds de modelmap, machtigingen, het geheugengebruik en de servicegrenzen controleren.
Hoeveel RAM moet ik reserveren voor andere apps?
Reserveer voldoende RAM voor het NAS-besturingssysteem, de bestandssysteemcache, databases, mediaservices, back-ups en gewone containers voordat je geheugen aan de LLM toewijst. Stem de modelgrootte niet af op het totale RAM-geheugen. Houd bij de keuze rekening met het beschikbare RAM nadat kerndiensten voldoende ruimte hebben gekregen.
Kan een lokale LLM mijn andere Docker-containers verstoren?
Het kan andere containers verstoren als het te veel geheugen, CPU-capaciteit, schijf-I/O of opslagruimte verbruikt. Het zal ze misschien niet direct „kapotmaken”, maar zonder limieten kan het vertragingen, herstartlussen, OOM-gebeurtenissen, gemiste back-upvensters of mislukte databasebewerkingen veroorzaken.
Wanneer moet ik de LLM naar een aparte machine verplaatsen?
Verplaats de LLM naar een aparte machine wanneer je grotere modellen, een lange context, meerdere gebruikers, GPU-intensieve workloads of snelle reacties nodig hebt die de NAS traag maken. In die opstelling kan de NAS de opslag en gegevensbron blijven, terwijl een desktop, mini-pc of AI-server met een GPU de inferentie afhandelt.
Een veilige lokale LLM-implementatie op een NAS begint met grenzen, niet met opgeklopte verwachtingen over modellen. Geef het model een bekend pad, stel resourcelimieten in voor de container, bescherm kritieke apps en back-ups en controleer de hele server na de eerste prompt. De implementatie is pas geslaagd als de LLM werkt en de NAS zich nog steeds gedraagt als een betrouwbare NAS.
Ondersteuning en tips
Meer om te lezen

Wat je moet controleren voordat je een communitymodel in Transformers laadt
Gebruik de Transformers Jinja-sandboxupdate om de herkomst van modellen, chatsjablonen, externe code, geserialiseerde gewichten en geïsoleerde eerste uitvoeringen te controleren.

Voer Mirage lokaal uit: OCR en objectdetectie vanuit één afbeelding
Probeer het kleine lokale visiemodel van Cactus Compute, test OCR en objectextractie met echte invoer en krijg inzicht in de beperkingen op het gebied...

Een codeeragent plannen in Open WebUI op een homeserver
Stel een rapportage-only automatisering van een codeeragent in Open WebUI in, selecteer de terminal en werkruimte en controleer de machtigingen, logboeken en herstel na...



