Встраивания

Gemini API предлагает модели эмбеддингов для генерации эмбеддингов для текста, изображений, видео и другого контента. Полученные встраивания можно использовать для таких задач, как семантический поиск, классификация и кластеризация. Это позволяет получать более точные результаты с учетом контекста, чем при использовании подходов на основе ключевых слов.

Последняя модель, gemini-embedding-2, – это первая мультимодальная модель эмбеддинга в Gemini API. Она сопоставляет текст, изображения, видео, аудио и документы в едином пространстве встраивания, что позволяет выполнять кросс-модальный поиск, классификацию и кластеризацию на более чем 100 языках. Подробнее о мультимодальных эмбеддингах… Для работы только с текстом по-прежнему доступна модель gemini-embedding-001.

Создание систем генерации с расширенным поиском (RAG) – распространенный вариант использования ИИ-продуктов. Векторные представления играют ключевую роль в значительном улучшении выходных данных модели, повышая их фактическую точность, связность и контекстуальное богатство. Если вы предпочитаете использовать управляемое решение RAG, мы создали инструмент File Search, который упрощает управление RAG и делает его более экономичным.

Генерация эмбеддингов

Используйте метод embedContent, чтобы сгенерировать эмбеддинги текста:

Python

from google import genai

client = genai.Client()

result = client.models.embed_content(
        model="gemini-embedding-2",
        contents="What is the meaning of life?"
)

print(result.embeddings)

JavaScript

import { GoogleGenAI } from "@google/genai";

async function main() {

    const ai = new GoogleGenAI({});

    const response = await ai.models.embedContent({
        model: 'gemini-embedding-2',
        contents: 'What is the meaning of life?',
    });

    console.log(response.embeddings);
}

main();

Java

import com.google.genai.Client;
import com.google.genai.types.EmbedContentResponse;

Client client = new Client();

EmbedContentResponse response =
    client.models.embedContent("gemini-embedding-2", "What is the meaning of life?", null);

System.out.println(response.embeddings().orElse(null));

Проложить маршрут

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

Укажите тип задачи, чтобы повысить эффективность

Встраивания можно использовать для самых разных задач – от классификации до поиска документов. Указав правильный тип задачи, вы сможете оптимизировать эмбеддинги для нужных связей, повысив точность и эффективность.

Типы задач с Embeddings 2

Для текстовых задач с gemini-embedding-2 настоятельно рекомендуем добавлять инструкции в запрос. Для этого нужно отформатировать запрос и документ с правильным префиксом задачи.

При создании одного эмбеддинга на основе мультимодальных входных данных мы обычно не рекомендуем добавлять к текстовой части входных данных инструкцию по задаче. В некоторых случаях это повышает эффективность, а в других – снижает.

В таблицах ниже показано, как форматировать запросы и документы для симметричных и асимметричных вариантов использования модели gemini-embedding-2.

Примеры использования извлечения (асимметричный формат)

В асимметричных случаях использования добавьте префикс задачи к запросу и примените структуру документа к контенту, который вы хотите встроить и извлечь.

Пример использования Структура запроса Структура документа
Поисковый запрос task: search result | query: {content} title: {title} | text: {content}
Если названия нет, используйте title: none.
Ответы на вопросы task: question answering | query: {content} title: {title} | text: {content}
Проверка фактов task: fact checking | query: {content} title: {title} | text: {content}
Получение кода task: code retrieval | query: {content} title: {title} | text: {content}

Пример использования

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

Примеры использования с одним вводом (симметричный формат)

В симметричных случаях использования для одной и той же задачи используйте одинаковое форматирование для запроса и документа.

Пример использования Структура входных данных
Классификация task: classification | query: {content}
Группирование task: clustering | query: {content}
Смысловое сходство task: sentence similarity | query: {content}
Не используйте этот параметр для поиска или извлечения данных. Она предназначена для определения семантического сходства текстов.

Пример использования

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

Важно, чтобы задача использовалась последовательно. Например, если документы встроены с помощью f'task: classification | query: {content}', запрос также должен быть встроен в соответствии с этим форматом задачи.

Типы задач с эмбеддингами 1

Для gemini-embedding-001 можно указать task_type в методе embedContent. Полный список поддерживаемых типов задач приведен в таблице Поддерживаемые типы задач.

