Was sind Embeddings? Einfach erklärt mit Beispielen: wie KI Bedeutung in Zahlen fasst

Was sind Embeddings? Einfach erklärt mit Beispielen: wie KI Bedeutung in Zahlen fasst

Von Christoph Kind · · inhaltlich geprüft am

Ein Embedding ist eine Liste von Zahlen – ein Vektor –, die die Bedeutung eines Wortes, Satzes oder Dokuments so abbildet, dass inhaltlich ähnliche Texte ähnliche Zahlen bekommen. Der Begriff kommt vom englischen „to embed", einbetten: Der Text wird in einen mathematischen Raum eingebettet, in dem Bedeutungsnähe zu räumlicher Nähe wird. Erzeugt werden Embeddings von einem Embedding-Modell, und sie sind die Grundlage für semantische Suche, RAG und Empfehlungssysteme.

Artikel-Übersicht

Embeddings sind die unsichtbare Magie hinter fast jeder modernen KI-Anwendung. Wenn du jemals eine semantische Suche gebaut, mit einem RAG-System experimentiert oder dich gefragt hast, wie ChatGPT eigentlich „Bedeutung" versteht, dann sind Embeddings die Antwort. In diesem Beitrag tauchen wir gemeinsam ein in die Welt der Vektoren – und zwar so, dass du am Ende nicht nur verstehst, was Embeddings sind, sondern auch warum sie funktionieren und wie du sie selbst einsetzt.

Wir starten bei den Grundlagen (Was ist überhaupt ein Vektor, was heißt Embedding auf Deutsch, was macht ein Embedding-Modell?), schauen uns an einer Beispieltabelle an, welche Wörter und Sätze nah beieinander liegen, und arbeiten uns über Ähnlichkeitsmaße und die Entstehung von Embeddings bis zu den Einsatzfeldern in der KI vor. Unterwegs gibt es Python-Code zum Mitmachen, Tabellen zur Orientierung und ehrliche Praxistipps zu Kosten.

Welches Embedding-Modell für deutsche Texte am besten passt, behandelt ein eigener Artikel: der Vergleich deutscher Embedding-Modelle. Wo die Vektoren gespeichert werden, steht im Vektordatenbanken-Vergleich, und wie alles in einer Anwendung zusammenspielt, in RAG selbst bauen.

Einleitung: Das Problem mit der Bedeutung

Computer sind grandios im Rechnen, aber katastrophal schlecht darin, Sprache zu verstehen. Für eine klassische Maschine ist das Wort „Hund" einfach eine Aneinanderreihung von Zeichen: H, u, n, d. Dass „Hund" und „Welpe" inhaltlich eng verwandt sind, während „Hund" und „Hangar" trotz ähnlicher Buchstaben rein gar nichts miteinander zu tun haben, ist für einen reinen Zeichenvergleich völlig unsichtbar.

Genau hier kommen Embeddings ins Spiel. Die Grundidee ist verblüffend elegant: Wir übersetzen Wörter, Sätze oder ganze Dokumente in Listen von Zahlen – sogenannte Vektoren – und zwar so, dass Bedeutungsnähe zu räumlicher Nähe wird. Dinge, die inhaltlich ähnlich sind, bekommen ähnliche Zahlenlisten. Dinge, die nichts miteinander zu tun haben, landen weit voneinander entfernt.

Stell dir eine riesige Landkarte vor, auf der nicht Städte, sondern Begriffe verzeichnet sind. „Hund", „Katze" und „Hamster" liegen dicht beieinander in der Region „Haustiere". „Berlin", „München" und „Hamburg" bilden ein eigenes Cluster. Und „Demokratie" liegt ganz woanders. Embeddings sind genau diese Landkarte – nur dass sie nicht zwei Dimensionen hat, sondern Hunderte oder Tausende. Lass uns Schritt für Schritt herausfinden, wie das funktioniert.

Was ist ein Embedding? Bedeutung als Zahlenliste

Ein Embedding ist ein Vektor aus Kommazahlen, der die Bedeutung eines Textstücks repräsentiert – ähnliche Bedeutung ergibt ähnliche Vektoren. Ein Embedding ist also nichts anderes als ein Vektor – eine geordnete Liste von Kommazahlen (Floats) –, der die Bedeutung eines Textstücks repräsentiert. Ein einfaches Beispiel mit nur drei Dimensionen könnte so aussehen:

hund   = [0.91, -0.12,  0.44]
welpe  = [0.88, -0.09,  0.41]
hangar = [-0.32, 0.77, -0.65]

