In een steeds onoverzichtelijker wordende wereld van informatie wordt het steeds belangrijker om je eigen databases gericht doorzoekbaar te maken - niet via klassieke full-text zoekopdrachten, maar via semantisch relevante antwoorden. Dit is precies waar het principe van de RAG database om de hoek komt kijken - een AI-ondersteunde zoekoplossing die bestaat uit twee centrale componenten:
- een vectordatabase (zoals Qdrant) waarin alle inhoud is opgeslagen als numerieke vectoren,
- en een taalmodel (bijv. via Ollama) dat de respectieve verzoeken op intelligente wijze combineert met de juiste inhoud.
In plaats van het model te laten "raden", gebruikt deze architectuur zijn eigen kennisbronnen - bijvoorbeeld:
- zelfgeschreven documentaires,
- Inhoud van websites,
- technische handleidingen,
- Ondersteunende databases,
- FAQ lijsten,
- of gearchiveerde tekstbronnen (bijvoorbeeld uit oude databases).
De beslissende factor: Al deze bronnen kunnen van tevoren worden voorbereid en "gechunked" (d.w.z. opgedeeld in kleine teksteenheden) om later de meest relevante tekstfragmenten voor een gebruikersvraag te kunnen leveren.
Dus of je nu je eigen kennisdatabase, interne documentatie of een heel productarchief analyseerbaar wilt maken - met Ollama + Qdrant kun je dit op je eigen Mac doen, zonder cloudbeperkingen en met volledige controle over de gegevens.
Wat is een RAG-database en waarom "chunking"?
RAG staat voor Retrieval-Augmented Generation - met andere woorden: tekst-genererende AI met ondersteuning voor het ophalen van informatie. In plaats van een taalmodel zoals GPT, Mistral of LLaMA alleen te trainen op wat het al "weet", kan het zelf toegang krijgen tot aanvullende informatie via een gekoppelde kennisdatabase (meestal een zogenaamde vectordatabase).
Voorbeeld:
Als je een taalmodel vraagt: "Wat staat er in mijn belastingaangifte van 2023?", zal het moeten gokken zonder toegang tot de oorspronkelijke gegevens. Als het echter toegang heeft tot een lokaal opgeslagen, vectorgebaseerde representatie van dit document, kan het de relevante informatie ophalen en opnemen in zijn antwoord.
Waarom inhoud wordt "gechunked
Documenten, websites of boeken zijn meestal veel te lang om in één keer te verwerken of te doorzoeken. Moderne taalmodellen hebben ook tokenlimieten - d.w.z. een beperkte lengte van tekst die ze in één keer kunnen begrijpen (vaak rond de 4.000-8.000 tokens, met nieuwere modellen zelfs 32.000 of meer).
Daarom gebruikt RAG de volgende truc:
- De oorspronkelijke tekst is verdeeld in kleine delen (chunks).
- Elke chunk wordt door een taalmodel omgezet in een vector (inbedding).
- Deze vectoren worden opgeslagen in een database zoals Qdrant.
- Wanneer de gebruiker een verzoek doet, wordt de prompt ook vertaald naar een vector - en worden de meest gelijkende chunks opgehaald.
- Deze inhoud wordt dan toegevoegd aan het taalmodel, bijvoorbeeld via een systeemprompt of contextinjectie.
Dit creëert een systeem dat zich gedraagt als een geheugen - maar zonder klassieke trefwoorden of full-text zoeken, maar puur op betekenis (semantiek) gebaseerd.
Vereisten en doel
We bouwen aan een lokaal RAG-systeem dat bestaat uit:
- een lokale LLM via Ollama
- een vectorgegevensbank met de naam Qdrant
- een Python-script dat teksten in stukken hakt, vectoriseert en in de database invoegt
- Optioneel: een eenvoudige interface of API voor query's
Doelplatform: macOS (Intel of Apple Silicon)
Dit is een vereiste:
- macOS 12 of nieuwer (Monterey of hoger)
- Basiskennis van terminals
- Python 3.10 of nieuwer
- Optioneel: Homebrew installiert
Stap 1: Ollama 1TP12Dier
Ollama is een slank hulpmiddel voor het uitvoeren van lokale taalmodellen zoals Mistral, LLaMA, Gemma of Codellama op uw eigen computer - zelfs zonder internet.
Installatie op de Mac:
curl -fsSL https://ollama.com/install.sh | sh
Als alternatief kan Ollama ook toegewezen worden via Homebrew install:
brew install ollama
Na de installatie:
ollama run mistral
Dit downloadt het Mistral 7B model en start het lokaal. Ollama wordt geleverd met een REST API, die we later zullen gebruiken voor vectorisatie. Je kunt natuurlijk ook andere modellen gebruiken, zoals Gemma3 (12B), Mistral Small (24B) of andere LLM's.
Stap 2: Qdrant 1TP12 dieren (lokale vectordatabase)
Qdrant is een bliksemsnelle vectordatabase gebaseerd op Rust. Het is gratis, open source en eenvoudig te starten op de Mac - bij voorkeur via Docker. Als je Docker nog niet hebt geïnstalleerd op je Mac 1TP12, kun je het downloaden van de Docker-website gratis en draai het op je Mac als een normaal desktopprogramma installieren. Je kunt Docker ook installeren via Homebrew install als je Homebrew al gebruikt:
brew install --cask docker
Start dan Qdrant via Docker:
docker run -p 6333:6333 -v qdrant_storage:/qdrant/storage qdrant/qdrant
Qdrant kan dan worden bereikt op
http://localhost:6333
Om te testen:
curl http://localhost:6333/collections
Stap 3: De Python-omgeving voorbereiden
We hebben Python nodig voor chunking, inbedding en communicatie met Qdrant.
Voorbereiding:
python3 -m venv rag-env source rag-env/bin/activate pip install qdrant-client sentence-transformers ollama numpy
Als ollama niet wordt herkend als Python-pakket, gebruik dan de REST API rechtstreeks via aanvragen:
pip install requests
Stap 4: Chunking en inbedding
Hieronder vind je een voorbeeldscript dat een tekstdocument opsplitst in chunks, embeddings aanmaakt via Ollama en ze invoegt in Qdrant:
import requests
from qdrant_client import QdrantClient
from qdrant_client.models import PointStruct
import uuid
# Konfiguration
CHUNK_SIZE = 500 # Zeichen
COLLECTION_NAME = "mein_rag_wissen"
# Text vorbereiten
with open("mein_text.txt", "r") as f:
text = f.read()
chunks = [text[i:i+CHUNK_SIZE] for i in range(0, len(text), CHUNK_SIZE)]
# Qdrant vorbereiten
client = QdrantClient("localhost", port=6333)
# Neue Collection anlegen (falls noch nicht vorhanden)
client.recreate_collection(
collection_name=COLLECTION_NAME,
vectors_config={"size": 4096, "distance": "Cosine"}
)
def get_embedding_ollama(text):
response = requests.post(
"http://localhost:11434/api/embeddings",
json={"model": "mistral", "prompt": text}
)
return response.json()["embedding"]
# Embeddings erzeugen und in Qdrant speichern
points = []
for i, chunk in enumerate(chunks):
vector = get_embedding_ollama(chunk)
points.append(PointStruct(
id=str(uuid.uuid4()),
vector=vector,
payload={"text": chunk}
))
client.upsert(collection_name=COLLECTION_NAME, points=points)
print(f"{len(points)} Chunks erfolgreich eingefügt.")
Stap 5: Query's via semantisch zoeken
Je kunt nu zoekopdrachten als een vector naar Qdrant sturen en het de meest relevante tekstsecties laten vinden:
query = "Wie funktioniert ein RAG-System?" query_vector = get_embedding_ollama(query) results = client.search( collection_name=COLLECTION_NAME, query_vector=query_vector, limit=3 ) for r in results: print(r.payload["text"])
Je kunt deze chunks dan bijvoorbeeld via een systeemprompt doorgeven aan Ollama en ze laten formuleren als een contextgerelateerd antwoord.
Chunking + JSON-export naar FileMaker en andere databases
In veel gevallen kan chunking al plaatsvinden in een bestaande databaseoplossing - bijvoorbeeld in FileMaker. Dit is precies hoe het werkt in mijn eigen werkomgeving: de brongegevens - zoals websitecontent, supportitems of technische artikelen - zijn al in gestructureerde vorm beschikbaar in FileMaker.
Zo werkt het proces:
- De teksten worden verdeeld in secties van bijvoorbeeld 300-500 tekens binnen FileMaker met behulp van zijn eigen chunking logica.
- Elke chunk krijgt zijn eigen ID en, indien van toepassing, metadata (titel, categorie, bron, taal, enz.).
- Alle chunks worden automatisch geëxporteerd als JSON-bestanden - bijvoorbeeld naar een specifieke map op een netwerkschijf of rechtstreeks naar de harde schijf van de AI-server.
- Een Python script op de server leest deze JSON bestanden en slaat ze op in de Qdrant database.
Voorbeeld van een geëxporteerd chunk-bestand (chunk_00017.json)
{
"id": "00017",
"text": "Dies ist ein einzelner Textabschnitt mit ca. 400 Zeichen, der aus einer größeren Quelle stammt. Er wurde in FileMaker vorbereitet und enthält alle relevanten Inhalte, die für eine semantische Suche benötigt werden.",
"metadata": {
"source": "support_center",
"category": "Fehlermeldung",
"language": "de",
"title": "Drucker wird nicht erkannt"
}
}
Het daaropvolgende importscript kan dan automatisch of regelmatig via de terminal worden uitgevoerd - bijvoorbeeld via een crontaak of handmatige oproep:
python3 import_json_chunks.py /Users/markus/Desktop/chunks/
Het script leest elke JSON chunk, genereert de bijbehorende vector (bijv. via Ollama of SentenceTransformers) en stuurt de invoer naar de Qdrant database.
Deze methode is niet alleen transparant, maar kan ook heel goed worden gecombineerd met bestaande IT-structuren - vooral in bedrijven die al FileMaker gebruiken of alles graag centraal en visueel gecontroleerd in kaart brengen om redenen van proceshelderheid.
Verbind databases met je lokale AI
Met Ollama en Qdrant kan in korte tijd een compleet, krachtig RAG-systeem worden opgezet op de Mac:
- Lokaal, zonder cloud of abonnement
- Uitbreidbaar, met je eigen inhoud
- Beveiligde gegevens, omdat niets de computer verlaat
- Efficiënt, want Qdrant blijft snel, zelfs op grote hoeveelheden gegevens
Als je je AI niet alleen wilt gebruiken om te chatten, maar ook als een echt kennis- en geheugensysteem, dan is deze combinatie een must. En het werkt met weinig moeite - met volledige controle over je eigen gegevens.
Huidig onderzoek naar het gebruik van lokale AI-systemen
Outlook: Wat is er mogelijk met RAG, Ollama en Qdrant?
De in dit artikel beschreven opzet vormt de technische basis voor een nieuwe manier van omgaan met kennis - lokaal, gecontroleerd en flexibel uitbreidbaar. Maar de reis eindigt hier zeker niet. Als je eenmaal het samenspel van chunking, embedding, semantisch zoeken en taalmodellen begrijpt, zul je snel beseffen hoe veelzijdig deze architectuur in de praktijk is.
1. verbinding met eigen databases
Of het nu FileMaker, MySQL, PostgreSQL of MongoDB is - elke inhoud kan regelmatig worden geëxtraheerd, gechunked en automatisch in de vectordatabase worden ingevoegd met behulp van gerichte query's. Dit verandert een klassieke database in een semantisch doorzoekbare kennisbron. Vooral in ondersteunende systemen, productarchieven of digitale bibliotheken opent dit volledig nieuwe toegangsmogelijkheden voor medewerkers of klanten.
2. automatisch importeren van webpagina's, PDF's of documenten
Content hoeft niet handmatig te worden overgezet. Met tools zoals BeautifulSoup, readability, pdfplumber of docx2txt kunnen hele websites, PDF-handleidingen of Word-documenten automatisch worden geïmporteerd, omgezet in tekstvorm en voorbereid voor chunking. Technische wiki's, klantenportalen of online documentatie kunnen bijvoorbeeld regelmatig worden bijgewerkt en in de RAG database worden ingevoerd.
3. kennisopbouw op lange termijn door structurering
In tegenstelling tot een klassieke AI-toepassing, die bij elke vraag vanaf nul begint, maakt een RAG-opzet het mogelijk om de onderliggende kennis stapsgewijs uit te breiden en te cureren. De gerichte selectie en voorbereiding van chunks creëert een eigen semantisch geheugen, dat met elke invoer waardevoller wordt.
4. verbinding met kennisgrafieken (Neo4j)
Als je nog een stap verder wilt gaan, kun je de informatie niet alleen semantisch opslaan, maar ook logisch aan elkaar koppelen. Met Neo4j, een grafiekdatabase, kunnen relaties tussen termen, personen, onderwerpen of categorieën worden gevisualiseerd en gericht worden bevraagd. Dit verandert een verzameling teksten in een gestructureerde kennisgrafiek die zowel door mensen als AI kan worden gebruikt - bijvoorbeeld om causale ketens, temporele sequenties of thematische clusters te visualiseren.
5. gebruiken in je eigen tools, apps of chatbots
Eenmaal opgezet kan de RAG-logica worden geïntegreerd in vrijwel elke toepassing: als semantische zoekfunctie in een interne webapp, als intelligente invoerhulp in een CRM-systeem of als chatbot met eigen expertise op de bedrijfswebsite. Door gebruik te maken van lokale API's (bijv. Ollama REST en Qdrant gRPC) blijven alle componenten flexibel en uitbreidbaar - zelfs buiten de traditionele bedrijfsgrenzen.
Degenen die de moed hebben om zich deze tools eigen te maken, leggen de basis voor onafhankelijke, lokale AI-systemen met echte gebruikswaarde - in de geest van controle, soevereiniteit en technische duidelijkheid.
Veelgestelde vragen over RAG met Ollama + Qdrant
1. Wat is een RAG-database en waar is die goed voor?
Een RAG-database (Retrieval Augmented Generation) combineert een vectordatabase met een taalmodel. Het maakt het mogelijk om je eigen inhoud - bijvoorbeeld documentatie of websites - semantisch doorzoekbaar te maken, zodat AI-modellen specifiek toegang hebben tot relevante delen van je eigen database.
2 Wat betekent "chunking" in deze context?
Chunking betekent het opsplitsen van lange teksten in kleinere, betekenisvolle samenhangende delen (chunks) - meestal tussen 200 en 500 tekens. Hierdoor kunnen individuele tekstgedeelten efficiënt worden opgeslagen in de vectordatabase en later worden opgehaald als er vragen rijzen.
3. waarom kun je niet gewoon hele teksten opslaan in Qdrant?
Omdat AI-modellen en vectorzoekopdrachten werken met beperkte tekstlengtes. Grote documenten zouden belangrijke inhoud "verbergen" of onnauwkeurig maken. Chunking verhoogt de nauwkeurigheid omdat specifieke secties worden vergeleken in plaats van complete teksten.
4. Kan ik inhoud van elke bron gebruiken?
Ja, zolang je de teksten in een bewerkbare vorm hebt (bv. als platte tekst, HTML, Markdown, PDF, FileMaker entries, enz.), kan je ze voorbereiden, chunken en integreren in Qdrant. Gemengde bronnen zijn ook mogelijk.
5. Moet ik kunnen programmeren om zo'n systeem te bouwen?
Basiskennis van Terminal en Python is nuttig, maar niet essentieel. Veel stappen (bv. chunking in FileMaker, JSON export) kunnen visueel en automatisch uitgevoerd worden. Het Qdrant importscript kan gemakkelijk aangepast worden.
6. Kan ik ook meerdere documenten of categorieën beheren?
Ja, elke chunk kan metadata bevatten - bijv. titel, bron, taal of categorie. Hiermee kan rekening worden gehouden tijdens het zoeken om de resultaten specifieker te filteren.
7 Welke modellen zijn geschikt voor het genereren van inbedding?
Je kunt een lokaal model gebruiken via Ollama (bijvoorbeeld mistral, llama2, gemma) of een apart inbeddingsmodel zoals all-MiniLM van sentence-transformers. Het is belangrijk dat het model insluitingsuitvoer genereert als vectoren.
8. Hoe start ik Qdrant op de Mac?
De eenvoudigste manier is via het Docker-commando:
docker run -p 6333:6333 -v qdrant_storage:/qdrant/storage qdrant/qdrant
Qdrant draait dan onder http://localhost:6333
9. Hoe groot kunnen mijn gegevensvolumes zijn?
Qdrant is zeer performant en kan gemakkelijk tienduizenden of honderdduizenden chunks beheren. De belangrijkste beperking is RAM en opslagruimte, niet het aantal.
10. Werkt dit ook met FileMaker?
Ja, je kunt alle chunking en JSON export rechtstreeks in FileMaker doen. De chunks worden geëxporteerd als individuele JSON-bestanden, die vervolgens worden geïmporteerd in Qdrant via een Python-script - volledig onafhankelijk van het originele systeem.
11. Kan ik dit ook op een andere server draaien in plaats van op de Mac?
Absoluut. De opstelling werkt ook op Linux-servers, Raspberry Pi of in de cloud (indien gewenst). Docker maakt het platformonafhankelijk. Voor productief gebruik wordt meestal een server met meer RAM en GPU-ondersteuning aanbevolen.
12. Hoe combineer ik de vectorzoekopdracht met Ollama?
Je maakt eerst een vector voor een gebruikersvraag via Ollama (Embedding API), zoekt daarmee de meest relevante chunks in Qdrant en geeft die als context mee aan het taalmodel. Ollama verwerkt vervolgens de vraag + context-relevante informatie en genereert een gefundeerd antwoord.
Afbeelding (c) geralt @ pixabay