В примере ниже показано, как с помощью SEMANTIC_SIMILARITY проверить, насколько близки по смыслу строки текста.

Python

from google import genai
from google.genai import types
import pandas as pd
from sklearn.metrics.pairwise import cosine_similarity

client = genai.Client()

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

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

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

print(df)

JavaScript

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

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

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

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

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

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

main();

Java

import java.util.Arrays;
import com.google.genai.Client;
import com.google.genai.types.ContentEmbedding;
import com.google.genai.types.EmbedContentConfig;
import com.google.genai.types.EmbedContentResponse;
import java.util.List;

Client client = new Client();

List<String> texts =
    Arrays.asList(
        "What is the meaning of life?",
        "What is the purpose of existence?",
        "How do I bake a cake?");

EmbedContentConfig config =
    EmbedContentConfig.builder().taskType("SEMANTIC_SIMILARITY").build();

EmbedContentResponse response =
    client.models.embedContent("gemini-embedding-001", texts, config);

List<ContentEmbedding> embeddings = response.embeddings().get();

for (int i = 0; i < texts.size(); i++) {
  for (int j = i + 1; j < texts.size(); j++) {
    List<Float> v1 = embeddings.get(i).values().get();
    List<Float> v2 = embeddings.get(j).values().get();
    double dotProduct = 0.0;
    double normA = 0.0;
    double normB = 0.0;
    for (int k = 0; k < v1.size(); k++) {
      dotProduct += v1.get(k) * v2.get(k);
      normA += v1.get(k) * v1.get(k);
      normB += v2.get(k) * v2.get(k);
    }
    double similarity = dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
    System.out.printf(
        "Similarity between '%s' and '%s': %.4f%n", texts.get(i), texts.get(j), similarity);
  }
}

Проложить маршрут

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

Фрагменты кода покажут, насколько похожи разные фрагменты текста друг на друга при запуске.

Поддерживаемые типы задач

Поддерживаемые типы задач для gemini-embedding-001:

Тип задачи Описание Примеры
SEMANTIC_SIMILARITY Векторные представления, оптимизированные для оценки сходства текстов. Рекомендательные системы, обнаружение дубликатов
КЛАССИФИКАЦИЯ Векторные представления, оптимизированные для классификации текстов по заданным ярлыкам. Анализ тональности текста, обнаружение спама
КЛАСТЕРИЗАЦИЯ Встраивания, оптимизированные для кластеризации текстов на основе их сходства. Организация документов, исследование рынка, обнаружение аномалий
RETRIEVAL_DOCUMENT Эмбеддинги, оптимизированные для поиска документов. Индексирование статей, книг или веб-страниц для поиска.
RETRIEVAL_QUERY Встраивания, оптимизированные для общих поисковых запросов. Используйте RETRIEVAL_QUERY для запросов и RETRIEVAL_DOCUMENT для документов, которые нужно получить. Пользовательский поиск
CODE_RETRIEVAL_QUERY Эмбеддинги, оптимизированные для извлечения блоков кода на основе запросов на естественном языке. Используйте CODE_RETRIEVAL_QUERY для запросов и RETRIEVAL_DOCUMENT для блоков кода, которые нужно получить. Поиск и подсказки по коду
QUESTION_ANSWERING Эмбеддинги для вопросов в системе вопросов и ответов, оптимизированные для поиска документов, отвечающих на вопрос. Используйте QUESTION_ANSWERING для вопросов и RETRIEVAL_DOCUMENT для документов, которые нужно получить. Окно чата
FACT_VERIFICATION Эмбеддинги для утверждений, которые нужно проверить, оптимизированные для получения документов, содержащих доказательства, подтверждающие или опровергающие утверждение. Используйте FACT_VERIFICATION для целевого текста и RETRIEVAL_DOCUMENT для документов, которые нужно получить. Автоматизированные системы проверки фактов

Как управлять размером встроенного объекта

Модели gemini-embedding-001 и gemini-embedding-2 обучаются с помощью метода Matryoshka Representation Learning (MRL). Он позволяет модели изучать многомерные эмбеддинги, у которых есть начальные сегменты (или префиксы), также являющиеся полезными и более простыми версиями тех же данных.

