Gemini 4 Argon ist jetzt verfügbar. Jetzt ausprobieren.

Google verwendet KI-Technologie, um Inhalte in Ihre bevorzugte Sprache zu übersetzen. KI-Übersetzungen können Fehler enthalten.

Einbettungen

Die Gemini API bietet Einbettungsmodelle zum Generieren von Einbettungen für Text, Bilder, Videos und andere Inhalte. Diese resultierenden Einbettungen können dann für Aufgaben wie semantische Suche, Klassifizierung und Clustering verwendet werden. Sie liefern genauere, kontextbezogene Ergebnisse als keywordbasierte Ansätze.

Das neueste Modell, gemini-embedding-2, ist das erste multimodale Einbettungsmodell in der Gemini API. Sie bildet Text, Bilder, Videos, Audio und Dokumente in einem einheitlichen Einbettungsbereich ab und ermöglicht so die modale Suche, Klassifizierung und Clusterbildung in über 100 Sprachen. Weitere Informationen finden Sie im Abschnitt zu multimodalen Einbettungen. Für Anwendungsfälle mit Nur-Text-Einbettungen ist gemini-embedding-001 weiterhin verfügbar.

Das Erstellen von RAG-Systemen (Retrieval Augmented Generation) ist ein häufiger Anwendungsfall für KI-Produkte. Einbettungen spielen eine wichtige Rolle bei der deutlichen Verbesserung von Modellausgaben, da sie die faktische Genauigkeit, Kohärenz und den Kontextreichtum verbessern. Wenn Sie eine verwaltete RAG-Lösung bevorzugen, können Sie das Tool Dateisuche verwenden, mit dem sich RAG einfacher verwalten lässt und das 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-2",
        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-2',
        contents: 'What is the meaning of life?',
    });

    console.log(response.embeddings);
}

main();

Java

import com.google.genai.Client;
import com.google.genai.types.EmbedContentResponse;

Client client = new Client();

EmbedContentResponse response =
    client.models.embedContent("gemini-embedding-2", "What is the meaning of life?", null);

System.out.println(response.embeddings().orElse(null));

Go

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

Aufgabentyp angeben, um die Leistung zu verbessern

Sie können Einbettungen für eine Vielzahl von Aufgaben verwenden, von der Klassifizierung bis zur Dokumentensuche. Wenn Sie den richtigen Aufgabentyp angeben, können Sie die Einbettungen für die beabsichtigten Beziehungen optimieren und so die Genauigkeit und Effizienz maximieren.

Aufgabentypen mit Embeddings 2

Für reine Textaufgaben mit gemini-embedding-2 empfehlen wir dringend, die Aufgabenanweisung in den Prompt einzufügen. Dazu müssen die Abfrage und das Dokument mit dem richtigen Aufgabenpräfix formatiert werden.

Wenn Sie eine einzelne Einbettung basierend auf einer multimodalen Eingabe generieren, empfehlen wir im Allgemeinen nicht, dem Textteil der Eingabe eine Aufgabenanweisung voranzustellen. In einigen Fällen wird die Leistung verbessert, in anderen jedoch verringert.

In den folgenden Tabellen finden Sie Beispiele für die Formatierung von Abfragen und Dokumenten für symmetrische und asymmetrische Anwendungsfälle mit dem Modell gemini-embedding-2.

Anwendungsfälle für den Abruf (asymmetrisches Format)

Fügen Sie bei asymmetrischen Anwendungsfällen das Aufgabenpräfix zur Abfrage hinzu und wenden Sie die Dokumentstruktur auf den Inhalt an, den Sie einbetten und abrufen möchten.

Anwendungsfall	Abfragestruktur	Dokumentstruktur
Suchanfrage	`task: search result \| query: {content}`	`title: {title} \| text: {content}` Wenn kein Titel vorhanden ist, verwenden Sie `title: none`.
Question Answering	`task: question answering \| query: {content}`	`title: {title} \| text: {content}`
Faktenchecks	`task: fact checking \| query: {content}`	`title: {title} \| text: {content}`
Codeabruf	`task: code retrieval \| query: {content}`	`title: {title} \| text: {content}`

Beispiel für die Verwendung

Python

# Generate embedding for a task's query. Use your correct task here:
def prepare_query(query):
    # return f"task: question answering | query: {query}"
    # return f"task: fact checking | query: {query}"
    # return f"task: code retrieval | query: {query}"
    return f"task: search result | query: {query}"

