---
term: 'Vektordatenbank und Embeddings'
seoTitle: 'Vektordatenbank und Embeddings: HNSW, ANN, wann sinnvoll?'
headline: 'Was sind Vektordatenbanken und Embeddings?'
slug: vektordatenbank
category: ai-modern-stack
shortDefinition: 'Ein Embedding ist ein numerischer Vektor, der Bedeutung erfasst; eine Vektordatenbank durchsucht diese Vektoren nach Ähnlichkeit statt nach Gleichheit.'
relatedTerms:
- retrieval-augmented-generation-rag
- nosql-vs-sql
- database-index
- access-control-lists-acl
contrastsWith:
- nosql-vs-sql
aboutTerms:
- 'Embeddings'
- 'Vector Database'
- 'HNSW / ANN'
- 'Cosine Similarity'
faq:
- question: 'Was ist ein Embedding, einfach erklärt?'
answer: 'Eine Zahlenreihe, die ein Modell einem Datenstück zuweist – Text, einem Bild, Audio –, sodass Dinge mit ähnlicher Bedeutung ähnliche Zahlen bekommen. Zwei Dokumente zum selben Thema landen als benachbarte Punkte in einem hochdimensionalen Raum, und genau das erlaubt es einem Rechner, "ähnlich" zu messen.'
- question: 'Was ist eine Vektordatenbank?'
answer: 'Ein System, das Embeddings speichert und die Frage "welche gespeicherten Elemente sind diesem am ähnlichsten" schnell beantwortet – über Indizes für die ungefähre Nächste-Nachbarn-Suche statt über exakte Treffer. Der Teil "Datenbank" – Dauerhaftigkeit, Aktualisierungen, Filterung nach Metadaten – unterscheidet sie von einer reinen In-Memory-Indexbibliothek.'
- question: 'Wie funktioniert die Ähnlichkeitssuche?'
answer: 'Die Anfrage wird mit demselben Modell eingebettet und dann über ein Abstandsmaß mit den gespeicherten Vektoren verglichen: Kosinus (nur der Winkel), Skalarprodukt (Winkel und Betrag) oder euklidisch (Abstand in gerader Linie). Bei normalisierten Vektoren ordnen alle drei die Ergebnisse identisch, und Text-Embedding-Modelle sind meist auf Kosinus abgestimmt.'
- question: 'Was ist der Unterschied zwischen exakter und ungefährer Suche?'
answer: 'Die exakte Suche (kNN) vergleicht die Anfrage mit jedem Vektor – perfekter Recall, aber lineare Laufzeit, brauchbar bis etwa eine Million Vektoren. Die ungefähre Suche (ANN, meist HNSW) überspringt die meisten Vergleiche und erreicht nahezu logarithmische Geschwindigkeit; sie tauscht ein paar Prozent Recall gegen um Größenordnungen schnellere Abfragen. Den wahren nächsten Nachbarn gelegentlich zu verfehlen ist in der Regel vertretbar.'
- question: 'Was ist HNSW?'
answer: 'Hierarchical Navigable Small World – der vorherrschende ANN-Index in Produktion. Er baut einen mehrschichtigen Nachbarschaftsgraphen: dünn besetzte obere Schichten liefern weite Abkürzungen, die dichte unterste Schicht enthält jeden Vektor, und die Suche steigt gierig von grob nach fein ab. Seine Stellschrauben wägen Recall gegen Geschwindigkeit und Speicher ab, und der Graph liegt im RAM.'
- question: 'Brauche ich eine dedizierte Vektordatenbank?'
answer: 'Im Maßstab einer Anwendung meist nicht. Eine allgemeine Datenbank mit Unterstützung für Vektorindizes – Postgres mit pgvector, die Vektorsuche von MongoDB – bewältigt rund bis zu 1 Mio. Vektoren pro Knoten bequem, direkt neben Ihren Anwendungsdaten und Berechtigungen. Spezialisierte Engines rechnen sich bei zig Millionen Vektoren, sehr hohen Abfrageraten oder hohem Recall unter starker Filterung.'
- question: 'Was ist Filterung nach Metadaten und warum ist sie wichtig?'
answer: 'Das Einschränken der Ähnlichkeitssuche über Felder – Tenant, Kategorie, Datum, Berechtigungen. Vorgelagertes Filtern begrenzt die Kandidaten vor der ANN-Suche; nachgelagertes Filtern kürzt danach und kann stillschweigend weniger zurückgeben, als Sie verlangt haben. Produktive Abfragen sind fast immer gefiltert, und wenn der Filter aus Berechtigungen besteht, ist er eine Sicherheitsgrenze.'
- question: 'Wofür werden Vektordatenbanken außer für RAG eingesetzt?'
answer: 'Für semantische Suche, Empfehlungen, die Erkennung von Beinahe-Duplikaten sowie von Anomalien und Betrug (Ausreißer sind Vektoren weit entfernt von allem anderen), dazu für Bild- und Audioähnlichkeit und Clustering. Retrieval-Augmented Generation ist der berühmte Anwendungsfall; die Ähnlichkeitssuche ist die allgemeine Fähigkeit darunter.'
codeLanguages: [javascript, dart, swift, kotlin]
externalAuthorities:
- name: 'HNSW — Malkov & Yashunin (arXiv:1603.09320)'
url: 'https://arxiv.org/abs/1603.09320'
- name: 'Efficient Estimation of Word Representations (word2vec, arXiv:1301.3781)'
url: 'https://arxiv.org/abs/1301.3781'
- name: 'pgvector — open-source vector search for Postgres'
url: 'https://github.com/pgvector/pgvector'
- name: 'MongoDB Vector Search — overview'
url: 'https://www.mongodb.com/docs/atlas/atlas-vector-search/vector-search-overview/'
cta:
title: 'Vektoren direkt neben Ihren Daten'
text: 'Auf Back4app sind Embeddings einfach Array-Felder auf Ihren Objekten – für die Ähnlichkeitssuche indiziert, von denselben ACLs gefiltert, die alles andere schützen, und in Cloud Code mit serverseitigem Modellschlüssel erzeugt.'
linkText: 'Kostenlos starten'
linkUrl: 'https://www.back4app.com/signup'
author: 'Back4app Engineering'
publishedDate: '2026-09-25'
translationKey: vector-database-embeddings
---
**Ein Embedding ist ein numerischer Vektor, der Bedeutung erfasst; eine Vektordatenbank durchsucht diese Vektoren nach Ähnlichkeit statt nach Gleichheit.** Die beiden Ideen sind eine einzige Fähigkeit: Ein Modell verwandelt Text (oder Bilder oder Audio) in eine Zahlenreihe, die so platziert ist, dass *ähnliche Bedeutung nahe beieinander landet*, und eine Vektordatenbank findet die nächstgelegenen Punkte schnell. Das ist der ganze Trick hinter semantischer Suche, Empfehlungen und [RAG](/glossary/de/rag/) – und für Anwendungsentwickler lautet die praktische Kernaussage, dass Embeddings nur ein Feld sind, das Sie neben den Daten speichern, die sie beschreiben.
## Das Wichtigste in Kürze
| Frage | Antwort |
| --- | --- |
| Embedding | Ein Vektor, bei dem ähnliche Bedeutung → benachbarte Punkte |
| Vektordatenbank | Speichert Vektoren + beantwortet "am nächsten hierzu" über ANN-Indizes |
| Das Maß | Kosinus (üblich für Text) · Skalarprodukt · euklidisch |
| Exakt vs. ANN | Perfekt-aber-linear vs. ~99 % Recall, um Größenordnungen schneller |
| Brauchen Sie eine dedizierte? | Meist erst ab ~1 Mio. Vektoren – Ihre Datenbank kann es vermutlich schon |
## Embeddings, ganz konkret
Vergessen Sie für einen Moment die 1.536 Dimensionen und stellen Sie sich drei vor: ein Spielzeugmodell, das jedes Wort danach bewertet, ob es *ein Tier ist*, ob es *ein Fahrzeug ist*, ob es *klein ist*.
```text
Tier Fahrzeug klein
Kätzchen 0.95 0.02 0.90
Katze 0.93 0.01 0.60
Lastwagen 0.03 0.96 0.05
Motorrad 0.04 0.94 0.55
"Kätzchen" liegt nahe bei "Katze" (beide stark Tier) und weit weg von "Lastwagen".
distance(Kätzchen, Katze) → klein → ähnlich
distance(Kätzchen, Lastwagen) → groß → ohne Bezug
Echte Modelle nutzen hunderte oder tausende Dimensionen statt drei,
aus Daten gelernt statt von Hand etikettiert – doch die Intuition ist genau diese:
Bedeutung wird Geometrie, und "ähnlich" wird "nah".
```
Der berühmte Beleg dafür, dass dabei echte Struktur entsteht, ist Arithmetik auf den Vektoren: In [trainierten Word Embeddings](https://arxiv.org/abs/1301.3781) landet *König − Mann + Frau* in der Nähe von *Königin*. Bedeutung, in Koordinaten übersetzt, rechnet.
## Wie die Ähnlichkeitssuche funktioniert
```mermaid
flowchart LR
accTitle: Von Daten über Embeddings zur Ähnlichkeitssuche
accDescr: Ein Modell bettet jedes Element in einen Vektor ein, der in einem Vektorindex gespeichert wird. Zur Abfragezeit wird die Anfrage mit demselben Modell eingebettet, und der Index liefert die nächstgelegenen Vektoren nach einem Abstandsmaß zurück, wahlweise gefiltert nach Metadaten wie Berechtigungen und nach Ähnlichkeit sortiert.
D["Elemente
(Text, Bilder, Audio)"] -->|"einbetten"| VS["Vektoren in einem Index"]
Q["Anfrage"] -->|"dasselbe Modell"| QV["Anfragevektor"]
QV --> S{"Nächste nach
Kosinus / Skalar / L2"}
VS --> S
S -->|"nach Metadaten / ACL filtern"| K["Top-k ähnliche
Ergebnisse"]
```
Drei Abstandsmaße dominieren: **Kosinus** misst den Winkel zwischen Vektoren (ohne Rücksicht auf die Länge), das **Skalarprodukt** bezieht den Betrag mit ein, und **euklidisch** ist der Abstand in gerader Linie. Die Einsicht, die Verwirrung erspart: Bei *normalisierten* Vektoren ordnen alle drei die Ergebnisse identisch, und weil Text-Embedding-Modelle üblicherweise normalisierte, auf Kosinus abgestimmte Vektoren ausgeben, ist die Frage "welches Maß?" für Sie meist schon beantwortet.
## Exakt vs. ungefähr: der ANN-Trade-off
| | Exakt (kNN) | Ungefähr (ANN) |
| --- | --- | --- |
| Vergleicht mit | Jedem Vektor | Einer klugen Teilmenge |
| Recall | 100 % | ~95–99 %, einstellbar |
| Geschwindigkeit | Linear – O(n) | Nahezu logarithmisch |
| Brauchbar bis | ~1 Mio. Vektoren | Zig Millionen und mehr |
| Kosten | CPU pro Abfrage | RAM für den Graphen |
Die exakte Suche prüft die Anfrage gegen jeden gespeicherten Vektor – perfekt, und bis etwa eine Million Vektoren auch vollkommen ausreichend. Darüber hinaus baut **[HNSW](https://arxiv.org/abs/1603.09320)** – der vorherrschende ungefähre Index – einen geschichteten Nachbarschaftsgraphen (dünn besetzte obere Schichten für weite Sprünge, eine dichte unterste Schicht, die alles enthält) und steigt gierig von grob nach fein ab, wobei er die meisten Vergleiche überspringt. Er ist ein [semantischer Verwandter des B-Baums](/glossary/de/datenbankindex/): Wo ein B-Baum "gleich" und "kleiner als" indiziert, indiziert ein ANN-Index "ähnlich zu". Der ehrliche Vorbehalt, den Anbieter gern abmildern: ANN kann den wahren nächsten Nachbarn *verfehlen*, seine Stellschrauben wägen Recall gegen Geschwindigkeit und Speicher ab, und der Graph liegt im RAM – weshalb die Dimensionierung einer Vektordatenbank in Wahrheit ein Gespräch über Arbeitsspeicher ist.
## Vektorindex vs. Vektordatenbank
Eine Unterscheidung, die der Begriffsbrei verdeckt: Eine In-Memory-**Indexbibliothek** (wie FAISS) berechnet nächste Nachbarn, aber sie speichert nicht dauerhaft, aktualisiert nicht und filtert nicht – nach einem Neustart wird neu indiziert, und eine `WHERE`-Klausel gibt es nicht. Eine **Vektordatenbank** umhüllt den Index mit Dauerhaftigkeit, inkrementellen Aktualisierungen und Filterung nach Metadaten. Genau diese Lücke erklärt, warum "nimm einfach eine Bibliothek" in Produktion scheitert – und warum *Ihre vorhandene Datenbank mit einem Vektorindex* oft die richtige Antwort ist: Sie bringt die Dauerhaftigkeit, die Transaktionen und die Berechtigungen bereits mit, die der Bibliothek fehlen.
## Brauchen Sie wirklich eine dedizierte Vektordatenbank?
Die neutrale Antwort, die Anbieterseiten nicht geben können. Eine Allzweckdatenbank mit Vektorunterstützung – Postgres über [pgvector](https://github.com/pgvector/pgvector), [die HNSW-Vektorindizes von MongoDB](https://www.mongodb.com/docs/atlas/atlas-vector-search/vector-search-overview/) über Array-Felder – bedient bequem **rund bis zu 1 Mio. Vektoren pro Knoten**, direkt neben Ihren Anwendungsdaten und deren [Berechtigungen](/glossary/de/zugriffskontrolllisten-acl/). Eine spezialisierte Engine verdient ihre Betriebskosten und ihre *Synchronisationssteuer für zwei Systeme* (den Vektorspeicher mit der führenden Datenbank konsistent zu halten) erst in wirklich großem Maßstab: bei zig Millionen Vektoren, sehr hohen Abfrageraten oder hohem Recall *unter* starker Filterung. Unterhalb von etwa einer Million Vektoren kostet ein spezialisierter Speicher meist mehr an Klebecode, als er an Leistung zurückgibt – die Rechnung, die die meisten "Sie brauchen eine Vektordatenbank"-Seiten strukturell nicht aufmachen können, weil sie selbst die Vektordatenbank sind.
## Filterung nach Metadaten ist die Sicherheitsgrenze
Vektorähnlichkeit ordnet nach Bedeutung und weiß *nichts* darüber, wer was lesen darf – die produktive Abfrage lautet deshalb nie "die zehn nächsten Nachbarn", sondern "die zehn nächsten Nachbarn, **die dieser Benutzer sehen darf**". Wer die Reihenfolge vertauscht, hat keinen Relevanzfehler, sondern ein Datenleck: **Vorgelagertes Filtern** engt die Kandidaten *vor* der ANN-Suche auf die erlaubte Menge ein (richtig); **nachgelagertes Filtern** kürzt danach, verrät damit die Existenz verbotener Elemente und liefert stillschweigend weniger als *k*. Wenn der Filter aus [ACLs](/glossary/de/zugriffskontrolllisten-acl/) besteht, ist vorgelagertes Filtern der Unterschied zwischen einer semantischen Suche und einem Sicherheitsvorfall – dieselbe Lektion, die [RAG](/glossary/de/rag/) auf die harte Tour lernt. Embeddings in der Datenbank zu speichern, die Ihre Berechtigungen ohnehin durchsetzt, ist der Weg, auf dem dieser Filter gratis dazukommt.
## Embeddings in echtem Code
**JavaScript:**
```javascript
// JavaScript — Cloud Code (cloud/main.js)
// Embeddings live as a field next to the data they describe
Parse.Cloud.beforeSave('Doc', async (req) => {
if (req.object.dirty('text')) {
// generate server-side; embedding API key stays on the server
req.object.set('embedding', await embed(req.object.get('text')));
req.object.set('embedModel', 'text-embed-v3'); // version it — models differ
}
});
// Similarity search, ACL-filtered: "nearest neighbors this user MAY see"
Parse.Cloud.define('semanticSearch', async (req) => {
const qVec = await embed(req.params.q);
return vectorSearch('Doc', qVec, { limit: 10, aclUser: req.user });
// The pre-filter is the security boundary, not a relevance tweak.
});
```
**Flutter:**
```dart
// Flutter / Dart — Back4app Flutter SDK
// The client searches by meaning — the vector math is server-side
final results = await ParseCloudFunction('semanticSearch')
.execute(parameters: {'q': 'how do refunds work?'});
for (final doc in results.result) print(doc['title']);
// "refund policy" matches "money back" though they share no keywords —
// because their embeddings are near each other. Filtered to your ACL.
```
**Swift:**
```swift
// iOS / Swift — Back4app Swift SDK
// The client searches by meaning — the vector math is server-side
let results: [[String: Any]] = try await Cloud.run(
name: "semanticSearch",
parameters: ["q": "how do refunds work?"])
for doc in results { print(doc["title"] ?? "") }
// "refund policy" matches "money back" though they share no keywords —
// because their embeddings are near each other. Filtered to your ACL.
```
**Kotlin:**
```kotlin
// Android / Kotlin — Back4app Android SDK
// The client searches by meaning — the vector math is server-side
val params = mapOf("q" to "how do refunds work?")
val results = ParseCloud.callFunction>>(
"semanticSearch", params)
results.forEach { println(it["title"]) }
// "refund policy" matches "money back" though they share no keywords —
// because their embeddings are near each other. Filtered to your ACL.
```
Beachten Sie das Feld `embedModel`: Vektoren aus verschiedenen Modellen – oder aus verschiedenen *Versionen* eines Modells – sind nicht vergleichbar, ein Wechsel des Einbettungsmodells bedeutet also, das gesamte Korpus neu einzubetten. Speichern Sie den Modellnamen bei den Vektoren, sonst macht ein stilles Upgrade aus Ihrem Index Rauschen.
## Typische Anwendungsfälle
- **Semantische Suche** – "Geld zurück" findet "Erstattungsrichtlinie", obwohl sie kein Stichwort teilen.
- **[Retrieval für RAG](/glossary/de/rag/)** – die Chunks holen, die die Antwort eines LLM verankern.
- **Empfehlungen** – Elemente, die im Embedding-Raum nahe an der Historie eines Benutzers liegen.
- **Deduplizierung und Clustering** – nahezu identische Inhalte als nahezu identische Vektoren.
- **Anomalie- und Betrugserkennung** – Ausreißer sind Vektoren fern von jedem normalen Beispiel.
## Wo sollten Ihre Vektoren liegen? Eine Entscheidungsmatrix
| Situation | Greifen Sie zu |
| --- | --- |
| Korpus im Anwendungsmaßstab (< ~1 Mio. Vektoren) | Dem Vektorindex Ihrer Datenbank – neben den Daten |
| Vektoren müssen Benutzerberechtigungen achten | Dort, wo die [ACLs](/glossary/de/zugriffskontrolllisten-acl/) ohnehin sind |
| Zig Millionen Vektoren, hohe QPS | Einer dedizierten Vektor-Engine |
| Exakte Begriffe *und* Bedeutung zählen beide | Hybrider Suche mit Rangfusion |
| Ein schneller Prototyp | pgvector oder einem eingebetteten Speicher – nicht überbauen |
| Ein Prozess, keine Persistenz nötig | Einer Indexbibliothek (FAISS) – mit ihren Grenzen leben |
## Grenzen und Trade-offs
- **Embeddings kodieren das Weltbild des Modells.** Verzerrungen, blinde Flecken und der Trainings-Stichtag fahren mit; die Geometrie ist nur so gut wie das Modell, das sie gezeichnet hat.
- **ANN ist absichtlich ungefähr.** Stellen Sie den Recall auf Ihren Einsatz ein; "findet meistens den besten Treffer" ist der Handel, den Sie für die Geschwindigkeit eingegangen sind.
- **Die Modellversion ist ein Schema.** Ein großes Korpus nach einem Modellwechsel neu einzubetten ist eine echte Migration, kein Umlegen eines Schalters.
- **Der Arbeitsspeicher ist die Decke.** HNSW-Graphen liegen im RAM; Vektorgrenzen pro Knoten sind Speichergrenzen unter anderem Namen.
- **Ähnlichkeit ist nicht Relevanz.** Nachbarschaft im Vektorraum ist ein starkes Signal, keine Garantie – hybride Suche und Reranking gibt es, weil reine Vektorsuche exakte Begriffe verfehlt.
## Vektoren mit Back4app
Back4app ist eine Open-Source-Plattform für Backend as a Service (BaaS), die eine verwaltete Datenbank, automatisch generierte REST- und GraphQL-APIs, Authentifizierung, Dateispeicher und Serverless-Funktionen mit Cloud Code kombiniert. Weil sie auf MongoDB läuft, ist die Speicherung genau die, die dieser Artikel empfiehlt: Ein Embedding ist ein **Array-Feld auf dem Objekt, das es beschreibt** – das Dokument und sein Vektor im selben Datensatz – mit HNSW-Vektorindizierung als tatsächlichem Mechanismus darunter. Die Folgen reihen sich sauber aneinander: Die [ACLs](/glossary/de/zugriffskontrolllisten-acl/), die ohnehin jede Abfrage regeln, werden *gratis* zum vorgelagerten Filter der Ähnlichkeitssuche, sodass das Retrieval keine Berechtigungsgrenze überschreiten kann; Embeddings entstehen in einem [Cloud-Code](/glossary/de/cloud-code-serverless-funktionen/)-Trigger `beforeSave`, der ein Einbettungsmodell mit [serverseitig gehaltenem Schlüssel](/glossary/de/api-schluessel-sicherheit/) aufruft; und es gibt keinen separaten Vektordienst, den Sie synchron halten, absichern und bezahlen müssten. Für die Korpora im Anwendungsmaßstab, die die meisten Produkte tatsächlich haben, ist "Vektordatenbank" kein System, das Sie einführen – es ist ein Feld, das Sie hinzufügen.