Gemini 4 Argon est désormais disponible. À vous de jouer.

Google utilise la technologie IA pour traduire le contenu dans votre langue préférée. Les traductions générées par IA peuvent contenir des erreurs.

Embeddings

L'API Gemini propose des modèles d'embedding pour générer des embeddings pour du texte, des images, des vidéos et d'autres contenus. Les embeddings obtenus peuvent ensuite être utilisés pour des tâches telles que la recherche sémantique, la classification et le clustering, ce qui permet d'obtenir des résultats plus précis et tenant compte du contexte que les approches basées sur des mots clés.

Le dernier modèle, gemini-embedding-2, est le premier modèle d'embedding multimodal de l'API Gemini. Il mappe le texte, les images, les vidéos, l'audio et les documents dans un espace d'embedding unifié, ce qui permet d'effectuer des recherches, des classifications et des regroupements cross-modaux dans plus de 100 langues. Pour en savoir plus, consultez la section Embeddings multimodaux. Pour les cas d'utilisation de texte uniquement, gemini-embedding-001 reste disponible.

La création de systèmes de génération augmentée par récupération (RAG) est un cas d'utilisation courant pour les produits d'IA. Les embeddings jouent un rôle clé dans l'amélioration significative des sorties du modèle, en améliorant la précision factuelle, la cohérence et la richesse contextuelle. Si vous préférez utiliser une solution RAG gérée, nous avons conçu l'outil Recherche de fichiers, qui facilite la gestion du RAG et le rend plus rentable.

Générer des embeddings

Utilisez la méthode embedContent pour générer des embeddings textuels :

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?"
        }]
        }
    }'

Spécifiez le type de tâche pour améliorer les performances

Vous pouvez utiliser des embeddings pour un large éventail de tâches, de la classification à la recherche de documents. Spécifier le bon type de tâche permet d'optimiser les embeddings pour les relations prévues, ce qui maximise la précision et l'efficacité.

Types de tâches avec Embeddings 2

Pour les tâches textuelles avec gemini-embedding-2, nous vous recommandons vivement d'ajouter l'instruction de la tâche dans votre prompt. Pour ce faire, formatez la requête et le document avec le préfixe de tâche approprié.

Lorsque vous générez un embedding unique basé sur une entrée multimodale, nous vous déconseillons généralement de faire précéder la partie textuelle de l'entrée d'une instruction de tâche. Dans certains cas, cela améliore les performances, mais dans d'autres, cela les réduit.

Les tableaux suivants montrent comment formater des requêtes et des documents pour des cas d'utilisation symétriques et asymétriques à l'aide du modèle gemini-embedding-2.

Cas d'utilisation de récupération (format asymétrique)

Dans les cas d'utilisation asymétriques, ajoutez le préfixe de la tâche à la requête et appliquez la structure du document pour le contenu que vous souhaitez intégrer et récupérer.

Cas d'utilisation	Structure d'une requête	Structure du document
Requête de recherche	`task: search result \| query: {content}`	`title: {title} \| text: {content}` Si aucun titre n'est disponible, utilisez `title: none`.
Systèmes de questions-réponses	`task: question answering \| query: {content}`	`title: {title} \| text: {content}`
Fact-checking	`task: fact checking \| query: {content}`	`title: {title} \| text: {content}`
Récupération du code	`task: code retrieval \| query: {content}`	`title: {title} \| text: {content}`

Exemple d'utilisation

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}"

Cas d'utilisation à entrée unique (format symétrique)

Dans les cas d'utilisation symétriques, pour la même tâche, utilisez la même mise en forme pour la requête et le document.

Cas d'utilisation	Structure d'entrée
Classification	`task: classification \| query: {content}`
Clustering	`task: clustering \| query: {content}`
Similarité sémantique	`task: sentence similarity \| query: {content}` Ne l'utilisez pas pour la recherche ou la récupération. Il est destiné à la similarité textuelle sémantique.

Exemple d'utilisation

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}'

Il est important que la tâche soit utilisée de manière cohérente. Par exemple, si les documents sont intégrés avec f'task: classification | query: {content}', la requête doit également être intégrée selon ce format de tâche.