# Generate embedding for document of an asymmetric retrieval task:
def prepare_document(content, title=None):
    if title is None:
        title = "none"
    return f"title: {title} | text: {content}"

Anwendungsfälle mit einer Eingabe (symmetrisches Format)

Verwenden Sie in symmetrischen Anwendungsfällen für dieselbe Aufgabe dieselbe Formatierung für die Abfrage und das Dokument.

Anwendungsfall	Eingabestruktur
Klassifizierung	`task: classification \| query: {content}`
Clustering	`task: clustering \| query: {content}`
Semantische Ähnlichkeit	`task: sentence similarity \| query: {content}` Verwenden Sie diese Funktion nicht für die Suche oder den Abruf. Es ist für die semantische Textähnlichkeit vorgesehen.

Verwendungsbeispiel

Python

# Generate embedding for query & document of your task.
def prepare_query_and_document(content):
    # return f'task: clustering | query: {content}'
    # return f'task: sentence similarity | query: {content}'
    return f'task: classification | query: {content}'

Es ist wichtig, dass die Aufgabe einheitlich verwendet wird. Wenn Dokumente beispielsweise mit f'task: classification | query: {content}' eingebettet sind, sollte die Abfrage auch im Format dieser Aufgabe eingebettet werden.

Aufgabentypen mit Embeddings 1

Für gemini-embedding-001 können Sie die task_type in der Methode embedContent angeben. Eine vollständige Liste der unterstützten Aufgabentypen finden Sie in der Tabelle Unterstützte Aufgabentypen.

Im folgenden Beispiel wird gezeigt, wie Sie mit SEMANTIC_SIMILARITY prüfen können, wie ähnlich die Bedeutung von Textstrings ist.

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";
// npm i compute-cosine-similarity
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,
        config: { 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();

Java

import java.util.Arrays;
import com.google.genai.Client;
import com.google.genai.types.ContentEmbedding;
import com.google.genai.types.EmbedContentConfig;
import com.google.genai.types.EmbedContentResponse;
import java.util.List;

Client client = new Client();

List<String> texts =
    Arrays.asList(
        "What is the meaning of life?",
        "What is the purpose of existence?",
        "How do I bake a cake?");

EmbedContentConfig config =
    EmbedContentConfig.builder().taskType("SEMANTIC_SIMILARITY").build();

EmbedContentResponse response =
    client.models.embedContent("gemini-embedding-001", texts, config);

List<ContentEmbedding> embeddings = response.embeddings().get();

for (int i = 0; i < texts.size(); i++) {
  for (int j = i + 1; j < texts.size(); j++) {
    List<Float> v1 = embeddings.get(i).values().get();
    List<Float> v2 = embeddings.get(j).values().get();
    double dotProduct = 0.0;
    double normA = 0.0;
    double normB = 0.0;
    for (int k = 0; k < v1.size(); k++) {
      dotProduct += v1.get(k) * v2.get(k);
      normA += v1.get(k) * v1.get(k);
      normB += v2.get(k) * v2.get(k);
    }
    double similarity = dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
    System.out.printf(
        "Similarity between '%s' and '%s': %.4f%n", texts.get(i), texts.get(j), similarity);
  }
}

Go

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 die verschiedenen Textabschnitte einander sind, wenn sie ausgeführt werden.

Unterstützte Aufgabentypen

Unterstützte Aufgabentypen für gemini-embedding-001:

Aufgabentyp	Beschreibung	Beispiele
SEMANTIC_SIMILARITY	Einbettungen, die für die Beurteilung der Textähnlichkeit optimiert sind.	Empfehlungssysteme, Duplikaterkennung
CLASSIFICATION	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 das Abrufen von Codeblöcken basierend auf Abfragen in natürlicher Sprache optimiert sind. Verwenden Sie `CODE_RETRIEVAL_QUERY` für Abfragen und `RETRIEVAL_DOCUMENT` für abzurufende Codeblöcke.	Codevorschläge und Suche
QUESTION_ANSWERING	Einbettungen für Fragen in einem Frage-Antwort-System, optimiert für die Suche nach Dokumenten, 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 Belege enthalten, die die Aussage unterstützen oder widerlegen. Verwenden Sie `FACT_VERIFICATION` für den Zieltext und `RETRIEVAL_DOCUMENT` für die abzurufenden Dokumente.	Automatisierte Faktencheck-Systeme

Einbettungsgröße steuern

Sowohl gemini-embedding-001 als auch gemini-embedding-2 werden mit der MRL-Technik (Matryoshka Representation Learning) trainiert. Dabei lernt ein Modell, hochdimensionale Einbettungen zu lernen, die Anfangssegmente (oder Präfixe) haben, die auch nützliche, einfachere Versionen derselben Daten sind.

Verwenden Sie den Parameter output_dimensionality, um die Größe des Ausgabe-Einbettungsvektors zu steuern. Durch die Auswahl einer kleineren Ausgabedimensionalität können Sie Speicherplatz sparen und die Recheneffizienz für nachgelagerte Anwendungen erhöhen, ohne dass die Qualität nennenswert beeinträchtigt wird. Standardmäßig geben beide Modelle eine 3072-dimensionale Einbettung aus. Sie können sie jedoch ohne Qualitätsverlust auf eine kleinere Größe kürzen, um Speicherplatz zu sparen. Wir empfehlen die Verwendung von 768, 1536 oder 3072 Ausgabedimensionen.

Python

from google import genai
from google.genai import types

client = genai.Client()

result = client.models.embed_content(
    model="gemini-embedding-2",
    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-2',
        contents: 'What is the meaning of life?',
        config: { outputDimensionality: 768 },
    });

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

