Embeddings sind Listen von Zahlen, die die Bedeutung eines Textes beschreiben. Ein Embedding-Modell liest einen Satz, etwa „Wann kommt mein Paket an?“, und gibt dafür zum Beispiel 1.024 Kommazahlen zurück. Das Entscheidende: Sätze mit ähnlicher Bedeutung bekommen ähnliche Zahlenlisten, auch wenn sie kein einziges Wort gemeinsam haben. Genau darauf beruhen semantische Suche, „ähnliche Artikel“-Empfehlungen und RAG, also Chatbots, die vor der Antwort in deinen eigenen Dokumenten nachschlagen.
Wenn du nur die Kurzfassung wolltest: Das war sie. Dieser Artikel geht weiter. Wir haben fünf Embedding-Modelle lokal mit Ollama 0.40.13 betrieben und an deutschen Texten gemessen, was sie können und wo sie danebenliegen. Wir haben geprüft, was mit langen Texten passiert, wie gut die Modelle Deutsch und Englisch zusammenbringen und ob sie ein „nicht“ bemerken.
Vier Befunde vorweg:
1. Bei 10 Kundenfragen, die kein Wort mit dem passenden Hilfetext teilen, fand das beliebte nomic-embed-text nur 2 von 10 richtigen Antworten. bge-m3 und qwen3-embedding fanden 9 von 10, qwen3 mit einer Suchanweisung sogar 10 von 10.
2. Für alle fünf Modelle war „Ich trinke gern Kaffee“ dem Satz „Ich trinke nicht gern Kaffee“ ähnlicher als „Morgens brauche ich unbedingt meinen Espresso“. Embeddings messen Thema, nicht Aussage.
3. Ein wichtiger Satz am Ende eines langen Textes war bei drei von vier getesteten Modellen spurlos verschwunden: Der Vektor war auf vier Nachkommastellen identisch mit dem Vektor ohne den Satz. Ollama kappt zu lange Eingaben ohne Warnung.
4. 100.000 Texte mit je 1.024 Zahlen belegen rund 410 MB und lassen sich auf einer normalen CPU in 13 Millisekunden komplett durchsuchen. Für kleine Projekte brauchst du keine Vektordatenbank.

Was sind Embeddings? Die Idee in einem Bild
Stell dir eine riesige Landkarte vor, auf der jeder Satz einen Ort hat. Sätze über Lieferungen liegen in einer Ecke, Sätze über Passwörter in einer anderen, Sätze über vegane Rezepte ganz woanders. Wer „Wann kommt mein Paket?“ sucht, schaut einfach, welche Orte in der Nähe liegen, und findet dort „Bestellungen werden innerhalb von zwei Werktagen verschickt“. Kein gemeinsames Wort, trotzdem Nachbarn.
Ein Embedding ist die Koordinate auf dieser Karte. Nur hat die Karte nicht zwei Dimensionen wie ein Stadtplan, sondern 384, 768 oder 1.024. Das kann sich kein Mensch vorstellen, für den Computer ist es aber nur eine längere Liste. Jede einzelne Zahl hat dabei keine verständliche Bedeutung. Es gibt also keine „Paket-Dimension“. Die Bedeutung steckt im Zusammenspiel aller Zahlen.
Das Wort „Embedding“ heißt wörtlich „Einbettung“: Ein Text wird in einen Zahlenraum eingebettet. Im Deutschen sagt man meistens einfach Embedding, manchmal auch Vektor, Einbettung oder Vektordarstellung. Gemeint ist dasselbe.
So sieht ein echtes Embedding aus, gekürzt auf die ersten Zahlen. Die Anfrage geht an einen lokal laufenden Ollama-Server:
curl -s http://127.0.0.1:11434/api/embed -d '{
"model": "bge-m3",
"input": "Wann kommt mein Paket an?"
}'
{
"model": "bge-m3",
"embeddings": [[-0.0213, 0.0367, -0.0491, 0.0118, ... ]]
}
Bei bge-m3 stehen in dieser Liste 1.024 Zahlen. Mehr ist ein Embedding nicht.