Types de tâches avec Embeddings 1

Pour gemini-embedding-001, vous pouvez spécifier task_type dans la méthode embedContent. Pour obtenir la liste complète des types de tâches compatibles, consultez le tableau Types de tâches compatibles.

L'exemple suivant montre comment utiliser SEMANTIC_SIMILARITY pour vérifier la similarité de sens entre des chaînes de texte.

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?"
        }
        ]
    }
    }'

Les extraits de code montrent à quel point les différents fragments de texte sont similaires les uns aux autres lorsqu'ils sont exécutés.

Types de tâches compatibles

Types de tâches compatibles avec gemini-embedding-001 :

Type de tâche	Description	Exemples
SEMANTIC_SIMILARITY	Embeddings optimisés pour évaluer la similitude de texte.	Systèmes de recommandation, détection des doublons
CLASSIFICATION	Embeddings optimisés pour classer des textes en fonction d'étiquettes prédéfinies.	Analyse des sentiments, détection du spam
CLUSTERING	Embeddings optimisés pour regrouper des textes en fonction de leurs similitudes.	Organisation de documents, étude de marché, détection d'anomalies
RETRIEVAL_DOCUMENT	Embeddings optimisés pour la recherche de documents.	Indexation d'articles, de livres ou de pages Web pour la recherche.
RETRIEVAL_QUERY	Embeddings optimisés pour les requêtes de recherche générales. Utilisez `RETRIEVAL_QUERY` pour les requêtes et `RETRIEVAL_DOCUMENT` pour les documents à récupérer.	Tests personnalisés sur le Réseau de Recherche
CODE_RETRIEVAL_QUERY	Embeddings optimisés pour la récupération de blocs de code en fonction de requêtes en langage naturel. Utilisez `CODE_RETRIEVAL_QUERY` pour les requêtes et `RETRIEVAL_DOCUMENT` pour les blocs de code à récupérer.	Suggestions de code et recherche
QUESTION_ANSWERING	Embeddings pour les questions dans un système de questions-réponses, optimisés pour trouver des documents qui répondent à la question. Utilisez `QUESTION_ANSWERING` pour les questions et `RETRIEVAL_DOCUMENT` pour les documents à récupérer.	Chatbox
FACT_VERIFICATION	Embeddings pour les instructions qui doivent être vérifiées, optimisés pour récupérer des documents contenant des preuves qui confirment ou réfutent l'instruction. Utilisez `FACT_VERIFICATION` pour le texte cible et `RETRIEVAL_DOCUMENT` pour les documents à récupérer.	Systèmes de fact-checking automatisés

Contrôler la taille de l'embedding

gemini-embedding-001 et gemini-embedding-2 sont tous deux entraînés à l'aide de la technique d'apprentissage de représentation Matryoshka (MRL), qui apprend à un modèle à apprendre des embeddings de grande dimension comportant des segments initiaux (ou préfixes) qui sont également des versions utiles et plus simples des mêmes données.

Utilisez le paramètre output_dimensionality pour contrôler la taille du vecteur d'embedding de sortie. En sélectionnant une dimensionnalité de sortie plus petite, vous pouvez économiser de l'espace de stockage et augmenter l'efficacité des calculs pour les applications en aval, tout en sacrifiant peu de qualité. Par défaut, les deux modèles génèrent un embedding de 3 072 dimensions, mais vous pouvez le tronquer à une taille plus petite sans perdre en qualité pour économiser de l'espace de stockage. Nous vous recommandons d'utiliser 768, 1 536 ou 3 072 dimensions de sortie.

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
    }'

Exemple de résultat de l'extrait de code :

Length of embedding: 768

Garantir la qualité pour les dimensions plus petites

Bien que les embeddings par défaut de 3 072 dimensions soient toujours normalisés, Gemini Embedding 2 normalise également automatiquement les dimensions tronquées (par exemple, 768, 1 536). Cela garantit que la similarité sémantique est calculée via la direction du vecteur plutôt que par sa magnitude, ce qui fournit des résultats plus précis dès le départ.

