So baust du eine Vector-Search-Anwendung mit MongoDB Atlas und Python

Bis vor Kurzem funktionierten Computer wie effiziente, aber wörtlich denkende Bibliothekarinnen. Wenn du nach "giant robot battles" gesucht hast, fanden sie nur Titel mit genau diesen Wörtern. Ein Volltreffer wie "Kaiju Mech Warfare" blieb außen vor. Computer erkannten Wörter, aber sie verpassten die Musik—es fehlten Verständnis, Nuancen und Kontext. Das war die Ära der Keyword-Suche, die uns viele Jahre als beste Option diente.

Dann kam die Revolution. Inspiriert vom menschlichen Gehirn entwickelte Künstliche Intelligenz eine neue Art zu lernen. Statt nur Wörter auswendig zu kennen, begann KI, Beziehungen zwischen ihnen zu begreifen. Sie versteht, dass sich "king" zu "man" verhält wie "queen" zu "woman". Sie erkennt, dass "happy", "joyful" und "ecstatic" dieselbe Gefühlswelt teilen, während "sombre" in einer ganz anderen Sphäre liegt.

Wie hat die KI das geschafft? Indem sie eine Landkarte der Bedeutung geschaffen hat.

Was ist Vector Search? Die Landkarte der Bedeutung

Stell dir eine riesige, mehrdimensionale Galaxie vor, in der jeder Begriff—ein Wort, ein Satz, ein Bild, ein Song—ein Stern ist. In dieser Galaxie gruppieren sich Sterne mit ähnlicher Bedeutung, während nicht zusammenhängende Lichtjahre voneinander entfernt sind.

Ein Vektorembedding ist einfach die Koordinate eines Sterns in dieser Galaxie. Es ist eine Liste von Zahlen (z. B. [0.12, -0.45, 0.89, ...]), die einen Begriff präzise auf dieser Bedeutungslandkarte verortet.

Vector Search ist die revolutionäre Fähigkeit, diese Karte zu navigieren. Wenn du fragst: "Ein Film über einen verwaisten Jungen, der entdeckt, dass er ein Zauberer ist", suchen wir nicht nach exakt diesen Keywords. Stattdessen:

1. Finden wir die Koordinate (den Vektor) deiner Frage auf der Karte.
2. Lokalisieren wir die nächsten Nachbarsterne (unsere Filmplots).

Die nächsten Sterne stehen für die semantisch ähnlichsten Ergebnisse. So hat sich KI vom wörtlichen Bibliothekar zur weisen Ratgeberin entwickelt, die versteht, was du wirklich meinst.

Warum ist das so wichtig?

Die Suche nach Bedeutung statt nach Stichwörtern treibt moderne KI-Anwendungen in allen Branchen an. Diese Fähigkeit ermöglicht:

• Netflix, dir unbekannte Filme zu empfehlen, die denselben "Vibe" wie deine Sehgewohnheiten haben.
• Spotify, Playlists mit Songs zusammenzustellen, die sich anfühlen wie deine Favoriten—unabhängig von Genre oder Ära.
• Chatbots und LLMs, die Intention hinter deinen Fragen zu verstehen und relevante, kontextbewusste Antworten zu liefern.
• E-Commerce-Seiten, Produkte anzuzeigen, die Bildern, die du hochlädst, visuell ähneln.

Vector Search schlägt die Brücke zwischen menschlicher Absicht und digitalen Daten und verändert grundlegend, wie wir mit Informationen interagieren. Diese Technologie lässt digitale Systeme weniger mechanisch wirken—und mehr wie intuitive Partner.

Lass uns loslegen: Baue deine erste Vector-Search-App mit MongoDB

Willkommen an der neuen Such-Frontier! MongoDB hat Vector Search in Atlas eingeführt. Damit kannst du Vektorembeddings (z. B. aus Text, Bildern oder Audio) direkt in MongoDB speichern und abfragen—ohne separates Vektordatenbank-System wie Pinecone oder Weaviate.