Используйте параметр output_dimensionality, чтобы управлять размером выходного вектора эмбеддинга. Выбор меньшей размерности выходных данных может сэкономить место в хранилище и повысить эффективность вычислений для последующих приложений, при этом качество пострадает незначительно. По умолчанию обе модели выводят эмбеддинг размерностью 3072, но вы можете усечь его до меньшего размера без потери качества, чтобы сэкономить место в хранилище. Рекомендуем использовать 768, 1536 или 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();

Java

import com.google.genai.Client;
import com.google.genai.types.ContentEmbedding;
import com.google.genai.types.EmbedContentConfig;
import com.google.genai.types.EmbedContentResponse;

Client client = new Client();

EmbedContentConfig config =
    EmbedContentConfig.builder().outputDimensionality(768).build();

EmbedContentResponse response =
    client.models.embedContent("gemini-embedding-2", "What is the meaning of life?", config);

ContentEmbedding embeddingObj = response.embeddings().get().get(0);
int embeddingLength = embeddingObj.values().get().size();

System.out.println("Length of embedding: " + embeddingLength);

Проложить маршрут

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

Пример выходных данных из фрагмента кода:

Length of embedding: 768

Как обеспечить качество при меньших размерах

В то время как стандартные эмбеддинги с 3072 измерениями всегда нормализованы, Gemini Embedding 2 также автоматически нормализует усеченные измерения (например, 768, 1536). Это гарантирует, что семантическое сходство рассчитывается по направлению вектора, а не по величине, что обеспечивает более точные результаты.

Более старые модели. Если вы используете gemini-embedding-001, вам нужно вручную нормализовать размеры, отличные от 3072, следующим образом:

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

Пример выходных данных для этого фрагмента кода:

Normed embedding length: 768
Norm of normed embedding: 1.000000

В таблице ниже приведены оценки MTEB (распространенный контрольный показатель для эмбеддингов) для разных размерностей. Примечательно, что результат показывает, что производительность не строго привязана к размеру размерности встраивания, при этом более низкие размерности достигают показателей, сопоставимых с их аналогами с более высокой размерностью.

Параметр MRL Оценка MTEB (Gemini Embedding 001)
2048 68,16
1536 68,17
768 67,99
512 67,55
256 66,19
128 63,31

Мультимодальные эмбеддинги

Модель gemini-embedding-2 поддерживает мультимодальные входные данные, позволяя встраивать изображения, видео, аудио и документы вместе с текстом. Все модальности сопоставляются с одним и тем же пространством встраивания, что позволяет выполнять кросс-модальный поиск и сравнение.

Поддерживаемые модальности и ограничения

Общее максимальное ограничение на количество входных токенов составляет 8192 токена.

Модальность Технические характеристики и ограничения
Текст Поддерживает до 8192 токенов.
Изображение Максимальное количество изображений в запросе – 6. Поддерживаемые форматы: PNG, JPEG.
Аудио Максимальная продолжительность – 180 секунд. Поддерживаемые форматы: MP3, WAV.
Видео Максимальная продолжительность – 120 секунд. Поддерживаемые форматы: MP4, MOV. Поддерживаемые кодеки: H264, H265, AV1, VP9.
Система обрабатывает не более 32 кадров на видео: короткие видео (≤32 с) дискретизируются с частотой 1 кадр/с, а более длинные видео равномерно дискретизируются до 32 кадров. Аудиодорожки в видеофайлах не обрабатываются.
Документы (PDF) Максимум один файл на запрос, до шести страниц.

Встраивание изображений

В следующем примере показано, как встроить изображение с помощью gemini-embedding-2.

Изображения можно предоставлять в виде встроенных данных или загруженных файлов через Files API.

Python

from google import genai
from google.genai import types

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

client = genai.Client()

result = client.models.embed_content(
    model='gemini-embedding-2',
    contents=[
        types.Part.from_bytes(
            data=image_bytes,
            mime_type='image/png',
        ),
    ]
)

print(result.embeddings)

JavaScript

import { GoogleGenAI } from "@google/genai";
import * as fs from "node:fs";

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

    const imgBase64 = fs.readFileSync("example.png", { encoding: "base64" });

    const response = await ai.models.embedContent({
        model: 'gemini-embedding-2',
        contents: [{
            inlineData: {
                mimeType: 'image/png',
                data: imgBase64,
            },
        }],
    });

    console.log(response.embeddings);
}

main();

Java

