Einbettungen

Die Gemini API bietet Modelle für Texteinbettung, mit denen Einbettungen für Wörter, Wortgruppen, Sätze und Code generiert werden können. Einbettungsaufgaben wie semantische Suche, Klassifizierung und Clustering, die genauere, kontextbezogene Ergebnisse als stichwortbasierte Ansätze liefern.

Das Erstellen von RAG-Systemen (Retrieval Augmented Generation) ist ein häufiger Anwendungsfall für KI-Produkte. Embeddings spielen eine wichtige Rolle bei der deutlichen Verbesserung der Modellausgaben in Bezug auf faktenorientierte Genauigkeit, Kohärenz und Kontextreichtum. Wenn Sie lieber eine verwaltete RAG-Lösung verwenden möchten, haben wir das Tool Dateisuche entwickelt, mit dem sich RAG einfacher verwalten lässt und kostengünstiger ist.

Einbettungen generieren

Verwenden Sie die Methode embedContent, um Texteinbettungen zu generieren:

Python

from google import genai

client = genai.Client()

result = client.models.embed_content(
        model="gemini-embedding-001",
        contents="What is the meaning of life?"
)

print(result.embeddings)

JavaScript

import { GoogleGenAI } from "@google/genai";

async function main() {

    const ai = new GoogleGenAI({});

    const response = await ai.models.embedContent({
        model: 'gemini-embedding-001',
        contents: 'What is the meaning of life?',
    });

    console.log(response.embeddings);
}

main();

Ok

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "log"

    "google.golang.org/genai"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, nil)
    if err != nil {
        log.Fatal(err)
    }

    contents := []*genai.Content{
        genai.NewContentFromText("What is the meaning of life?", genai.RoleUser),
    }
    result, err := client.Models.EmbedContent(ctx,
        "gemini-embedding-001",
        contents,
        nil,
    )
    if err != nil {
        log.Fatal(err)
    }

    embeddings, err := json.MarshalIndent(result.Embeddings, "", "  ")
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(string(embeddings))
}

REST

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-001:embedContent" \
    -H "Content-Type: application/json" \
    -H "x-goog-api-key: ${GEMINI_API_KEY}" \
    -d '{
        "model": "models/gemini-embedding-001",
        "content": {
        "parts": [{
            "text": "What is the meaning of life?"
        }]
        }
    }'

Sie können auch Embeddings für mehrere Chunks gleichzeitig generieren, indem Sie sie als Liste von Strings übergeben.

Python

from google import genai

client = genai.Client()

result = client.models.embed_content(
        model="gemini-embedding-001",
        contents= [
            "What is the meaning of life?",
            "What is the purpose of existence?",
            "How do I bake a cake?"
        ]
)

for embedding in result.embeddings:
    print(embedding)

JavaScript

import { GoogleGenAI } from "@google/genai";

async function main() {

    const ai = new GoogleGenAI({});

    const response = await ai.models.embedContent({
        model: 'gemini-embedding-001',
        contents: [
            'What is the meaning of life?',
            'What is the purpose of existence?',
            'How do I bake a cake?'
        ],
    });

    console.log(response.embeddings);
}

main();

Ok

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "log"

    "google.golang.org/genai"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, nil)
    if err != nil {
        log.Fatal(err)
    }

    contents := []*genai.Content{
        genai.NewContentFromText("What is the meaning of life?"),
        genai.NewContentFromText("How does photosynthesis work?"),
        genai.NewContentFromText("Tell me about the history of the internet."),
    }
    result, err := client.Models.EmbedContent(ctx,
        "gemini-embedding-001",
        contents,
        nil,
    )
    if err != nil {
        log.Fatal(err)
    }

    embeddings, err := json.MarshalIndent(result.Embeddings, "", "  ")
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(string(embeddings))
}