main();

Java

import com.google.genai.Client;
import com.google.genai.types.ContentEmbedding;
import com.google.genai.types.EmbedContentConfig;
import com.google.genai.types.EmbedContentResponse;

Client client = new Client();

EmbedContentConfig config =
    EmbedContentConfig.builder().outputDimensionality(768).build();

EmbedContentResponse response =
    client.models.embedContent("gemini-embedding-2", "What is the meaning of life?", config);

ContentEmbedding embeddingObj = response.embeddings().get().get(0);
int embeddingLength = embeddingObj.values().get().size();

System.out.println("Length of embedding: " + embeddingLength);

Go

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-2",
        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-2: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 aus dem Code-Snippet:

Length of embedding: 768

Qualität bei kleineren Abmessungen sicherstellen

Die standardmäßigen Einbettungen mit 3.072 Dimensionen werden immer normalisiert. Gemini Embedding 2 normalisiert außerdem automatisch gekürzte Dimensionen (z. B. 768, 1.536). So wird die semantische Ähnlichkeit anhand der Vektorrichtung und nicht anhand der Größe berechnet, was sofort genauere Ergebnisse liefert.

Ältere Modelle: Wenn Sie gemini-embedding-001 verwenden, müssen Sie Dimensionen, die nicht 3072 sind, manuell so normalisieren:

Python

import numpy as np
from numpy.linalg import norm

# Only for embeddings from `gemini-embedding-001`
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, ein häufig verwendeter Benchmark für Einbettungen, für verschiedene Dimensionen aufgeführt. Das Ergebnis zeigt, dass die Leistung nicht strikt an die Größe der Einbettungsdimension gebunden ist. Mit niedrigeren Dimensionen werden Werte erzielt, die mit denen ihrer höheren Dimensionen vergleichbar sind.

MRL-Dimension	MTEB-Score (Gemini Embedding 001)
2048	68.16
1.536	68.17
768	67,99
512	67,55
256	66,19
128	63,31

Multimodale Einbettungen

Das Modell gemini-embedding-2 unterstützt multimodale Eingaben, sodass Sie Bilder, Videos, Audio und Dokumente zusammen mit Text einbetten können. Alle Modalitäten werden demselben Einbettungsbereich zugeordnet, was eine modalitätsübergreifende Suche und einen modalitätsübergreifenden Vergleich ermöglicht.

Unterstützte Modalitäten und Limits

Das maximale Limit für Eingabetokens beträgt insgesamt 8.192 Tokens.

Modalität	Spezifikationen und Limits
Text	Unterstützt bis zu 8.192 Tokens.
Bild	Maximal 6 Bilder pro Anfrage. Unterstützte Formate: PNG, JPEG.
Audio	Maximale Dauer: 180 Sekunden. Unterstützte Formate: MP3, WAV.
Video	Maximale Dauer: 120 Sekunden Unterstützte Formate: MP4, MOV. Unterstützte Codecs: H264, H265, AV1, VP9. Das System verarbeitet maximal 32 Frames pro Video: Bei kurzen Videos (≤ 32 Sekunden) wird 1 Frame pro Sekunde abgetastet, während bei längeren Videos gleichmäßig 32 Frames abgetastet werden. Audiotracks in Videodateien werden nicht verarbeitet.
Dokumente (PDF)	Maximal 1 Datei pro Anfrage, bis zu 6 Seiten.