Anciens modèles : si vous utilisez gemini-embedding-001, vous devez normaliser manuellement les dimensions autres que 3072 comme suit :

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

Exemple de résultat de cet extrait de code :

Normed embedding length: 768
Norm of normed embedding: 1.000000

Le tableau suivant présente les scores MTEB, un benchmark couramment utilisé pour les embeddings, pour différentes dimensions. Notamment, le résultat montre que les performances ne sont pas strictement liées à la taille de la dimension d'embedding, les dimensions inférieures obtenant des scores comparables à ceux de leurs équivalents de dimension supérieure.

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

Embeddings multimodaux

Le modèle gemini-embedding-2 accepte les entrées multimodales, ce qui vous permet d'intégrer des images, des vidéos, des contenus audio et des documents en plus du texte. Toutes les modalités sont mappées dans le même espace d'embedding, ce qui permet d'effectuer des recherches et des comparaisons multimodales.

Modalités et limites acceptées

La limite maximale globale de jetons d'entrée est de 8 192 jetons.

Modalité	Spécifications et limites
Texte	Accepte jusqu'à 8 192 jetons.
Image	6 images maximum par requête. Formats acceptés : PNG, JPEG.
Audio	Durée maximale de 180 secondes. Formats compatibles : MP3, WAV.
Vidéo	Durée maximale de 120 secondes. Formats acceptés : MP4, MOV. Codecs compatibles : H264, H265, AV1, VP9. Le système traite un maximum de 32 images par vidéo : les vidéos courtes (≤ 32 s) sont échantillonnées à 1 FPS, tandis que les vidéos plus longues sont échantillonnées de manière uniforme à 32 images. Les pistes audio ne sont pas traitées dans les fichiers vidéo.
Documents (PDF)	Un fichier maximum par requête, jusqu'à six pages.

Embedding d'images

L'exemple suivant montre comment intégrer une image à l'aide de gemini-embedding-2.

Les images peuvent être fournies sous forme de données intégrées ou de fichiers importés via l'API Files.

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}"'"
                }
            }]
        }
    }'

Agrégation d'embeddings

Lorsque vous travaillez avec du contenu multimodal, la façon dont vous structurez votre entrée affecte la sortie de l'embedding :

Plusieurs parties (agrégées) : l'ajout de plusieurs entrées directement au paramètre contents produit un seul embedding agrégé pour toutes les entrées.
Plusieurs objets Content (distincts) : encapsuler chaque entrée dans un objet Content et les transmettre dans le paramètre contents renvoie des embeddings distincts pour chaque entrée.
Représentation au niveau du post : pour les objets complexes tels que les posts sur les réseaux sociaux comportant plusieurs éléments multimédias, nous vous recommandons d'agréger des embeddings distincts (par exemple, en calculant la moyenne) pour créer une représentation cohérente au niveau du post.

L'exemple suivant montre comment créer un embedding agrégé pour une entrée de texte et d'image. Il vous suffit d'ajouter plusieurs entrées au paramètre contents :

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}"'"
                    }
                }
            ]
        }
    }'

En revanche, si vous utilisez des objets Content dans le paramètre contents, il renvoie des embeddings distincts. Cet exemple crée plusieurs embeddings en un seul appel d'embedding :

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}"'"}}]}
            }
        ]
    }'

Intégrer du contenu audio

L'exemple suivant montre comment intégrer un fichier audio à l'aide de gemini-embedding-2.

Les fichiers audio peuvent être fournis sous forme de données intégrées ou de fichiers importés via l'API Files.

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}"'"
                }
            }]
        }
    }'

Intégration de la vidéo…

L'exemple suivant montre comment intégrer une vidéo à l'aide de gemini-embedding-2.

Les vidéos peuvent être fournies sous forme de données intégrées ou de fichiers importés via l'API Files.

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}"'"
                }
            }]
        }
    }'

Si vous devez intégrer des vidéos de plus de 120 secondes, vous pouvez les diviser en segments qui se chevauchent et intégrer ces segments individuellement.

Vectoriser des documents