In diesem Tutorial bauen wir mit Python und MongoDB Atlas eine einfache, aber leistungsstarke Empfehlung für Schuhe. Du lernst, wie du Text in aussagekräftige numerische Repräsentationen (Vektoren) transformierst und anschließend mit der integrierten Vector Search in Atlas Produkte mit ähnlichen Beschreibungen findest.

Was du lernen wirst

• Wie du dich verbindest: Sicher zu einem MongoDB-Atlas-Cluster mit Pythons pymongo-Bibliothek.
• Wie du Dokumente erstellst und einfügst, die Vektorembeddings enthalten.
• Wie du Vektorembeddings generierst aus Text mit der Bibliothek sentence-transformers.
• Wie du einen Vector-Search-Index in der MongoDB-Atlas-Oberfläche erstellst.
• Wie du eine semantische Suchanfrage mit der $vectorSearch-Aggregation ausführst.

Voraussetzungen

• Ein kostenloses MongoDB-Atlas-Konto
• Python 3.9+ lokal installiert
• Abhängigkeiten installieren:

pip install pymongo sentence-transformers numpyBereitgestellt von

Schritt 1: MongoDB-Atlas-Cluster erstellen

• Bei Atlas anmelden.

• Kostenlosen Cluster erstellen. Einen User anlegen und Benutzername sowie Passwort kopieren.

• Nach dem Anlegen des Users klicke auf Choose a connection method. Du siehst den ersten Screen unten. Klicke auf Drivers und gehe zum zweiten Screen. Wähle Python als Treiber und die passende Version. Kopiere den Connection String.

• Gehe zu Database Deployments → klicke Browse Collections → Erstelle eine neue Datenbank:
• Datenbankname: vectorDemo
• Collections-Name: items

• Aktiviere Vector Search:
• Navigiere in der MongoDB-Atlas-Oberfläche zu Vector Search Indexes → Erstelle einen neuen Index für items.
• Name des Index: „vector_index“
• Diese Definition verwenden:

{
  "fields": [
    {
      "type": "vector",
      "path": "embedding",
      "numDimensions": 768,
      "similarity": "cosine"
    }
  ]
}
Bereitgestellt von

Hinweis: 768 ist die Embedding-Größe, die wir mit dem sentence-transformers-Modell verwenden.

Die Indexdefinition verstehen:

• "type": "vector": Sagt MongoDB Atlas, dass dies ein Vektorindex ist.
• "path": "embedding": Verweist auf das Feld in unseren Dokumenten, das die Vektoren enthält.
• "numDimensions": 768: Das muss der Dimension der Vektoren entsprechen, die unser Modell erzeugt.
• "similarity": "cosine": Der Algorithmus, der die „Nähe“ von Vektoren misst. Hervorragend für textbasierte Ähnlichkeit.

Schritt 2: Python mit MongoDB Atlas verbinden

Hol dir deinen MongoDB-Atlas-Connection-String:

• In MongoDB Atlas auf Connect → Drivers → Python klicken.
• Ersetze <username>, <password> und <cluster-url> im folgenden Snippet.

from pymongo import MongoClient

# Replace with your Atlas connection string
uri = "mongodb+srv://<username>:<password>@<cluster-url>/vectorDemo?retryWrites=true&w=majority"

client = MongoClient(uri)
db = client["vectorDemo"]
collection = db["items"]
print("Connected to MongoDB Atlas")

# Clear existing
collection.delete_many({})
print("Cleared collection.")Bereitgestellt von

Schritt 3: Embeddings mit Python erzeugen

Wir verwenden SentenceTransformers, um Text in Embeddings zu konvertieren.

from sentence_transformers import SentenceTransformer
# Choose model: higher-quality for search -> "sentence-transformers/all-mpnet-base-v2" (768-d)
# If you need faster/smaller: "all-MiniLM-L6-v2" (384-d)
MODEL_NAME = "sentence-transformers/all-mpnet-base-v2"
# MODEL_NAME = "all-MiniLM-L6-v2"

# Note: if you use all-mpnet-base-v2, your Atlas vector index must use numDimensions: 768
# If you use all-MiniLM-L6-v2, index numDimensions: 384
model = SentenceTransformer(MODEL_NAME)

