--- title: Embeddings url: https://platform.claude.com/docs/de/build-with-claude/embeddings description: Text-Embeddings sind numerische Darstellungen von Text, die das Messen semantischer Ähnlichkeit ermöglichen. Dieser Leitfaden führt in Embeddings, ihre Anwendungen und die Verwendung von Embedding-Modellen für Aufgaben wie Suche, Empfehlungen und Anomalieerkennung ein. --- ## 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** | Modell | Kontextlänge | Embedding-Dimension | Beschreibung | | ---------------- | ------------ | ------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `voyage-4-large` | 32.000 | 1024 (Standard), 256, 512, 2048 | Die beste allgemeine und mehrsprachige Retrieval-Qualität. Siehe den [Voyage-4-Blogbeitrag](https://blog.voyageai.com/2026/01/15/voyage-4/) für Details. | | `voyage-4` | 32.000 | 1024 (Standard), 256, 512, 2048 | Optimiert für allgemeine und mehrsprachige Retrieval-Qualität. Balanciert Qualität und Effizienz. Siehe den [Voyage-4-Blogbeitrag](https://blog.voyageai.com/2026/01/15/voyage-4/) für Details. | | `voyage-4-lite` | 32.000 | 1024 (Standard), 256, 512, 2048 | Optimiert für Latenz und Kosten. Siehe den [Voyage-4-Blogbeitrag](https://blog.voyageai.com/2026/01/15/voyage-4/) für Details. | | `voyage-code-4` | 32.000 | 1024 (Standard), 256, 512, 2048 | Optimiert für **Code**-Retrieval und agentische Coding-Anwendungen. Siehe den [voyage-code-4-Blogbeitrag](https://blog.voyageai.com/2026/08/13/voyage-code-4/) für Details. | | `voyage-4-nano` | 32.000 | 2048 (Standard), 256, 512, 1024 | Open-Weight-Modell (Apache-2.0-Lizenz), das du von [Hugging Face](https://huggingface.co/voyageai/voyage-4-nano) herunterlädst und selbst ausführst. Nicht über die Atlas Embedding and Reranking API verfügbar. Siehe den [Voyage-4-Blogbeitrag](https://blog.voyageai.com/2026/01/15/voyage-4/) für Details. | **Vorherige Generation** Den Lebenszyklusstatus und den empfohlenen Ersatz für jedes Modell findest du unter [Model deprecations, lifecycle states, and support](https://www.mongodb.com/docs/voyageai/models/lifecycle/) in der MongoDB-Dokumentation. | Modell | Kontextlänge | Embedding-Dimension | Beschreibung | | ------------------ | ------------ | ------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `voyage-3-large` | 32.000 | 1024 (Standard), 256, 512, 2048 | Vorherige Generation von `voyage-4-large`. Details findest du im [voyage-3-large-Blogbeitrag](https://blog.voyageai.com/2025/01/07/voyage-3-large/). | | `voyage-3.5` | 32.000 | 1024 (Standard), 256, 512, 2048 | Vorherige Generation von `voyage-4`. Details findest du im [voyage-3.5-Blogbeitrag](https://blog.voyageai.com/2025/05/20/voyage-3-5/). | | `voyage-3.5-lite` | 32.000 | 1024 (Standard), 256, 512, 2048 | Vorherige Generation von `voyage-4-lite`. Details findest du im [voyage-3.5-Blogbeitrag](https://blog.voyageai.com/2025/05/20/voyage-3-5/). | | `voyage-code-3` | 32.000 | 1024 (Standard), 256, 512, 2048 | Vorherige Generation von `voyage-code-4`. Details findest du im [voyage-code-3-Blogbeitrag](https://blog.voyageai.com/2024/12/04/voyage-code-3/). | | `voyage-finance-2` | 32.000 | 1024 | Optimiert für **Finanz**-Retrieval und RAG. Details findest du im [voyage-finance-2-Blogbeitrag](https://blog.voyageai.com/2024/06/03/domain-specific-embeddings-finance-edition-voyage-finance-2/). | | `voyage-law-2` | 16.000 | 1024 | Optimiert für **juristisches** Retrieval und RAG. Details findest du im [voyage-law-2-Blogbeitrag](https://blog.voyageai.com/2024/04/15/domain-specific-embeddings-and-retrieval-legal-edition-voyage-law-2/). | Zusätzlich bietet Voyage AI die folgenden multimodalen Embedding-Modelle an. Rufe diese Modelle mit `multimodal_embed()` statt mit `embed()` auf: | Modell | Kontextlänge | Embedding-Dimension | Beschreibung | | ----------------------- | ------------ | ------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `voyage-multimodal-3.5` | 32.000 | 1024 (Standard), 256, 512, 2048 | Leistungsfähiges multimodales Embedding-Modell, das verschachtelten Text, Bilder und Videos vektorisieren kann. Bietet Videounterstützung als erstes produktionsreifes Video-Embedding-Modell. Details findest du im [voyage-multimodal-3.5-Blogbeitrag](https://blog.voyageai.com/2026/01/15/voyage-multimodal-3-5/). | | `voyage-multimodal-3` | 32.000 | 1024 | Vorherige Generation von `voyage-multimodal-3.5`. Vektorisiert verschachtelten Text und inhaltsreiche Bilder, wie Screenshots von PDFs, Folien, Tabellen, Abbildungen und mehr. Details findest du im [voyage-multimodal-3-Blogbeitrag](https://blog.voyageai.com/2024/11/12/voyage-multimodal-3/). | 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: | Modell | Kontextlänge | Embedding-Dimension | Beschreibung | | ------------------ | ------------ | ------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `voyage-context-4` | 120.000 | 1024 (Standard), 256, 512, 2048 | Kontextualisierte Chunk-Embeddings, optimiert für allgemeine und mehrsprachige Retrieval-Qualität. Details findest du im [voyage-context-4-Blogbeitrag](https://blog.voyageai.com/2026/06/29/voyage-context-4/). | | `voyage-context-3` | 120.000 | 1024 (Standard), 256, 512, 2048 | Vorherige Generation von `voyage-context-4`. Details findest du im [voyage-context-3-Blogbeitrag](https://blog.voyageai.com/2025/07/23/voyage-context-3/). | 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: | Modell | Kontextlänge | Beschreibung | | ----------------- | ------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------- | | `rerank-3` | 32.000 | Höchste Genauigkeit. Empfohlen für die meisten Anwendungen. Details findest du im [rerank-3-Blogbeitrag](https://blog.voyageai.com/2026/09/30/rerank-3/). | | `rerank-3-lite` | 32.000 | Optimiert für Latenz und Kosten. Details findest du im [rerank-3-Blogbeitrag](https://blog.voyageai.com/2026/09/30/rerank-3/). | | `rerank-2.5` | 32.000 | Vorherige Generation von `rerank-3`. Details findest du im [rerank-2.5-Blogbeitrag](https://blog.voyageai.com/2025/08/11/rerank-2-5/). | | `rerank-2.5-lite` | 32.000 | Vorherige Generation von `rerank-3-lite`. Details findest du im [rerank-2.5-Blogbeitrag](https://blog.voyageai.com/2025/08/11/rerank-2-5/). | Brauchst du Hilfe bei der Entscheidung, welches Modell du verwenden sollst? Siehe [Voyage AI embedding and reranking models overview](https://www.mongodb.com/docs/voyageai/models/) 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: ```bash export VOYAGE_API_KEY="" ``` Weitere Details findest du unter [Voyage AI quick start](https://www.mongodb.com/docs/voyageai/quickstart/) in der MongoDB-Dokumentation. Du kannst die Embeddings entweder über das offizielle [`voyageai`-Python-Paket](https://github.com/voyage-ai/voyageai-python) 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](https://www.mongodb.com/docs/voyageai/api-and-clients/#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. ```bash pip install -U voyageai ``` Anschließend kannst du ein Client-Objekt erstellen und damit beginnen, deine Texte einzubetten: ```python 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: ```text [-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](https://www.mongodb.com/docs/voyageai/api-and-clients/) 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: ```bash cURL 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: ```json { "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](https://www.mongodb.com/docs/voyageai/tutorials/migrate-to-atlas/) in der MongoDB-Dokumentation. Die vollständige Referenz zu Anfragen und Antworten findest du unter [Create text embeddings](https://www.mongodb.com/docs/api/doc/atlas-embedding-and-reranking-api/operation/operation-createembedding) 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](https://aws.amazon.com/marketplace/seller-profile?id=c9032c7b-70dd-459f-834f-c1e23cf3d092) verfügbar. Eine Anleitung findest du unter [Deploy Voyage AI models using AWS Marketplace](https://www.mongodb.com/docs/voyageai/management/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 ```python 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. ```python 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, ```python 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. ```python 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?](https://platform.claude.com/docs/de/build-with-claude/embeddings#faq) in den FAQ. Die Ausgabe ist das fünfte Dokument, das tatsächlich das relevanteste für die Abfrage ist: ```text wrap 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](https://platform.claude.com/cookbook/third-party-pinecone-rag-using-pinecone) an. ## FAQ Embedding-Modelle stützen sich auf leistungsstarke neuronale Netze, um semantischen Kontext zu erfassen und zu komprimieren, ähnlich wie generative Modelle. Das Team erfahrener KI-Forscher von Voyage AI optimiert jede Komponente des Embedding-Prozesses, darunter: * Modellarchitektur * Datenerhebung * Verlustfunktionen * Auswahl des Optimierers Erfahre mehr über den technischen Ansatz von Voyage AI im [Voyage-AI-Blog](https://blog.voyageai.com/). Für allgemeine Embeddings sind die empfohlenen Modelle: * `voyage-4-large`: Beste Qualität * `voyage-4-lite`: Niedrigste Latenz und Kosten * `voyage-4`: Ausgewogene Leistung Verwende für Retrieval den Parameter `input_type`, um anzugeben, ob der Text vom Typ Abfrage oder Dokument ist. Domänenspezifische Modelle: * Juristische Aufgaben: `voyage-law-2` * Code-Retrieval und agentisches Coding: `voyage-code-4` * Finanzbezogene Aufgaben: `voyage-finance-2` Für Retrieval auf Chunk- und Dokumentebene: `voyage-context-4` Für Text, Bilder und Video: `voyage-multimodal-3.5` Du kannst Voyage-AI-Embeddings mit Skalarprodukt-Ähnlichkeit, Kosinus-Ähnlichkeit oder euklidischer Distanz verwenden. Eine Erklärung zur Embedding-Ähnlichkeit findest du in diesem [Leitfaden zur Vektorähnlichkeit](https://www.pinecone.io/learn/vector-similarity/). Voyage-AI-Embeddings sind auf die Länge 1 normalisiert, was bedeutet, dass: * Kosinus-Ähnlichkeit äquivalent zur Skalarprodukt-Ähnlichkeit ist, wobei letztere schneller berechnet werden kann. * Kosinus-Ähnlichkeit und euklidische Distanz zu identischen Rangfolgen führen. Siehe [Tokenization](https://www.mongodb.com/docs/voyageai/tutorials/tokenization/) in der MongoDB-Dokumentation. Verwende für alle Retrieval-Aufgaben und Anwendungsfälle (zum Beispiel RAG) den Parameter `input_type`, um anzugeben, ob der Eingabetext eine Abfrage oder ein Dokument ist. Lass `input_type` nicht weg und setze nicht `input_type=None`. Die Angabe, ob der Eingabetext eine Abfrage oder ein Dokument ist, kann bessere dichte Vektordarstellungen für das Retrieval erzeugen, was zu einer besseren Retrieval-Qualität führen kann. Bei Verwendung des Parameters `input_type` werden dem Eingabetext vor dem Einbetten spezielle Prompts vorangestellt. Konkret: > 📘 **Mit `input_type` verknüpfte Prompts** > > * Für eine Abfrage lautet der Prompt `"Represent the query for retrieving supporting documents: "`. > > * Für ein Dokument lautet der Prompt `"Represent the document for retrieval: "`. > > * Beispiel > > * Bei `input_type="query"` wird eine Abfrage wie „When is Apple's conference call scheduled?“ zu „**Represent the query for retrieving supporting documents:** When is Apple's conference call scheduled?“ > * Bei `input_type="document"` wird ein Dokument wie „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.“ zu „**Represent the document for retrieval:** 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.“ Die „quantization“ (Quantisierung) bei Embeddings wandelt hochpräzise Werte, wie 32-Bit-Gleitkommazahlen mit einfacher Genauigkeit, in Formate mit geringerer Präzision wie 8-Bit-Ganzzahlen oder 1-Bit-Binärwerte um und reduziert so Speicherplatz, Arbeitsspeicher und Kosten um das 4-Fache bzw. 32-Fache. Unterstützte Voyage-AI-Modelle ermöglichen die Quantisierung, indem du den Ausgabedatentyp mit dem Parameter `output_dtype` angibst: * `float`: Jedes zurückgegebene Embedding ist eine Liste von 32-Bit-Gleitkommazahlen (4 Byte) mit einfacher Genauigkeit. Dies ist der Standard und bietet die höchste Präzision bzw. Retrieval-Genauigkeit. * `int8` und `uint8`: Jedes zurückgegebene Embedding ist eine Liste von 8-Bit-Ganzzahlen (1 Byte) im Bereich von -128 bis 127 bzw. 0 bis 255. * `binary` und `ubinary`: Jedes zurückgegebene Embedding ist eine Liste von 8-Bit-Ganzzahlen, die bitgepackte, quantisierte Einzelbit-Embedding-Werte darstellen: `int8` für `binary` und `uint8` für `ubinary`. Die Länge der zurückgegebenen Liste von Ganzzahlen beträgt 1/8 der tatsächlichen Dimension des Embeddings. Der Binärtyp verwendet die Offset-Binary-Methode, wie das folgende Beispiel zeigt. > **Beispiel für binäre Quantisierung** > > Betrachte die folgenden acht Embedding-Werte: -0.03955078, 0.006214142, -0.07446289, -0.039001465, 0.0046463013, 0.00030612946, -0.08496094 und 0.03994751. Bei der binären Quantisierung werden Werte kleiner oder gleich null zu einer binären Null und positive Werte zu einer binären Eins quantisiert, was die folgende Binärsequenz ergibt: 0, 1, 0, 0, 1, 1, 0, 1. Diese acht Bits werden dann in eine einzelne 8-Bit-Ganzzahl gepackt, 01001101 (wobei das Bit ganz links das höchstwertige Bit ist). > > * `ubinary`: Die Binärsequenz wird direkt umgewandelt und als vorzeichenlose Ganzzahl (`uint8`) 77 dargestellt. > * `binary`: Die Binärsequenz wird als vorzeichenbehaftete Ganzzahl (`int8`) -51 dargestellt, berechnet mit der Offset-Binary-Methode (77 - 128 = -51). Welche Modelle die einzelnen Datentypen unterstützen, findest du unter [Create text embeddings](https://www.mongodb.com/docs/api/doc/atlas-embedding-and-reranking-api/operation/operation-createembedding) in der Dokumentation der Atlas Embedding and Reranking API. Matryoshka-Learning erzeugt Embeddings mit Darstellungen von grob bis fein innerhalb eines einzigen Vektors. Voyage-AI-Modelle, die mehrere Ausgabedimensionen unterstützen, wie `voyage-code-4`, erzeugen solche Matryoshka-Embeddings. Um kürzere Vektoren von der API zu erhalten, übergib `output_dimension` (zum Beispiel `output_dimension=256`). Um bereits gespeicherte Vektoren zu verkürzen, kürze sie, indem du die führende Teilmenge der Dimensionen beibehältst, und normalisiere sie anschließend erneut. Der folgende Python-Code zeigt beispielsweise, wie du 1024-dimensionale Vektoren auf 256 Dimensionen kürzt: ```python 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](https://www.mongodb.com/docs/voyageai/management/billing/#model-pricing) in der MongoDB-Dokumentation.