Embedding

L'API Gemini offre modelli di incorporamento per generare incorporamenti per testo, immagini, video e altri contenuti. Questi embedding risultanti possono essere utilizzati per attività come la ricerca semantica, la classificazione e il clustering, fornendo risultati più accurati e sensibili al contesto rispetto agli approcci basati su parole chiave.

L'ultimo modello, gemini-embedding-2, è il primo modello di incorporamento multimodale nell'API Gemini. Mappa testo, immagini, video, audio e documenti in uno spazio di incorporamento unificato, consentendo la ricerca, la classificazione e il clustering cross-modali in oltre 100 lingue. Per saperne di più, consulta la sezione sugli incorporamenti multimodali. Per i casi d'uso solo testo, gemini-embedding-001 rimane disponibile.

La creazione di sistemi di Retrieval Augmented Generation (RAG) è un caso d'uso comune per i prodotti AI. Gli incorporamenti svolgono un ruolo chiave nel migliorare significativamente gli output del modello con una maggiore accuratezza fattuale, coerenza e ricchezza contestuale. Se preferisci utilizzare una soluzione RAG gestita, abbiamo creato lo strumento Ricerca file, che semplifica la gestione della RAG e la rende più conveniente.

Generazione degli incorporamenti in corso…

Utilizza il metodo embedContent per generare incorporamenti di testo:

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

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

Specifica il tipo di attività per migliorare il rendimento

Puoi utilizzare gli incorporamenti per un'ampia gamma di attività, dalla classificazione alla ricerca di documenti. Specificare il tipo di attività corretto aiuta a ottimizzare gli incorporamenti per le relazioni previste, massimizzando l'accuratezza e l'efficienza.

Tipi di attività con Embeddings 2

Per le attività solo di testo con gemini-embedding-2, ti consigliamo vivamente di aggiungere le istruzioni dell'attività nel prompt. A tal fine, formatta la query e il documento con il prefisso dell'attività corretto.

Le tabelle seguenti mostrano esempi di formattazione di query e documenti per casi d'uso simmetrici e asimmetrici utilizzando il modello gemini-embedding-2.

Casi d'uso per il recupero (formato asimmetrico)

Nei casi d'uso asimmetrici, aggiungi il prefisso dell'attività alla query e applica la struttura del documento per i contenuti che vuoi incorporare e recuperare.

Caso d'uso Struttura della query Struttura del documento
Query di ricerca task: search result | query: {content} title: {title} | text: {content}
Se non è presente un titolo, utilizza title: none.
Question answering task: question answering | query: {content} title: {title} | text: {content}
Fact checking task: fact checking | query: {content} title: {title} | text: {content}
Recupero del codice task: code retrieval | query: {content} title: {title} | text: {content}

Esempio di utilizzo

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

Casi d'uso con un solo input (formato simmetrico)

Nei casi d'uso simmetrici, per la stessa attività, utilizza la stessa formattazione per la query e il documento.

Caso d'uso Struttura dell'input
Classificazione task: classification | query: {content}
Clustering task: clustering | query: {content}
Similarità semantica task: sentence similarity | query: {content}
Non utilizzare questo campo per la ricerca o il recupero. È destinato alla similarità semantica del testo.

Esempio di utilizzo

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

È importante che l'attività venga utilizzata in modo coerente. Ad esempio, se i documenti sono incorporati con f'task: classification | query: {content}', anche la query deve essere incorporata seguendo il formato di questa attività.

Tipi di attività con incorporamenti 1

Per gemini-embedding-001, puoi specificare task_type nel metodo embedContent. Per un elenco completo dei tipi di attività supportati, consulta la tabella Tipi di attività supportati.

L'esempio seguente mostra come utilizzare SEMANTIC_SIMILARITY per verificare il grado di somiglianza semantica di stringhe di testo.

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

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

Gli snippet di codice mostreranno il grado di somiglianza tra i diversi blocchi di testo quando vengono eseguiti.

Tipi di attività supportati

Tipi di attività supportati per gemini-embedding-001:

Tipo di attività Descrizione Esempi
SEMANTIC_SIMILARITY Incorporamenti ottimizzati per valutare la somiglianza del testo. Sistemi di suggerimenti, rilevamento dei duplicati
CLASSIFICAZIONE Embedding ottimizzati per classificare i testi in base a etichette preimpostate. Analisi del sentiment, rilevamento dello spam
CLUSTERING Incorporamenti ottimizzati per raggruppare i testi in base alle loro somiglianze. Organizzazione dei documenti, ricerca di mercato, rilevamento anomalie
RETRIEVAL_DOCUMENT Incorporamenti ottimizzati per la ricerca di documenti. Indicizzazione di articoli, libri o pagine web per la ricerca.
RETRIEVAL_QUERY Incorporamenti ottimizzati per le query di ricerca generali. Utilizza RETRIEVAL_QUERY per le query e RETRIEVAL_DOCUMENT per i documenti da recuperare. Ricerca personalizzata
CODE_RETRIEVAL_QUERY Incorporamenti ottimizzati per il recupero di blocchi di codice in base a query in linguaggio naturale. Utilizza CODE_RETRIEVAL_QUERY per le query e RETRIEVAL_DOCUMENT per i blocchi di codice da recuperare. Suggerimenti di codice e ricerca
QUESTION_ANSWERING Incorporamenti per le domande in un sistema di risposta alle domande, ottimizzati per trovare documenti che rispondano alla domanda. Utilizza QUESTION_ANSWERING per le domande e RETRIEVAL_DOCUMENT per i documenti da recuperare. Chatbox
FACT_VERIFICATION Incorporamenti per le affermazioni che devono essere verificate, ottimizzati per il recupero di documenti che contengono prove a sostegno o confutazione dell'affermazione. Utilizza FACT_VERIFICATION per il testo di destinazione; RETRIEVAL_DOCUMENT per i documenti da recuperare Sistemi di verifica dei fatti automatizzati

Controllare le dimensioni dell'incorporamento

gemini-embedding-001 e gemini-embedding-2 vengono addestrati utilizzando la tecnica di apprendimento della rappresentazione Matrioska (MRL), che insegna a un modello a imparare incorporamenti di grandi dimensioni con segmenti iniziali (o prefissi) che sono anche versioni più semplici e utili degli stessi dati.

Utilizza il parametro output_dimensionality per controllare le dimensioni del vettore di incorporamento di output. La selezione di una dimensionalità di output più piccola può consentire di risparmiare spazio di archiviazione e aumentare l'efficienza di calcolo per le applicazioni downstream, sacrificando poco in termini di qualità. Per impostazione predefinita, entrambi i modelli restituiscono un embedding a 3072 dimensioni, ma puoi troncarlo a una dimensione più piccola senza perdere qualità per risparmiare spazio di archiviazione. Ti consigliamo di utilizzare dimensioni di output pari a 768, 1536 o 3072.

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

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

Output di esempio dello snippet di codice:

Length of embedding: 768

Garantire la qualità per le dimensioni più piccole

Mentre gli incorporamenti predefiniti a 3072 dimensioni vengono sempre normalizzati, Gemini Embedding 2 normalizza automaticamente anche le dimensioni troncate (ad es. 768, 1536). In questo modo, la similarità semantica viene calcolata tramite la direzione del vettore anziché la magnitudo, fornendo risultati più accurati fin da subito.

Modelli precedenti: se utilizzi gemini-embedding-001, devi normalizzare manualmente le dimensioni non 3072 nel seguente modo:

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

Output di esempio di questo snippet di codice:

Normed embedding length: 768
Norm of normed embedding: 1.000000

La tabella seguente mostra i punteggi MTEB, un benchmark di uso comune per gli incorporamenti, per diverse dimensioni. In particolare, il risultato mostra che il rendimento non è strettamente legato alle dimensioni della dimensione di incorporamento, con dimensioni inferiori che ottengono punteggi paragonabili a quelli delle dimensioni superiori.

