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. Les tâches d'embedding telles que la recherche sémantique, la classification et le clustering fournissent des résultats plus précis et plus contextuels 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 produits d'IA. Les embeddings jouent un rôle clé dans l'amélioration significative des sorties des modèles, en offrant une meilleure précision factuelle, une meilleure cohérence et une meilleure richesse contextuelle. Si vous préférez utiliser une solution RAG gérée, nous avons créé l'outil Recherche de fichiers, qui facilite la gestion et réduit les coûts du RAG.

Générer des embeddings

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

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

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 "Content-Type: application/json" \
    -H "x-goog-api-key: $GEMINI_API_KEY" \
    -d '{
    "content": {
        "parts": [
        {
            "text": "What is the meaning of life?"
        },
        {
            "text": "How much wood would a woodchuck chuck?"
        },
        {
            "text": "How does the brain work?"
        }
        ]
    },
    "taskType": "SEMANTIC_SIMILARITY"
    }'

Spécifier 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 pandas as pd
from sklearn.metrics.pairwise import cosine_similarity

client = genai.Client()

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

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

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

print(df)

JavaScript

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

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

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

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

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

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

main();

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 montreront à quel point les différents blocs de texte sont similaires les uns aux autres lorsqu'ils sont exécutés.

Types de tâches compatibles

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, études de marché, détection des 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 affirmations à valider, optimisés pour récupérer les documents contenant des preuves qui soutiennent ou réfutent l'affirmation. 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), qui apprend à un modèle à apprendre des embeddings de grande dimension dont les segments initiaux (ou préfixes) 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. Sélectionner une dimensionnalité de sortie plus petite peut permettre d'économiser de l'espace de stockage et d'accroître l'efficacité du calcul pour les applications en aval, tout en sacrifiant peu en termes 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 '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

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'intégration, 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 : rechercher 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
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 ou des valeurs aberrantes cachées.

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 des embeddings

Lorsque vous déployez 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`
Dernière mise à jour	Juin 2025

Pour les modèles d'embeddings obsolètes, consultez la page Obsolescence.

Embeddings par lot

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

Avis sur l'utilisation responsable

Contrairement aux modèles d'IA générative qui créent du contenu, 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.