import com.google.genai.Client;
import com.google.genai.types.Content;
import com.google.genai.types.EmbedContentResponse;
import com.google.genai.types.Part;
import java.nio.file.Files;
import java.nio.file.Paths;

Client client = new Client();

byte[] imageBytes = Files.readAllBytes(Paths.get("example.png"));

Content content = Content.fromParts(Part.fromBytes(imageBytes, "image/png"));

EmbedContentResponse response =
    client.models.embedContent("gemini-embedding-2", content, null);

System.out.println(response.embeddings().orElse(null));

REST

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

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

Агрегирование эмбеддингов

При работе с мультимодальным контентом структура входных данных влияет на выходные данные эмбеддинга:

  • Несколько частей (агрегированные). Если добавить несколько входных данных непосредственно в параметр contents, будет создано одно агрегированное встраивание для всех входных данных.
  • Несколько объектов Content (отдельно). Если вы упакуете каждый входной элемент в объект Content и передадите их в параметре contents, то получите отдельные эмбеддинги для каждого элемента.
  • Представление на уровне публикации. Для сложных объектов, таких как публикации в социальных сетях с несколькими мультимедийными объектами, мы рекомендуем агрегировать отдельные эмбеддинги (например, путем усреднения), чтобы создать согласованное представление на уровне публикации.

В следующем примере показано, как создать одно агрегированное встраивание для входных данных текста и изображения. Просто добавьте несколько значений в параметр contents:

Python

from google import genai
from google.genai import types

client = genai.Client()

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

result = client.models.embed_content(
    model='gemini-embedding-2',
    contents=[
        "An image of a dog",
        types.Part.from_bytes(
            data=image_bytes,
            mime_type='image/png',
        ),
    ]
)

# This produces one embedding
for embedding in result.embeddings:
    print(embedding.values)

JavaScript

import { GoogleGenAI } from "@google/genai";
import * as fs from "node:fs";

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

    const imgBase64 = fs.readFileSync("dog.png", { encoding: "base64" });

    const response = await ai.models.embedContent({
        model: 'gemini-embedding-2',
        contents: [
            'An image of a dog',
            {
                inlineData: {
                    mimeType: 'image/png',
                    data: imgBase64,
                },
            },
        ],
    });

    // This produces one embedding
    for (const embedding of response.embeddings) {
        console.log(embedding.values);
    }
}

main();

Java

import com.google.genai.Client;
import com.google.genai.types.Content;
import com.google.genai.types.ContentEmbedding;
import com.google.genai.types.EmbedContentResponse;
import com.google.genai.types.Part;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Collections;

Client client = new Client();

byte[] imageBytes = Files.readAllBytes(Paths.get("dog.png"));

Content content =
    Content.fromParts(
        Part.fromText("An image of a dog"),
        Part.fromBytes(imageBytes, "image/png"));

EmbedContentResponse response =
    client.models.embedContent("gemini-embedding-2", content, null);

// This produces one embedding
for (ContentEmbedding embedding : response.embeddings().orElse(Collections.emptyList())) {
  System.out.println(embedding.values().orElse(Collections.emptyList()));
}

REST

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

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

Если же вы используете объекты Content внутри параметра contents, то возвращаются отдельные эмбеддинги. В этом примере создается несколько эмбеддингов за один вызов:

Python

from google import genai
from google.genai import types

client = genai.Client()

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

result = client.models.embed_content(
    model="gemini-embedding-2",
    contents=[
        types.Content(parts=[types.Part.from_text(text="task: classification | query: An image of a dog")]),
        types.Content(
            parts=[
                types.Part.from_bytes(
                    data=image_bytes,
                    mime_type="image/png",
                ),
            ]
        ),
    ],
)

# This produces two embeddings
for embedding in result.embeddings:
    print(embedding.values)

JavaScript

import { GoogleGenAI } from "@google/genai";
import * as fs from "node:fs";

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

    const imgBase64 = fs.readFileSync("dog.png", { encoding: "base64" });

    const response = await ai.models.embedContent({
        model: 'gemini-embedding-2',
        contents: [
            { parts: [{ text: 'task: classification | query: An image of a dog' }] },
            {
                parts: [{
                    inlineData: {
                        mimeType: 'image/png',
                        data: imgBase64,
                    },
                }],
            },
        ],
    });

    // This produces two embeddings
    for (const embedding of response.embeddings) {
        console.log(embedding.values);
    }
}

