Hoe je embeddings opslaat en opvraagt in MongoDB

De opkomst van LLM’s en semantisch zoeken heeft fundamenteel veranderd hoe we zoek-, aanbevelings- en retrievesystemen bouwen. Traditioneel zoeken op trefwoorden—via SQL LIKE, omgekeerde Lucene-indexen of full-text indexes—schiet steeds vaker tekort wanneer gebruikers natuurlijke-taalbegrip verwachten.

Hier komen embeddings en vectordatabases in beeld.

MongoDB heeft zich hierin snel ontwikkeld met Atlas Vector Search, waardoor ontwikkelaars één database hebben voor documenten + metadata + vectoren—alles onder één API. In deze gids behandelen we:

• Wat MongoDB is.
• Wat query-embeddings zijn en waarom ze belangrijk zijn.
• Wanneer je embeddings moet gebruiken.
• Hoe je embeddings opslaat in MongoDB.
• Hoe je ze genereert en opvraagt met Python.

Deze tutorial is hands-on en klaar om te integreren in je retrieval-augmented generation (RAG)-, similarity search- of aanbevelingspijplijn.

Wat is MongoDB?

MongoDB is een documentgeoriënteerde NoSQL-database die data opslaat in flexibele BSON-documenten—BSON is een binair gecodeerde JavaScript Object Notation (JSON)—een tekstuele objectnotatie die veel wordt gebruikt om data te verzenden en op te slaan in webapplicaties. In tegenstelling tot starre relationele databases maakt MongoDB schema-evolutie eenvoudig en biedt het:

• Horizontale schaalbaarheid (sharding).
• Rijk aggregatiekader.
• Full-text search.
• Vector search.
• Time series-collecties.
• Schemaflexibiliteit.

MongoDB Atlas—de volledig beheerde clouddienst—breidt dit uit met:

• Atlas Search (gebouwd op Lucene).
• Atlas Vector Search (semantisch zoeken via HNSW-indexering).
• Automatisch schalen, back-ups, beveiliging en monitoring.

MongoDB is een sterke keuze geworden voor AI-workloads omdat vectoren vaak naast metadata staan, en MongoDB Atlas dat allemaal bundelt in één systeem.

Wat zijn embeddings en waarom gebruiken we query-embeddings?

Als je werkt met zoeken of retrieval in AI-toepassingen, is een van de eerste concepten die je tegenkomt embeddings. 

Een embedding is in essentie een numerieke representatie, een lange lijst met drijvende-kommagetallen, die de betekenis van een stuk tekst (of afbeelding, audio, enz.) vastlegt. In plaats van naar exacte woorden te kijken, mappen embeddings tekst naar een vectorruimte waar vergelijkbare ideeën dicht bij elkaar eindigen. Neem bijvoorbeeld drie verschillende gebruikersuitspraken:

• Probleem met facturatie
• Betaalfout
• Salaris niet bijgeschreven

Hoewel de woorden verschillen, beschrijven alle drie een financieel probleem. Een goed embeddingmodel plaatst deze teksten dicht bij elkaar in de vectorruimte, zodat je ze kunt opvragen op basis van betekenis in plaats van trefwoorden.

Dit wordt extra belangrijk wanneer de gebruiker een zoekopdracht uitvoert. De tekst die ze typen—“Waarom is mijn salaris vertraagd?”—wordt ook omgezet in een embedding. Deze nieuwe vector heet een query-embedding. Je vergelijkt deze queryvector vervolgens met alle opgeslagen embeddings om te vinden welke documenten semantisch vergelijkbaar zijn. Hoe dichter de vectoren bij elkaar liggen, hoe relevanter het resultaat.

MongoDB Atlas maakt deze hele workflow extreem eenvoudig met Atlas Vector Search. Nadat je je documenten en hun embeddings in een MongoDB-collectie hebt opgeslagen, maakt Atlas een vectorindex (onder water met HNSW) die snel vergelijkbare documenten op schaal kan ophalen. Als je bijvoorbeeld supportartikelen met hun embeddings opslaat, kan een query als…

query = "Why isn't my salary showing up this month?"
query_vec = get_embedding(query) # Explained in below examplesMogelijk gemaakt door

…direct in MongoDB worden gebruikt:

results = collection.aggregate([
    {
        "$vectorSearch": {
            "path": "embedding",
            "queryVector": query_vec,
            "index": "vector_index",
            "limit": 3
        }
    }
])
Mogelijk gemaakt door

MongoDB retourneert automatisch de 3 beste supportartikelen waarvan de embeddings het dichtst bij de query liggen—zonder dat je zelf trefwoorden hoeft te matchen of handmatig te scoren.

Dit is de kracht van embeddings in MongoDB Atlas: je slaat betekenis op, niet alleen tekst, en je zoekt op intentie, niet alleen woorden. Deze verschuiving is waarom embeddings een kernbouwsteen zijn geworden voor semantisch zoeken, RAG-systemen, AI-assistenten en intelligente kennissystemen.