Du siehst sofort: Die Zahlen von „hund" und „welpe" liegen nah beieinander, während „hangar" deutlich abweicht. Genau das ist das Ziel. Die einzelnen Zahlen nennt man Komponenten oder Features des Vektors. In echten Embedding-Modellen sind diese Komponenten allerdings nicht von Menschen interpretierbar – niemand kann sagen „Dimension 47 steht für ‚Tierhaftigkeit'". Die Bedeutung steckt im Gesamtmuster aller Zahlen, nicht in einzelnen Werten.

Ein wichtiger Punkt: Embeddings sind dicht (engl. dense). Im Gegensatz zu älteren Verfahren wie One-Hot-Encoding oder TF-IDF, bei denen ein Vektor fast nur aus Nullen besteht und Zehntausende Einträge lang sein kann, ist ein Embedding kompakt und jede Dimension trägt Information. Diese Dichte ist der Grund, warum Embeddings so leistungsfähig und gleichzeitig speichereffizient sind.

Was bedeutet Embedding auf Deutsch?

„Embedding" heißt auf Deutsch „Einbettung", das Verb „to embed" bedeutet „einbetten". Gemeint ist, dass ein Wort oder Text in einen Zahlenraum eingebettet wird – er bekommt dort einen festen Platz, und dieser Platz drückt seine Bedeutung aus.

Der Begriff stammt aus der Mathematik, wo eine Einbettung eine Struktur in eine andere überträgt, ohne ihre wesentlichen Beziehungen zu zerstören. Genau das leistet ein Embedding in der KI: Die Beziehungen zwischen Wörtern und Sätzen – was ähnlich ist, was nichts miteinander zu tun hat – bleiben im Zahlenraum erhalten.

Im deutschsprachigen Fachalltag hat sich die englische Form durchgesetzt. Du liest „Embedding", „Embeddings" oder eingedeutscht „embedden" („die Dokumente embedden" = ihre Vektoren berechnen); „Worteinbettung" oder „Vektoreinbettung" findest du vor allem in Lehrbüchern und Übersetzungen. Gelegentlich taucht die Falschschreibung „Embeding" auf – gemeint ist dasselbe.

Was ist ein Embedding-Modell?

Ein Embedding-Modell ist ein neuronales Netz, das Text (oder Bilder, Audio) entgegennimmt und als Ergebnis genau einen Vektor fester Länge zurückgibt. Es erzeugt keinen Text wie ein Chatbot, sondern nur diese Zahlenliste. Ein Embedding-Modell beantwortet also nicht die Frage „Was soll ich antworten?", sondern „Wo im Bedeutungsraum liegt dieser Text?".

Drei Eigenschaften unterscheiden Embedding-Modelle voneinander:

  • Dimensionen: wie lang der Vektor ist, typisch 384 bis 4096 Zahlen.
  • Maximale Eingabelänge: wie viele Token das Modell auf einmal einbetten kann, von 512 bis zu mehreren Zehntausend.
  • Sprachen und Datenart: rein englisch, mehrsprachig oder multimodal (Text und Bild im selben Raum).

Wichtig für die Praxis: Ein Embedding-Modell legt den Raum fest. Vektoren aus verschiedenen Modellen lassen sich nicht vergleichen. Wer das Modell wechselt, muss den gesamten Bestand neu berechnen – deshalb lohnt sich die Auswahl am Anfang. Wie die Modelle intern arbeiten, steht weiter unten im Abschnitt zu Encoder-Modellen; welche Modelle es gibt, in der knappen Übersicht am Ende und ausführlich im Vergleich deutscher Embedding-Modelle.

Beispiel: Wie ähnlich sind sich Wörter und Sätze?

Embeddings messen Bedeutungsnähe, nicht Buchstabengleichheit. Die folgende Tabelle ist ein illustratives Beispiel: Die Einstufung beschreibt, was ein gutes mehrsprachiges Embedding-Modell typischerweise liefert, sie ist keine Messung. Echte Werte hängen vom Modell ab – und manche Modelle, etwa die im Praxisteil genutzte E5-Familie, vergeben selbst für unverwandte Sätze noch Kosinus-Werte um 0,7, sodass nur der Vergleich innerhalb eines Modells aussagekräftig ist.

Text A Text B Ähnlichkeit (illustrativ) Warum
„Hund" „Welpe" sehr hoch fast dieselbe Bedeutung, nur das Alter unterscheidet sich
„Hund" „Katze" hoch beide Haustiere, tauchen in ähnlichen Zusammenhängen auf
„Hund" „Hangar" niedrig ähnliche Buchstaben, aber keine inhaltliche Verbindung
„Wie kündige ich mein Abo?" „Vertragsbeendigung in den Kontoeinstellungen" hoch dieselbe Absicht, obwohl kein Wort übereinstimmt
„Ich sitze auf der Bank im Park." „Ich hebe Geld bei der Bank ab." niedrig bis mittel gleiches Wort, verschiedene Bedeutung – kontextbezogene Modelle trennen das
„Wie spät ist es?" „What time is it?" hoch gleiche Bedeutung in zwei Sprachen – nur bei mehrsprachigen Modellen
„Der Film war großartig." „Der Film war furchtbar." mittel bis hoch gleiches Thema, entgegengesetzte Wertung – Embeddings erfassen das Thema oft stärker als die Stimmung

