Gemini 2.5 Flash Image (alias Nano Banana) est désormais disponible dans l'API Gemini. En savoir plus

Cette page a été traduite par l'API Cloud Translation.

Embeddings

L'API Gemini propose des modèles d'embedding de texte pour générer des embeddings pour les mots, les expressions, les phrases et le code. Ces embeddings fondamentaux permettent d'effectuer des tâches de traitement du langage naturel (NLP) avancées, telles que la recherche sémantique, la classification et le clustering. Ils fournissent des résultats plus précis et tenant compte du contexte que les approches basées sur les mots clés.

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 embeddings. Les embeddings jouent un rôle clé dans l'amélioration significative des résultats des modèles en termes de précision factuelle, de cohérence et de richesse contextuelle. Ils récupèrent efficacement les informations pertinentes des bases de connaissances, représentées par des embeddings, qui sont ensuite transmises en tant que contexte supplémentaire dans la requête d'entrée aux modèles de langage, ce qui les guide pour générer des réponses plus informées et plus précises.

Pour en savoir plus sur les variantes de modèles d'embedding disponibles, consultez la section Versions de modèle. Pour les applications de niveau entreprise et les charges de travail à volume élevé, nous vous suggérons d'utiliser des modèles d'embedding sur Vertex AI.

Génération d'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-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();

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

Vous pouvez également générer des embeddings pour plusieurs blocs à la fois en les transmettant sous forme de liste de chaînes.

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();

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

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 souhaitées, ce qui maximise la précision et l'efficacité. Pour obtenir la liste complète des types de tâches acceptés, consultez le tableau Types de tâches acceptés.

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

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();

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

Voici un exemple de résultat de cet extrait de code :

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

Types de tâches compatibles

Type de tâche	Description	Exemples
SEMANTIC_SIMILARITY	Embeddings optimisés pour évaluer la similarité 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, études 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 les 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 déclarations à valider, optimisés pour récupérer les documents contenant des preuves qui soutiennent ou réfutent la déclaration. 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'intégration

Le modèle d'embedding Gemini, gemini-embedding-001, est entraîné à l'aide de la technique d'apprentissage de la représentation Matryoshka (MRL, Matryoshka Representation Learning). Cette technique permet à un modèle d'apprendre des embeddings de grande dimension dont les segments initiaux (ou préfixes) sont également des versions plus simples et utiles 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é de calcul pour les applications en aval, tout en sacrifiant peu de qualité. Par défaut, il génère 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 des dimensions de sortie de 768, 1 536 ou 3 072.

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();

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

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

Length of embedding: 768

Garantir la qualité pour les dimensions plus petites

L'embedding de dimension 3072 est normalisé. Les embeddings normalisés produisent une similarité sémantique plus précise en comparant la direction du vecteur, et non son amplitude. Pour les autres dimensions, y compris 768 et 1536, vous devez normaliser les embeddings comme suit :

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

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. Le résultat montre notamment 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 homologues de dimension supérieure.

Dimension MRL	Score MTEB
2048	68.16
1536	68.17
768	67.99
512	67.55
256	66,19
128	63.31

Cas d'utilisation

Les embeddings de texte 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 proches sémantiquement à partir d'un texte d'entrée.

Tutoriel sur la recherche de documents
Reclassement des résultats de recherche : les éléments les plus pertinents sont mis en avant en attribuant un score sémantique aux résultats initiaux par rapport à la requête.

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

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

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

Tutoriel sur la visualisation du clustering

Stocker les embeddings

Lorsque vous mettez des 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 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

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, prend en charge : 128 à 3 072, recommandé : 768, 1 536, 3 072
Versions	Pour en savoir plus, consultez les schémas de version de modèle. Stable : `gemini-embedding-001` Expérimental : `gemini-embedding-exp-03-07`
Dernière mise à jour	Juin 2025

Avis sur l'utilisation responsable

Contrairement aux modèles d'IA générative qui créent de nouveaux contenus, le modèle Gemini Embedding est uniquement destiné à transformer le format de vos données d'entrée en représentation numérique. Bien que Google soit responsable de la fourniture d'un modèle d'embedding qui transforme le format de vos données d'entrée au format numérique demandé, les utilisateurs conservent l'entière responsabilité 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 mettez en ligne. 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 capacités du modèle et découvrir comment personnaliser et visualiser vos embeddings.