REST

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-001:embedContent" \
    -H "Content-Type: application/json" \
    -H "x-goog-api-key: $GEMINI_API_KEY" \
    -d '{
    "content": {
        "parts": [
        {
            "text": "What is the meaning of life?"
        },
        {
            "text": "How much wood would a woodchuck chuck?"
        },
        {
            "text": "How does the brain work?"
        }
        ]
    },
    "taskType": "SEMANTIC_SIMILARITY"
    }'

Aufgabentyp angeben, um die Leistung zu verbessern

Sie können Einbettungen für eine Vielzahl von Aufgaben verwenden, von der Klassifizierung bis zur Dokumentsuche. Wenn Sie den richtigen Aufgabentyp angeben, werden die Einbettungen für die beabsichtigten Beziehungen optimiert, wodurch sich die Genauigkeit und Effizienz maximieren lassen. Eine vollständige Liste der unterstützten Aufgabentypen finden Sie in der Tabelle Unterstützte Aufgabentypen.

Im folgenden Beispiel wird gezeigt, wie Sie SEMANTIC_SIMILARITY verwenden können, um zu prüfen, wie ähnlich sich Strings von Texten in ihrer Bedeutung sind.

Python

from google import genai
from google.genai import types
import pandas as pd
from sklearn.metrics.pairwise import cosine_similarity

client = genai.Client()

texts = [
    "What is the meaning of life?",
    "What is the purpose of existence?",
    "How do I bake a cake?",
]

result = client.models.embed_content(
    model="gemini-embedding-001",
    contents=texts,
    config=types.EmbedContentConfig(task_type="SEMANTIC_SIMILARITY")
)

# Create a 3x3 table to show the similarity matrix
df = pd.DataFrame(
    cosine_similarity([e.values for e in result.embeddings]),
    index=texts,
    columns=texts,
)

print(df)

JavaScript

import { GoogleGenAI } from "@google/genai";
import * as cosineSimilarity from "compute-cosine-similarity";

async function main() {
    const ai = new GoogleGenAI({});

    const texts = [
        "What is the meaning of life?",
        "What is the purpose of existence?",
        "How do I bake a cake?",
    ];

    const response = await ai.models.embedContent({
        model: 'gemini-embedding-001',
        contents: texts,
        taskType: 'SEMANTIC_SIMILARITY'
    });

    const embeddings = response.embeddings.map(e => e.values);

    for (let i = 0; i < texts.length; i++) {
        for (let j = i + 1; j < texts.length; j++) {
            const text1 = texts[i];
            const text2 = texts[j];
            const similarity = cosineSimilarity(embeddings[i], embeddings[j]);
            console.log(`Similarity between '${text1}' and '${text2}': ${similarity.toFixed(4)}`);
        }
    }
}

main();

Ok

package main

import (
    "context"
    "fmt"
    "log"
    "math"

    "google.golang.org/genai"
)

// cosineSimilarity calculates the similarity between two vectors.
func cosineSimilarity(a, b []float32) (float64, error) {
    if len(a) != len(b) {
        return 0, fmt.Errorf("vectors must have the same length")
    }

    var dotProduct, aMagnitude, bMagnitude float64
    for i := 0; i < len(a); i++ {
        dotProduct += float64(a[i] * b[i])
        aMagnitude += float64(a[i] * a[i])
        bMagnitude += float64(b[i] * b[i])
    }

    if aMagnitude == 0 || bMagnitude == 0 {
        return 0, nil
    }

    return dotProduct / (math.Sqrt(aMagnitude) * math.Sqrt(bMagnitude)), nil
}

func main() {
    ctx := context.Background()
    client, _ := genai.NewClient(ctx, nil)
    defer client.Close()

    texts := []string{
        "What is the meaning of life?",
        "What is the purpose of existence?",
        "How do I bake a cake?",
    }

    var contents []*genai.Content
    for _, text := range texts {
        contents = append(contents, genai.NewContentFromText(text, genai.RoleUser))
    }

    result, _ := client.Models.EmbedContent(ctx,
        "gemini-embedding-001",
        contents,
        &genai.EmbedContentRequest{TaskType: genai.TaskTypeSemanticSimilarity},
    )

    embeddings := result.Embeddings

    for i := 0; i < len(texts); i++ {
        for j := i + 1; j < len(texts); j++ {
            similarity, _ := cosineSimilarity(embeddings[i].Values, embeddings[j].Values)
            fmt.Printf("Similarity between '%s' and '%s': %.4f\n", texts[i], texts[j], similarity)
        }
    }
}

