Geheugen voor lokale AI met Ollama en Qdrant

Ollama ontmoet Qdrant: Een lokaal geheugen voor je AI op de Mac

door

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

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)

Qdrant op Docker onder Apple macOS

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.

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.

Plaats een reactie