Wie entstehen Embeddings?
Ein Embedding-Modell ist ein neuronales Netz, das mit sehr vielen Textpaaren trainiert wurde. Ihm wurde gezeigt: Diese Frage gehört zu dieser Antwort, diese Überschrift zu diesem Absatz, dieser Satz ist eine Umformulierung von jenem. Dazu kamen Paare, die nicht zusammengehören. Das Training schiebt die Zahlen so lange hin und her, bis Zusammengehöriges nah beieinander und Fremdes weit auseinander liegt.
Technisch sind die meisten Embedding-Modelle verwandt mit den Sprachmodellen hinter ChatGPT oder Claude. Sie zerlegen den Text in Tokens (Wortstücke), lassen ihn durch mehrere Schichten laufen und fassen das Ergebnis am Ende zu einem einzigen Vektor zusammen. Der Unterschied: Ein Chatmodell sagt das nächste Wort voraus, ein Embedding-Modell gibt einen Ort im Bedeutungsraum aus. Es schreibt keinen Text. Darum sind Embedding-Modelle auch viel kleiner: Unser kleinstes Testmodell wog 45 MB, das größte 1,2 GB.
Wie misst man, ob zwei Embeddings ähnlich sind?
Fast immer mit der Kosinus-Ähnlichkeit (englisch cosine similarity). Sie misst den Winkel zwischen zwei Vektoren. Zeigen beide in dieselbe Richtung, ist der Wert 1. Stehen sie senkrecht zueinander, ist er 0. Zeigen sie in entgegengesetzte Richtungen, ist er -1. In der Praxis landen Texte meistens irgendwo zwischen 0 und 1.
In Python sind das drei Zeilen:
import math
def kosinus(a, b):
skalar = sum(x * y for x, y in zip(a, b))
return skalar / math.sqrt(sum(x * x for x in a) * sum(y * y for y in b))
Ein praktischer Nebenbefund aus unserem Test: Alle fünf Modelle liefern Vektoren mit der Länge 1 (wir haben die Norm nachgerechnet, sie lag jeweils bei 1,0000). Bei solchen normierten Vektoren ist die Kosinus-Ähnlichkeit einfach das Skalarprodukt, die Division fällt weg. Das macht die Suche schneller und ist der Grund, warum viele Vektordatenbanken „dot product“ und „cosine“ als gleichwertig anbieten.
Wichtig: Die absoluten Werte sind zwischen Modellen nicht vergleichbar. Bei qwen3-embedding hatten zwei völlig fremde Sätze eine Ähnlichkeit von 0,11, bei mxbai-embed-large 0,59. Ein Schwellenwert wie „ab 0,7 ist es ein Treffer“ gilt deshalb immer nur für ein Modell und muss neu bestimmt werden, wenn du das Modell wechselst.

