Embeddings

Vor der Implementierung von Embeddings

Bei der Auswahl eines Embeddings-Anbieters gibt es mehrere Faktoren, die du je nach deinen Bedürfnissen und Vorlieben berücksichtigen kannst:

• Datensatzgröße und Domänenspezifität: Größe des Trainingsdatensatzes des Modells und seine Relevanz für die Domäne, die du einbetten möchtest. Größere oder domänenspezifischere Daten erzeugen im Allgemeinen bessere domäneninterne Embeddings
• Inferenzleistung: Geschwindigkeit der Embedding-Abfrage und End-to-End-„Latency“ (Latenz). Dies ist ein besonders wichtiger Aspekt für groß angelegte Produktionsbereitstellungen
• Anpassung: Optionen für fortgesetztes Training auf privaten Daten oder die Spezialisierung von Modellen für sehr spezifische Domänen. Dies kann die Leistung bei einzigartigen Vokabularen verbessern

So erhältst du Embeddings mit Anthropic

Anthropic bietet kein eigenes Embedding-Modell an. Ein Embeddings-Anbieter mit einer großen Vielfalt an Modellen und Fähigkeiten ist Voyage AI von MongoDB.

Voyage AI entwickelt Embedding-Modelle und „rerankers“ (Neubewertungsmodelle). Zu seinen Embedding-Modellen gehören allgemeine, multimodale, kontextualisierte und domänenspezifische Modelle.

Der Rest dieses Leitfadens bezieht sich auf Voyage AI, aber du solltest verschiedene Embeddings-Anbieter prüfen, um die beste Lösung für deinen spezifischen Anwendungsfall zu finden.

Verfügbare Modelle

Voyage AI bietet die folgenden Text-Embedding-Modelle an:

Neueste Generation

Vorherige Generation

Den Lebenszyklusstatus und den empfohlenen Ersatz für jedes Modell findest du unter Model deprecations, lifecycle states, and support in der MongoDB-Dokumentation.

Zusätzlich bietet Voyage AI die folgenden multimodalen Embedding-Modelle an. Rufe diese Modelle mit multimodal_embed() statt mit embed() auf:

Die folgenden kontextualisierten Chunk-Embedding-Modelle erzeugen Vektoren auf Chunk-Ebene, die den vollständigen Dokumentkontext ohne manuelle Metadaten-Anreicherung erfassen. Rufe diese Modelle mit contextualized_embed() statt embed() auf:

Das Limit von 120.000 Token gilt, wenn du enable_auto_chunking auf true setzt. Andernfalls darf die Gesamtzahl der Token über alle Eingaben hinweg 32.000 nicht überschreiten.

Voyage AI bietet außerdem Reranker an, die eine Abfrage und eine Liste von Dokumenten entgegennehmen und diese nach Relevanz für die Abfrage sortiert zurückgeben. Rufe diese Modelle mit rerank() auf:

Brauchst du Hilfe bei der Entscheidung, welches Modell du verwenden sollst? Siehe Voyage AI embedding and reranking models overview in der MongoDB-Dokumentation.

Erste Schritte mit Voyage AI

Um auf Voyage-AI-Modelle zuzugreifen, erstelle einen Modell-API-Key in MongoDB Atlas:

1. Registriere dich für ein MongoDB-Atlas-Konto oder melde dich an.
2. Wähle in deinem Atlas-Projekt in der Navigationsleiste AI Model APIs aus, klicke auf Create model API key, benenne den Key und klicke auf Create.
3. Lege den API-Key der Einfachheit halber als Umgebungsvariable fest:

export VOYAGE_API_KEY=""

Weitere Details findest du unter Voyage AI quick start in der MongoDB-Dokumentation.

Du kannst die Embeddings entweder über das offizielle voyageai-Python-Paket oder über HTTP-Anfragen abrufen, wie in den folgenden Abschnitten beschrieben. Voyage AI hat außerdem einen offiziellen TypeScript-Client. Um ihn mit einem Modell-API-Key aus Atlas zu verwenden, setze seine Option environment auf https://ai.mongodb.com/v1, wie unter TypeScript client in der MongoDB-Dokumentation beschrieben.

Voyage-AI-Python-Bibliothek

Installiere das Paket voyageai mit dem folgenden Befehl. Um einen Modell-API-Key aus Atlas zu verwenden, benötigst du Version 0.3.7 oder höher.

pip install -U voyageai

Anschließend kannst du ein Client-Objekt erstellen und damit beginnen, deine Texte einzubetten:

import voyageai

vo = voyageai.Client()
# Hierbei wird automatisch die Umgebungsvariable VOYAGE_API_KEY verwendet.
# Alternativ kannst du vo = voyageai.Client(api_key="") verwenden

texts = ["Sample text 1", "Sample text 2"]

result = vo.embed(texts, model="voyage-4", input_type="document")
print(result.embeddings[0])
print(result.embeddings[1])

result.embeddings ist eine Liste von zwei Embedding-Vektoren, die jeweils 1024 Gleitkommazahlen enthalten. Nach dem Ausführen des obigen Codes werden die beiden Embeddings auf dem Bildschirm ausgegeben:

[-0.013131560757756233, 0.019828535616397858, ...]   # embedding for "Sample text 1"
[-0.0069352793507277966, 0.020878976210951805, ...]  # embedding for "Sample text 2"

Beim Erstellen der Embeddings kannst du der Funktion embed() einige weitere Argumente übergeben.

Weitere Informationen zum Python-Paket findest du unter Accessing Voyage AI models in der MongoDB-Dokumentation.

Voyage-AI-HTTP-API

