Embedding-Modelle im Vergleich

Was dieser Artikel über Embedding-Modelle behandelt

• Was Embedding-Modelle sind und wie sie funktionieren.
• nomic-embed-text, multilingual-e5, bge-m3 und andere im Vergleich.
• Welches Modell für welche Sprache und welchen Zweck.
• Hardware-Anforderungen und Geschwindigkeit.
• Praxisbeispiele für RAG und semantische Suche.

Einleitung: Embedding-Modelle verständlich erklärt

Embedding-Modelle wandeln Text in Zahlen (Vektoren) um. Ähnliche Texte haben ähnliche Vektoren. Das ermöglicht semantische Suche: Statt Keywords zu matchen, findet das System Texte mit ähnlicher Bedeutung. Embeddings sind die Basis für RAG, semantische Suche und Dokumenten-Clustering.

Dieser Artikel richtet sich an Anwender, die Embedding-Modelle für RAG oder Suche wählen wollen. Grundlagen findest Du in Embeddings und Lokales RAG.

Warum brauche ich Embedding-Modelle?

Stell Dir vor, Du suchst nach „Urlaubsantrag” und willst auch Dokumente finden, die „Urlaub beantragen” oder „Ferienantrag” enthalten, obwohl die Wörter anders sind. Embeddings verstehen die Bedeutung, nicht nur die Wörter. Das ist die Basis für RAG und intelligente Suche.

Embedding-Modelle im Vergleich kurz erklärt

Embedding-Modelle wandeln Text in Vektoren (z.B. 768 Zahlen). Ähnliche Texte haben ähnliche Vektoren. nomic-embed-text ist ein guter Allrounder, multilingual-e5 für Mehrsprachigkeit, bge-m3 für lange Dokumente.

Der Kerngedanke lautet: Text → Zahlen → Ähnlichkeit finden.

Für wen ist dieser Artikel gedacht?

• RAG-Entwickler, die Embeddings für Dokumentensuche brauchen.
• Suchmaschinen-Bauer, die semantische Suche implementieren.
• Datenanalysten, die Texte clustern und klassifizieren.
• Self-Hoster, die Embeddings lokal erstellen.

Vorkenntnisse in RAG sind hilfreich.

Wichtige Begriffe

• Embedding - Text zu Vektor. Wann nützlich: für semantische Suche.
• RAG - Retrieval-Augmented Generation. Wann nützlich: die Hauptanwendung.
• Vektordatenbank - Speicher für Embeddings. Wann nützlich: für Suche.
• Semantische Suche - Bedeutung statt Keywords. Wann nützlich: für bessere Treffer.
• Ollama - Modellserver. Wann nützlich: für Embeddings.
• Cosine Similarity - Ähnlichkeitsmaß. Wann nützlich: für Vergleiche.

Wie Embeddings funktionieren

Text: "Der Hund spielt im Garten"
         │
         ▼
Embedding-Modell
         │
         ▼
Vektor: [0.23, -0.45, 0.78, ..., 0.12]  (768 Dimensionen)

Ähnlicher Text: "Ein Hund spielt draußen"
         │
         ▼
Vektor: [0.21, -0.43, 0.81, ..., 0.15]  (ähnlich!)

Unähnlicher Text: "Die Katze schläft auf dem Sofa"
         │
         ▼
Vektor: [-0.67, 0.89, -0.23, ..., 0.45]  (unähnlich)

Die Modelle im Vergleich

Modell	Entwickler	Dimensionen	Sprachen	Max Länge	Best für
nomic-embed-text	Nomic AI	768	Englisch	8K	Allgemeine RAG
multilingual-e5	Microsoft	1024	100+	512	Mehrsprachige RAG
bge-m3	BAAI	1024	100+	8K	Lange Dokumente
bge-large-en	BAAI	1024	Englisch	512	Englische Texte
gte-Qwen2	Alibaba	1536	Mehrsprachig	32K	Sehr lange Dokumente
mxbai-embed-large	Mixedbread	1024	Englisch	512	Englische RAG

Detaillierter Vergleich

1. nomic-embed-text (Nomic AI)

Stärken:

• Standard-Embedding für Ollama
• Gute Qualität für englische Texte
• Schnell und effizient
• Gut dokumentiert

Schwächen:

• Nur Englisch (für Deutsch suboptimal)
• 768 Dimensionen (weniger als andere)

Empfehlung: nomic-embed-text für englische Dokumente.

2. multilingual-e5 (Microsoft)

Stärken:

• 100+ Sprachen inklusive Deutsch
• Sehr gute Qualität
• Standard für mehrsprachige Anwendungen
• multilingual-e5-large: Beste Version

Schwächen:

• Nur 512 Token Kontext (kurze Texte)
• Größer als nomic

Empfehlung: multilingual-e5 für deutsche/mehrsprachige Dokumente.

3. bge-m3 (BAAI)

Stärken:

• Mehrsprachig (100+ Sprachen)
• 8K Kontext (lange Dokumente)
• Sehr gute Qualität
• Hybrid: Dense + Sparse + Multi-Vector

Schwächen:

• Größer und langsamer
• Komplexer (3 Modi)

Empfehlung: bge-m3 für lange, mehrsprachige Dokumente.

4. gte-Qwen2 (Alibaba)