Wofür braucht man Embeddings?
Embeddings sind selten das Produkt, aber oft das Fundament. Die wichtigsten Einsatzzwecke:
Semantische Suche. Die klassische Suche findet Wörter. Wer „Kennwort vergessen“ eintippt, findet keinen Artikel über „Passwort zurücksetzen“, außer jemand hat Synonyme gepflegt. Eine Suche mit Embeddings findet ihn, weil sie Bedeutung vergleicht. Die Texte werden einmal in Vektoren umgewandelt und gespeichert, bei jeder Suche wird nur die Anfrage neu umgewandelt und mit allen gespeicherten Vektoren verglichen.
RAG (Retrieval Augmented Generation). Ein Chatbot soll Fragen zu deinen eigenen Dokumenten beantworten, zum Beispiel zu deinem Wiki oder deinen Handbüchern. Weil nicht alle Dokumente in den Kontext eines Sprachmodells passen, sucht das System zuerst per Embedding die passenden Abschnitte heraus und gibt nur diese dem Sprachmodell mit. Embeddings entscheiden also, was das Modell überhaupt zu sehen bekommt. Ist die Suche schlecht, ist die Antwort schlecht, egal wie gut das Sprachmodell ist.
Empfehlungen und Duplikate. „Ähnliche Artikel“ unter einem Blogpost, „Kunden kauften auch“ auf Basis von Produktbeschreibungen, doppelte Support-Tickets oder fast gleiche Produkttexte finden: alles Nachbarschaftssuche im Vektorraum.
Gruppieren und Sortieren. Tausende Kundenfeedbacks automatisch in Themen aufteilen, ohne vorher Kategorien festzulegen. Man rechnet Embeddings aus und lässt einen Clustering-Algorithmus Gruppen bilden.
Klassifizieren mit wenigen Beispielen. Für jede Kategorie ein paar Beispielsätze einbetten, neue Texte der nächstgelegenen Kategorie zuordnen. Für einfache Aufgaben reicht das erstaunlich weit, ohne ein Modell zu trainieren.
Embeddings gibt es übrigens nicht nur für Text. Bilder, Audio und Produktdaten lassen sich genauso einbetten. Bildersuchen wie „finde ähnliche Fotos“ funktionieren nach demselben Prinzip. In diesem Artikel bleiben wir beim Text.
Kurze deutsche Einführung von Wolfgang Klaus (Juli 2025). Etwas älter, aber die Grundidee hat sich seitdem nicht geändert.
Unser Test: 5 Embedding-Modelle lokal mit Ollama
Theorie gibt es im Netz genug. Uns hat interessiert, wie sich Embeddings an deutschen Texten schlagen, denn fast alle Anleitungen testen auf Englisch. In unserer Ollama-Anleitung hatten wir schon bemerkt, dass das beliebte nomic-embed-text auf Deutsch schwächelt. Diesmal haben wir es systematisch gemacht.
Der Aufbau:
- Eine eigene, abgeschottete Ollama-Instanz (Version 0.40.13) nur auf 127.0.0.1, mit eigenem Modellordner. Nach dem Test wurden Instanz und alle Modelle (2,6 GB) wieder gelöscht.
- Nur CPU, 12 Kerne, keine Grafikkarte. Der Server lief nebenbei unter Last, die Zeiten sind deshalb nur als Größenordnung zu verstehen.
- Fünf Modelle, die man mit einem
ollama pullbekommt:
| Modell | Download | Dimensionen | Kontext in Ollama | Laden in den RAM |
|---|---|---|---|---|
| all-minilm | 45 MB | 384 | 256 Tokens | 49 MB |
| nomic-embed-text | 274 MB | 768 | 2.048 Tokens | 389 MB |
| mxbai-embed-large | 669 MB | 1.024 | 512 Tokens | nicht gemessen |
| bge-m3 | 1,2 GB | 1.024 | 2.048 Tokens (gemessen) | 1,2 GB |
| qwen3-embedding:0.6b | 639 MB | 1.024 | 4.096 Tokens | nicht gemessen |
Die Downloads dauerten zwischen 2,8 und 6,0 Sekunden. Die Kontextlängen für all-minilm, nomic-embed-text und bge-m3 haben wir aus ollama ps und aus dem gemessenen Abschneiden abgelesen, die für mxbai-embed-large stammt aus der Modellbeschreibung.
Der eigentliche Test: Zehn kurze Hilfetexte, wie sie in einem Shop oder Kundenportal stehen könnten: Passwort zurücksetzen, Versand, Rücksendung, Zahlungsarten, volle Festplatte, abgelaufenes Zertifikat, Backups, vegane Rezepte, Konto löschen, Newsletter abmelden. Dazu zehn Fragen, die absichtlich andere Wörter benutzen als der passende Hilfetext:
- „Ich komme nicht mehr in meinen Account rein“ → Hilfetext zu „Passwort zurücksetzen … Kennwort vergessen“
- „Kann ich die Schuhe wieder umtauschen?“ → „Du kannst Artikel innerhalb von 30 Tagen zurückschicken“
- „Wie werde ich mein Profil komplett los?“ → „Dein Konto kannst du … endgültig löschen“
- „Ich will keine Werbemails mehr bekommen“ → „Vom Newsletter abmelden …“
Genau das ist der Fall, für den man Embeddings überhaupt einsetzt. Eine Wortsuche hätte fast alle zehn verfehlt. Gezählt haben wir, wie oft der richtige Hilfetext ganz oben landete.
Ergebnis 1: Welches Embedding-Modell versteht Deutsch?
| Modell | Treffer (deutsche Fragen) | Treffer (englische Fragen, deutsche Texte) | Abstand zum Zweitplatzierten |
|---|---|---|---|
| all-minilm | 6 / 10 | 5 / 10 | 0,051 |
| nomic-embed-text | 2 / 10 | 4 / 10 | 0,018 |
| mxbai-embed-large | 5 / 10 | 6 / 10 | 0,053 |
| bge-m3 | 9 / 10 | 8 / 10 | 0,113 |
| qwen3-embedding:0.6b | 9 / 10 | 10 / 10 | 0,130 |
Die letzte Spalte ist mindestens so wichtig wie die Trefferzahl. Sie zeigt, wie deutlich der beste Treffer vor dem zweitbesten lag. Bei nomic-embed-text betrug der Abstand im Schnitt 0,018: Das Modell sah praktisch alle Hilfetexte als gleich ähnlich an und griff mehr oder weniger zufällig einen heraus. Fünf seiner acht Fehler landeten beim Text über Zahlungsarten, egal ob nach Passwort, Paket oder Kontolöschung gefragt wurde. bge-m3 und qwen3-embedding trennten sechs- bis siebenmal so deutlich.
Ein paar Beobachtungen, die uns überrascht haben:
Das kleinste Modell schlug das bekannteste. all-minilm mit 45 MB fand 6 von 10, nomic-embed-text mit 274 MB nur 2. Größe allein sagt also wenig. Entscheidend ist, mit welchen Sprachen ein Modell trainiert wurde. bge-m3 und qwen3-embedding sind ausdrücklich mehrsprachig, die anderen drei überwiegend englisch trainiert.
Der gemeinsame Fehler der beiden Besten ist lehrreich. Sowohl bge-m3 als auch qwen3-embedding ordneten „Ich komme nicht mehr in meinen Account rein“ dem Text über das Löschen des Kontos zu statt dem über das Passwort. Das ist nachvollziehbar: Beide Texte drehen sich um das Konto, und das Wort „Account“ ist näher an „Konto“ als an „Kennwort“. Für einen Menschen ist die Absicht klar, für die Modelle war es knapp. Wer eine Hilfe-Suche baut, sollte solche Grenzfälle bewusst testen, statt sich auf eine hohe Trefferquote bei einfachen Fragen zu verlassen.
Suchanweisungen helfen manchen Modellen. qwen3-embedding ist darauf trainiert, vor der Suchanfrage eine kurze Anweisung zu bekommen. Wir haben der Frage diesen Text vorangestellt (die Hilfetexte blieben unverändert):
Instruct: Given a customer question, retrieve the help text that answers it
Query: Ich komme nicht mehr in meinen Account rein
Mit Anweisung lag qwen3-embedding bei 10 von 10. Der vorher falsch zugeordnete Passwort-Text lag nun vorne, mit 0,485 gegen 0,410 für „Konto löschen“. Andere Modelle erwarten andere Präfixe. nomic-embed-text etwa will search_query: und search_document:, bge-m3 braucht keine. Das steht auf der jeweiligen Modellseite, und es lohnt sich, es nachzulesen.
Deutsch und Englisch durcheinander. In der dritten Spalte haben wir dieselben Fragen auf Englisch gestellt, die Hilfetexte blieben deutsch. qwen3-embedding fand alle zehn, bge-m3 acht. Wer ein zweisprachiges Wiki oder internationale Kundschaft hat, kann mit diesen Modellen eine gemeinsame Suche über beide Sprachen bauen. Wie stark das auseinandergeht, zeigt ein einzelner Satz: „Der Hund schläft auf dem Sofa“ gegen „The dog is sleeping on the couch“ ergab bei all-minilm 0,12, also so gut wie keine Ähnlichkeit, bei qwen3-embedding 0,81.
Zehn Fragen sind ein kleiner Test, kein Benchmark. Er reicht aber, um ein ungeeignetes Modell zu entlarven, und genau das empfehlen wir dir auch: Bevor du eine Suche auf ein Embedding-Modell baust, nimm zehn echte Fragen aus deinem Alltag und prüfe, was oben landet. Das dauert eine halbe Stunde und spart Wochen an rätselhaften Suchergebnissen.
Ergebnis 2: Embeddings sehen kein „nicht“
Der zweite Test sollte zeigen, was „ähnliche Bedeutung“ für ein Embedding-Modell eigentlich heißt. Wir haben drei Sätze mit „Ich trinke gern Kaffee.“ verglichen:
| Vergleichssatz | all-minilm | nomic | mxbai | bge-m3 | qwen3 |
|---|---|---|---|---|---|
| „Ich trinke nicht gern Kaffee.“ | 0,953 | 0,988 | 0,896 | 0,829 | 0,841 |
| „Morgens brauche ich unbedingt meinen Espresso.“ | 0,515 | 0,691 | 0,706 | 0,736 | 0,556 |
| „Der Server hat keinen Speicherplatz mehr.“ | 0,350 | 0,576 | 0,589 | 0,429 | 0,109 |
Bei allen fünf Modellen war der Satz mit der gegenteiligen Aussage dem Original am ähnlichsten. Der Espresso-Satz, der dasselbe meint, kam deutlich dahinter. Bei nomic-embed-text lag die Verneinung bei 0,988, fast identisch.
Das ist kein Fehler einzelner Modelle, sondern eine Eigenschaft von Embeddings: Sie messen, worüber ein Text spricht, nicht, was er behauptet. „Ich trinke gern Kaffee“ und „Ich trinke nicht gern Kaffee“ handeln vom selben Thema mit fast denselben Wörtern. Für eine Suche ist das oft sogar richtig: Wer nach Kaffeevorlieben sucht, will beide Sätze finden. Für alles, was auf die Aussage ankommt, ist es gefährlich:
- Ein RAG-System fragt nach „Ist Produkt X glutenfrei?“ und findet den Absatz „Produkt X ist nicht glutenfrei“. Gut, solange das Sprachmodell danach genau liest.
- Eine Duplikaterkennung hält „Die Lieferung ist angekommen“ und „Die Lieferung ist nicht angekommen“ für denselben Fall.
- Ein Filter für positive Bewertungen per Embedding-Nähe sortiert auch die negativen ein.
Die Konsequenz für die Praxis: Embeddings sind gut darin, Kandidaten zu finden. Ob ein Kandidat wirklich passt, sollte bei wichtigen Entscheidungen ein zweiter Schritt prüfen, etwa ein Sprachmodell, das den gefundenen Text liest, oder ein sogenannter Reranker.
Etwas besser sah es bei Mehrdeutigkeit aus. „Ich sitze auf der Bank im Park“ war bei allen Modellen „Ich ruhe mich auf einer Parkbank aus“ ähnlicher (0,84 bis 0,94) als „Ich habe Geld bei der Bank abgehoben“ (0,44 bis 0,78). Den Kontext eines Wortes erfassen die Modelle also, die Verneinung eines Satzes kaum.

