Флэш-память Gemini 3.8 теперь доступна. Попробуйте!

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

Встраивания

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

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

Создание систем генерации с расширенным поиском (RAG) – распространенный вариант использования продуктов на основе ИИ. Встраивание играет ключевую роль в значительном улучшении результатов работы модели, повышая фактическую точность, согласованность и контекстную насыщенность. Если вы предпочитаете использовать управляемое решение RAG, мы создали инструмент Поиск файлов, который упрощает управление 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}', то запрос также должен быть встроен в соответствии с этим форматом.

Типы задач с Embeddings 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 обучаются с помощью метода обучения представлений "Матрешка" (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 (общепринятый контрольный показатель для встраивания) для разных параметров. Примечательно, что результаты показывают, что эффективность не строго связана с размером встраиваемого параметра, поскольку более низкие параметры достигают результатов, сопоставимых с более высокими.

Параметр "Местоположение в списке воспроизведения"	Оценка 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 токенов.
Изображение	В одном запросе можно указать не более шести изображений. Поддерживаемые форматы: 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 г.

Информацию о моделях для создания встраиваемых объектов, поддержка которых прекращена, можно найти на странице Прекращение поддержки.

Переход с 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% ниже цены по умолчанию. Примеры того, как начать работу, можно найти в справочном руководстве по пакетному API.

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

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

Начните использовать векторные представления

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

Пример использования	Структура запроса	Структура документа
Поисковый запрос	`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}`