Bilder einbetten

Das folgende Beispiel zeigt, wie Sie ein Bild mit gemini-embedding-2 einbetten.

Bilder können als Inline-Daten oder als hochgeladene Dateien über die Files API bereitgestellt werden.

Python

from google import genai
from google.genai import types

with open('example.png', 'rb') as f:
    image_bytes = f.read()

client = genai.Client()

result = client.models.embed_content(
    model='gemini-embedding-2',
    contents=[
        types.Part.from_bytes(
            data=image_bytes,
            mime_type='image/png',
        ),
    ]
)

print(result.embeddings)

JavaScript

import { GoogleGenAI } from "@google/genai";
import * as fs from "node:fs";

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

    const imgBase64 = fs.readFileSync("example.png", { encoding: "base64" });

    const response = await ai.models.embedContent({
        model: 'gemini-embedding-2',
        contents: [{
            inlineData: {
                mimeType: 'image/png',
                data: imgBase64,
            },
        }],
    });

    console.log(response.embeddings);
}

main();

Java

import com.google.genai.Client;
import com.google.genai.types.Content;
import com.google.genai.types.EmbedContentResponse;
import com.google.genai.types.Part;
import java.nio.file.Files;
import java.nio.file.Paths;

Client client = new Client();

byte[] imageBytes = Files.readAllBytes(Paths.get("example.png"));

Content content = Content.fromParts(Part.fromBytes(imageBytes, "image/png"));

EmbedContentResponse response =
    client.models.embedContent("gemini-embedding-2", content, null);

System.out.println(response.embeddings().orElse(null));

REST

IMG_PATH="/path/to/your/image.png"
IMG_BASE64=$(base64 -w0 "${IMG_PATH}")

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-2:embedContent" \
    -H "Content-Type: application/json" \
    -H "x-goog-api-key: ${GEMINI_API_KEY}" \
    -d '{
        "content": {
            "parts": [{
                "inline_data": {
                    "mime_type": "image/png",
                    "data": "'"${IMG_BASE64}"'"
                }
            }]
        }
    }'

Einbettungsaggregation

Wenn Sie mit multimodalen Inhalten arbeiten, wirkt sich die Strukturierung Ihrer Eingabe auf die Einbettungsausgabe aus:

Mehrere Teile (aggregiert): Wenn Sie mehrere Eingaben direkt dem Parameter contents hinzufügen, wird eine aggregierte Einbettung für alle Eingaben erstellt.
Mehrere Content-Objekte (separat): Wenn Sie jede Eingabe in ein Content-Objekt verpacken und im Parameter contents übergeben, werden separate Einbettungen für jeden Eintrag zurückgegeben.
Darstellung auf Beitragsebene: Bei komplexen Objekten wie Social-Media-Beiträgen mit mehreren Mediendateien empfehlen wir, separate Einbettungen zu aggregieren (z. B. durch Mittelwertbildung), um eine kohärente Darstellung auf Beitragsebene zu erstellen.

Im folgenden Beispiel wird gezeigt, wie Sie eine aggregierte Einbettung für Text- und Bildeingaben erstellen. Fügen Sie dem Parameter contents einfach mehrere Eingaben hinzu:

Python

from google import genai
from google.genai import types

client = genai.Client()

with open('dog.png', 'rb') as f:
    image_bytes = f.read()

result = client.models.embed_content(
    model='gemini-embedding-2',
    contents=[
        "An image of a dog",
        types.Part.from_bytes(
            data=image_bytes,
            mime_type='image/png',
        ),
    ]
)

# This produces one embedding
for embedding in result.embeddings:
    print(embedding.values)

JavaScript

import { GoogleGenAI } from "@google/genai";
import * as fs from "node:fs";

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

    const imgBase64 = fs.readFileSync("dog.png", { encoding: "base64" });

    const response = await ai.models.embedContent({
        model: 'gemini-embedding-2',
        contents: [
            'An image of a dog',
            {
                inlineData: {
                    mimeType: 'image/png',
                    data: imgBase64,
                },
            },
        ],
    });

    // This produces one embedding
    for (const embedding of response.embeddings) {
        console.log(embedding.values);
    }
}

main();

Java

import com.google.genai.Client;
import com.google.genai.types.Content;
import com.google.genai.types.ContentEmbedding;
import com.google.genai.types.EmbedContentResponse;
import com.google.genai.types.Part;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Collections;