Ergebnis 3: Lange Texte werden still abgeschnitten
Jedes Embedding-Modell hat eine Höchstlänge, gemessen in Tokens. Ein Token entspricht im Deutschen grob drei bis vier Buchstaben. Was passiert, wenn ein Text länger ist?
Wir haben einen langen, langweiligen Fülltext gebaut (rund 3.800 Tokens, 200 Mal derselbe Satz über das Wetter) und ans Ende einen wichtigen Satz gehängt: „Wichtig: Der Notfallschlüssel liegt im Tresor im Keller.“ Dann haben wir das Embedding mit und ohne diesen Satz verglichen.
| Modell | Verarbeitete Tokens | Ähnlichkeit mit/ohne Schlusssatz | Satz am Anfang statt am Ende |
|---|---|---|---|
| all-minilm | 256 | 1,0000 | 0,944 |
| nomic-embed-text | 2.048 | 1,0000 | 0,976 |
| bge-m3 | 2.048 | 1,0000 | 0,897 |
| qwen3-embedding:0.6b | 3.818 (alles) | 0,943 | 0,813 |
Bei drei von vier Modellen war der Vektor mit dem wichtigen Satz auf vier Nachkommastellen identisch mit dem Vektor ohne ihn. Der Satz wurde abgeschnitten und hat das Ergebnis nicht im Geringsten beeinflusst. Wer in dieser Datenbank nach dem Notfallschlüssel sucht, findet das Dokument nie. Und weder die Antwort von Ollama noch ein Fehlercode deuten darauf hin: Ollama antwortete mit Status 200, der einzige Hinweis ist das Feld prompt_eval_count in der Antwort, das bei 256 oder 2.048 stehen blieb.
Stand der Satz am Anfang, veränderte er den Vektor zwar, aber nur wenig, weil er in einem riesigen Fülltext unterging. Auch das ist eine Erkenntnis: Ein einzelner Satz in einem langen Dokument zählt im Embedding kaum. Selbst qwen3-embedding, das den ganzen Text verarbeitete, kam nur auf 0,943 Unterschied.
Ollama kann auch laut scheitern, wenn man es darum bittet. Mit "truncate": false antwortete es bei all-minilm und nomic-embed-text mit HTTP 400, bei bge-m3 mit HTTP 413, jeweils mit der Meldung „the input length exceeds the context length“. Für eine Datenbank, in die du Dokumente einspielst, ist das die bessere Einstellung: Ein Fehler, den man sieht, ist besser als ein Dokument, das heimlich zur Hälfte fehlt.
curl -s http://127.0.0.1:11434/api/embed -d '{
"model": "bge-m3",
"input": "… sehr langer Text …",
"truncate": false
}'
# {"error":"the input length exceeds the context length"}
Die Lösung heißt Chunking. Lange Dokumente zerlegt man vor dem Einbetten in kleinere Stücke, typischerweise einige hundert Tokens, und speichert für jedes Stück ein eigenes Embedding. Bewährt haben sich Stücke entlang von Absätzen oder Überschriften, mit etwas Überlappung, damit ein Gedanke nicht genau an der Grenze zerschnitten wird. Zu jedem Stück speicherst du, aus welchem Dokument und von welcher Stelle es stammt. Dann findet die Suche den Absatz mit dem Notfallschlüssel, weil er nicht mehr in 200 Wettersätzen untergeht.
Wie viel Speicher und Rechenzeit brauchen Embeddings?
Ein Embedding besteht aus Kommazahlen, üblicherweise mit 4 Byte pro Zahl (float32). Daraus ergibt sich der Speicherbedarf direkt:
| Menge | Dimensionen | Speicher | Komplette Suche (1 Anfrage, CPU) |
|---|---|---|---|
| 100.000 Texte | 384 | 154 MB | 5 ms |
| 100.000 Texte | 1.024 | 410 MB | 13 ms |
| 1.000.000 Texte | 384 | 1,5 GB | 36 ms |
Gemessen haben wir mit NumPy und zufälligen normierten Vektoren: einmal alle Vektoren mit der Anfrage multiplizieren, die zehn besten heraussuchen. Keine Indexstruktur, keine Datenbank, einfach Rechnen. Selbst eine Million Einträge waren in unter 40 Millisekunden durchsucht.
Das heißt: Für Hilfeseiten, ein Firmenwiki, ein paar tausend Produkte oder die Artikel eines Blogs brauchst du keine spezielle Vektordatenbank. Die Vektoren passen in den Arbeitsspeicher, eine Tabelle in deiner bestehenden Datenbank oder eine Datei. Wer ohnehin PostgreSQL betreibt, kann mit der Erweiterung pgvector Embeddings direkt neben den übrigen Daten speichern. Unser Vergleich SQLite vs. PostgreSQL hilft bei der Frage, welche Datenbank zu deinem Projekt passt. Spezialisierte Vektordatenbanken mit Näherungsverfahren (etwa HNSW-Indizes) lohnen sich erst bei vielen Millionen Einträgen oder sehr vielen gleichzeitigen Anfragen.
Teurer als das Suchen ist das Erzeugen der Embeddings. Auf unserem ausgelasteten Server ohne Grafikkarte brauchten die Modelle für 200 kurze Sätze zwischen 7 Sekunden (all-minilm) und 18 Sekunden (bge-m3). Das passiert aber nur einmal pro Text, beim Einspielen. Pro Suchanfrage wird nur die Frage selbst eingebettet, das dauerte bei allen Modellen deutlich unter einer Sekunde. Mit einer Grafikkarte ist das Einbetten großer Mengen um ein Vielfaches schneller.
Zwei weitere Messungen:
Embeddings sind reproduzierbar. Derselbe Text ergab bei jedem Modell zweimal hintereinander exakt denselben Vektor, Zahl für Zahl. Das ist wichtig, weil du gespeicherte Vektoren sonst nie mit neuen vergleichen könntest.
Weniger Dimensionen sind möglich, aber nicht bei jedem Modell sinnvoll. Ollama nimmt einen Parameter dimensions an. Bei qwen3-embedding, das für kürzbare Vektoren trainiert wurde, lag die Trefferzahl mit 1.024, 512, 256, 128 und 64 Dimensionen bei 9, 8, 10, 7 und 9 von 10. Bei zehn Fragen ist das Rauschen, kein Trend. Kürzere Vektoren sparen also Speicher, ohne in unserem kleinen Test klar zu schaden. Bemerkenswert: Ollama kürzte auch bei all-minilm auf 256 Dimensionen, ohne Warnung, obwohl dieses Modell nicht dafür trainiert wurde. Ob die gekürzten Vektoren dort noch taugen, sagt dir niemand. Kürze nur bei Modellen, deren Beschreibung das ausdrücklich unterstützt.
Die wichtigste Regel: Ein Modell, ein Vektorraum
Embeddings aus verschiedenen Modellen sind nicht miteinander vergleichbar, auch nicht, wenn sie zufällig gleich viele Dimensionen haben. bge-m3, mxbai-embed-large und qwen3-embedding liefern alle 1.024 Zahlen, aber jedes Modell hat seine eigene Landkarte. Ein Vektor aus dem einen Modell auf der Karte des anderen zeigt auf irgendeinen Ort.
Daraus folgen drei praktische Regeln:
- Speichere zu jedem Vektor, mit welchem Modell (und welcher Version) er erzeugt wurde.
- Wechselst du das Modell, musst du alle Texte neu einbetten. Es gibt keinen Umrechnungsweg.
- Anfrage und Dokumente müssen mit demselben Modell und denselben Einstellungen eingebettet werden, inklusive Präfixe und Dimensionen.
Das klingt selbstverständlich, ist aber eine häufige Fehlerquelle: Jemand testet ein neues Modell für die Suchanfragen, vergisst die gespeicherten Dokumente, und die Suche liefert plötzlich Unsinn, ohne dass irgendwo ein Fehler erscheint.

