Lokale AI met geheugen - zonder cloud, zonder abonnement, zonder omleidingen
In een vorige artikelen Ik heb uitgelegd hoe je Ollama configureert op de Mac install. Als je deze stap al hebt voltooid, heb je nu een krachtig lokaal taalmodel - zoals Mistral, LLaMA3 of een ander compatibel model dat via REST API kan worden aangesproken.
Het model "weet" echter alleen wat er in de huidige prompt staat. Het herinnert zich geen eerdere gesprekken. Wat ontbreekt is een herinnering.
Dit is precies waarom we Qdrant gebruiken, een moderne semantische vectordatabase.
In dit artikel laat ik het je stap voor stap zien:
- hoe installier Qdrant op de Mac (via Docker)
- Hoe embeddings maken met Python
- hoe inhoud op te slaan, te doorzoeken en te integreren in de Ollama workflow
- en hoe een volledige prompt→geheugen→antwoordreeks eruit ziet
Waarom Qdrant?
Qdrant slaat geen traditionele teksten op, maar vectoren die de betekenis van een tekst weergeven als een numerieke code. Dit betekent dat inhoud niet alleen exact kan worden gevonden, maar ook semantisch vergelijkbaar is - zelfs als de woorden verschillen.
Ollama + Qdrant resulteert dus:
Een lokaal taalmodel met langetermijngeheugen - veilig, controleerbaar en uitbreidbaar.
Vereisten
- Ollama is installiert en loopt (→ bijv. ollama run mistral)
- Docker is installiert: https://www.docker.com/products/docker-desktop
- Python 3.9+
Pakketinstallation van Qdrant:
pip install qdrant-client sentence-transformers
Qdrant starten (Docker)
docker run -p 6333:6333 -p 6334:6334 qdrant/qdrant
Qdrant wordt dan uitgevoerd:
http://localhost:6333 (REST API)
http://localhost:6334 (gRPC, niet vereist voor dit artikel)
Python-voorbeeld voor Ollama + Qdrant
We schrijven nu een eenvoudig basisscript dat:
- accepteert de gebruikersprompt
- genereert een inbeddingsvector uit deze
- zoekt naar semantisch vergelijkbare herinneringen in Qdrant
- het antwoord wordt gegenereerd met context via Ollama
- slaat het nieuwe gesprek op als herinnering
Python-Script: ollama_memory.py
import requests
from sentence_transformers import SentenceTransformer
from qdrant_client import QdrantClient
from qdrant_client.models import Distance, VectorParams, PointStruct
# Einstellungen
OLLAMA_URL = "http://localhost:11434/api/generate"
COLLECTION_NAME = "memory"
VECTOR_SIZE = 384 # für 'all-MiniLM-L6-v2'
# Lade Embedding-Modell
embedder = SentenceTransformer("all-MiniLM-L6-v2")
# Verbinde mit Qdrant
qdrant = QdrantClient(host="localhost", port=6333)
# Erstelle Collection (einmalig)
def create_collection():
if COLLECTION_NAME not in qdrant.get_collections().collections:
qdrant.recreate_collection(
collection_name=COLLECTION_NAME,
vectors_config=VectorParams(size=VECTOR_SIZE, distance=Distance.COSINE)
)
# Füge Eintrag ins Gedächtnis hinzu
def add_to_memory(text: str):
vector = embedder.encode(text).tolist()
point = PointStruct(id=hash(text), vector=vector, payload={"text": text})
qdrant.upsert(collection_name=COLLECTION_NAME, points=[point])
# Suche im Gedächtnis
def search_memory(query: str, top_k=3):
vector = embedder.encode(query).tolist()
hits = qdrant.search(
collection_name=COLLECTION_NAME,
query_vector=vector,
limit=top_k
)
return [hit.payload["text"] for hit in hits]
# Sende Anfrage an Ollama
def query_ollama(context: list[str], user_prompt: str):
prompt = "\n\n".join(context + [user_prompt])
response = requests.post(OLLAMA_URL, json={
"model": "mistral",
"prompt": prompt,
"stream": False
})
return response.json()["response"]
# Ablauf
def main():
create_collection()
print("Frage an die KI:")
user_prompt = input("> ")
context = search_memory(user_prompt)
answer = query_ollama(context, user_prompt)
print("\nAntwort von Ollama:")
print(answer.strip())
# Speichern der Konversation
full_entry = f"Frage: {user_prompt}\nAntwort: {answer.strip()}"
add_to_memory(full_entry)
if __name__ == "__main__":
main()
Opmerkingen over de praktijk
Je kunt ook je eigen inbeddingsmodellen gebruiken, bijv. via Ollama (bijv. nomic-embed-text) of Hugging Face-modellen.
Qdrant ondersteunt payload filters, tijdsperioden en velden (erg handig voor latere uitbreiding!)
De hash(text)-ID is voldoende voor eenvoudige tests, voor professionele toepassingen kun je beter UUID's gebruiken.
Lokale AI met geheugen - en wat je ermee kunt doen
In de vorige hoofdstukken heb ik laten zien hoe je een echt, lokaal AI-geheugen kunt bouwen op een Mac met Ollama en Qdrant. Een opstelling die werkt zonder de cloud, zonder abonnement en zonder externe servers - snel, veilig, privé.
Maar wat nu?
Waar kan deze technologie eigenlijk voor gebruikt worden? Wat is ermee mogelijk - vandaag, morgen, overmorgen?
Het antwoord: heel veel.
Want wat je hier hebt is meer dan alleen een chatbot. Het is een platformonafhankelijke denkmachine met een langetermijngeheugen. En dat opent deuren.
🔍 1. persoonlijke kennisbank
Je kunt Ollama + Qdrant gebruiken als je persoonlijke langetermijngeheugen.
Documenten, notities uit gesprekken, ideeën - alles wat je hem vertelt kan semantisch worden opgeslagen en teruggevonden.
Voorbeeld:
"Wat was mijn bedrijfsidee van afgelopen donderdag?"
"Welke klanten wilden een upgrade in maart?"
In plaats van mappen te doorzoeken, stel je gewoon vragen aan je systeem. Wat vooral spannend is, is dat het ook werkt met onnauwkeurige vragen omdat Qdrant semantisch zoekt, niet alleen op trefwoorden.
📄 2. automatisch loggen en samenvatten
In combinatie met audio- of tekstinvoer kan het systeem een lopend logboek bijhouden:
- Notities in vergaderingen
- Gesprekken met klanten
- Dagelijkse logboeken of projectgeschiedenissen
Deze gegevens worden automatisch in het geheugen van Qdrant opgeslagen en kunnen dus later als een assistent worden opgevraagd:
"Wat zei meneer Meier ook alweer over de levering?"
"Hoe was het proces bij project XY?"
🧠 3. persoonlijke coach of agenda-assistent
Door regelmatig gedachten, stemmingen of beslissingen op te schrijven, creëer je een reflectieve metgezel:
"Wat was mijn grootste vooruitgang deze maand?"
"Hoe reageerde ik toen op tegenslagen?"
Het systeem leert je na verloop van tijd kennen - en wordt een echte spiegel, niet alleen een chatbot.
4. zakelijke toepassingen met FileMaker
Als je - zoals ik - FileMaker gebruikt, kun je deze opstelling rechtstreeks aansluiten:
- Vragen verzenden vanaf FileMaker
- Antwoorden automatisch ophalen en opslaan
- Beheer geheugentoegang direct via REST API of shellscript
Dit zorgt voor een extreem krachtige combinatie:
- FileMaker = Frontend, gebruikersinterface, bedieningscentrum
- Ollama = Taalintelligentie
- Qdrant = semantisch langetermijngeheugen
Het resultaat: een echte AI-component voor FileMaker-oplossingen - lokaal, veilig en op maat gemaakt.
🛠️ 5. Ondersteuning in het dagelijks leven: herinneringen, ideeën, aanbevelingen
"Herinner me volgende week aan dit idee".
"Welke boeken heb ik je al aangeraden?"
"Wat kan ik de heer Müller nu aanbieden?"
Met doelgerichte geheugenlogica (tijdstempels, categorieën, gebruikers) kun je je geheugen doelgericht structureren en gebruiken voor vele gebieden van het leven en het bedrijfsleven.
🤖 6. basis voor een agenssysteem
Als je vooruit denkt, kun je ook agentachtige systemen bouwen met deze opstelling:
- AI neemt eenvoudige taken over
- AI herkent patronen in de loop van de tijd
- AI geeft proactieve hints
Voorbeeld:
"Je hebt deze week al vier keer dezelfde vraag gesteld - wil je een notitie opslaan?"
"Opvallend veel klanten hebben dit product genoemd - zal ik dat voor u samenvatten?"
🌐 7. integratie met andere tools
Het systeem kan gemakkelijk worden gekoppeld aan andere tools:
- Neo4jom semantische relaties grafisch weer te geven
- Bestanden & PDF'sinhoud automatisch indexeren
- Mail parsere-mails analyseren en onthouden
- Spraakassistenteninteractie via spraak
8. Alles blijft lokaal - en onder controle
Het grootste voordeel: jij beslist wat er wordt opgeslagen. Jij beslist hoe lang het opgeslagen blijft. En: het verlaat nooit je computer als je dat niet wilt. In een wereld waar veel mensen blindelings vertrouwen op cloud AI, is dit een krachtig tegenwicht - vooral voor freelancers, ontwikkelaars, auteurs en ondernemers.
Huidig onderzoek naar het gebruik van lokale AI-systemen
Tem Ollama + Qdrant: Hoe je je lokale AI structuur, regels en afstemming geeft
Als je de moeite hebt genomen om Ollama en Qdrant lokaal op je Mac te installeren, heb je al veel bereikt. Je hebt nu:
- Een AI in de lokale taal
- Een semantisch geheugen
- En een werkende pijplijn die prompt → geheugen → Ollama → reactie in kaart brengt
Maar iedereen die ermee werkt, realiseert zich snel: het heeft regels nodig. Structuur. Orde.
Want zonder controle zal je assistent snel veranderen in een babbelkous die te veel onthoudt, zichzelf constant herhaalt of irrelevante herinneringen ophaalt.
Wat ontbreekt er nog?
Een orkest heeft ook een dirigent. En dat is nu precies jouw taak: controleren in plaats van alleen gebruiken.
Module 1: Een "router" voor geheugenlogica
In plaats van botweg alles op te slaan of botweg alles te zoeken, zou je van tevoren moeten beslissen of er überhaupt iets moet worden opgeslagen of geladen. Je kunt dit bijvoorbeeld doen met een eenvoudige relevantie router die je tussen de prompt en het geheugen plaatst:
VoorbeeldControleer relevantie via prompt naar Ollama zelf
def is_relevant_for_memory(prompt, response):
prüf_prompt = f"""
Nutzer hat gefragt: "{prompt}"
Die KI hat geantwortet: "{response}"
Sollte man sich diesen Dialog langfristig merken? Antworte nur mit 'Ja' oder 'Nein'.
"""
result = query_ollama([], prüf_prompt).strip().lower()
return result.startswith("ja")
Dus je geeft Ollama de taak om zijn antwoord te evalueren - en alleen als het als relevant wordt geclassificeerd, sla je het op in Qdrant.
Module 2: Oudere berichten uitsluiten (contextbeperking)
Vooral bij langere sessies wordt het problematisch als oude berichten in de context blijven terugkomen. Het model vergeet niet - het loopt vast.
OplossingBeperk het contextvenster.
Je kunt dit op twee manieren doen:
Methode 1: Het aantal treffers beperken
context = search_memory(user_prompt, top_k=3)
Alleen wat semantisch relevant is, wordt hier geladen - niet alles.
Methode 2Beperk de tijd
# Nur Nachrichten der letzten 7 Tage now = datetime.utcnow() filter = Filter( must=[ FieldCondition(key="timestamp", range=Range(gte=now - timedelta(days=7))) ] )
Je kunt de tijd dus "afsnijden" als het systeem te ver in het verleden reikt.
Module 3: Contextgewichten en labels introduceren
Niet elk item in je geheugen heeft dezelfde waarde. Je kunt ze gewicht of categorieën geven:
- Vast (bijv. "Gebruiker heet Markus")
- Tijdelijk (bijv. "Vandaag is het dinsdag")
- Situatie (bijv. "Chat vanaf vandaag 10:30 uur")
Qdrant ondersteunt zogenaamde payloads - d.w.z. extra informatie per item. Hierdoor kun je later filteren of prioriteiten stellen.
Module 4: Fijnafstelling via de prompt
De prompt zelf is een krachtige besturingseenheid.
Hier zijn een paar trucjes die je kunt gebruiken om Ollama slimmer te maken:
Voorbeeld prompt met instructies:
Je bent een lokale assistent met een semantisch geheugen. Als je meerdere herinneringen vindt, gebruik dan alleen de drie meest relevante. Verwijs niet naar informatie ouder dan 10 dagen tenzij het expliciet gemarkeerd is. Negeer triviale herinneringen zoals "Goedemorgen" of "Dank je wel". Antwoord precies en in de stijl van een ervaren counsellor.
Hierdoor kun je de fijnafstelling direct in de prompt zelf uitvoeren - zonder nieuwe modellen, zonder training.
En: je kunt de prompt dynamisch genereren, afhankelijk van de situatie.
Module 5: Opslaghygiëne
Naarmate het geheugen groeit, wordt het verwarrend.
Een eenvoudig onderhoudsscript dat irrelevante of dubbele inhoud verwijdert, is goud waard.
Voorbeeld:
"Vergeet alles wat met 'weer' te maken heeft."
"Verwijder vermeldingen die ouder zijn dan 3 maanden en nooit zijn opgehaald."
Qdrant ondersteunt dit via API - en je kan het bijvoorbeeld één keer per week automatiseren.
Module 6: FileMaker als bedieningspaneel
Als je - net als ik - met FileMaker werkt, kun je dit allemaal op afstand regelen via REST-API:
- Snel verzenden
- Context ophalen
- Antwoord ontvangen
- Laat een taxatie uitvoeren
- Opslaan of vergeten
Alles wat je nodig hebt is een kleine REST-module in FileMaker (Invoegen vanaf URL met JSON) en een paar scripts.
Het resultaat: een interface waarmee je je AI kunt besturen als een levend notitieboek - maar dan met intelligentie.
Conclusie: AI is zo goed als het leiderschap
Ollama is krachtig. Qdrant is flexibel. Maar zonder duidelijke regels worden beide een ongestructureerde berg gegevens. De truc is niet om alles op te slaan, maar om alleen datgene beschikbaar te houden wat relevant is en om doelgericht te denken in plaats van alleen maar te onthouden.
Nieuwe artikelreeks: ChatGPT-verhalen als kennisbank voor je AI
Als je je eigen AI-geheugen al hebt opgebouwd met Ollama en Qdrant, is het de moeite waard om eens te kijken naar een nieuwe serie artikelen die hier begint. Het gaat over hoe de ChatGPT-gegevensexport integreren in dit systeem laat. Veel gebruikers realiseren zich niet eens dat ze hun hele chatgeschiedenis kunnen exporteren - en dat deze gegevens een waardevolle bron van kennis zijn. In deze serie laat ik je zien hoe je deze gesprekken kunt analyseren, omzetten in embeddings en vervolgens importeren in een vector database. Hierdoor kan je lokale AI later toegang krijgen tot eerdere gesprekken en deze gebruiken als context voor reacties. Op deze manier groeit een persoonlijk kennisarchief stap voor stap vanuit individuele dialogen.
Veelgestelde vragen
- Waarom heeft een lokale AI überhaupt een „geheugen“ nodig? Is het taalmodel niet genoeg?
Een taalmodel werkt alleen met de huidige prompt en de context die je het op dat moment geeft. Het onthoudt dus niet permanent eerdere gesprekken, documenten of informatie. Dit is precies waar een lokaal geheugen om de hoek komt kijken. Met een extra database kan de AI eerdere inhoud opslaan en ophalen wanneer dat nodig is. Het model krijgt dan niet alleen je huidige vraag als antwoord, maar ook relevante informatie uit dit geheugen. Dit resulteert in veel consistentere en beter geïnformeerde antwoorden. Zonder een dergelijk systeem blijft een taalmodel in feite een pure tekstgenerator zonder enige langetermijnkennis van je eigen gegevens of projecten. - Wat is Qdrant precies en waarom wordt het in dit systeem gebruikt?
Qdrant is een moderne vectordatabase die speciaal is ontwikkeld voor semantisch zoeken. In tegenstelling tot traditionele databases slaat het informatie niet alleen op als tekst, maar als zogenaamde vectoren - wiskundige representaties van betekenis. Hierdoor kan het inhoud niet alleen doorzoeken op identieke woorden, maar ook op nabijheid van inhoud. Dus als je een vraag stelt, kan Qdrant geschikte tekstpassages uit je kennisbank vinden, zelfs als ze niet exact dezelfde termen bevatten. In combinatie met een taalmodel creëert dit een soort intelligent geheugen voor de AI. - Wat betekent de term „RAG“, die vaak in deze context wordt gebruikt?
RAG staat voor „Retrieval Augmented Generation“. Dit is een techniek waarbij een taalmodel aanvullende informatie ophaalt uit een database voordat het een antwoord geeft. Het model genereert zijn antwoord dus niet alleen uit de training, maar vult het ook aan met geschikte informatie uit een kennisbron. Deze methode lost een typisch probleem van taalmodellen op: Ze weten alleen wat ze tijdens de training hebben geleerd. In plaats daarvan geeft RAG ze toegang tot actuele of persoonlijke gegevens - zoals documentatie, websites of hun eigen aantekeningen. - Hoe werken Ollama en Qdrant eigenlijk samen?
In deze opstelling neemt Ollama de rol van taalmodel op zich, terwijl Qdrant fungeert als semantisch geheugen. Wanneer je een vraag stelt, zoekt Qdrant eerst naar relevante tekstfragmenten. Deze resultaten worden dan samen met je vraag doorgegeven aan het taalmodel. Het model gebruikt deze extra informatie om een gefundeerd antwoord te formuleren. De typische volgorde is dus: Vraag → Zoeken in geheugen → Context uitbreiden → Antwoord genereren. - Welke soorten gegevens kan ik opnemen in dit AI-geheugen?
Eigenlijk bijna alles dat in tekst kan worden omgezet. Dit omvat documentatie, websites, Markdown-bestanden, PDF's, database-items of zelfs persoonlijke notities. Het enige belangrijke is dat de inhoud kan worden opgesplitst in kleinere tekstdelen voordat het wordt opgeslagen in de database. Deze zogenaamde „chunks“ vormen later de basis voor de semantische zoekopdracht. Hierdoor kan de AI specifiek toegang krijgen tot individuele relevante secties in plaats van hele documenten te moeten doorzoeken. - Waarom wordt een vectordatabase gebruikt in plaats van een normale tekstzoekopdracht?
Klassieke zoekmachines werken meestal met trefwoorden. Dit betekent dat ze alleen resultaten vinden die precies dezelfde termen bevatten. Een vectordatabase zoekt daarentegen naar betekenis. Het kan dus ook teksten vinden die inhoudelijk op elkaar lijken, zelfs als er andere woorden zijn gebruikt. Dit is cruciaal voor AI-systemen omdat vragen vaak anders geformuleerd zijn dan in de originele documenten. Semantische zoekopdrachten maken de link tussen vraag en antwoord veel betrouwbaarder. - Hoe worden teksten eigenlijk omgezet in vectoren?
Hiervoor worden zogenaamde inbeddingsmodellen gebruikt. Deze modellen analyseren teksten en zetten ze om in getalvectoren die hun betekenis weergeven. Elk tekstgedeelte krijgt dus een wiskundige voorstelling in wat bekend staat als vectorruimte. Gelijksoortige inhoud staat dichter bij elkaar dan totaal verschillende onderwerpen. Als er later een vraag wordt gesteld, wordt deze ook omgezet in een vector. Qdrant kan dan heel snel de meest gelijkaardige items in het geheugen vinden. - Waarom wordt Qdrant vaak gebruikt via Docker installiert?
Docker vereenvoudigt de installatie van complexe software aanzienlijk. In plaats van veel afzonderlijke afhankelijkheden handmatig in te stellen, draait Qdrant gewoon in een container. Dit betekent dat de installatie betrouwbaar werkt op verschillende systemen en eenvoudig gestart of gestopt kan worden. Deze methode is vooral praktisch op de Mac omdat het het systeem schoon houdt en tegelijkertijd een stabiele omgeving biedt voor de database. - Kan ik dit systeem volledig offline gebruiken?
Ja, dat is een van de grootste voordelen van deze architectuur. Zowel het taalmodel als de vectordatabase draaien lokaal op je eigen computer. Dit betekent dat er geen gegevens naar externe servers worden gestuurd. Dit creëert een volledig private AI-omgeving. Dit is een doorslaggevend voordeel ten opzichte van cloudsystemen, vooral voor gevoelige gegevens of interne bedrijfsdocumenten. - Hoe groot kan zo'n lokaal AI-geheugen worden?
Dit hangt vooral af van je opslagruimte en de prestaties van het systeem. Moderne vectordatabases kunnen gemakkelijk miljoenen tekstfragmenten beheren. Voor veel persoonlijke projecten zijn echter maar een paar duizend documenten genoeg om een zeer krachtig kennissysteem te maken. De kwaliteit van de gegevensstructuur is belangrijker dan de hoeveelheid informatie. - Kan AI echt „leren“ met dit systeem?
Niet in de klassieke zin. Het taalmodel zelf wordt niet opnieuw getraind. In plaats daarvan wordt de kennis buiten het model opgeslagen en opgehaald wanneer dat nodig is. Hoewel de AI hierdoor in staat lijkt om te leren, heeft hij in feite alleen toegang tot een steeds groeiende opslag van kennis. Deze benadering heeft één groot voordeel: er kan op elk moment nieuwe informatie worden toegevoegd zonder dat het model opnieuw hoeft te worden getraind. - Welke praktische toepassingen vloeien voort uit zo'n lokaal AI-geheugen?
De mogelijkheden zijn verbazingwekkend divers. Je kunt bijvoorbeeld een persoonlijke kennisdatabase opzetten, technische documentatie doorzoekbaar maken of interne bedrijfsdocumenten laten analyseren. Auteurs, ontwikkelaars of onderzoekers profiteren hier ook van omdat ze grote hoeveelheden informatie op een gestructureerde manier toegankelijk kunnen maken. Eigenlijk ontstaat er een soort persoonlijke onderzoeksassistent die je eigen gegevens begrijpt. - Kan ik meerdere gegevensbronnen tegelijk integreren?
Ja, met Qdrant kan elk tekstfragment extra metadata krijgen, zoals bron, categorie of taal. Hierdoor kunnen verschillende databases samen beheerd worden. Deze metadata kunnen zelfs specifiek gefilterd worden tijdens het zoeken. De AI kan bijvoorbeeld alleen rekening houden met inhoud van een specifieke documentatie of een specifiek project. - Waarin verschilt dit systeem van klassieke chatbots?
De meeste chatbots werken uitsluitend met de kennis van hun trainingsdataset. Ze kunnen dus geen specifieke informatie verschaffen over je eigen inhoud. Een RAG-systeem daarentegen combineert een taalmodel met een eigen kennisbank. Hierdoor kan de AI antwoorden geven die direct zijn afgestemd op je eigen gegevens. Dit maakt het veel nuttiger voor productief werk. - Welke rol speelt Python in deze opstelling?
Python wordt vaak gebruikt om de verbinding tussen het taalmodel en de database te regelen. Met een paar scripts kunnen teksten worden ingelezen, omgezet in vectoren en opgeslagen in Qdrant. Python kan ook de zoekopdracht uitvoeren en de gevonden resultaten doorsturen naar het taalmodel. Zo ontstaat een flexibele pijplijn die naar eigen wens kan worden aangepast. - Is het opzetten van zo'n systeem alleen voor ontwikkelaars?
Niet noodzakelijk. Hoewel het opzetten van het systeem een zekere mate van technisch inzicht vereist, zijn veel van de benodigde tools nu veel eenvoudiger geworden. Met een beetje geduld kan zelfs zonder diepgaande programmeerkennis een werkend systeem worden opgezet. Iedereen die er wel eens mee te maken heeft gehad, zal snel het enorme potentieel van zulke lokale AI-infrastructuren herkennen. - Wat zijn de grenzen van een lokaal AI-geheugen?
De belangrijkste beperking is de rekenkracht van je eigen computer. Grote modellen of enorme kennisdatabases kunnen meer geheugen en CPU-kracht vereisen. De kwaliteit van de antwoorden hangt ook sterk af van de structuur van de gegevens. Als documenten slecht zijn voorbereid, kan de AI slechts in beperkte mate goede resultaten leveren. - Waarom wordt deze combinatie van Ollama en Qdrant beschouwd als een bijzonder interessante architectuur voor lokale AI?
Omdat het twee cruciale componenten samenbrengt: een krachtig taalmodel en een snelle semantische database. Samen creëren ze een complete AI-werkomgeving die volledig lokaal kan worden bediend. Hierdoor kunnen persoonlijke kennissystemen, intelligente zoekmachines of gespecialiseerde assistenten worden opgezet - zonder afhankelijkheid van de cloud en met volledige controle over je eigen gegevens.