Stärken:

• 32K Kontext (sehr lange Dokumente)
• Mehrsprachig
• Sehr gute Qualität
• Qwen-basiert

Schwächen:

• 1536 Dimensionen (mehr Speicher)
• Weniger verbreitet

Empfehlung: gte-qwen2 für sehr lange Dokumente.

Sprachen-Vergleich

Modell	Deutsch	Englisch	Mehrsprachig	Anmerkung
nomic-embed-text	⭐⭐	⭐⭐⭐⭐⭐	⭐	Nur Englisch
multilingual-e5	⭐⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐⭐⭐	100+ Sprachen
bge-m3	⭐⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐⭐⭐	100+ Sprachen
gte-Qwen2	⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐⭐	Mehrsprachig

Kontextlänge-Vergleich

Modell	Max Tokens	Für was
multilingual-e5	512	Kurze Texte, Sätze
bge-large-en	512	Kurze Texte
nomic-embed-text	8K	Mittellange Dokumente
bge-m3	8K	Lange Dokumente
gte-Qwen2	32K	Sehr lange Dokumente

Praxisbeispiel: Embeddings mit Ollama

import requests

# Embedding erstellen
def get_embedding(text, model="nomic-embed-text"):
    response = requests.post(
        "http://ollama:11434/api/embeddings",
        json={
            "model": model,
            "prompt": text
        }
    )
    return response.json()["embedding"]

# Beispiel
text = "Der Hund spielt im Garten"
embedding = get_embedding(text)
print(f"Dimensionen: {len(embedding)}")
# Output: Dimensionen: 768

Praxisbeispiel: RAG-Pipeline

import chromadb
import requests

# 1. Dokumente embedden und speichern
chroma = chromadb.HttpClient(host="chromadb", port=8000)
collection = chroma.get_or_create_collection("dokumente")

documents = [
    "Der Hund spielt im Garten.",
    "Katzen schlafen gerne auf dem Sofa.",
    "Vögel fliegen am Himmel."
]

for i, doc in enumerate(documents):
    embedding = get_embedding(doc)
    collection.add(
        ids=[f"doc_{i}"],
        documents=[doc],
        embeddings=[embedding]
    )

# 2. Semantische Suche
query = "Welches Tier spielt draußen?"
query_embedding = get_embedding(query)

results = collection.query(
    query_embeddings=[query_embedding],
    n_results=1
)

print(results["documents"][0])
# Output: ["Der Hund spielt im Garten."]

Praxisbeispiel: Deutsche Dokumente

# multilingual-e5 für deutsche Dokumente
def get_german_embedding(text):
    response = requests.post(
        "http://ollama:11434/api/embeddings",
        json={
            "model": "multilingual-e5",
            "prompt": text
        }
    )
    return response.json()["embedding"]

# Deutsche Dokumente
docs = [
    "Der Mitarbeiter beantragt Urlaub.",
    "Die Rechnung ist fällig.",
    "Das Meeting findet morgen statt."
]

for doc in docs:
    emb = get_german_embedding(doc)
    # In Vektordatenbank speichern

Sicherheitshinweise

• Embeddings sind nicht reversibel: Man kann aus dem Vektor nicht den Originaltext rekonstruieren. Aber sie können sensible Informationen enthalten.
• Lokale Embeddings: Bei Ollama bleiben alle Embeddings lokal. Bei Cloud-APIs gehen Texte raus.
• Bias: Embedding-Modelle haben Bias. Für kritische Anwendungen testen.
• Dimensionen: Höhere Dimensionen = mehr Speicher, aber nicht immer besser.

Typische Stolpersteine

• Falsches Modell für Sprache: nomic-embed-text für deutsche Dokumente = suboptimal. Nutze multilingual-e5.
• Zu kurze Kontextlänge: Lange Dokumente müssen ge-chunked werden. bge-m3 oder gte-Qwen2 für lange Texte.
• Embedding-Modell für Generierung: Embedding-Modelle generieren keinen Text. Sie erstellen nur Vektoren.
• Vergleich ohne Normalisierung: Cosine Similarity braucht normalisierte Vektoren.
• Zu viele Dimensionen: 1536 Dimensionen brauchen mehr Speicher und sind nicht immer besser.

Weiterführende Links

• Embeddings - Grundlagen.
• Embedding-Modelle - Für RAG.
• Lokales RAG - RAG-Pipeline.
• Vektordatenbanken - Speicher.
• Ollama - Modellserver.
• Chunking - Text-Aufteilung.
• Hybrid Search - Kombinierte Suche.

Key Takeaways:

• Embeddings wandeln Text in Vektoren für semantische Suche.
• nomic-embed-text = Standard für Englisch.
• multilingual-e5 = bestes für Deutsch und Mehrsprachigkeit.
• bge-m3 = bestes für lange Dokumente.
• gte-Qwen2 = für sehr lange Dokumente (32K).
• Für deutsche RAG: multilingual-e5 oder bge-m3.

FAQ

Quellen und weiterführende Literatur

• nomic-embed-text - Ollama-Modell.
• multilingual-e5 - Microsoft-Modell.
• bge-m3 - BAAI-Modell.
• Ollama Embeddings - Embedding-API.
• MTEB Leaderboard - Embedding-Benchmarks.