Client client = new Client();

byte[] imageBytes = Files.readAllBytes(Paths.get("dog.png"));

Content content =
    Content.fromParts(
        Part.fromText("An image of a dog"),
        Part.fromBytes(imageBytes, "image/png"));

EmbedContentResponse response =
    client.models.embedContent("gemini-embedding-2", content, null);

// This produces one embedding
for (ContentEmbedding embedding : response.embeddings().orElse(Collections.emptyList())) {
  System.out.println(embedding.values().orElse(Collections.emptyList()));
}

REST

IMG_PATH="/path/to/your/dog.png"
IMG_BASE64=$(base64 -w0 "${IMG_PATH}")

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-2:embedContent" \
    -H "Content-Type: application/json" \
    -H "x-goog-api-key: ${GEMINI_API_KEY}" \
    -d '{
        "content": {
            "parts": [
                {"text": "An image of a dog"},
                {
                    "inline_data": {
                        "mime_type": "image/png",
                        "data": "'"${IMG_BASE64}"'"
                    }
                }
            ]
        }
    }'

Wenn Sie dagegen Content-Objekte im Parameter contents verwenden, werden separate Einbettungen zurückgegeben. In diesem Beispiel werden mehrere Einbettungen in einem Einbettungsaufruf erstellt:

Python

from google import genai
from google.genai import types

client = genai.Client()

with open('dog.png', 'rb') as f:
    image_bytes = f.read()

result = client.models.embed_content(
    model="gemini-embedding-2",
    contents=[
        types.Content(parts=[types.Part.from_text(text="task: classification | query: An image of a dog")]),
        types.Content(
            parts=[
                types.Part.from_bytes(
                    data=image_bytes,
                    mime_type="image/png",
                ),
            ]
        ),
    ],
)

# This produces two embeddings
for embedding in result.embeddings:
    print(embedding.values)

JavaScript

import { GoogleGenAI } from "@google/genai";
import * as fs from "node:fs";

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

    const imgBase64 = fs.readFileSync("dog.png", { encoding: "base64" });

    const response = await ai.models.embedContent({
        model: 'gemini-embedding-2',
        contents: [
            { parts: [{ text: 'task: classification | query: An image of a dog' }] },
            {
                parts: [{
                    inlineData: {
                        mimeType: 'image/png',
                        data: imgBase64,
                    },
                }],
            },
        ],
    });

    // This produces two embeddings
    for (const embedding of response.embeddings) {
        console.log(embedding.values);
    }
}

main();

Java

import java.util.Arrays;
import com.google.genai.Client;
import com.google.genai.types.Content;
import com.google.genai.types.ContentEmbedding;
import com.google.genai.types.EmbedContentResponse;
import com.google.genai.types.Part;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Collections;
import java.util.List;

Client client = new Client();

byte[] imageBytes = Files.readAllBytes(Paths.get("dog.png"));

List<Content> contents =
    Arrays.asList(
        Content.fromParts(Part.fromText("task: classification | query: An image of a dog")),
        Content.fromParts(Part.fromBytes(imageBytes, "image/png")));

// Embed each Content object separately to produce separate embeddings
for (Content content : contents) {
  EmbedContentResponse response =
      client.models.embedContent("gemini-embedding-2", content, null);
  for (ContentEmbedding embedding : response.embeddings().orElse(Collections.emptyList())) {
    System.out.println(embedding.values().orElse(Collections.emptyList()));
  }
}

REST

IMG_PATH="/path/to/your/dog.png"
IMG_BASE64=$(base64 -w0 "${IMG_PATH}")

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-2:batchEmbedContents" \
    -H "Content-Type: application/json" \
    -H "x-goog-api-key: ${GEMINI_API_KEY}" \
    -d '{
        "requests": [
            {
                "model": "models/gemini-embedding-2",
                "content": {"parts": [{"text": "task: classification | query: An image of a dog"}]}
            },
            {
                "model": "models/gemini-embedding-2",
                "content": {"parts": [{"inline_data": {"mime_type": "image/png", "data": "'"${IMG_BASE64}"'"}}]}
            }
        ]
    }'

Audio einbetten

Das folgende Beispiel zeigt, wie Sie eine Audiodatei mit gemini-embedding-2 einbetten.

Audiodateien können als Inline-Daten oder als hochgeladene Dateien über die Files API bereitgestellt werden.

Python

from google import genai
from google.genai import types

with open('example.mp3', 'rb') as f:
    audio_bytes = f.read()