Les documents au format PDF peuvent être intégrés directement. Le modèle traite le contenu visuel et textuel de chaque page.

Les fichiers PDF peuvent être fournis en tant que données intégrées ou en tant que fichiers importés via l'API Files.

Comment le modèle traite-t-il les PDF ?

Lorsque vous intégrez un PDF, le modèle traite le document à l'aide de caractéristiques visuelles et textuelles :

Représentation visuelle : le modèle affiche chaque page sous forme d'image, ce qui consomme 258 jetons par page.
Extraction de texte : le modèle extrait le texte du document. Pour les PDF natifs (qui contiennent du texte numérique), le modèle extrait directement le texte. Pour les PDF scannés (qui contiennent des images de texte), le modèle exécute automatiquement la reconnaissance optique des caractères (OCR) pour extraire le texte.

Pour calculer le nombre total de jetons d'un PDF, ajoutez les jetons visuels (258 par page) aux jetons de texte. Vos entrées doivent respecter la limite de 8 192 jetons du modèle (partagée entre toutes les modalités). Le système tronque silencieusement les entrées qui dépassent cette limite.

Limites des PDF

Fichiers par requête : vous pouvez envoyer un fichier PDF au maximum.
Limite de pages : vous pouvez envoyer un maximum de six pages par fichier. Pour une qualité optimale, nous vous recommandons vivement d'utiliser une page par PDF.

L'exemple suivant montre comment intégrer un PDF à l'aide de gemini-embedding-2 :

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}"'"
                }
            }]
        }
    }'

Cas d'utilisation

Les embeddings textuels sont essentiels pour de nombreux cas d'utilisation courants de l'IA, tels que :

Génération augmentée par récupération (RAG) : les embeddings améliorent la qualité du texte généré en récupérant et en intégrant des informations pertinentes dans le contexte d'un modèle.
Récupération d'informations : recherchez le texte ou les documents les plus similaires d'un point de vue sémantique à partir d'un texte d'entrée.

Tutoriel sur la recherche de documents
Nouveau classement des recherches : hiérarchisez les éléments les plus pertinents en attribuant un score sémantique aux résultats initiaux par rapport à la requête.

Tutoriel sur le reclassement de la recherche
Détection d'anomalies : la comparaison de groupes d'embeddings peut aider à identifier des tendances cachées ou des anomalies.

Tutoriel sur la détection d'anomalies
Classification : catégorisez automatiquement du texte en fonction de son contenu, par exemple pour l'analyse des sentiments ou la détection du spam.

Tutoriel sur la classification
Clustering : appréhendez efficacement les relations complexes en créant des clusters et des visualisations de vos embeddings.

Tutoriel sur la visualisation du clustering

Stocker des embeddings

Lorsque vous passez les embeddings en production, il est courant d'utiliser des bases de données vectorielles pour stocker, indexer et récupérer efficacement des embeddings de grande dimension. Google Cloud propose des services de données gérés qui peuvent être utilisés à cette fin, y compris Gemini Enterprise Agent Platform Vector Search 2.0, BigQuery, AlloyDB et Cloud SQL.

Les tutoriels suivants montrent comment utiliser d'autres bases de données vectorielles tierces avec Gemini Embedding.

Versions de modèle

Gemini Embedding 2

Propriété	Description
Code du modèle	API Gemini `gemini-embedding-2`
Types de données acceptés	Entrée Texte, image, vidéo, audio, PDF Résultat Embeddings textuels
Limites de jetons^[*]	Limite de jetons d'entrée 8 192 Taille de la dimension de sortie Flexible, accepte : 128 à 3 072, recommandé : 768, 1 536, 3 072
versions	Pour en savoir plus, consultez les modèles de version de modèle. Stable : `gemini-embedding-2`
Dernière mise à jour	Avril 2026

Embedding Gemini

Propriété	Description
Code du modèle	API Gemini `gemini-embedding-001`
Types de données acceptés	Entrée Texte Résultat Embeddings textuels
Limites de jetons^[*]	Limite de jetons d'entrée 2 048 Taille de la dimension de sortie Flexible, accepte : 128 à 3 072, recommandé : 768, 1 536, 3 072
versions	Pour en savoir plus, consultez les modèles de version de modèle. Stable : `gemini-embedding-001`
Dernière mise à jour	Juin 2025