REST

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-001:embedContent" \
    -H "Content-Type: application/json" \
    -H "x-goog-api-key: $GEMINI_API_KEY" \
    -d '{
    "taskType": "SEMANTIC_SIMILARITY",
    "content": {
        "parts": [
        {
            "text": "What is the meaning of life?"
        },
        {
            "text": "How much wood would a woodchuck chuck?"
        },
        {
            "text": "How does the brain work?"
        }
        ]
    }
    }'

Die Code-Snippets zeigen, wie ähnlich sich die verschiedenen Textblöcke sind, wenn sie ausgeführt werden.

Unterstützte Aufgabentypen

Aufgabentyp	Beschreibung	Beispiele
SEMANTIC_SIMILARITY	Einbettungen, die für die Beurteilung der Textähnlichkeit optimiert sind.	Empfehlungssysteme, Erkennung von Duplikaten
KLASSIFIZIERUNG	Einbettungen, die für die Klassifizierung von Texten nach vordefinierten Labels optimiert sind.	Sentimentanalyse, Spamerkennung
CLUSTERING	Einbettungen, die für das Clustern von Texten basierend auf ihren Ähnlichkeiten optimiert sind.	Dokumentorganisation, Marktforschung, Anomalieerkennung
RETRIEVAL_DOCUMENT	Für die Dokumentsuche optimierte Einbettungen.	Artikel, Bücher oder Webseiten für die Suche indexieren.
RETRIEVAL_QUERY	Einbettungen, die für allgemeine Suchanfragen optimiert sind. Verwenden Sie `RETRIEVAL_QUERY` für Abfragen und `RETRIEVAL_DOCUMENT` für abzurufende Dokumente.	Benutzerdefinierte Suche
CODE_RETRIEVAL_QUERY	Einbettungen, die für den Abruf von Codeblöcken auf Grundlage von Anfragen in natürlicher Sprache optimiert sind. Verwenden Sie `CODE_RETRIEVAL_QUERY` für Anfragen und `RETRIEVAL_DOCUMENT` für abzurufende Codeblöcke.	Codevorschläge und Suche
QUESTION_ANSWERING	Einbettungen für Fragen in einem Frage-Antwort-System, die für das Auffinden von Dokumenten optimiert sind, die die Frage beantworten. Verwenden Sie `QUESTION_ANSWERING` für Fragen und `RETRIEVAL_DOCUMENT` für abzurufende Dokumente.	Chatbox
FACT_VERIFICATION	Einbettungen für Aussagen, die überprüft werden müssen, optimiert für das Abrufen von Dokumenten, die Beweise für oder gegen die Aussage enthalten. Verwenden Sie `FACT_VERIFICATION` für den Zieltext und `RETRIEVAL_DOCUMENT` für abzurufende Dokumente.	Automatisierte Faktenchecksysteme

Größe von Einbettungen steuern

Das Gemini-Einbettungsmodell gemini-embedding-001 wird mit der MRL-Technik (Matryoshka Representation Learning) trainiert. Dabei wird einem Modell beigebracht, hochdimensionale Einbettungen zu lernen, deren Anfangssegmente (oder Präfixe) auch nützliche, einfachere Versionen derselben Daten sind.

Mit dem Parameter output_dimensionality können Sie die Größe des Ausgabebettungsvektors steuern. Durch die Auswahl einer kleineren Ausgabedimensionalität kann Speicherplatz gespart und die Recheneffizienz für nachgelagerte Anwendungen gesteigert werden, ohne dass die Qualität wesentlich beeinträchtigt wird. Standardmäßig wird eine 3.072-dimensionale Einbettung ausgegeben. Sie können sie jedoch auf eine kleinere Größe kürzen, ohne die Qualität zu beeinträchtigen, um Speicherplatz zu sparen. Wir empfehlen, die Ausgabedimensionen 768, 1536 oder 3072 zu verwenden.