main();

Java

import java.util.Arrays;
import com.google.genai.Client;
import com.google.genai.types.Content;
import com.google.genai.types.ContentEmbedding;
import com.google.genai.types.EmbedContentResponse;
import com.google.genai.types.Part;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Collections;
import java.util.List;

Client client = new Client();

byte[] imageBytes = Files.readAllBytes(Paths.get("dog.png"));

List<Content> contents =
    Arrays.asList(
        Content.fromParts(Part.fromText("task: classification | query: An image of a dog")),
        Content.fromParts(Part.fromBytes(imageBytes, "image/png")));

// Embed each Content object separately to produce separate embeddings
for (Content content : contents) {
  EmbedContentResponse response =
      client.models.embedContent("gemini-embedding-2", content, null);
  for (ContentEmbedding embedding : response.embeddings().orElse(Collections.emptyList())) {
    System.out.println(embedding.values().orElse(Collections.emptyList()));
  }
}

REST

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

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

Встраивание аудио

В примере ниже показано, как встроить аудиофайл с помощью тега gemini-embedding-2.

Аудиофайлы можно передавать как встроенные данные или загружать через Files API.

Python

from google import genai
from google.genai import types

with open('example.mp3', 'rb') as f:
    audio_bytes = f.read()

client = genai.Client()

result = client.models.embed_content(
    model='gemini-embedding-2',
    contents=[
        types.Part.from_bytes(
            data=audio_bytes,
            mime_type='audio/mpeg',
        ),
    ]
)

print(result.embeddings)

JavaScript

import { GoogleGenAI } from "@google/genai";
import * as fs from "node:fs";

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

    const audioBase64 = fs.readFileSync("example.mp3", { encoding: "base64" });

    const response = await ai.models.embedContent({
        model: 'gemini-embedding-2',
        contents: [{
            inlineData: {
                mimeType: 'audio/mpeg',
                data: audioBase64,
            },
        }],
    });

    console.log(response.embeddings);
}

main();

Java

import com.google.genai.Client;
import com.google.genai.types.Content;
import com.google.genai.types.EmbedContentResponse;
import com.google.genai.types.Part;
import java.nio.file.Files;
import java.nio.file.Paths;

Client client = new Client();

byte[] audioBytes = Files.readAllBytes(Paths.get("example.mp3"));

Content content = Content.fromParts(Part.fromBytes(audioBytes, "audio/mpeg"));

EmbedContentResponse response =
    client.models.embedContent("gemini-embedding-2", content, null);

System.out.println(response.embeddings().orElse(null));

REST

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

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-2:embedContent" \
    -H "Content-Type: application/json" \
    -H "x-goog-api-key: ${GEMINI_API_KEY}" \
    -d '{
        "content": {
            "parts": [{
                "inline_data": {
                    "mime_type": "audio/mpeg",
                    "data": "'"${AUDIO_BASE64}"'"
                }
            }]
        }
    }'

Встраивание видео

В примере ниже показано, как встроить видео с помощью тега gemini-embedding-2.

Видео можно передавать в виде встроенных данных или загружать через Files API.

Python

from google import genai
from google.genai import types

client = genai.Client()

with open('example.mp4', 'rb') as f:
    video_bytes = f.read()

result = client.models.embed_content(
    model='gemini-embedding-2',
    contents=[
        types.Part.from_bytes(
            data=video_bytes,
            mime_type='video/mp4',
        ),
    ]
)

print(result.embeddings[0].values)

JavaScript

import { GoogleGenAI } from "@google/genai";
import * as fs from "node:fs";

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

    const videoBase64 = fs.readFileSync("example.mp4", { encoding: "base64" });

    const response = await ai.models.embedContent({
        model: 'gemini-embedding-2',
        contents: [{
            inlineData: {
                mimeType: 'video/mp4',
                data: videoBase64,
            },
        }],
    });

    console.log(response.embeddings);
}

main();

Java

import com.google.genai.Client;
import com.google.genai.types.Content;
import com.google.genai.types.EmbedContentResponse;
import com.google.genai.types.Part;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Collections;

Client client = new Client();

byte[] videoBytes = Files.readAllBytes(Paths.get("example.mp4"));

Content content = Content.fromParts(Part.fromBytes(videoBytes, "video/mp4"));