Wanneer gebruik je query-embeddings

Gebruik embeddings wanneer je semantische gelijkenis wilt, zoals:

Retrieval-augmented generation (RAG)

• Voorzie je LLM van accurate context uit je kennisbank
• Vervang kwetsbaar zoekwerk op trefwoorden

Chatbots die diep begrip vereisen

• Portaal-helpdesk
• Klantondersteuning

Productaanbeveling

• “vergelijkbare items bij dit item”

Document- of duplicaatdetectie

• Clusteren
• Onderwerpen groeperen

Als zoeken op trefwoorden faalt

• Queries zoals “vertraging salarisbijschrijving” vs. “probleem met betalingsverwerking”

Gebruik embeddings niet wanneer:

• Je exacte overeenkomst nodig hebt (ID’s, factuurnummers).
• Je dataset piepklein is (eenvoudig zoeken volstaat).
• Je numerieke filtering/vergelijkingen nodig hebt (laat metadata dat afhandelen).

Hoe embeddings opslaan in MongoDB

Het mooie van MongoDB is dat embeddings van nature in documenten passen. Je slaat ze gewoon op als arrays van floats.

Voorbeeld documentschema

Dit is een typische documentstructuur:

{
  "_id": "uuid-123",
  "text": "This is a sample document about MongoDB vector search.",
  "embedding": [0.123, -0.241, 0.998, ...],
  "tags": ["mongodb", "vector", "ai"],
  "createdAt": "2025-01-01T10:20:00Z"
}
Mogelijk gemaakt door

Belangrijke aandachtspunten:

• Elke embedding in een collectie moet dezelfde dimensionaliteit hebben.
• Embeddings worden idealiter opgeslagen als float32 (MongoDB converteert intern naar float64).
• Als je documenten lang zijn, chunk ze dan voordat je embedt.
• Sla metadata apart op—tags, categorie, URL, tijdstempels, enz. Dit maakt hybride zoeken krachtig.

Een vectorindex maken in MongoDB (kritieke stap)

Voordat je embeddings opslaat of opvraagt, moet je een vectorzoekindex maken in MongoDB Atlas.

Ga in MongoDB Atlas naar: Atlas → Database → Collections → Search → Create Search Index

Gebruik een definitie zoals:

{
  "fields": [
    {
      "type": "vector",
      "path": "embedding",
      "numDimensions": 1536,
      "similarity": "cosine"
    }
  ]
}
Mogelijk gemaakt door

Dit vertelt MongoDB:

• Het veld embedding bevat vectoren.
• Elke vector heeft 1536 dimensies.
• Gebruik cosine similarity voor ranking.

Deze index voedt alle vectorzoekqueries.

MongoDB bevat native vectorzoekfunctionaliteit met ondersteuning voor:

• Cosine similarity.
• Euclidische afstand.
• dotProduct-scoring.

Kies op basis van je embeddingmodel—maar hoe weten we wat we moeten kiezen? Laten we de diepte in gaan.

Cosine similarity

Wat het meet

Het meet hoe uitgelijnd twee vectoren zijn—oftewel de hoek ertussen. Het negeert de grootte en kijkt alleen naar de richting.

Intuïtie

• Als twee vectoren dezelfde kant op wijzen → gelijkenis dicht bij 1
• Tegenovergestelde richtingen → –1
• Orthogonaal (onverwant) → 0

Wanneer te gebruiken

Gebruik cosine wanneer de grootte er niet toe doet, maar alleen het patroon of het concept dat wordt uitgedrukt.

Veelvoorkomende toepassingen

• Tekstembeddings/NLP
• Semantisch zoeken
• Aanbevelingssystemen op basis van betekenis, niet schaal

Cosine is de veiligste standaard voor de meeste embeddingmodellen.

Euclidische afstand

Wat het meet

Het meet de kortste afstand tussen twee vectoren in de ruimte.

Intuïtie

• Kleine afstand → vectoren zijn vergelijkbaar
• Grote afstand → vectoren liggen ver uit elkaar

Wanneer te gebruiken

Gebruik Euclidisch wanneer absolute waarden en groottes ertoe doen, niet alleen richting.

Veelvoorkomende toepassingen

• Afbeeldingsembeddings
• Fysieke metingen/sensordata
• Clustering-algoritmen zoals K-means (dat intern Euclidisch gebruikt)

Als je data van nature in een geometrische ruimte leeft (bijv. pixelintensiteiten), is Euclidisch vaak logischer.

Dot product

Wat het meet

Het meet een combinatie van gelijkenis én grootte. 

Wiskundig: dot(u, v) = |u| × |v| × cos(θ)

Intuïtie

• Grotere grootte EN uitlijning → hogere score
• Gevoelig voor vectorlengte
• Niet automatisch genormaliseerd