def embed_text(text: str):
    return model.encode(text).tolist()Bereitgestellt von

Schritt 4: Beispieldokumente mit Embeddings einfügen

Speichern wir einige Produktbeschreibungen mit ihren Embeddings in MongoDB.

# Each product includes name, description, list of features, use_cases and tags.
products = [
    # Marathon / long-distance running (explicit!)
    {
        "name": "MarathonPro 3000",
        "description": "Designed specifically for marathon and ultra distance running: maximum cushioning, breathable knit upper, responsive midsole and engineered heel support for long-run comfort.",
        "features": ["marathon", "long-distance", "max cushioning", "breathable", "support"],
        "category": "shoes",
        "use_cases": ["marathon", "long-distance running", "road running"],
        "tags": ["running", "endurance", "comfort"]
    },
    {
        "name": "Enduro LongRun",
        "description": "Lightweight long-run trainer optimized for marathon pacing with added cushioning, stable platform, and enhanced forefoot energy return for hours of comfortable running.",
        "features": ["long-run", "lightweight", "energy return", "cushioning"],
        "category": "shoes",
        "use_cases": ["marathon", "road running"],
        "tags": ["running","marathon","comfort"]
    },

    # Road running / neutral
    {
        "name": "Red Road Runner",
        "description": "Neutral road running shoe for daily training: breathable mesh, moderate cushioning and responsive ride; suitable for tempo runs and long easy runs.",
        "features": ["road running", "breathable", "moderate cushioning"],
        "category": "shoes",
        "use_cases": ["training", "road running", "tempo runs"],
        "tags": ["running","training"]
    },

    # Trail running (explicit trail)
    {
        "name": "TrailMaster RidgeGrip",
        "description": "Trail-running shoe with aggressive outsole, rock plate for protection, waterproof upper, designed for technical trails and rugged terrain.",
        "features": ["trail", "high grip", "rock plate", "waterproof"],
        "category": "shoes",
        "use_cases": ["trail running", "hiking", "off-road"],
        "tags": ["trail","outdoors"]
    },

    # Tennis & court
    {
        "name": "CourtPro Tennis",
        "description": "Court shoe with lateral support, non-marking sole and reinforced toe; built for tennis footwork and short intense bursts, not for long-distance running.",
        "features": ["court", "lateral support", "non-marking sole"],
        "category": "shoes",
        "use_cases": ["tennis","court sports"],
        "tags": ["tennis","sport"]
    },

    # Formal
    {
        "name": "Oxford Leather Formal",
        "description": "Classic leather formal shoe for office and events: polished leather, sturdy sole, refined silhouette.",
        "features": ["formal", "leather", "office"],
        "category": "shoes",
        "use_cases": ["formal wear","office"],
        "tags": ["formal","leather"]
    },

    # Hiking
    {
        "name": "Alpine Trek Boots",
        "description": "High-ankle hiking boots with waterproof membrane, ankle support and durable lugged outsole for mountain treks.",
        "features": ["hiking", "waterproof", "ankle support", "lugged outsole"],
        "category": "shoes",
        "use_cases": ["hiking","trekking","outdoor"],
        "tags": ["outdoors","hiking"]
    },

    # Casual sneakers
    {
        "name": "Classic Canvas Sneaker",
        "description": "Casual everyday canvas sneaker with rubber sole, comfortable fit for daily wear and walking.",
        "features": ["casual","canvas", "everyday"],
        "category": "shoes",
        "use_cases": ["casual","walking"],
        "tags": ["casual"]
    },

    # Cross-trainer
    {
        "name": "CrossFit Trainer",
        "description": "Stable cross-trainer shoe engineered for gym workouts, short sprints, and lateral movements; flexible yet supportive.",
        "features": ["cross-train","stable","gym"],
        "category": "shoes",
        "use_cases": ["gym","cross-training"],
        "tags": ["training","gym"]
    },

    # Cleats
    {
        "name": "Pro Soccer Cleats",
        "description": "Low-profile football/soccer cleats with studded outsole; optimized for grip on grass and agility.",
        "features": ["cleats","studs","agility"],
        "category": "shoes",
        "use_cases": ["soccer","football"],
        "tags": ["sports","cleats"]
    }
]

