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. Ils fournissent des résultats plus précis et plus adaptés au contexte que les approches basées sur les mots clés.

Le dernier modèle, gemini-embedding-2-preview, 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 la recherche, la classification et le clustering cross-modal dans plus de 100 langues. Pour en savoir plus, consultez la section Embeddings multimodaux. Pour les cas d'utilisation uniquement basés sur du texte, 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 résultats 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 du RAG et le rend plus rentable.

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é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 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 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

gemini-embedding-001 et gemini-embedding-2-preview sont tous deux entraînés à l'aide de la technique d'apprentissage de la représentation Matryoshka (MRL, Matryoshka Representation Learning), qui apprend à un modèle à apprendre des intégrations 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é de calcul pour les applications en aval, tout en sacrifiant peu en termes 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 perte de 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 des vecteurs, et non leur magnitude. 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

Embeddings multimodaux

Le modèle gemini-embedding-2-preview 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 la recherche et la comparaison intermodales.

Modalités et limites acceptées

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

Modalité Spécifications et limites
Texte Il accepte jusqu'à 8 192 jetons.
Image Six images maximum par requête. Formats acceptés : PNG, JPEG.
Audio Durée maximale de 80 secondes. Formats compatibles : MP3, WAV.
Vidéo Durée maximale de 128 secondes. Formats acceptés : MP4, MOV ; codecs acceptés : H264, H265, AV1, VP9
Documents (PDF) Six pages maximum.

Intégrer des images

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

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-preview',
    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-preview',
        contents: [{
            inlineData: {
                mimeType: 'image/png',
                data: imgBase64,
            },
        }],
    });

    console.log(response.embeddings);
}

main();

REST

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

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-2-preview: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 d'embedding :

  • Entrée de contenu unique : si vous envoyez plusieurs parties (par exemple, du texte et une image) dans une même entrée de contenu, une intégration agrégée sera générée pour toutes les modalités de cette entrée.
  • Plusieurs entrées : l'envoi de plusieurs entrées dans le tableau 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 les moyennant) afin de créer une représentation cohérente au niveau du post.

L'exemple suivant montre comment créer un embedding agrégé pour les entrées de texte et d'image. Utilisez le champ parts pour combiner plusieurs entrées :

Python

from google import genai
from google.genai import types

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

result = client.models.embed_content(
    model='gemini-embedding-2-preview',
    contents=[
        types.Content(
            parts=[
                types.Part(text="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-preview',
        contents: {
            parts: [
                { text: 'An image of a dog' },
                { inlineData: { mimeType: 'image/png', data: imgBase64 } },
            ],
        },
    });

    console.log(response.embeddings);
}

main();

REST

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

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-2-preview: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, cet exemple crée plusieurs embeddings en un seul appel d'embedding :

Python

from google import genai
from google.genai import types

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

result = client.models.embed_content(
    model='gemini-embedding-2-preview',
    contents=[
        "The dog is cute",
        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-preview',
        contents: [
            'The dog is cute',
            {
                inlineData: {
                    mimeType: 'image/png',
                    data: imgBase64,
                },
            },
        ],
    });

    console.log(response.embeddings);
}

main();

REST

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

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

Intégrer de l'audio

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

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-preview',
    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-preview',
        contents: [{
            inlineData: {
                mimeType: 'audio/mpeg',
                data: audioBase64,
            },
        }],
    });

    console.log(response.embeddings);
}

main();

REST

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

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-2-preview: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égrer une vidéo

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

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-preview',
    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-preview',
        contents: [{
            inlineData: {
                mimeType: 'video/mp4',
                data: videoBase64,
            },
        }],
    });

    console.log(response.embeddings);
}

main();

REST

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

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-2-preview: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 128 secondes, vous pouvez les découper en segments qui se chevauchent et intégrer ces segments individuellement.

Intégrer 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 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.pdf', 'rb') as f:
    pdf_bytes = f.read()

client = genai.Client()

result = client.models.embed_content(
    model='gemini-embedding-2-preview',
    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-preview',
        contents: [{
            inlineData: {
                mimeType: 'application/pdf',
                data: pdfBase64,
            },
        }],
    });

    console.log(response.embeddings);
}

main();

REST

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

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-2-preview: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 de texte sont essentiels pour de nombreux cas d'utilisation courants de l'IA, tels que :

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

Gemini Embedding 2 (preview)

Propriété Description
Code du modèle

API Gemini

gemini-embedding-2-preview
Types de données acceptés pour

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, 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.
  • Aperçu : gemini-embedding-2-preview
Dernière mise à jour Novembre 2025

Embedding Gemini

Propriété Description
Code du modèle

API Gemini

gemini-embedding-001
Types de données acceptés pour

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 Embeddings obsolètes, consultez la page Abandons.

Migration depuis gemini-embedding-001

Les espaces d'intégration entre gemini-embedding-001 et gemini-embedding-2-preview 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-preview, vous devez réintégrer toutes vos données existantes.

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 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.