Die letzte Zeile ist die lehrreichste. Embeddings sagen, worüber ein Text spricht, nicht unbedingt, was er darüber sagt. Für eine Suche ist das genau richtig; für eine Stimmungsanalyse braucht es zusätzlich einen Klassifikator, der auf den Vektoren aufsetzt. Wie du die Werte für eigene Sätze selbst ausrechnest, zeigt der Praxisteil weiter unten.

Der Vektorraum und semantische Nähe

Wenn jedes Embedding ein Punkt in einem Raum ist, dann spannen alle Embeddings zusammen einen Vektorraum auf. Bei einem 1024-dimensionalen Modell ist das ein 1024-dimensionaler Raum – unmöglich für uns vorzustellen, aber mathematisch völlig handhabbar.

Das Faszinierende: In diesem Raum bekommen Richtungen eine Bedeutung. Ein berühmtes frühes Beispiel aus der Word2Vec-Ära ist die Vektor-Arithmetik:

vektor("König") - vektor("Mann") + vektor("Frau") ≈ vektor("Königin")

Die Beziehung „männlich → weiblich" entspricht also einer bestimmten Richtung im Raum, die man von einem Begriff auf einen anderen übertragen kann. Moderne Satz-Embeddings sind komplexer und solche sauberen Analogien funktionieren nicht mehr so plakativ, aber das Grundprinzip bleibt: Geometrische Beziehungen kodieren semantische Beziehungen.

„Semantische Nähe" bedeutet also schlicht: Zwei Texte, deren Embeddings im Vektorraum nahe beieinander liegen, sind sich inhaltlich ähnlich. Und „nah" lässt sich präzise messen – womit wir beim nächsten Thema sind.

Ähnlichkeitsmaße: Wie man Nähe misst

Wie nah sind sich zwei Vektoren? Dafür gibt es mehrere Maße, und die Wahl ist nicht egal. Die drei wichtigsten:

1. Kosinus-Ähnlichkeit (Cosine Similarity) – der Klassiker. Sie misst den Winkel zwischen zwei Vektoren, ignoriert aber deren Länge. Das Ergebnis liegt zwischen -1 (genau entgegengesetzt) und +1 (identische Richtung), wobei 0 „nichts miteinander zu tun" bedeutet. Weil es nur auf die Richtung ankommt, ist Kosinus-Ähnlichkeit robust gegenüber unterschiedlichen Textlängen – der Standard bei Text-Embeddings.

2. Dot-Product (Skalarprodukt) – multipliziert die Vektoren komponentenweise und summiert auf. Das Dot-Product berücksichtigt sowohl Winkel als auch Länge. Bei normalisierten Vektoren (Länge = 1) ist das Dot-Product mathematisch identisch zur Kosinus-Ähnlichkeit – und schneller zu berechnen. Deshalb arbeiten viele Vektordatenbanken intern mit dem Dot-Product auf normalisierten Vektoren.

3. Euklidische Distanz (L2) – die „Luftlinie" zwischen zwei Punkten, also das, was wir intuitiv unter Abstand verstehen. Je kleiner, desto ähnlicher. Sie wird seltener für Text verwendet, ist aber bei manchen Clustering-Verfahren Standard.

Hier die drei Maße im Überblick:

Maß Wertebereich Berücksichtigt Länge? Typischer Einsatz
Kosinus-Ähnlichkeit -1 bis +1 (höher = ähnlicher) Nein Text-Embeddings, semantische Suche
Dot-Product -∞ bis +∞ (höher = ähnlicher) Ja Vektor-DBs (auf normalisierten Vektoren)
Euklidische Distanz (L2) 0 bis +∞ (kleiner = ähnlicher) Ja Clustering, Bild-Embeddings

Ein wichtiger Merksatz: Sind alle Vektoren normalisiert, liefern Kosinus, Dot-Product und (in der Rangfolge) auch die euklidische Distanz dasselbe Ergebnis. Mehr dazu im Abschnitt zur Normalisierung.

Wie Embeddings entstehen: Encoder-Modelle