client = genai.Client()

result = client.models.embed_content(
    model='gemini-embedding-2',
    contents=[
        types.Part.from_bytes(
            data=audio_bytes,
            mime_type='audio/mpeg',
        ),
    ]
)

print(result.embeddings)

JavaScript

import { GoogleGenAI } from "@google/genai";
import * as fs from "node:fs";

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

    const audioBase64 = fs.readFileSync("example.mp3", { encoding: "base64" });

    const response = await ai.models.embedContent({
        model: 'gemini-embedding-2',
        contents: [{
            inlineData: {
                mimeType: 'audio/mpeg',
                data: audioBase64,
            },
        }],
    });

    console.log(response.embeddings);
}

main();

Java

import com.google.genai.Client;
import com.google.genai.types.Content;
import com.google.genai.types.EmbedContentResponse;
import com.google.genai.types.Part;
import java.nio.file.Files;
import java.nio.file.Paths;

Client client = new Client();

byte[] audioBytes = Files.readAllBytes(Paths.get("example.mp3"));

Content content = Content.fromParts(Part.fromBytes(audioBytes, "audio/mpeg"));

EmbedContentResponse response =
    client.models.embedContent("gemini-embedding-2", content, null);

System.out.println(response.embeddings().orElse(null));

REST

AUDIO_PATH="/path/to/your/example.mp3"
AUDIO_BASE64=$(base64 -w0 "${AUDIO_PATH}")

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-2:embedContent" \
    -H "Content-Type: application/json" \
    -H "x-goog-api-key: ${GEMINI_API_KEY}" \
    -d '{
        "content": {
            "parts": [{
                "inline_data": {
                    "mime_type": "audio/mpeg",
                    "data": "'"${AUDIO_BASE64}"'"
                }
            }]
        }
    }'

Video einbetten

Das folgende Beispiel zeigt, wie ein Video mit gemini-embedding-2 eingebettet wird.

Videos können als Inline-Daten oder als hochgeladene Dateien über die Files API bereitgestellt werden.

Python

from google import genai
from google.genai import types

client = genai.Client()

with open('example.mp4', 'rb') as f:
    video_bytes = f.read()

result = client.models.embed_content(
    model='gemini-embedding-2',
    contents=[
        types.Part.from_bytes(
            data=video_bytes,
            mime_type='video/mp4',
        ),
    ]
)

print(result.embeddings[0].values)

JavaScript

import { GoogleGenAI } from "@google/genai";
import * as fs from "node:fs";

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

    const videoBase64 = fs.readFileSync("example.mp4", { encoding: "base64" });

    const response = await ai.models.embedContent({
        model: 'gemini-embedding-2',
        contents: [{
            inlineData: {
                mimeType: 'video/mp4',
                data: videoBase64,
            },
        }],
    });

    console.log(response.embeddings);
}

main();

Java

import com.google.genai.Client;
import com.google.genai.types.Content;
import com.google.genai.types.EmbedContentResponse;
import com.google.genai.types.Part;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Collections;

Client client = new Client();

byte[] videoBytes = Files.readAllBytes(Paths.get("example.mp4"));

Content content = Content.fromParts(Part.fromBytes(videoBytes, "video/mp4"));

EmbedContentResponse response =
    client.models.embedContent("gemini-embedding-2", content, null);

System.out.println(
    response.embeddings().get().get(0).values().orElse(Collections.emptyList()));

REST

VIDEO_PATH="/path/to/your/video.mp4"
VIDEO_BASE64=$(base64 -w0 "${VIDEO_PATH}")

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-2:embedContent" \
    -H "Content-Type: application/json" \
    -H "x-goog-api-key: ${GEMINI_API_KEY}" \
    -d '{
        "content": {
            "parts": [{
                "inline_data": {
                    "mime_type": "video/mp4",
                    "data": "'"${VIDEO_BASE64}"'"
                }
            }]
        }
    }'

Wenn Sie Videos mit einer Länge von mehr als 120 Sekunden einbetten müssen, können Sie das Video in überlappende Segmente aufteilen und diese Segmente einzeln einbetten.

Dokumente einbetten

Dokumente im PDF-Format können direkt eingebettet werden. Das Modell verarbeitet die visuellen und textlichen Inhalte jeder Seite.

PDFs können als Inline-Daten oder als hochgeladene Dateien über die Files API bereitgestellt werden.

So verarbeitet das Modell PDFs

