Das mistral-embed-Modell
Auf dieser Seite
Überblick über mistral-embed
mistral-embed ist das Text-Embedding-Modell von Mistral AI. Es wandelt beliebigen Text in einen 1024-dimensionalen Vektor um, unabhängig von der Eingabelänge – sei es ein kurzer Satz oder ein ganzer Absatz, das Ausgabe-Vektor hat stets dieselbe Größe. Diese feste Dimensionalität ist kein Detail: Sie ermöglicht es Ihnen, sowohl einen Produkttitel als auch seine vollständige Beschreibung im selben Vektorraum zu indizieren und sie direkt zu vergleichen, ohne dass spezielle Verarbeitungsschritte erforderlich sind, um unterschiedliche Formate auszugleichen.
Dieses Modell ist für semantische Suche, Klassifizierung und Clustering-Aufgaben bei natürlichsprachigem Text (Artikel, Dokumente, Gespräche und mehr) optimiert. Nutzen Sie es, um eine Wissensdatenbank, eine FAQ, Transkripte von Meetings oder ein Jahrzehnt Support-Tickets zu indizieren.
Einrichtung und Installation
Bevor Sie die API aufrufen, installieren Sie das Mistral Python SDK und konfigurieren Sie Ihren API-Schlüssel:
# Installation
# pip install mistralai
import os
from mistralai.client import Mistral
# Initialisierung des Clients
api_key = os.environ.get("MISTRAL_API_KEY")
client = Mistral(api_key=api_key)Holen Sie sich Ihren API-Schlüssel aus der Mistral-Konsole. Speichern Sie ihn in einer Umgebungsvariable, um ihn aus Ihrem Code herauszuhalten. Das Lesen über os.environ.get ist nicht nur theoretische Hygiene: Es verhindert, dass Ihr Schlüssel in einer Git-History-Snapshot landet, an dem Tag, an dem Ihr Projekt veröffentlicht wird.
Generierung von Embeddings
Der API-Aufruf ist unkompliziert: Übermitteln Sie eine Liste von Texten und rufen Sie die entsprechenden Vektoren ab. Beachten Sie, dass selbst für einen einzelnen Text die Eingabe eine Liste sein muss – die API arbeitet stets im Batch-Modus, was sich lohnt, sobald Ihr Korpus wächst.
from mistralai.client import Mistral
client = Mistral(api_key=api_key)
# Generierung von Embeddings für einen oder mehrere Texte
response = client.embeddings.create(
model="mistral-embed",
inputs=[
"Embeddings erfassen semantische Bedeutung.",
"Mistral AI bietet Hochleistungsmodelle.",
"RAG verbessert die Antwortqualität."
],
)
# Zugriff auf die Vektoren
for i, data in enumerate(response.data):
print(f"Text {i+1}: Vektor mit {len(data.embedding)} Dimensionen")
print(f" Erste Elemente: {data.embedding[:5]}")Typische Ausgabe:
Text 1: Vektor mit 1024 Dimensionen
Erste Elemente: [0.0234, -0.1567, 0.0891, 0.0123, -0.0456]
Text 2: Vektor mit 1024 Dimensionen
Erste Elemente: [0.0189, -0.1234, 0.0678, 0.0345, -0.0567]
Text 3: Vektor mit 1024 Dimensionen
Erste Elemente: [0.0312, -0.1456, 0.0789, 0.0234, -0.0345]Struktur der API-Antwort
Die Antwort enthält mehr als nur Vektoren. Sie gibt auch an, welches Modell tatsächlich verwendet wurde und wie viele Token verbraucht wurden – zwei Informationen, die Sie protokollieren möchten, sobald die Codierung in der Produktion läuft und jemand die Rechnung erklären muss. Achten Sie besonders auf das Feld index: Es zeigt die Position des Textes in der von Ihnen gesendeten Liste an und ermöglicht es Ihnen, jeden Vektor wieder mit seinem Quelldokument zu verknüpfen.
response = client.embeddings.create(
model="mistral-embed",
inputs=["Beispieltext zur Codierung."],
)
# Antwortobjekt
print(response.model) # "mistral-embed"
print(response.usage) # verbrauchte Token
# Embedding-Daten
embedding_data = response.data[0]
print(embedding_data.index) # 0 (Position in der inputs-Liste)
print(len(embedding_data.embedding)) # 1024
print(type(embedding_data.embedding)) # list[float]Vollständiges Beispiel: Codieren und Speichern
Hier ist eine typische Pipeline zum Codieren eines Dokumentenkorpus und zur Vorbereitung der Vektoren für spätere Suche. Der Wechsel zu NumPy ist der kritische Schritt: Während Ihre Vektoren Python-Listen sind, findet jede Ähnlichkeitsberechnung elementweise statt; sobald Sie eine Matrix aufgebaut haben, vergleicht eine einzelne Operation die Abfrage gegen das gesamte Korpus.
import numpy as np
from mistralai.client import Mistral
client = Mistral(api_key=api_key)
# Dokumentenkorpus
documents = [
"Mistral AI ist ein französisches Unternehmen für künstliche Intelligenz.",
"RAG kombiniert Informationsabruf und Textgenerierung.",
"Embeddings ermöglichen semantische Suche.",
"Python ist die am weitesten verbreitete Sprache in der Datenwissenschaft.",
"FAISS ist eine Vektorsuch-Bibliothek von Meta.",
]
# Codierung aller Dokumente
response = client.embeddings.create(
model="mistral-embed",
inputs=documents,
)
# Umwandlung in eine NumPy-Matrix für Berechnungen
embeddings_matrix = np.array([d.embedding for d in response.data])
print(f"Embedding-Matrix: {embeddings_matrix.shape}")
# Embedding-Matrix: (5, 1024)
# Speichern für späteren Gebrauch
np.save("document_embeddings.npy", embeddings_matrix)Das Speichern als .npy vermeidet die Kosten, jedes Mal neu zu codieren, wenn Ihre Anwendung neu gestartet wird. Bei einem Korpus von mehreren tausend Dokumenten ist dies der Unterschied zwischen einem sofortigen Start und mehreren Minuten an abgerechneten API-Aufrufen.
Grenzen und Best Practices
Vier Faktoren bestimmen die Qualität Ihrer Ergebnisse. Erstens die maximale Länge: Das Modell kürzt Texte, die zu lang sind, und diese Kürzung erfolgt stumm – ein 40-seitiger Bericht, der in einem Block codiert wird, repräsentiert effektiv nur seinen Anfang. Bevorzugen Sie Abschnitte von 512 bis 2048 Token, die im Abschnitt zum Chunking behandelt werden.
Zweitens unterscheidet sich mistral-embed von manchen anderen APIs darin, dass es zwischen query und document nicht unterscheidet: Es gibt keine Eingabetypen, Sie übermitteln einfach den Text. In der Praxis durchlaufen Benutzerfragen und indizierte Dokumente denselben Aufruf mit denselben Parametern, was Ihren Suchcode vereinfacht.
Der dritte Punkt ist die Kosten: Embeddings werden pro Token abgerechnet. Das Codieren von tausend Dokumenten einzeln kostet in Token genauso viel wie das Codieren in einem Batch, aber es vervielfacht die Netzwerk-Roundtrips und die Verarbeitungszeit; Sie optimieren dies durch das Batchen von Aufrufen, was Gegenstand der nächsten Lektion zum Batchen ist. Schließlich hilft Ihnen die Determiniertheit: Für denselben Text gibt das Modell stets denselben Vektor zurück. Sie können Embeddings daher nach Text-Hash zwischenspeichern und nur neu codieren, was sich zwischen zwei Versionen eines Dokuments tatsächlich geändert hat.
Kernaussagen
- mistral-embed erzeugt 1024-dimensionale Vektoren für beliebigen Text
- Die API akzeptiert eine Liste von Eingaben und gibt die entsprechenden Vektoren zurück
- Vektoren sind Listen von Floats, die leicht in NumPy-Arrays umgewandelt werden können
- Speichern Sie Ihre Embeddings als NumPy-Matrix für Ähnlichkeitsberechnungen
- Denken Sie daran, lange Texte vor der Codierung aufzuteilen