Dimensione MRL Punteggio MTEB (Gemini Embedding 001)
2048 68.16
1536 68.17
768 67,99
512 67,55
256 66,19
128 63,31

Embedding multimodali

Il modello gemini-embedding-2 supporta l'input multimodale, consentendoti di incorporare contenuti di immagini, video, audio e documenti insieme al testo. Tutte le modalità vengono mappate nello stesso spazio di incorporamento, consentendo la ricerca e il confronto cross-modale.

Modalità supportate e limiti

Il limite massimo complessivo di token di input è di 8192 token.

Modalità Specifiche e limiti
Testo Supporta fino a 8192 token.
Image Massimo 6 immagini per richiesta. Formati supportati: PNG, JPEG.
Audio Durata massima di 180 secondi. Formati supportati: MP3, WAV.
Video Durata massima di 120 secondi. Formati supportati: MP4, MOV. Codec supportati: H264, H265, AV1, VP9.
Il sistema elabora un massimo di 32 fotogrammi per video: i video brevi (≤ 32 secondi) vengono campionati a 1 fps, mentre i video più lunghi vengono campionati in modo uniforme a 32 fotogrammi. Le tracce audio non vengono elaborate nei file video.
Documenti (PDF) Massimo 6 pagine.

Incorporare immagini

L'esempio seguente mostra come incorporare un'immagine utilizzando gemini-embedding-2.

Le immagini possono essere fornite come dati in linea o come file caricati tramite 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();

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

Aggregazione dell'incorporamento

Quando lavori con contenuti multimodali, la struttura dell'input influisce sull'output dell'incorporamento:

  • Singola voce di contenuti:l'invio di più parti (ad esempio, testo e un'immagine) all'interno di una singola voce di contenuti produce un unico incorporamento aggregato per tutte le modalità all'interno di quella voce.
  • Più voci:l'invio di più voci nell'array contents restituisce incorporamenti separati per ogni voce.
  • Rappresentazione a livello di post: per oggetti complessi come i post sui social media con più elementi multimediali, ti consigliamo di aggregare incorporamenti separati (ad esempio, calcolando la media) per creare una rappresentazione coerente a livello di post.

Per generare un embedding aggregato, fornisci più tipi di input all'interno della stessa richiesta. Il seguente esempio mostra come creare un singolo embedding multimodale da dati di testo e immagine.

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',
    contents=[
        "An image of a dog",
        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("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,
                },
            },
        ],
    });

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

Incorporare l'audio

L'esempio seguente mostra come incorporare un file audio utilizzando gemini-embedding-2.

I file audio possono essere forniti come dati incorporati o come file caricati tramite 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();

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

Incorporamento di video

L'esempio seguente mostra come incorporare un video utilizzando gemini-embedding-2.

I video possono essere forniti come dati in linea o come file caricati tramite 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();

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

Se devi incorporare video di durata superiore a 120 secondi, puoi suddividerli in segmenti sovrapposti e incorporarli singolarmente.

Incorporare documenti

I documenti in formato PDF possono essere incorporati direttamente. Il modello elabora i contenuti visivi e di testo di ogni pagina.

I PDF possono essere forniti come dati incorporati o come file caricati tramite 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',
    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();

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

Casi d'uso

Gli incorporamenti di testo sono fondamentali per una serie di casi d'uso comuni dell'AI, ad esempio:

Memorizzazione degli embedding

Quando porti gli embedding in produzione, è comune utilizzare database vettoriali per archiviare, indicizzare e recuperare in modo efficiente gli embedding ad alta dimensionalità. Google Cloud offre servizi di dati gestiti che possono essere utilizzati a questo scopo, tra cui Gemini Enterprise Agent Platform Vector Search 2.0, BigQuery, AlloyDB e Cloud SQL.

I seguenti tutorial mostrano come utilizzare altri database vettoriali di terze parti con Gemini Embedding.

Versioni modello

Embedding Gemini 2

Proprietà Descrizione
Codice modello

API Gemini

gemini-embedding-2
Tipi di dati supportati

Ingresso

Testo, immagine, video, audio, PDF

Output

Text embedding
Limiti dei token[*]