Wenn Sie eine PDF-Datei einbetten, verarbeitet das Modell das Dokument sowohl mit visuellen als auch mit Textfunktionen:

Visuelle Darstellung: Das Modell rendert jede Seite als Bild, was 258 Tokens pro Seite verbraucht.
Textextraktion: Das Modell extrahiert Text aus dem Dokument. Bei nativen PDFs (die digitalen Text enthalten) extrahiert das Modell den Text direkt. Bei gescannten PDFs (die Bilder von Text enthalten) führt das Modell automatisch eine optische Zeichenerkennung (OCR) durch, um den Text zu extrahieren.

Wenn Sie die Gesamtzahl der Tokens für eine PDF-Datei berechnen möchten, addieren Sie die visuellen Tokens (258 pro Seite) zu den Text-Tokens. Ihre Eingaben müssen innerhalb des Limits von 8.192 Tokens des Modells liegen (geteilt über alle Modalitäten). Das System schneidet Eingaben, die dieses Limit überschreiten, automatisch ab.

PDF-Limits

Dateien pro Anfrage: Sie können maximal eine PDF-Datei einreichen.
Seitenlimit: Sie können maximal 6 Seiten pro Datei einreichen. Für die beste Qualität empfehlen wir dringend, 1 Seite pro PDF zu verwenden.

Das folgende Beispiel zeigt, wie Sie eine PDF-Datei mit gemini-embedding-2 einbetten:

Python

from google import genai
from google.genai import types

with open('example.pdf', 'rb') as f:
    pdf_bytes = f.read()

client = genai.Client()

result = client.models.embed_content(
    model='gemini-embedding-2',
    contents=[
        types.Part.from_bytes(
            data=pdf_bytes,
            mime_type='application/pdf',
        ),
    ]
)

print(result.embeddings)

JavaScript

import { GoogleGenAI } from "@google/genai";
import * as fs from "node:fs";

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

    const pdfBase64 = fs.readFileSync("example.pdf", { encoding: "base64" });

    const response = await ai.models.embedContent({
        model: 'gemini-embedding-2',
        contents: [{
            inlineData: {
                mimeType: 'application/pdf',
                data: pdfBase64,
            },
        }],
    });

    console.log(response.embeddings);
}

main();

Java

import com.google.genai.Client;
import com.google.genai.types.Content;
import com.google.genai.types.EmbedContentResponse;
import com.google.genai.types.Part;
import java.nio.file.Files;
import java.nio.file.Paths;

Client client = new Client();

byte[] pdfBytes = Files.readAllBytes(Paths.get("example.pdf"));

Content content = Content.fromParts(Part.fromBytes(pdfBytes, "application/pdf"));

EmbedContentResponse response =
    client.models.embedContent("gemini-embedding-2", content, null);

System.out.println(response.embeddings().orElse(null));

REST

PDF_PATH="/path/to/your/example.pdf"
PDF_BASE64=$(base64 -w0 "${PDF_PATH}")

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-2:embedContent" \
    -H "Content-Type: application/json" \
    -H "x-goog-api-key: ${GEMINI_API_KEY}" \
    -d '{
        "content": {
            "parts": [{
                "inline_data": {
                    "mime_type": "application/pdf",
                    "data": "'"${PDF_BASE64}"'"
                }
            }]
        }
    }'

Anwendungsfälle

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

Retrieval-Augmented Generation (RAG): Einbettungen verbessern die Qualität von generiertem Text, indem relevante Informationen abgerufen und in den Kontext eines Modells einbezogen werden.
Informationsabruf: Suchen Sie nach dem semantisch ähnlichsten Text oder den semantisch ähnlichsten Dokumenten für einen bestimmten Eingabetext.

Anleitung zur Dokumentsuche
Suchergebnisse neu sortieren: Priorisieren Sie die relevantesten Elemente, indem Sie die ersten Ergebnisse semantisch anhand der Abfrage bewerten.

Anleitung zum Neusortieren von Suchergebnissen
Anomalieerkennung: Durch den Vergleich von Gruppen von Einbettungen können versteckte Trends oder Ausreißer identifiziert werden.

Anleitung zur Anomalieerkennung
Klassifizierung: Text wird automatisch anhand seines Inhalts kategorisiert, z. B. für Sentimentanalysen oder Spamerkennung.

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

Anleitung zur Visualisierung von Clustern

Einbettungen speichern

Wenn Sie Einbettungen in die Produktion überführen, 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 Gemini Enterprise Agent Platform Vector Search 2.0, BigQuery, AlloyDB und Cloud SQL.

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