Python

from google import genai
from google.genai import types

client = genai.Client()

result = client.models.embed_content(
    model="gemini-embedding-001",
    contents="What is the meaning of life?",
    config=types.EmbedContentConfig(output_dimensionality=768)
)

[embedding_obj] = result.embeddings
embedding_length = len(embedding_obj.values)

print(f"Length of embedding: {embedding_length}")

JavaScript

import { GoogleGenAI } from "@google/genai";

async function main() {
    const ai = new GoogleGenAI({});

    const response = await ai.models.embedContent({
        model: 'gemini-embedding-001',
        content: 'What is the meaning of life?',
        outputDimensionality: 768,
    });

    const embeddingLength = response.embedding.values.length;
    console.log(`Length of embedding: ${embeddingLength}`);
}

main();

Ok

package main

import (
    "context"
    "fmt"
    "log"

    "google.golang.org/genai"
)

func main() {
    ctx := context.Background()
    // The client uses Application Default Credentials.
    // Authenticate with 'gcloud auth application-default login'.
    client, err := genai.NewClient(ctx, nil)
    if err != nil {
        log.Fatal(err)
    }
    defer client.Close()

    contents := []*genai.Content{
        genai.NewContentFromText("What is the meaning of life?", genai.RoleUser),
    }

    result, err := client.Models.EmbedContent(ctx,
        "gemini-embedding-001",
        contents,
        &genai.EmbedContentRequest{OutputDimensionality: 768},
    )
    if err != nil {
        log.Fatal(err)
    }

    embedding := result.Embeddings[0]
    embeddingLength := len(embedding.Values)
    fmt.Printf("Length of embedding: %d\n", embeddingLength)
}

REST

curl -X POST "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-001:embedContent" \
    -H 'Content-Type: application/json' \
    -H "x-goog-api-key: $GEMINI_API_KEY" \
    -d '{
        "content": {"parts":[{ "text": "What is the meaning of life?"}]},
        "output_dimensionality": 768
    }'

Beispielausgabe des Code-Snippets:

Length of embedding: 768

Qualität bei kleineren Abmessungen sicherstellen

Die 3.072‑dimensionale Einbettung wird normalisiert. Normalisierte Einbettungen führen zu einer genaueren semantischen Ähnlichkeit, da die Vektorrichtung und nicht die ‑größe verglichen wird. Für andere Dimensionen, einschließlich 768 und 1536, müssen Sie die Einbettungen so normalisieren:

Python

import numpy as np
from numpy.linalg import norm

embedding_values_np = np.array(embedding_obj.values)
normed_embedding = embedding_values_np / np.linalg.norm(embedding_values_np)

print(f"Normed embedding length: {len(normed_embedding)}")
print(f"Norm of normed embedding: {np.linalg.norm(normed_embedding):.6f}") # Should be very close to 1

Beispielausgabe dieses Code-Snippets:

Normed embedding length: 768
Norm of normed embedding: 1.000000

In der folgenden Tabelle sind die MTEB-Werte aufgeführt, ein häufig verwendeter Benchmark für Einbettungen für verschiedene Dimensionen. Das Ergebnis zeigt, dass die Leistung nicht unbedingt an die Größe der Einbettungsdimension gebunden ist. Niedrigere Dimensionen erreichen Werte, die mit denen ihrer Pendants mit höherer Dimension vergleichbar sind.

MRL-Dimension	MTEB-Wert
2048	68.16
1.536	68,17
768	67,99
512	67,55
256	66.19
128	63,31

Anwendungsfälle

Texteinbettungen sind für eine Vielzahl gängiger KI-Anwendungsfälle von entscheidender Bedeutung, z. B.:

Retrieval-Augmented Generation (RAG): Mithilfe von Einbettungen wird die Qualität von generiertem Text verbessert, indem relevante Informationen abgerufen und in den Kontext eines Modells eingebunden werden.
Information Retrieval:Suchen Sie anhand eines Eingabetexts nach dem semantisch ähnlichsten Text oder den semantisch ähnlichsten Dokumenten.

Anleitung zur Dokumentsuche
Neubewertung der Suche: Die relevantesten Elemente werden priorisiert, indem die ursprünglichen Ergebnisse semantisch anhand der Anfrage bewertet werden.

Tutorial zum Neusortieren von Suchergebnissen
Anomalieerkennung:Durch den Vergleich von Gruppen von Einbettungen lassen sich verborgene Trends oder Ausreißer erkennen.

Anleitung zur Anomalieerkennung
Klassifizierung:Text wird basierend auf seinem Inhalt automatisch kategorisiert, z. B. für die Sentimentanalyse oder die Spamerkennung.

Anleitung zur Klassifizierung
Clustering:Erfassen Sie komplexe Beziehungen effektiv, indem Sie Cluster und Visualisierungen Ihrer Einbettungen erstellen.

Anleitung zur Visualisierung von Clustern

Einbettungen speichern

Wenn Sie Einbettungen in der Produktion verwenden, ist es üblich, Vektordatenbanken zu verwenden, um hochdimensionale Einbettungen effizient zu speichern, zu indexieren und abzurufen. Google Cloud bietet verwaltete Datendienste, die für diesen Zweck verwendet werden können, darunter BigQuery, AlloyDB und Cloud SQL.

In den folgenden Anleitungen wird gezeigt, wie Sie andere Vektordatenbanken von Drittanbietern mit Gemini Embedding verwenden.

Modellversionen

Attribut	Beschreibung
Modellcode	Gemini API `gemini-embedding-001`
Unterstützte Datentypen	Eingabe Text Ausgabe Texteinbettungen
Token-Limits^[*]	Eingabetokenlimit 2.048 Größe der Ausgabedimension Flexibel, unterstützt: 128–3072, empfohlen: 768, 1536, 3072
-Versionen	Weitere Informationen finden Sie unter Muster für Modellversionen. Stabil: `gemini-embedding-001`
Letzte Aktualisierung	Juni 2025

Informationen zu eingestellten Embeddings-Modellen finden Sie auf der Seite Einstellungen.

Batch-Einbettungen

Wenn die Latenz kein Problem darstellt, können Sie das Gemini Embeddings-Modell mit der Batch API verwenden. So lässt sich ein viel höherer Durchsatz zu 50% des Standardpreises für Einbettungen erzielen. Beispiele für die ersten Schritte finden Sie im Batch API Cookbook.

Hinweis zur verantwortungsvollen Nutzung

Im Gegensatz zu generativen KI-Modellen, die neue Inhalte erstellen, ist das Gemini Embedding-Modell nur dazu gedacht, das Format Ihrer Eingabedaten in eine numerische Darstellung zu transformieren. Google ist zwar für die Bereitstellung eines Einbettungsmodells verantwortlich, das das Format Ihrer Eingabedaten in das erforderliche numerische Format umwandelt, die Nutzer behalten jedoch die volle Verantwortung für die von ihnen eingegebenen Daten und die resultierenden Einbettungen. Mit der Nutzung des Gemini Embedding-Modells bestätigen Sie, dass Sie über die erforderlichen Rechte für die von Ihnen hochgeladenen Inhalte verfügen. Erstellen Sie keine Inhalte, durch die die Rechte anderer, zum Beispiel Rechte an geistigem Eigentum oder das Recht auf Privatsphäre, verletzt werden. Die Nutzung dieses Dienstes unterliegt unserer Richtlinie zur unzulässigen Nutzung und den Google-Nutzungsbedingungen.

Erste Schritte mit Einbettungen

Im Notebook zur Kurzanleitung für Einbettungen können Sie die Modellfunktionen kennenlernen und erfahren, wie Sie Ihre Einbettungen anpassen und visualisieren.