# ---------- Create 'canonical_text' to improve embedding quality for better scoring ----------
for p in products:
    # join features and others into one rich text blob
    features = ", ".join(p["features"])
    uses = ", ".join(p["use_cases"])
    tags = ", ".join(p["tags"])
    canonical = f"{p['name']}. {p['description']}. Features: {features}. Use cases: {uses}. Tags: {tags}."
    p["canonical_text"] = canonical

# ---------- Embed canonical_text----------
print("Embedding items...")
for p in products:
    p["embedding"] = embed_text(p["canonical_text"])

# ---------- Insert into MongoDB ----------
collection.insert_many(products)
Bereitgestellt von

Mit insert_many führen wir einen einzigen, effizienten Bulk-Write in unsere Datenbank aus.

Schritt 5: Deine erste Vektorsuche ausführen

Jetzt kommt der spannendste Teil! Wir verwenden das Aggregation-Framework von MongoDB und $vectorSearch—den Operator, um die beste Schuhsuche zu finden.

query_text = "25k long running best shoes"
query_embedding = embed_text(query_text)

pipeline = [
    {
        "$vectorSearch": {
            "index": "vector_index",  # Use the vector search index you created
            "path": "embedding",
            "queryVector": query_embedding,
            "numCandidates": 100,
            "limit": 3
        }
    },
    {
        "$project": {
            "name": 1,
            "description":1,
            "score": {"$meta": "vectorSearchScore"}
        }
    }
]

results = collection.aggregate(pipeline)

print(f"\nSearch results for: '{query_text}'\n")
for r in results:
    print(f"- {r['name']} (score: {r['score']:.4f})")Bereitgestellt von

Die $vectorSearch-Pipeline im Detail:

• $vectorSearch: Der Kernoperator. Er vergleicht effizient unseren queryVector mit dem indizierten Feld plot_embedding in allen Dokumenten.
• $project: Formt die Ausgabe. Wir nehmen name und description auf, blenden das störende _id und andere Felder aus und fügen vor allem ein score-Feld mit $meta: "vectorSearchScore" hinzu. Dieser Score von 0 bis 1 zeigt an, wie ähnlich das Ergebnis zu unserer Anfrage ist.

Erwartete Ausgabe

Wenn alles korrekt eingerichtet ist, siehst du etwas wie:

Search results for: '25k long running best shoes'

- MarathonPro 3000 (score: 0.7980)
- Red Road Runner (score: 0.7479)
- Enduro LongRun (score: 0.7389)Bereitgestellt von

Beachte, dass „MarathonPro 3000“ ganz oben steht—genau wie erwartet.

Glückwunsch! Du hast von Grund auf eine Vector-Search-Anwendung gebaut. Du hast gelernt, wie du dich mit einer Datenbank verbindest, Daten erstellst und validierst, Vektorembeddings erzeugst und die Power von MongoDB Atlas nutzt, um Informationen wirklich intelligent zu finden. Willkommen in der Zukunft der Dateninteraktion.

Fazit

In diesem Tutorial hast du erfolgreich gelernt:

• Mit MongoDB Atlas verbinden mittels Python und pymongo—die Basis datenbankgetriebener Anwendungen.
• Embeddings erstellen (nur Text) aus einem realistischen Produktkatalog mit hochwertigen Modellen wie all-mpnet-base-v2 und sie mit sauberer Normalisierung in MongoDB speichern.
• Ein reiches, strukturiertes Dataset aufbauen mit canonical_text (Name, Beschreibung, Features, Use Cases, Tags), um die Relevanz der Embeddings zu verbessern.
• Vektorähnlichkeitssuchen durchführen mit der $vectorSearch-Aggregationsstufe von MongoDB, um auf Basis natürlicher Sprache semantisch ähnliche Produkte zu finden.

Nächste Schritte (probiere selbst aus)

• Nutzerbewertungen speichern und eine semantische Suchmaschine aufbauen.

Experimentiere mit verschiedenen Ähnlichkeitsmetriken (dotProduct, euclidean).