Limite di token di input

8192

Dimensioni della dimensione di output

Flessibile, supporta: 128 - 3072, consigliato: 768, 1536, 3072
Versioni
Per ulteriori dettagli, leggi i pattern delle versioni del modello.
  • Stabile: gemini-embedding-2
Ultimo aggiornamento Aprile 2026

Embedding Gemini

Proprietà Descrizione
Codice modello

API Gemini

gemini-embedding-001
Tipi di dati supportati

Ingresso

Testo

Output

Text embedding
Limiti dei token[*]

Limite di token di input

2048

Dimensioni della dimensione di output

Flessibile, supporta: 128 - 3072, consigliato: 768, 1536, 3072
Versioni
Per ulteriori dettagli, leggi i pattern delle versioni del modello.
  • Stabile: gemini-embedding-001
Ultimo aggiornamento Giugno 2025

Per i modelli di incorporamento ritirati, visita la pagina Ritiri.

Migrazione da gemini-embedding-001

Gli spazi di incorporamento tra gemini-embedding-001 e gemini-embedding-2 sono incompatibili. Ciò significa che non puoi confrontare direttamente gli incorporamenti generati da un modello con quelli generati dall'altro. Se esegui l'upgrade a gemini-embedding-2, devi incorporare nuovamente tutti i dati esistenti.

Oltre all'incompatibilità, esistono diverse altre differenze notevoli tra i due modelli:

  • Specifica del tipo di attività:con gemini-embedding-001, specifichi il tipo di attività utilizzando il parametro task_type (ad es. SEMANTIC_SIMILARITY, RETRIEVAL_DOCUMENT). Con gemini-embedding-2, il parametro task_type non è supportato. Devi invece includere le istruzioni per l'attività direttamente nel prompt per le attività solo di testo. Per informazioni dettagliate su come formattare i prompt per diversi casi d'uso, consulta la sezione Tipi di attività con Embeddings 2.

  • Aggregazione di incorporamenti:gemini-embedding-001 genera incorporamenti individuali per ogni stringa in un elenco di input. Al contrario, gemini-embedding-2 produce un unico embedding aggregato quando vengono forniti più input (come testo e immagini) in un'unica richiesta. Se devi generare più incorporamenti per input separati contemporaneamente con gemini-embedding-2, utilizza l'API Batch. Per saperne di più, consulta Incorporamento dell'aggregazione.

  • Normalizzazione:se utilizzi output_dimensionality per richiedere incorporamenti con meno di 3072 dimensioni, gemini-embedding-2 normalizza automaticamente questi incorporamenti troncati. Con gemini-embedding-001, devi eseguire la normalizzazione manuale per le dimensioni diverse da 3072. Per i dettagli, vedi Garantire la qualità per dimensioni più piccole.

Incorporamenti batch

Se la latenza non è un problema, prova a utilizzare i modelli Gemini Embeddings con l'API Batch. Ciò consente un throughput molto più elevato al 50% del prezzo di Embedding predefinito. Trova esempi su come iniziare nella raccolta di ricette dell'API Batch.

Avviso sull'utilizzo responsabile

A differenza dei modelli di AI generativa che creano nuovi contenuti, il modello Gemini Embedding ha lo scopo di trasformare il formato dei dati di input in una rappresentazione numerica. Sebbene Google sia responsabile di fornire un modello di incorporamento che trasforma il formato dei dati di input nel formato numerico richiesto, gli utenti mantengono la piena responsabilità dei dati inseriti e degli incorporamenti risultanti. Utilizzando il modello Gemini Embedding, confermi di detenere i diritti necessari per i contenuti caricati. Non generare contenuti che violano la proprietà intellettuale o i diritti di privacy altrui. L'utilizzo di questo servizio è soggetto alle nostre Norme relative all'uso vietato e ai Termini di servizio di Google.

Inizia a creare con gli incorporamenti

Consulta il notebook della guida rapida sugli incorporamenti per esplorare le funzionalità del modello e scoprire come personalizzare e visualizzare gli incorporamenti.