Woher kommen diese magischen Zahlen? Sie werden von Encoder-Modellen erzeugt – neuronalen Netzen, die darauf trainiert wurden, Text in sinnvolle Vektoren zu übersetzen. Die meisten modernen Embedding-Modelle basieren auf der Transformer-Architektur, genauer auf dem Encoder-Teil (Verwandte des BERT-Modells) oder auf umfunktionierten Decoder-LLMs.

Der grobe Ablauf:

  1. Tokenisierung: Der Text wird in Tokens zerlegt (Wortteile, etwa „un", „glaub", „lich").
  2. Kontextualisierung: Der Transformer verarbeitet alle Tokens gleichzeitig und reichert jedes Token mit Kontext aus dem gesamten Satz an. „Bank" im Satz „Ich sitze auf der Bank" bekommt einen anderen Vektor als in „Ich gehe zur Bank".
  3. Pooling: Aus den vielen Token-Vektoren wird ein Vektor für den ganzen Text gebildet – meist durch Mittelwertbildung (Mean Pooling) oder über ein spezielles [CLS]-Token.

Das Entscheidende ist das Training. Modelle lernen über kontrastives Lernen: Man zeigt ihnen Paare von Texten, die zusammengehören (z. B. eine Frage und ihre Antwort), und Paare, die nicht zusammengehören. Das Modell lernt, die Embeddings zusammengehörender Texte näher zueinander zu schieben und die anderen auseinander. Über Millionen solcher Paare entsteht ein Vektorraum, in dem Bedeutung tatsächlich Geometrie wird.

Dimensionalität: Was die Zahl der Dimensionen bedeutet

Embedding-Modelle erzeugen Vektoren mit einer festen Anzahl von Dimensionen – typisch sind heute 384, 768, 1024, 1536 oder 3072. Doch was bedeutet das praktisch?

Mehr Dimensionen = mehr Kapazität für Nuancen. Ein 3072-dimensionaler Vektor kann feinere Bedeutungsunterschiede erfassen als ein 384-dimensionaler. Aber: Mehr ist nicht automatisch besser. Höhere Dimensionalität bedeutet auch:

  • Mehr Speicher: Ein Vektor mit 3072 Float32-Werten belegt rund 12 KB. Bei einer Million Dokumenten sind das allein 12 GB nur für die Vektoren.
  • Langsamere Suche: Jede Ähnlichkeitsberechnung muss mehr Zahlen verrechnen.
  • Höhere Kosten: In der Vektordatenbank und beim Embedding selbst.

Ein cleverer Trick moderner Modelle ist Matryoshka Representation Learning (MRL) – benannt nach den russischen Schachtelpuppen. Solche Modelle werden so trainiert, dass die ersten Dimensionen des Vektors die wichtigste Information enthalten. Du kannst den Vektor einfach abschneiden (z. B. von 1024 auf 256 Dimensionen) und verlierst nur wenig Qualität, sparst aber massiv Speicher. OpenAIs text-embedding-3-Modelle, Nomic, Jina v3 und Qwen3-Embedding unterstützen das.

# OpenAI: Embedding mit reduzierter Dimension anfordern
from openai import OpenAI
client = OpenAI()

resp = client.embeddings.create(
    model="text-embedding-3-large",
    input="Embeddings sind großartig",
    dimensions=256  # statt der vollen 3072 Dimensionen
)
print(len(resp.data[0].embedding))  # -> 256

Token-, Satz- und Dokument-Embeddings

Nicht jedes Embedding ist gleich – es kommt darauf an, welche Texteinheit du kodierst:

Token-Embeddings repräsentieren einzelne Tokens (Wortteile) im Kontext. Sie sind die Bausteine, die innerhalb eines Transformers entstehen. Für sich allein nutzt du sie selten direkt – sie sind eher das Zwischenprodukt.

Satz- bzw. Text-Embeddings (Sentence Embeddings) kodieren einen kompletten Satz oder kurzen Absatz in einen Vektor. Das ist der Typ, den du für semantische Suche, Klassifikation und die meisten Anwendungen brauchst. Die berühmte sentence-transformers-Bibliothek hat diesen Ansatz populär gemacht.

Dokument-Embeddings fassen längere Texte zusammen. Hier gibt es eine Tücke: Quetschst du ein 50-seitiges PDF in einen einzigen Vektor, verwässert die Bedeutung – der Vektor wird zum unscharfen Mittelwert von allem. Deshalb teilt man in der Praxis lange Dokumente in Chunks (etwa Absätze von 200–500 Tokens) auf und embeddet jeden Chunk einzeln. Genau das ist die Grundlage von RAG.

Faustregel: Embedde die Granularität, in der du später suchen willst. Suchst du nach passenden Absätzen, embedde Absätze. Suchst du nach ähnlichen Produkten, embedde Produktbeschreibungen.

Embeddings in der KI: wofür man sie braucht

In der KI sind Embeddings das Bindeglied zwischen Sprache und Rechnung: Sie machen Bedeutung vergleichbar, sortierbar und durchsuchbar. Sie stecken an zwei Stellen. Erstens innerhalb jedes Sprachmodells: Bevor ein LLM wie GPT, Claude oder Gemini einen Text verarbeitet, wandelt seine erste Schicht jedes Token in einen Vektor um – mehr dazu in der Transformer-Architektur. Zweitens neben dem Sprachmodell: Eigene Embedding-Modelle erzeugen die Vektoren, mit denen Anwendungen Dokumente finden, gruppieren und vergleichen.

Für die zweite Rolle brauchst du sie in der Praxis. Die wichtigsten Einsatzgebiete:

  • Semantische Suche: Statt nach exakten Stichwörtern zu suchen, findest du inhaltlich passende Treffer. Die Suchanfrage „Wie kündige ich mein Abo?" findet auch ein Dokument mit dem Titel „Vertragsbeendigung" – obwohl kein einziges Wort übereinstimmt.
  • RAG (Retrieval-Augmented Generation): Das Herzstück moderner KI-Assistenten. Bevor das LLM antwortet, werden per Embedding-Suche die relevantesten Wissensschnipsel aus deiner Datenbasis geholt und in den Prompt gepackt. So antwortet das Modell faktenbasiert statt halluziniert.
  • Clustering: Ähnliche Dokumente automatisch gruppieren – etwa Tausende Kundenfeedbacks in Themencluster sortieren, ohne vorher Kategorien festzulegen.
  • Klassifikation: Texte automatisch Kategorien zuordnen (Spam/kein Spam, Stimmungsanalyse, Ticket-Routing). Embeddings als Eingabe für einen schlanken Klassifikator sind oft erstaunlich treffsicher.
  • Empfehlungssysteme: „Ähnliche Artikel", „Das könnte dir auch gefallen" – Produkte oder Inhalte mit nahen Embeddings werden empfohlen.
  • Deduplizierung & Ähnlichkeitsabgleich: Duplikate oder Paraphrasen finden, etwa bei der Datenbereinigung.

Praxis: Embeddings erzeugen und Kosinus-Ähnlichkeit berechnen

Genug Theorie – lass uns Code schreiben! Wir starten mit einem komplett lokalen Beispiel über sentence-transformers, das ohne API-Kosten läuft.

# pip install sentence-transformers numpy
from sentence_transformers import SentenceTransformer
import numpy as np

# Ein kompaktes, mehrsprachiges Modell (gut für Deutsch)
model = SentenceTransformer("intfloat/multilingual-e5-base")

saetze = [
    "Der Hund spielt im Garten.",
    "Ein Welpe tollt auf der Wiese herum.",
    "Die Aktienkurse sind heute gefallen.",
]

# E5-Modelle erwarten ein Präfix - wichtig für gute Ergebnisse!
embeddings = model.encode(
    ["query: " + s for s in saetze],
    normalize_embeddings=True  # direkt normalisieren
)

print(embeddings.shape)  # (3, 768) -> 3 Vektoren, je 768 Dimensionen

def kosinus(a, b):
    # Bei normalisierten Vektoren = einfaches Dot-Product
    return float(np.dot(a, b))

print("Hund vs. Welpe:  ", round(kosinus(embeddings[0], embeddings[1]), 3))
print("Hund vs. Aktien: ", round(kosinus(embeddings[0], embeddings[2]), 3))

Die Ausgabe zeigt eindrücklich, was Embeddings leisten: Die beiden Hunde-Sätze haben eine hohe Ähnlichkeit (typisch um 0,85–0,90), während der Aktien-Satz deutlich abfällt (eher um 0,70 oder darunter) – obwohl kein einziges Wort exakt übereinstimmt. Genau das ist semantische Nähe in Aktion. ✅

Und so sieht es mit der OpenAI-API aus:

# pip install openai numpy
from openai import OpenAI
import numpy as np

client = OpenAI()  # API-Key über Umgebungsvariable OPENAI_API_KEY

def embed(texte, model="text-embedding-3-small"):
    resp = client.embeddings.create(model=model, input=texte)
    return [np.array(d.embedding) for d in resp.data]

vektoren = embed(["Der Hund spielt", "Ein Welpe tollt", "Aktienkurse fallen"])
# OpenAI liefert bereits normalisierte Vektoren -> Dot-Product = Kosinus
print(round(float(np.dot(vektoren[0], vektoren[1])), 3))

Praxis: Eine Mini-Semantik-Suche bauen

Jetzt bauen wir eine kleine, aber vollständige semantische Suche. Wir embedden eine kleine Wissensbasis, dann eine Suchanfrage, und holen die ähnlichsten Treffer.

from sentence_transformers import SentenceTransformer
import numpy as np

model = SentenceTransformer("intfloat/multilingual-e5-base")

# Unsere "Datenbank"
dokumente = [
    "So kündigst du dein Abonnement in den Kontoeinstellungen.",
    "Die Lieferung erfolgt innerhalb von 3 bis 5 Werktagen.",
    "Passwort vergessen? Setze es über den Link in der E-Mail zurück.",
    "Rückgaben sind innerhalb von 30 Tagen kostenlos möglich.",
]

# E5: Dokumente mit "passage:" praefixen, Anfragen mit "query:"
doc_emb = model.encode(["passage: " + d for d in dokumente],
                       normalize_embeddings=True)

def suche(frage, top_k=2):
    q = model.encode("query: " + frage, normalize_embeddings=True)
    scores = doc_emb @ q          # Dot-Product gegen alle Dokumente
    rang = np.argsort(scores)[::-1]  # absteigend sortieren
    return [(dokumente[i], round(float(scores[i]), 3)) for i in rang[:top_k]]

for treffer, score in suche("Wie beende ich meinen Vertrag?"):
    print(f"{score}  {treffer}")

Obwohl die Anfrage „Wie beende ich meinen Vertrag?" lautet und im Dokument nur von „kündigen" und „Abonnement" die Rede ist, landet der richtige Treffer ganz oben. Das ist die Superkraft semantischer Suche: Sie versteht Bedeutung, nicht nur Buchstaben. Für echte Datenmengen würdest du doc_emb in einer Vektordatenbank (z. B. Qdrant, Weaviate, pgvector, Pinecone) speichern, die die Ähnlichkeitssuche mit ANN-Algorithmen blitzschnell skaliert.

Normalisierung: Der oft übersehene Schritt

Normalisieren heißt, einen Vektor auf die Länge 1 zu skalieren (L2-Normalisierung), ohne seine Richtung zu ändern. Klingt nach Detail, ist aber praxisrelevant:

import numpy as np

def normalisieren(v):
    return v / np.linalg.norm(v)

Warum lohnt sich das?

  • Konsistenz: Auf normalisierten Vektoren ist das schnelle Dot-Product identisch zur Kosinus-Ähnlichkeit. Du kannst also überall das günstigere Dot-Product nutzen.
  • Performance: Viele Vektordatenbanken sind mit normalisierten Vektoren und Dot-Product-Metrik am schnellsten.
  • Vergleichbarkeit: Scores liegen sauber im Bereich -1 bis +1, was Schwellenwerte (Thresholds) leichter wählbar macht.

Achtung: Manche Modelle (OpenAI, Cohere) liefern bereits normalisierte Vektoren – dann musst du nichts tun. Bei lokalen Modellen setzt du normalize_embeddings=True. Wichtig: Embeddings unterschiedlicher Modelle sind nie kompatibel. Du kannst einen OpenAI-Vektor nicht mit einem BGE-Vektor vergleichen – sie leben in völlig verschiedenen Räumen. Wenn du das Modell wechselst, musst du alles neu embedden.

Embedding-Modelle: eine knappe Übersicht

Grob teilt sich das Feld in kommerzielle API-Modelle (bequem, keine Infrastruktur) und offene Modelle (selbst gehostet, datenschutzfreundlich, kostenlos im Betrieb). Für den Einstieg reichen diese Vertreter, die du in den Codebeispielen oben schon gesehen hast oder die als Standard gelten:

Modell Typ Dimensionen Wofür
OpenAI text-embedding-3-small API 1536 (kürzbar) günstiger, pragmatischer Start
OpenAI text-embedding-3-large API 3072 (kürzbar) höhere Qualität per API
multilingual-e5-base / -large offen 768 / 1024 bewährt für Deutsch, läuft auf bescheidener Hardware
BGE-M3 (BAAI) offen 1024 Dense und Sparse aus einem Modell, 100+ Sprachen
Qwen3-Embedding (0.6B bis 8B) offen 1024 bis 4096 (kürzbar) starke mehrsprachige Qualität zum Selbsthosten

Für deutsche Texte gilt eine Grundregel: Achte auf „multilingual" im Modellnamen – rein englische Modelle glänzen auf englischen Benchmarks, liefern auf Deutsch aber schwächere Treffer. Welches Modell für deutsche Texte konkret am besten abschneidet, mit Benchmarks, Kosten und Hardwarebedarf, steht im Vergleich deutscher Embedding-Modelle. Hier bleibt es bewusst bei der Übersicht.

MTEB: Der Benchmark als Auswahlhilfe

Der wichtigste Kompass bei der Modellwahl ist das MTEB (Massive Text Embedding Benchmark) und seine Bestenliste auf Hugging Face. MTEB testet Modelle über Dutzende Aufgaben hinweg – Retrieval, Clustering, Klassifikation, semantische Ähnlichkeit (STS) und mehr – in vielen Sprachen. Die Spitze der Liste wechselt regelmäßig; den aktuellen Stand für Deutsch ordnet der Modellvergleich ein.

Aber – und das ist der entscheidende Praxistipp – die Spitze der Bestenliste ist selten die beste Wahl für dich. Drei Gründe:

  1. Aufgaben-Fit: Schau auf die Teildisziplin, die zu deinem Anwendungsfall passt. Für RAG zählt vor allem der Retrieval-Score, nicht der Gesamtdurchschnitt.
  2. Sprache: Nutze die multilinguale oder die deutsche/europäische Teilwertung, nicht die englische Gesamtwertung.
  3. Praktikabilität: Ein 8B-Modell mit 0,5 Punkten Vorsprung bringt dir nichts, wenn es auf deiner Hardware nicht läuft oder die Suche zu langsam macht. Kleinere Modelle wie multilingual-e5-base oder Qwen3-0.6B sind oft die klügere Wahl.

Und immer gilt: Teste auf deinen eigenen Daten. Lege dir ein kleines Set echter Anfragen mit den erwarteten Treffern an und miss die Trefferqualität (z. B. Recall@5). Kein Benchmark der Welt schlägt einen Test mit deinen realen Daten.

Kosten im Blick: API vs. Self-Hosting

Geld und Ressourcen entscheiden in der Praxis oft mehr als der letzte Benchmark-Punkt. Ein ehrlicher Blick auf die Kostenseite (Stand November 2026, laut OpenAI-Preisliste):

Option Preis / Aufwand Wann sinnvoll?
OpenAI text-embedding-3-small 0,02 $ / 1 Mio. Tokens Standard, sehr günstig, kleine bis mittlere Projekte
OpenAI text-embedding-3-large 0,13 $ / 1 Mio. Tokens Höhere Qualität nötig
OpenAI Batch API 50 % Rabatt Große Offline-Jobs ohne Eile
Offene Modelle (self-hosted) „nur" Hardware/Strom Datenschutz, hohe Volumina, volle Kontrolle

Ein Rechenbeispiel: Du willst 100.000 Dokumente à durchschnittlich 500 Tokens embedden – das sind 50 Mio. Tokens. Mit text-embedding-3-small kostet das rund 1 $. Mit text-embedding-3-large etwa 6,50 $. Embeddings sind also überraschend günstig – der Kostentreiber bei API-Modellen ist selten das initiale Embedding, sondern das wiederholte Embedden bei jeder Suchanfrage und das erneute Embedden nach einem Modellwechsel.

Self-Hosting offener Modelle ist ab gewissen Volumina oder bei Datenschutzanforderungen (Stichwort DSGVO, keine Drittland-Übermittlung) attraktiv: Die Modelle sind kostenlos, du zahlst nur Hardware und Strom. Ein Modell wie multilingual-e5-base läuft sogar auf einer CPU passabel, mit GPU richtig flott. Für sensible Daten im deutschsprachigen Raum ist das oft der einzig gangbare Weg.

Wohin mit den Vektoren?

Wie Embeddings im Inneren eines Sprachmodells entstehen — sie sind dort die erste Schicht, bevor die Attention greift —, ordne ich im Überblick zur Transformer-Architektur ein.

Embeddings zu erzeugen ist der erste Schritt; sie zu speichern und durchsuchbar zu machen der zweite. Welches System dafür passt — und ab welcher Größenordnung überhaupt eine spezialisierte Datenbank nötig ist — steht im Vektordatenbanken-Vergleich. Wie beides in einer vollständigen Strecke zusammenspielt, zeigt RAG selbst bauen.

Wer die Einbettung ohne Anbieter berechnen will, findet den lokalen Weg in Ollama: lokale Sprachmodelle betreiben — ein Embedding-Modell belegt dort unter einem Gigabyte und läuft neben dem eigentlichen Sprachmodell mit.

Ein Hinweis, der später teuer wird, wenn man ihn übergeht: Ein Wechsel des Embedding-Modells erzwingt die Neuberechnung des gesamten Bestands. Vektoren verschiedener Modelle liegen in verschiedenen Räumen und lassen sich nicht vergleichen. Das ist die stärkste Bindung im ganzen Aufbau — stärker als die Wahl der Datenbank.

Häufige Fragen

Was sind Embeddings? Embeddings sind Vektoren – Listen von Kommazahlen –, die die Bedeutung von Wörtern, Sätzen oder Dokumenten abbilden. Inhaltlich ähnliche Texte bekommen ähnliche Vektoren, unverwandte liegen weit auseinander. Dadurch kann ein Computer Bedeutung vergleichen, ohne auf gleiche Wörter angewiesen zu sein.

Was ist ein Embedding in der KI? In der KI ist ein Embedding die Zahlendarstellung eines Inhalts, mit der ein Modell rechnen kann. Sprachmodelle wandeln intern jedes Token in ein Embedding um; eigene Embedding-Modelle erzeugen Vektoren für ganze Sätze und Dokumente, etwa für semantische Suche und RAG.

Was bedeutet Embedding auf Deutsch? „Embedding" heißt „Einbettung", vom englischen „to embed" (einbetten). Ein Text wird in einen Zahlenraum eingebettet, in dem seine Bedeutung als Position erscheint. Im deutschen Sprachgebrauch ist die englische Form üblich.

Was ist ein Embedding-Modell? Ein neuronales Netz, das Text oder Bilder entgegennimmt und einen Vektor fester Länge zurückgibt – keinen Text. Bekannte Embedding-Modelle sind OpenAIs text-embedding-3, multilingual-e5, BGE-M3 und Qwen3-Embedding. Vektoren verschiedener Modelle sind nicht miteinander vergleichbar.

Welche Embedding-Modelle gibt es für Deutsch? Gut geeignet sind mehrsprachige Modelle, erkennbar meist an „multilingual" im Namen, etwa multilingual-e5, BGE-M3 oder Qwen3-Embedding, sowie die großen API-Modelle. Einen ausführlichen Vergleich mit Empfehlung je Einsatzfall gibt es im Vergleich deutscher Embedding-Modelle.

Wofür braucht man Embeddings? Für semantische Suche, RAG-Systeme, Clustering, Klassifikation, Empfehlungen und das Finden von Duplikaten. Überall, wo nach Bedeutung statt nach exakten Wörtern gesucht oder sortiert werden soll, sind Embeddings der Grundbaustein.

Was ist der Unterschied zwischen Embedding und Vektordatenbank? Das Embedding ist der Vektor selbst, die Vektordatenbank ist der Speicher, der viele Vektoren schnell nach Ähnlichkeit durchsucht. Welche Datenbank wann passt, steht im Vektordatenbanken-Vergleich.

Zusammenfassung und praktische Tipps

Wir haben eine Menge Boden abgedeckt – fassen wir das Wichtigste zusammen:

  • Embeddings übersetzen Bedeutung in Vektoren. Inhaltliche Ähnlichkeit wird zu räumlicher Nähe im Vektorraum.
  • Embedding heißt Einbettung: Der Text bekommt einen Platz in einem Zahlenraum, der seine Bedeutung ausdrückt.
  • Ein Embedding-Modell legt den Raum fest. Vektoren verschiedener Modelle sind nicht vergleichbar.
  • Kosinus-Ähnlichkeit ist der Standard für Text. Auf normalisierten Vektoren ist sie identisch zum schnelleren Dot-Product.
  • Embeddings entstehen durch Encoder-Modelle (Transformer), trainiert mit kontrastivem Lernen.
  • Dimensionalität ist ein Kompromiss aus Qualität, Speicher und Geschwindigkeit. Matryoshka-Modelle lassen dich Vektoren flexibel kürzen.
  • Für lange Texte gilt: Chunken statt alles in einen Vektor pressen – die Basis von RAG.
  • Anwendungsfälle reichen von semantischer Suche über RAG und Clustering bis zu Empfehlungen.

Konkrete Empfehlungen für deinen Einstieg:

  1. Schneller Prototyp? Nimm text-embedding-3-small (API) oder multilingual-e5-base (lokal).
  2. Deutsche/mehrsprachige Daten? Achte auf „multilingual" im Modellnamen – BGE-M3, multilingual-e5, Qwen3-Embedding.
  3. Normalisiere deine Vektoren und nutze Dot-Product.
  4. Wechselst du das Modell, embedde alles neu – Vektoren sind nicht modellübergreifend kompatibel.
  5. Teste auf deinen echten Daten, nicht nur auf der MTEB-Bestenliste.
  6. Speichere Vektoren in einer Vektordatenbank, sobald es mehr als ein paar Tausend werden.

Mein Rat: Bevor du Modelle vergleichst, schreib zwanzig echte Suchanfragen aus deinem Anwendungsfall auf und notiere, welches Dokument jeweils gefunden werden müsste. Mit dieser kleinen Liste testest du jedes Modell in einer halben Stunde – und sie sagt dir mehr als jede Bestenliste, weil sie deine Sprache, deine Fachbegriffe und deine Dokumente enthält.

Ressourcen