Modellversionen

Gemini Embedding 2

Attribut	Beschreibung
-Modellcode	Gemini API `gemini-embedding-2`
Unterstützte Datentypen	Eingabe Text, Bild, Video, Audio, PDF Ausgabe Texteinbettungen
Token limits^[*]	Tokeneingabelimit 8.192 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-2`
Letzte Aktualisierung	April 2026

Gemini-Einbettung

Attribut	Beschreibung
-Modellcode	Gemini API `gemini-embedding-001`
Unterstützte Datentypen	Eingabe Text Ausgabe Texteinbettungen
Token limits^[*]	Tokeneingabelimit 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 Einbettungsmodellen finden Sie auf der Seite Einstellungen.

Migration von gemini-embedding-001

Die Einbettungsbereiche zwischen gemini-embedding-001 und gemini-embedding-2 sind nicht kompatibel. Das bedeutet, dass Sie Einbettungen, die von einem Modell generiert wurden, nicht direkt mit Einbettungen vergleichen können, die von einem anderen Modell generiert wurden. Wenn Sie ein Upgrade auf gemini-embedding-2 durchführen, müssen Sie alle vorhandenen Daten neu einbetten.

Neben der Inkompatibilität gibt es noch einige andere wichtige Unterschiede zwischen den beiden Modellen:

Aufgabentyp angeben: Bei gemini-embedding-001 geben Sie den Aufgabentyp mit dem Parameter task_type an (z.B. SEMANTIC_SIMILARITY, RETRIEVAL_DOCUMENT). Bei gemini-embedding-2 wird der Parameter task_type nicht unterstützt. Stattdessen sollten Sie die Aufgabenanweisungen direkt in den Prompt für reine Textaufgaben einfügen. Weitere Informationen zum Formatieren von Prompts für verschiedene Anwendungsfälle finden Sie unter Aufgabentypen mit Embeddings 2.
Einbettungsaggregation: gemini-embedding-001 generiert einzelne Einbettungen für jeden String in einer Liste von Eingaben. Im Gegensatz dazu erzeugt gemini-embedding-2 eine einzelne, aggregierte Einbettung, wenn mehrere Eingaben (z. B. Text und Bilder) direkt in einer Anfrage bereitgestellt werden. Wenn Sie separate Einbettungen für einzelne Eingaben generieren möchten, verpacken Sie jede Eingabe in ein Content-Objekt oder verwenden Sie die Batch API. Weitere Informationen finden Sie unter Einbettungsaggregation.
Normalisierung: Wenn Sie output_dimensionality verwenden, um Einbettungen mit weniger als 3.072 Dimensionen anzufordern, normalisiert gemini-embedding-2 diese gekürzten Einbettungen automatisch. Bei gemini-embedding-001 müssen Sie die Normalisierung für andere Dimensionen als 3072 manuell durchführen. Weitere Informationen finden Sie unter Qualität bei kleineren Dimensionen sicherstellen.

Batch-Einbettungen

Wenn die Latenz kein Problem darstellt, können Sie die Gemini Embeddings-Modelle mit der Batch API verwenden. Dies ermöglicht einen viel höheren Durchsatz zu 50 % des Standardpreises für Einbettungen. Beispiele für den Einstieg finden Sie im Batch API-Cookbook.

Hinweis zur verantwortungsvollen Nutzung

Im Gegensatz zu generativen KI-Modellen, die neue Inhalte erstellen, ist das Gemini-Einbettungsmodell 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 gewünschte numerische Format umwandelt, die Nutzer tragen jedoch die volle Verantwortung für die von ihnen eingegebenen Daten und die resultierenden Einbettungen. Durch die Nutzung des Gemini-Einbettungsmodells 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. Ihre Verwendung dieses Dienstes unterliegt unserer Richtlinie zur unzulässigen Nutzung von generativer KI und den Google-Nutzungsbedingungen.

Mit Einbettungen entwickeln

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

Anwendungsfall	Abfragestruktur	Dokumentstruktur
Suchanfrage	`task: search result \| query: {content}`	`title: {title} \| text: {content}` Wenn kein Titel vorhanden ist, verwenden Sie `title: none`.
Question Answering	`task: question answering \| query: {content}`	`title: {title} \| text: {content}`
Faktenchecks	`task: fact checking \| query: {content}`	`title: {title} \| text: {content}`
Codeabruf	`task: code retrieval \| query: {content}`	`title: {title} \| text: {content}`