Embeddings verständlich erklärt: Wie Maschinen Bedeutung in Zahlen fassen

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?), arbeiten uns über Ähnlichkeitsmaße und die Entstehung von Embeddings vor und landen schließlich bei einem praktischen Vergleich der besten Embedding-Modelle 2026. Unterwegs gibt es jede Menge Python-Code zum Mitmachen, Tabellen zur Orientierung und ehrliche Praxistipps zu Kosten und Modellauswahl. Schnall dich an – es wird anschaulich.

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 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.

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	-8 bis +8 (höher = ähnlicher)	Ja	Vektor-DBs (auf normalisierten Vektoren)
Euklidische Distanz (L2)	0 bis +8 (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:

Tokenisierung: Der Text wird in Tokens zerlegt (Wortteile, etwa „un", „glaub", „lich").
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".
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.

Typische Anwendungsfälle

Embeddings sind erstaunlich vielseitig. 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.

Aktuelle Embedding-Modelle 2026 im Überblick

Die Landschaft ist 2026 vielfältig wie nie. Grob teilt sie sich in kommerzielle API-Modelle (bequem, keine Infrastruktur) und offene Modelle (selbst gehostet, datenschutzfreundlich, kostenlos im Betrieb). Hier die wichtigsten:

Modell	Typ	Dimensionen	Max. Kontext	Stärke
OpenAI text-embedding-3-small	API	1536 (kürzbar)	8191	Günstig, solide, einfach
OpenAI text-embedding-3-large	API	3072 (kürzbar)	8191	Höhere Qualität, mehrsprachig
Google Gemini Embedding 001	API	bis 3072 (MRL)	8192	Top-Werte auf englischer MTEB
Cohere Embed v4	API	1024 (256/512/1536 wählbar)	bis 128k	Multimodal, RAG-optimiert
Qwen3-Embedding-8B	offen	4096 (kürzbar)	32768	Spitze auf multilingualer MTEB
Qwen3-Embedding-0.6B	offen	1024 (32–1024)	32768	Stark & klein, gutes Preis-Leistung
BGE-M3 (BAAI)	offen	1024	8192	Dense + Sparse + Multi-Vektor, 100+ Sprachen
multilingual-e5-large	offen	1024	512	Bewährt, sehr gut für Deutsch
Nomic Embed Text v2	offen	768 (MRL)	8192	MoE-Architektur, ~100 Sprachen
gte-multilingual-base	offen	768	8192	Sehr schnell, kompakt
Jina Embeddings v3	offen/API	1024 (MRL bis 32)	8192	Frontier-Mehrsprachigkeit, 570M Parameter

Welches wofür?

Schneller Start ohne Infrastruktur: text-embedding-3-small ist der pragmatische Default – billig, gut genug, in zwei Zeilen integriert.
Maximale Qualität per API: text-embedding-3-large, Gemini Embedding 001 oder Cohere Embed v4.
Selbst hosten, beste multilinguale Qualität: Qwen3-Embedding (8B für Top-Qualität, 0.6B für ressourcenschonend).
Hybrid-Suche (dense + sparse) aus einem Modell: BGE-M3 ist hier konkurrenzlos praktisch.
Bewährtes Arbeitstier für Deutsch: multilingual-e5-large läuft auf bescheidener Hardware und liefert verlässlich gute Ergebnisse.

Zur Mehrsprachigkeit und Deutsch: Alle oben genannten mehrsprachigen Modelle (E5, BGE-M3, Qwen3, Nomic v2, GTE-multilingual, Jina v3, Cohere, Gemini) verarbeiten Deutsch gut. Achte beim Begriff „multilingual" im Modellnamen darauf – rein englische Modelle wie bge-large-en oder NV-Embed-v2 sind für deutsche Texte keine gute Wahl, auch wenn sie auf englischen Benchmarks glänzen.

MTEB: Der Benchmark als Auswahlhilfe

Wie entscheidest du dich bei dieser Auswahl? Der wichtigste Kompass 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.

Stand 2026 führen auf der multilingualen Bestenliste große offene Modelle wie Qwen3-Embedding-8B (MTEB-Score um 70,6) und NVIDIAs neue Llama-Embed-Nemotron-Reihe. Auf der englischen Bestenliste liegt unter anderem Gemini Embedding 001 weit vorn.

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

Aufgaben-Fit: Schau auf die Teildisziplin, die zu deinem Anwendungsfall passt. Für RAG zählt vor allem der Retrieval-Score, nicht der Gesamtdurchschnitt.
Sprache: Nutze die multilinguale oder die deutsche/europäische Teilwertung, nicht die englische Gesamtwertung.
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 Juni 2026):

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.

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.
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:

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

Embeddings sind das stille Fundament der modernen KI – und jetzt hast du das Werkzeug, um sie zu verstehen und einzusetzen. Schnapp dir den Code, embedde deine ersten Sätze und beobachte, wie Bedeutung zu Zahlen wird. Viel Spaß beim Experimentieren! ??

Ressourcen

OpenAI: New embedding models and API updates – Ankündigung und Details zu text-embedding-3
OpenAI Embeddings – Dokumentation – offizielle Anleitung und Preise
MTEB Leaderboard auf Hugging Face – die aktuelle Bestenliste der Embedding-Modelle
Sentence-Transformers Dokumentation – die wichtigste Bibliothek für lokale Embeddings
Qwen3-Embedding (GitHub) – Code, Modelle und technischer Report
BAAI/bge-m3 auf Hugging Face – mehrsprachiges Hybrid-Modell
intfloat/multilingual-e5-large – bewährtes mehrsprachiges Modell
Nomic Embed Text v2 – offenes MoE-Embedding-Modell
Jina Embeddings v3 – Frontier-Mehrsprachigkeit mit MRL
Cohere Embed v4 – multimodale Embeddings für RAG