EmbedContentResponse response =
    client.models.embedContent("gemini-embedding-2", content, null);

System.out.println(
    response.embeddings().get().get(0).values().orElse(Collections.emptyList()));

REST

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

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-2:embedContent" \
    -H "Content-Type: application/json" \
    -H "x-goog-api-key: ${GEMINI_API_KEY}" \
    -d '{
        "content": {
            "parts": [{
                "inline_data": {
                    "mime_type": "video/mp4",
                    "data": "'"${VIDEO_BASE64}"'"
                }
            }]
        }
    }'

Если вам нужно встроить видео продолжительностью более 120 секунд, вы можете разбить его на перекрывающиеся сегменты и встроить их по отдельности.

Встраивание документов

Документы в формате PDF можно встраивать напрямую. Модель обрабатывает визуальный и текстовый контент каждой страницы.

PDF-файлы можно передавать как встроенные данные или загружать через Files API.

Как модель обрабатывает PDF-файлы

Когда вы встраиваете PDF-файл, модель обрабатывает документ, используя как визуальные, так и текстовые функции:

  • Визуальное представление. Модель преобразует каждую страницу в изображение, что требует 258 токенов на страницу.
  • Извлечение текста. Модель извлекает текст из документа. Из нативных PDF-файлов (содержащих цифровой текст) модель извлекает текст напрямую. Для отсканированных PDF-файлов (которые содержат изображения текста) модель автоматически запускает оптическое распознавание символов (OCR) для извлечения текста.

Чтобы рассчитать общее количество токенов для PDF-файла, сложите визуальные токены (258 на страницу) и текстовые токены. Входные данные не должны превышать лимит модели в 8192 токена (для всех модальностей). Система автоматически усекает входные данные, превышающие это ограничение.

Ограничения для PDF-файлов

  • Количество файлов в запросе. Вы можете отправить не более одного PDF-файла.
  • Ограничение на количество страниц. В одном файле может быть не более шести страниц. Для наилучшего качества мы настоятельно рекомендуем использовать одну страницу на PDF-файл.

В примере ниже показано, как встроить PDF-файл с помощью gemini-embedding-2:

Python

from google import genai
from google.genai import types

with open('example.pdf', 'rb') as f:
    pdf_bytes = f.read()

client = genai.Client()

result = client.models.embed_content(
    model='gemini-embedding-2',
    contents=[
        types.Part.from_bytes(
            data=pdf_bytes,
            mime_type='application/pdf',
        ),
    ]
)

print(result.embeddings)

JavaScript

import { GoogleGenAI } from "@google/genai";
import * as fs from "node:fs";

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

    const pdfBase64 = fs.readFileSync("example.pdf", { encoding: "base64" });

    const response = await ai.models.embedContent({
        model: 'gemini-embedding-2',
        contents: [{
            inlineData: {
                mimeType: 'application/pdf',
                data: pdfBase64,
            },
        }],
    });

    console.log(response.embeddings);
}

main();

Java

import com.google.genai.Client;
import com.google.genai.types.Content;
import com.google.genai.types.EmbedContentResponse;
import com.google.genai.types.Part;
import java.nio.file.Files;
import java.nio.file.Paths;

Client client = new Client();

byte[] pdfBytes = Files.readAllBytes(Paths.get("example.pdf"));

Content content = Content.fromParts(Part.fromBytes(pdfBytes, "application/pdf"));

EmbedContentResponse response =
    client.models.embedContent("gemini-embedding-2", content, null);

System.out.println(response.embeddings().orElse(null));

REST

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

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-2:embedContent" \
    -H "Content-Type: application/json" \
    -H "x-goog-api-key: ${GEMINI_API_KEY}" \
    -d '{
        "content": {
            "parts": [{
                "inline_data": {
                    "mime_type": "application/pdf",
                    "data": "'"${PDF_BASE64}"'"
                }
            }]
        }
    }'

Примеры использования

Встраивание текста имеет решающее значение для множества распространенных вариантов использования ИИ, таких как:

Хранение эмбеддингов

При использовании эмбеддингов в рабочей среде часто применяются векторные базы данных, которые позволяют эффективно хранить, индексировать и извлекать многомерные эмбеддинги. Google Cloud предлагает управляемые сервисы данных, которые можно использовать для этой цели, включая Gemini Enterprise Agent Platform Vector Search 2.0, BigQuery, AlloyDB и Cloud SQL.