Embeddings lokal oder per API?
Embeddings kannst du bei großen Anbietern per API bestellen oder selbst erzeugen. Beides hat seinen Platz:
Lokal mit Ollama (wie in unserem Test) behältst du die Daten auf deinem eigenen Rechner oder Server. Für Kundendaten, interne Dokumente oder alles mit Datenschutzfragen ist das ein starkes Argument. Die Modelle sind klein, laufen ohne Grafikkarte und kosten nichts außer Strom. Wie du Ollama einrichtest, steht in unserer Ollama-Anleitung. Einen Überblick über lokale KI insgesamt gibt Lokale KI.
Per API bekommst du ohne eigene Hardware oft sehr starke Modelle und musst nichts betreiben. Dafür verlassen deine Texte dein Haus, und du bist an den Anbieter gebunden: Wenn er ein Modell abschaltet, musst du alles neu einbetten (siehe Regel 2). Die Preise für Embeddings sind im Vergleich zu Chatmodellen niedrig, bei großen Datenmengen summiert es sich trotzdem.
Unsere Empfehlung für deutsche Texte nach diesem Test: bge-m3 oder qwen3-embedding:0.6b lokal ausprobieren, mit zehn echten Fragen aus deinem Alltag gegenprüfen und erst dann eine größere Lösung bauen. Für rein englische Inhalte sind auch die kleineren Modelle brauchbar.
Ein Mini-Beispiel: Semantische Suche in 25 Zeilen
So einfach kann eine semantische Suche aussehen. Das Skript bettet einige Texte ein, merkt sich die Vektoren und sucht dann zu einer Frage den passendsten Text. Es braucht nur Python und einen laufenden Ollama-Server mit bge-m3.
import json, math, urllib.request
def embed(texte):
anfrage = urllib.request.Request(
"http://127.0.0.1:11434/api/embed",
data=json.dumps({"model": "bge-m3", "input": texte, "truncate": False}).encode(),
headers={"Content-Type": "application/json"},
)
return json.load(urllib.request.urlopen(anfrage))["embeddings"]
texte = [
"Um dein Passwort zurückzusetzen, klicke auf Kennwort vergessen.",
"Bestellungen werden innerhalb von zwei Werktagen verschickt.",
"Du kannst Artikel innerhalb von 30 Tagen zurückschicken.",
]
vektoren = embed(texte)
frage = "Wann kommt mein Paket an?"
f = embed([frage])[0]
# Vektoren sind normiert, also reicht das Skalarprodukt
werte = [sum(a * b for a, b in zip(f, v)) for v in vektoren]
bester = max(range(len(texte)), key=lambda i: werte[i])
print(f"{werte[bester]:.3f} {texte[bester]}")
Für ein echtes Projekt würdest du die Vektoren in einer Datenbank oder Datei speichern, statt sie bei jedem Start neu zu berechnen, die Texte in sinnvolle Stücke zerlegen und das Ergebnis bei wichtigen Fragen von einem Sprachmodell gegenlesen lassen. Das Prinzip bleibt dasselbe.
Englische Einsteigererklärung von The Data and AI Guy (Juli 2026), gut als Ergänzung zur Grundidee.
Typische Fehler mit Embeddings
Aus unseren Messungen und aus der Praxis die häufigsten Stolpersteine:
- Das Modell nicht an den eigenen Texten testen. Englische Benchmarks sagen wenig über deutsche Kundenfragen. nomic-embed-text ist ein gutes Modell für Englisch und war in unserem deutschen Test das schwächste.
- Lange Dokumente am Stück einbetten. Alles nach der Kontextgrenze verschwindet still, und auch innerhalb der Grenze geht ein einzelner Satz in viel Text unter. Chunking ist Pflicht.
- Einen festen Schwellenwert aus einem Tutorial übernehmen. Ähnlichkeitswerte sind von Modell zu Modell völlig verschieden. In unserem Test reichte die Ähnlichkeit zweier fremder Sätze von 0,11 bis 0,59.
- Modelle mischen. Anfragen mit einem anderen Modell oder anderen Präfixen einbetten als die Dokumente.
- Embeddings für Wahrheit halten. Sie finden Texte zum selben Thema, egal ob dort das Gegenteil steht.
- Zu früh eine Vektordatenbank einführen. Bis zu sehr vielen Einträgen reicht die bestehende Datenbank oder sogar eine Datei.
Fazit: Was sind Embeddings, und wann lohnen sie sich?
Embeddings sind Zahlenlisten, die Bedeutung abbilden. Sie machen es möglich, Texte nach Inhalt statt nach Wörtern zu finden, und sie sind die Grundlage fast jeder KI-Anwendung, die mit eigenen Dokumenten arbeitet. Ein Embedding-Modell ist klein, läuft lokal ohne Grafikkarte und liefert reproduzierbare Ergebnisse.
Unser Test hat aber auch gezeigt, wo die Grenzen liegen: Die Modellwahl entscheidet über alles (2 gegen 9 Treffer bei denselben Fragen), lange Texte werden ohne Warnung abgeschnitten, und ein „nicht“ ist für Embeddings fast unsichtbar. Wer das weiß, baut mit wenig Aufwand eine Suche, die Kundenfragen deutlich besser versteht als jede Stichwortsuche. Wer es nicht weiß, wundert sich über Ergebnisse, für die es keine Fehlermeldung gibt.
Unser Rat zum Start: Ollama installieren, bge-m3 oder qwen3-embedding holen, zehn echte Fragen gegen zehn echte Texte testen. Wenn das passt, hast du die Grundlage für semantische Suche oder RAG in einem Nachmittag.
Häufige Fragen zu Embeddings
Was sind Embeddings in einfachen Worten?
Embeddings sind Zahlenlisten, die die Bedeutung eines Textes beschreiben. Texte mit ähnlicher Bedeutung bekommen ähnliche Zahlenlisten, auch wenn sie andere Wörter benutzen. So kann ein Computer Bedeutung vergleichen, indem er Zahlen vergleicht.
Was ist der Unterschied zwischen einem Embedding und einem Vektor?
Ein Vektor ist allgemein eine Liste von Zahlen. Ein Embedding ist ein Vektor, der von einem Modell so erzeugt wurde, dass sein Ort im Zahlenraum die Bedeutung des Eingabetextes widerspiegelt. Jedes Embedding ist ein Vektor, aber nicht jeder Vektor ist ein Embedding.
Was ist der Unterschied zwischen Embeddings und Tokens?
Tokens sind die Wortstücke, in die ein Modell Text zerlegt, bevor es ihn verarbeitet. Ein Embedding ist das Ergebnis am Ende: ein einziger Vektor für den ganzen Text. Innerhalb von Sprachmodellen gibt es zusätzlich Token-Embeddings, also Vektoren für einzelne Wortstücke. Wenn man im Alltag von Embeddings für Suche oder RAG spricht, ist der Vektor für den ganzen Text gemeint.
Wie viele Dimensionen sollte ein Embedding haben?
Das legt das Modell fest, üblich sind 384 bis 1.024, bei großen API-Modellen auch mehr. Mehr Dimensionen bedeuten mehr Speicher, aber nicht automatisch bessere Ergebnisse. In unserem Test schlug das Modell mit 384 Dimensionen das mit 768 deutlich. Manche Modelle erlauben kürzere Vektoren, das spart Speicher.
Welches Embedding-Modell ist am besten für Deutsch?
In unserem Test mit Ollama lagen bge-m3 und qwen3-embedding:0.6b klar vorne (je 9 von 10 Treffern, qwen3 mit Suchanweisung 10 von 10). nomic-embed-text fand nur 2 von 10. Teste trotzdem mit deinen eigenen Texten, zehn Fragen reichen für einen ersten Eindruck.
Brauche ich eine Vektordatenbank?
Für die meisten kleinen und mittleren Projekte nicht. 100.000 Texte mit 1.024 Dimensionen belegen rund 410 MB und lassen sich auf einer CPU in etwa 13 Millisekunden komplett durchsuchen. Eine bestehende PostgreSQL-Datenbank mit pgvector oder sogar eine Datei reicht. Spezialisierte Vektordatenbanken lohnen sich erst bei vielen Millionen Einträgen.
Kann man Embeddings von verschiedenen Modellen mischen?
Nein. Jedes Modell erzeugt seinen eigenen Zahlenraum. Auch bei gleicher Dimensionszahl sind die Vektoren nicht vergleichbar. Wechselst du das Modell, musst du alle Texte neu einbetten.
Was passiert, wenn ein Text zu lang für das Embedding-Modell ist?
Bei Ollama wird er standardmäßig ohne Warnung abgeschnitten. In unserem Test hatte ein wichtiger Satz am Ende eines langen Textes bei drei von vier Modellen null Einfluss auf das Ergebnis. Mit "truncate": false bekommst du stattdessen einen Fehler. Lange Dokumente solltest du vor dem Einbetten in kleinere Stücke zerlegen.
Verstehen Embeddings Verneinungen?
Kaum. In unserem Test war „Ich trinke nicht gern Kaffee“ bei allen fünf Modellen dem Satz „Ich trinke gern Kaffee“ ähnlicher als ein Satz mit gleicher Bedeutung, aber anderen Wörtern. Embeddings messen das Thema, nicht die Aussage. Für Entscheidungen, bei denen die Aussage zählt, gehört ein zweiter Prüfschritt dazu.
Was haben Embeddings mit RAG zu tun?
RAG-Systeme suchen vor der Antwort die passenden Stellen aus deinen Dokumenten heraus und geben sie dem Sprachmodell mit. Diese Suche läuft fast immer über Embeddings. Die Qualität der Embeddings bestimmt damit, welche Informationen das Sprachmodell überhaupt zu sehen bekommt.
Kann ich Embeddings ohne Grafikkarte erzeugen?
Ja. Alle fünf Modelle in unserem Test liefen nur auf der CPU. Das Einbetten großer Textmengen dauert dann länger, eine einzelne Suchanfrage war aber bei allen Modellen in deutlich unter einer Sekunde eingebettet.
Sind Embeddings bei jedem Aufruf gleich?
In unserem Test ja: Derselbe Text ergab bei allen fünf Modellen zweimal hintereinander exakt denselben Vektor. Unterschiedliche Modellversionen oder Einstellungen können aber andere Vektoren liefern, darum solltest du zu jedem gespeicherten Vektor Modell und Version notieren.