Wanneer te gebruiken

Gebruik dot product wanneer je wilt dat langere vectoren meer invloed hebben of wanneer het embeddingmodel is getraind met dot product in gedachten.

Veelvoorkomende toepassingen

• Embeddings van grote taalmodellen die inner product-scoring veronderstellen
• Similariteitslagen in neurale netwerken
• Aanbevelingsmodellen waar de “sterkte” van features betekenisvol is

Snelle vuistregel

Embeddings genereren, opslaan en opvragen in MongoDB (Python-tutorial)

Laten we dit doorlopen alsof we een echt systeem bouwen.

Installeer dependencies

pip install pymongo openaiMogelijk gemaakt door

Embeddings genereren

Met OpenAI (vervang door elke embeddingprovider die je verkiest):

import os
from openai import OpenAI

os.environ["OPENAI_API_KEY"] = "your_api_key_here"
client = OpenAI()

def get_embedding(text: str):
    response = client.embeddings.create(
        model="text-embedding-3-small",
        input=text
    )
    return response.data[0].embeddingMogelijk gemaakt door

Verbinding maken met MongoDB en documenten invoegen

Met OpenAI (vervang door elke embeddingprovider die je verkiest):

from pymongo import MongoClient
import uuid

mongo = MongoClient("<MONGODB_ATLAS_URI>")
db = mongo["vector_db"]
collection = db["documents"]

text = "This is a sample document about MongoDB vector search."
embedding = get_embedding(text)

document = {
    "_id": str(uuid.uuid4()),
    "text": text,
    "embedding": embedding,
    "tags": ["mongodb", "search"],
}

collection.insert_one(document)
print("Document inserted successfully!")Mogelijk gemaakt door

Op dit punt is je data klaar voor semantisch zoeken.

Embeddings opvragen in MongoDB

Nu komt het leuke deel: vergelijkbare documenten ophalen met een vectorquery. MongoDB gebruikt $vectorSearch in een aggregatiepijplijn.

Queryvector genereren

from pymongo import MongoClient
query = "How does MongoDB handle semantic search?"
query_vec = get_embedding(query)Mogelijk gemaakt door

Vectorzoekopdracht uitvoeren (query-embeddings)

results = collection.aggregate([
    {
        "$vectorSearch": {
            "index": "vector_index",
            "path": "embedding",
            "queryVector": query_vec,
            "numCandidates": 100,
            "limit": 5,
            "similarity": "cosine"
        }
    },
    {
        "$project": {
            "text": 1,
            "score": {"$meta": "vectorSearchScore"}
        }
    }
])

for r in results:
    print(r)Mogelijk gemaakt door

Dit retourneert de vijf meest semantisch vergelijkbare documenten.

Dit is krachtig voor RAG-pijplijnen waar je semantisch zoeken wilt.

Stap-voor-stap uitleg van bovenstaande query

$vectorSearch → Vindt documenten waarvan het veld embedding het dichtst bij queryVector ligt met de opgegeven similariteitsmetriek

numCandidates → Hoeveel potentiële matches de engine moet overwegen voordat de topresultaten worden gekozen

limit → Aantal uiteindelijke vergelijkbare resultaten om te retourneren

$project → Retourneert de oorspronkelijke tekst plus een speciaal veld genaamd score

Wat is het score-veld?

MongoDB Atlas Vector Search retourneert een speciaal metadataveld, "score": {"$meta": "vectorSearchScore"}, dat aangeeft hoe vergelijkbaar een opgeslagen vector is met je queryvector.

De betekenis van de score hangt af van de similariteitsmetriek die je kiest, zoals hieronder uitgelegd:

Best practices

• Chunk lange documenten (300–500 tokens per stuk): Betere relevantie + voorkomt lange blobs embedden
• Sla metadata apart op: Helpt bij filteren en rangschikken
• Batchgewijs embeddings genereren: Verbetert throughput en verlaagt modelkosten
• Gebruik float32-embeddings in je model: MongoDB gebruikt intern float64 maar accepteert float32-arrays
• Indexeer alleen het vectorveld: Extra velden in de index verhogen geheugen- en latentie

Veelvoorkomende valkuilen om te vermijden

Tot slot

Embeddings en semantisch zoeken zijn nu fundamenteel voor moderne AI-producten. Of je nu een chatbot, RAG-pijplijn, aanbevelingsmachine of slimme zoeklaag bouwt, je hebt een betrouwbare manier nodig om vectoren op te slaan en ze efficiënt op te vragen.

MongoDB geeft je een uniform platform waar:

• Je tekst leeft.
• Je metadata leeft.
• Je embeddings leven.
• Je vectorzoekopdrachten draaien.
• Alles samen schaalt.

Dit voorkomt de complexiteit van het jongleren met aparte databases en laat je focussen op het bouwen van productfunctionaliteit, niet infrastructuur.