Du kannst Embeddings auch abrufen, indem du HTTP-Anfragen an die Atlas Embedding and Reranking API sendest. Beispielsweise kannst du eine HTTP-Anfrage über den Befehl curl in einem Terminal senden:

curl https://ai.mongodb.com/v1/embeddings \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $VOYAGE_API_KEY" \
  -d '{
    "input": ["Sample text 1", "Sample text 2"],
    "model": "voyage-4",
    "input_type": "document"
  }'

Die Antwort, die du erhältst, ist ein JSON-Objekt, das die Embeddings und die Token-Nutzung enthält:

{
  "object": "list",
  "data": [
    {
      "object": "embedding",
      "embedding": [-0.013131560757756233, 0.019828535616397858 /* ... */],
      "index": 0
    },
    {
      "object": "embedding",
      "embedding": [-0.0069352793507277966, 0.020878976210951805 /* ... */],
      "index": 1
    }
  ],
  "model": "voyage-4",
  "usage": {
    "total_tokens": 10
  }
}

Modell-API-Keys aus Atlas funktionieren mit ai.mongodb.com, mit Ausnahme von Keys, die auf eine Region beschränkt sind; diese verwenden den Endpunkt der jeweiligen Region. Wenn du stattdessen einen API-Key von der Voyage-AI-Plattform hast, siehe Migrate your applications to use the Atlas Embedding and Reranking API in der MongoDB-Dokumentation.

Die vollständige Referenz zu Anfragen und Antworten findest du unter Create text embeddings in der Dokumentation der Atlas Embedding and Reranking API.

AWS Marketplace

Voyage-AI-Modelle sind auch im AWS Marketplace über das Verkäuferprofil von MongoDB verfügbar. Eine Anleitung findest du unter Deploy Voyage AI models using AWS Marketplace in der MongoDB-Dokumentation.

Schnellstart-Beispiel

Das folgende kurze Beispiel zeigt, wie du Embeddings verwendest.

Angenommen, du hast einen kleinen Korpus von sechs Dokumenten, aus dem abgerufen werden soll

documents = [
    "The Mediterranean diet emphasizes fish, olive oil, and vegetables, believed to reduce chronic diseases.",
    "Photosynthesis in plants converts light energy into glucose and produces essential oxygen.",
    "20th-century innovations, from radios to smartphones, centered on electronic advancements.",
    "Rivers provide water, irrigation, and habitat for aquatic species, vital for ecosystems.",
    "Apple's conference call to discuss fourth fiscal quarter results and business updates is scheduled for Thursday, November 2, 2023 at 2:00 p.m. PT / 5:00 p.m. ET.",
    "Shakespeare's works, like 'Hamlet' and 'A Midsummer Night's Dream,' endure in literature.",
]

Verwende zunächst Voyage AI, um jedes Dokument in einen Embedding-Vektor umzuwandeln.

import voyageai

vo = voyageai.Client()

# Bette die Dokumente ein
doc_embds = vo.embed(documents, model="voyage-4", input_type="document").embeddings

Die Embeddings ermöglichen dir semantische Suche / Retrieval im Vektorraum. Gegeben sei eine Beispielabfrage,

query = "When is Apple's conference call scheduled?"

Wandle sie als Nächstes in ein Embedding um und führe eine Nächste-Nachbarn-Suche durch, um das relevanteste Dokument anhand der Distanz im Embedding-Raum zu finden.

import numpy as np

# Bette die Abfrage ein
query_embd = vo.embed([query], model="voyage-4", input_type="query").embeddings[0]

# Berechne die Ähnlichkeit
# Voyage AI-Embeddings sind auf Länge 1 normiert, daher sind Skalarprodukt
# und Kosinus-Ähnlichkeit identisch.
similarities = np.dot(doc_embds, query_embd)

retrieved_id = np.argmax(similarities)
print(documents[retrieved_id])

Beachte, dass input_type="document" und input_type="query" zum Einbetten des Dokuments bzw. der Abfrage verwendet werden. Mehr zu input_type findest du unter Wann und wie sollte ich den Parameter input_type verwenden? in den FAQ.

Die Ausgabe ist das fünfte Dokument, das tatsächlich das relevanteste für die Abfrage ist:

Apple's conference call to discuss fourth fiscal quarter results and business updates is scheduled for Thursday, November 2, 2023 at 2:00 p.m. PT / 5:00 p.m. ET.

Wenn du nach einer detaillierten Sammlung von Rezepten suchst, wie du RAG mit Embeddings einschließlich Vektordatenbanken umsetzt, sieh dir das RAG-Rezept an.

FAQ

import voyageai
import numpy as np


def embd_normalize(v: np.ndarray) -> np.ndarray:
    """
    Normalize the rows of a 2D numpy array to unit vectors by dividing each row by its Euclidean
    norm. Raises a ValueError if any row has a norm of zero to prevent division by zero.
    """
    row_norms = np.linalg.norm(v, axis=1, keepdims=True)
    if np.any(row_norms == 0):
        raise ValueError("Cannot normalize rows with a norm of zero.")
    return v / row_norms


vo = voyageai.Client()

# Erzeuge voyage-code-4-Vektoren, standardmäßig 1024-dimensionale Gleitkommazahlen
embd = vo.embed(["Sample text 1", "Sample text 2"], model="voyage-code-4").embeddings

# Lege eine kürzere Dimension fest
short_dim = 256

# Kürze die Vektoren auf die kürzere Dimension und normalisiere sie
resized_embd = embd_normalize(np.array(embd)[:, :short_dim]).tolist()

Preise

Die aktuellsten Preisdetails findest du unter Model pricing in der MongoDB-Dokumentation.