В следующих руководствах показано, как использовать другие сторонние векторные базы данных с Gemini Embedding.

Версии модели

Gemini Embedding 2

Свойство Описание
Код модели

Gemini API

gemini-embedding-2
Поддерживаемые типы данных

Ввод данных

Текст, изображение, видео, аудио, PDF

Выходные данные

Текстовые эмбеддинги
Ограничения на количество токенов[*]

Лимит входных токенов

8192

Размер выходного параметра

Гибкий, поддерживаются значения от 128 до 3072. Рекомендуемые значения: 768, 1536, 3072.
Версии
Подробнее о шаблонах версий моделей…
  • Стабильная: gemini-embedding-2
Последнее обновление Апрель 2026 г.

Встраивание Gemini

Свойство Описание
Код модели

Gemini API

gemini-embedding-001
Поддерживаемые типы данных

Ввод данных

Текст

Выходные данные

Текстовые эмбеддинги
Ограничения на количество токенов[*]

Лимит входных токенов

2048

Размер выходного параметра

Гибкий, поддерживаются значения от 128 до 3072. Рекомендуемые значения: 768, 1536, 3072.
Версии
Подробнее о шаблонах версий моделей…
  • Стабильная: gemini-embedding-001
Последнее обновление Июнь 2025 г.

Информацию об устаревших моделях Embeddings можно найти на странице Прекращение поддержки.

Переход с gemini-embedding-001

Пространства встраивания между gemini-embedding-001 и gemini-embedding-2 несовместимы. Это означает, что вы не можете напрямую сравнивать встраивания, созданные одной моделью, со встраиваниями, созданными другой. Если вы переходите на gemini-embedding-2, вам нужно заново встроить все существующие данные.

Помимо несовместимости, между этими двумя моделями есть и другие существенные различия:

  • Указание типа задачи. В gemini-embedding-001 тип задачи указывается с помощью параметра task_type (например, SEMANTIC_SIMILARITY, RETRIEVAL_DOCUMENT). В gemini-embedding-2 параметр task_type не поддерживается. Вместо этого вы должны включить инструкции к задаче непосредственно в подсказку для текстовых задач. Подробную информацию о том, как форматировать запросы для разных сценариев использования, можно найти в разделе Типы задач с Embeddings 2.

  • Агрегирование эмбеддингов. gemini-embedding-001 генерирует отдельные эмбеддинги для каждой строки в списке входных данных. В отличие от нее, gemini-embedding-2 создает единый агрегированный эмбеддинг, когда в одном запросе передается несколько входных данных (например, текст и изображения). Чтобы сгенерировать отдельные эмбеддинги для отдельных входных данных, оберните каждый входной элемент в объект Content или используйте Batch API. Подробнее об агрегировании эмбеддингов…

  • Нормализация. Если вы используете output_dimensionality для запроса эмбеддингов с менее чем 3072 измерениями, gemini-embedding-2 автоматически нормализует эти усеченные эмбеддинги. gemini-embedding-001, вам нужно будет вручную нормализовать размеры, отличные от 3072. Подробнее о том, как обеспечить качество при меньших размерах…

Пакетные встраивания

Если задержка не имеет значения, попробуйте использовать модели Gemini Embeddings с Batch API. Это позволяет значительно повысить пропускную способность при 50% от цены встраивания по умолчанию. Примеры того, как начать работу, можно найти в руководстве по Batch API.

Уведомление об ответственном использовании

В отличие от моделей генеративного ИИ, которые создают новый контент, модель Gemini Embedding предназначена только для преобразования формата входных данных в числовое представление. Google предоставляет модель встраивания, которая преобразует формат входных данных в требуемый числовой формат, но пользователи несут полную ответственность за вводимые данные и полученные встраивания. Используя модель Gemini Embedding, вы подтверждаете, что обладаете всеми необходимыми правами на загружаемый контент. Не генерируйте материалы, нарушающие права на интеллектуальную собственность или право на неприкосновенность частной жизни. Работа с этим сервисом регулируется Правилами в отношении запрещенного использования и Условиями использования Google.

Начните использовать эмбеддинги

Чтобы узнать больше о возможностях модели, а также о том, как настраивать и визуализировать эмбеддинги, ознакомьтесь с кратким руководством по эмбеддингам.