Gemini 2.5 Flash Image (auch Nano Banana genannt) ist jetzt in der Gemini API verfügbar. Weitere Informationen

Diese Seite wurde von der Cloud Translation API übersetzt.

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. Diese grundlegenden Einbettungen ermöglichen erweiterte NLP-Aufgaben wie semantische Suche, Klassifizierung und Clustering und liefern genauere, kontextbezogene Ergebnisse als keywordbasierte Ansätze.

Das Erstellen von RAG-Systemen (Retrieval Augmented Generation) ist ein häufiger Anwendungsfall für Embeddings. Embeddings spielen eine wichtige Rolle bei der Verbesserung der Modellausgaben in Bezug auf faktenorientierte Genauigkeit, Kohärenz und Kontext. Sie rufen effizient relevante Informationen aus Wissensdatenbanken ab, die durch Einbettungen dargestellt werden. Diese werden dann als zusätzlicher Kontext im Eingabe-Prompt an Sprachmodelle übergeben, damit diese fundiertere und genauere Antworten generieren können.

Weitere Informationen zu den verfügbaren Varianten von Einbettungsmodellen finden Sie im Abschnitt Modellversionen. Für Anwendungen auf Unternehmensniveau und Arbeitslasten mit hohem Volumen empfehlen wir die Verwendung von Einbettungsmodellen in Vertex AI.

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 "x-goog-api-key: $GEMINI_API_KEY" \
-H 'Content-Type: application/json' \
-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 "x-goog-api-key: $GEMINI_API_KEY" \
-H 'Content-Type: application/json' \
-d '{"model": "models/gemini-embedding-001",
     "content": [
        {"parts": [{"text": "What is the meaning of life?"}]},
        {"parts": [{"text": "What is the purpose of existence?"}]},
        {"parts": [{"text": "How do I bake a cake?"}]}
        ]
    }'

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 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 die Bedeutung von Textstrings ist.

Python

from google import genai
from google.genai import types
import numpy as np
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 = [
    np.array(e.values) for e in client.models.embed_content(
        model="gemini-embedding-001",
        contents=texts,
        config=types.EmbedContentConfig(task_type="SEMANTIC_SIMILARITY")).embeddings
]

# Calculate cosine similarity. Higher scores = greater semantic similarity.

embeddings_matrix = np.array(result)
similarity_matrix = cosine_similarity(embeddings_matrix)

for i, text1 in enumerate(texts):
    for j in range(i + 1, len(texts)):
        text2 = texts[j]
        similarity = similarity_matrix[i, j]
        print(f"Similarity between '{text1}' and '{text2}': {similarity:.4f}")

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 -X POST "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-001:embedContent" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-H 'Content-Type: application/json' \
-d '{
    "contents": [
        {"parts": [{"text": "What is the meaning of life?"}]},
        {"parts": [{"text": "What is the purpose of existence?"}]},
        {"parts": [{"text": "How do I bake a cake?"}]}
    ],
    "embedding_config": {
        "task_type": "SEMANTIC_SIMILARITY"
    }
}'

Im Folgenden finden Sie ein Beispiel für die Ausgabe dieses Code-Snippets:

Similarity between 'What is the meaning of life?' and 'What is the purpose of existence?': 0.9481

Similarity between 'What is the meaning of life?' and 'How do I bake a cake?': 0.7471

Similarity between 'What is the purpose of existence?' and 'How do I bake a cake?': 0.7371

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	Einbettungen, die für die Dokumentsuche optimiert sind.	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 Matryoshka Representation Learning-Technik (MRL) 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 "x-goog-api-key: YOUR_GEMINI_API_KEY" \
-H 'Content-Type: application/json' \
-d '{
    "contents": [
        {"parts": [{"text": "What is the meaning of life?"}]}
    ],
    "embedding_config": {
        "output_dimensionality": 768
    }
}'

Beispielausgabe des Code-Snippets:

Length of embedding: 768

Qualität bei kleineren Abmessungen

Die 3.072-dimensionale Einbettung wird normalisiert. Normalisierte Einbettungen führen zu einer genaueren semantischen Ähnlichkeit, da die Vektorrichtung und nicht die ‑länge 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.

Dimension „MRL“	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 des generierten Texts verbessert, indem relevante Informationen abgerufen und in den Kontext eines Modells eingebunden werden.
Information Retrieval:Suchen Sie nach dem semantisch ähnlichsten Text oder den semantisch ähnlichsten Dokumenten zu einem Eingabetext.

Anleitung zur Dokumentsuche
Neubewertung der Suche: Die relevantesten Elemente werden priorisiert, indem die ersten 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 automatisch anhand seines Inhalts kategorisiert, z. B. für die Sentimentanalyse oder die Spamerkennung.

Anleitung zur Klassifizierung
Clustering:Komplexe Beziehungen lassen sich effektiv erfassen, indem Sie Cluster und Visualisierungen Ihrer Einbettungen erstellen.

Anleitung zur Visualisierung von Clustering

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` Test: `gemini-embedding-exp-03-07`
Letzte Aktualisierung	Juni 2025

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 umzuwandeln. 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. Durch die 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.