Pour en savoir plus sur les modèles d'embeddings obsolètes, consultez la page Obsolescence.

Migration depuis gemini-embedding-001

Les espaces d'embedding entre gemini-embedding-001 et gemini-embedding-2 sont incompatibles. Cela signifie que vous ne pouvez pas comparer directement les embeddings générés par un modèle avec ceux générés par l'autre. Si vous passez à gemini-embedding-2, vous devez réintégrer toutes vos données existantes.

Au-delà de l'incompatibilité, il existe plusieurs autres différences notables entre les deux modèles :

Spécification du type de tâche : avec gemini-embedding-001, vous spécifiez le type de tâche à l'aide du paramètre task_type (par exemple, SEMANTIC_SIMILARITY, RETRIEVAL_DOCUMENT). Avec gemini-embedding-2, le paramètre task_type n'est pas accepté. Vous devez plutôt inclure les instructions de la tâche directement dans le prompt pour les tâches textuelles. Pour en savoir plus sur la mise en forme des requêtes pour différents cas d'utilisation, consultez Types de tâches avec Embeddings 2.
Agrégation d'embeddings : gemini-embedding-001 génère des embeddings individuels pour chaque chaîne d'une liste d'entrées. En revanche, gemini-embedding-2 produit un seul embedding agrégé lorsque plusieurs entrées (comme du texte et des images) sont fournies directement dans une seule requête. Pour générer des embeddings distincts pour des entrées individuelles, encapsulez chaque entrée dans un objet Content ou utilisez l'API Batch. Pour en savoir plus, consultez Agrégation d'embeddings.
Normalisation : si vous utilisez output_dimensionality pour demander des embeddings de moins de 3 072 dimensions, gemini-embedding-2 normalise automatiquement ces embeddings tronqués. Avec gemini-embedding-001, vous devez effectuer une normalisation manuelle pour les dimensions autres que 3072. Pour en savoir plus, consultez Assurer la qualité pour les dimensions plus petites.

Embeddings par lot

Si la latence n'est pas un problème, essayez d'utiliser les modèles d'embeddings Gemini avec l'API Batch. Cela permet d'obtenir un débit beaucoup plus élevé à 50 % du prix par défaut des embeddings. Vous trouverez des exemples pour vous aider à démarrer dans le guide de l'API Batch.

Avis d'utilisation responsable

Contrairement aux modèles d'IA générative qui créent du contenu, le modèle d'embedding Gemini est uniquement destiné à transformer le format de vos données d'entrée en une représentation numérique. Bien que Google soit responsable de fournir un modèle d'embedding qui transforme le format de vos données d'entrée au format numérique demandé, les utilisateurs restent entièrement responsables des données qu'ils saisissent et des embeddings qui en résultent. En utilisant le modèle d'embedding Gemini, vous confirmez que vous disposez des droits nécessaires sur tous les contenus que vous importez. Ne générez aucun contenu qui porte atteinte à la propriété intellectuelle ou aux droits au respect de la confidentialité d'autrui. Votre utilisation de ce service est soumise à notre Règlement sur les utilisations interdites et aux Conditions d'utilisation de Google.

Commencer à créer avec des embeddings

Consultez le notebook de démarrage rapide sur les embeddings pour explorer les fonctionnalités du modèle et apprendre à personnaliser et à visualiser vos embeddings.

Cas d'utilisation	Structure d'une requête	Structure du document
Requête de recherche	`task: search result \| query: {content}`	`title: {title} \| text: {content}` Si aucun titre n'est disponible, utilisez `title: none`.
Systèmes de questions-réponses	`task: question answering \| query: {content}`	`title: {title} \| text: {content}`
Fact-checking	`task: fact checking \| query: {content}`	`title: {title} \| text: {content}`
Récupération du code	`task: code retrieval \| query: {content}`	`title: {title} \| text: {content}`