Text embeddings API

ה-API של הטמעות טקסט ממיר נתונים טקסטואליים לווקטורים מספריים. הייצוגים הווקטוריים האלה נועדו לתעד את המשמעות הסמנטית וההקשר של המילים שהם מייצגים.

מודלים נתמכים:

אפשר לקבל הטמעות טקסט באמצעות המודלים הבאים:

שם הדגם	תיאור	מידות הפלט	אורך מקסימלי של רצף	שפות טקסט נתמכות
gemini-embedding-001	ביצועים מתקדמים במשימות באנגלית, במשימות רב-לשוניות ובמשימות קוד. הוא מאחד את המודלים שהיו בעבר מיוחדים, כמו text-embedding-005 ו-text-multilingual-embedding-002, ומשיג ביצועים טובים יותר בתחומים שלהם. אפשר לקרוא פרטים נוספים בדוח הטכני שלנו.	עד 3,072	‫2,048 טוקנים	שפות נתמכות לטקסט
text-embedding-005	מתמחה במשימות באנגלית ובקוד.	עד 768	‫2,048 טוקנים	אנגלית
text-multilingual-embedding-002	מתמחה במשימות רב-לשוניות.	עד 768	‫2,048 טוקנים	שפות נתמכות לטקסט

‫gemini-embedding-001 הוא המודל הגדול שלנו שנועד לספק את הביצועים הכי טובים, כדי להבטיח איכות הטמעה מעולה.

תחביר

curl

PROJECT_ID = PROJECT_ID
REGION = us-central1
MODEL_ID = MODEL_ID

curl -X POST \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: application/json" \
  https://${REGION}-aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/${REGION}/publishers/google/models/${MODEL_ID}:predict -d \
  '{
    "instances": [
      ...
    ],
    "parameters": {
      ...
    }
  }'

Python

PROJECT_ID = PROJECT_ID
REGION = us-central1
MODEL_ID = MODEL_ID

import vertexai
from vertexai.language_models import TextEmbeddingModel

vertexai.init(project=PROJECT_ID, location=REGION)

model = TextEmbeddingModel.from_pretrained(MODEL_ID)
embeddings = model.get_embeddings(...)

רשימת פרמטרים

שדות ברמה העליונה
instances	רשימה של אובייקטים שמכילים את השדות הבאים: content ‫title (אופציונלי) ‫task_type (אופציונלי)
parameters	אובייקט שמכיל את השדות הבאים: ‫autoTruncate (אופציונלי) ‫outputDimensionality (אופציונלי)

instance שדות
content	string הטקסט שרוצים ליצור לו הטמעות.
task_type	string (אופציונלי) הפרמטר הזה משמש להעברת מידע על האפליקציה במורד הזרם, כדי לעזור למודל ליצור הטמעות טובות יותר. אם לא מציינים ערך, ברירת המחדל היא RETRIEVAL_QUERY. RETRIEVAL_QUERY RETRIEVAL_DOCUMENT SEMANTIC_SIMILARITY CLASSIFICATION CLUSTERING QUESTION_ANSWERING FACT_VERIFICATION CODE_RETRIEVAL_QUERY מידע נוסף על סוגי משימות זמין במאמר בחירת סוג משימת הטמעה.
title	string (אופציונלי) הן עוזרות למודל ליצור הטמעות טובות יותר. בתוקף רק עם task_type=RETRIEVAL_DOCUMENT.

task_type

בטבלה הבאה מתוארים ערכי הפרמטר task_type והתרחישים לדוגמה שמשויכים לכל ערך:

task_type	תיאור
RETRIEVAL_QUERY	מציין שהטקסט הנתון הוא שאילתה בהגדרה של חיפוש או אחזור. משתמשים ב-RETRIEVAL_DOCUMENT לצד המסמך.
RETRIEVAL_DOCUMENT	מציין שהטקסט הנתון הוא מסמך בהגדרה של חיפוש או אחזור.
SEMANTIC_SIMILARITY	מציין שהטקסט הנתון משמש לדמיון סמנטי בין טקסטים (STS).
CLASSIFICATION	מציין שההטמעה משמשת לסיווג.
CLUSTERING	מציין שההטמעה משמשת לאשכולות.
QUESTION_ANSWERING	מציין שההטמעה של השאילתה משמשת למענה על שאלות. משתמשים ב-RETRIEVAL_DOCUMENT לצד המסמך.
FACT_VERIFICATION	מציין שהטמעת השאילתה משמשת לאימות עובדות. משתמשים ב-RETRIEVAL_DOCUMENT לצד המסמך.
CODE_RETRIEVAL_QUERY	מציינת שהטמעת השאילתה משמשת לאחזור קוד עבור Java ו-Python. משתמשים ב-RETRIEVAL_DOCUMENT לצד המסמך.

משימות אחזור:

שאילתה: משתמשים ב-task_type=RETRIEVAL_QUERY כדי לציין שטקסט הקלט הוא שאילתת חיפוש. מאגר מידע: משתמשים ב-task_type=RETRIEVAL_DOCUMENT כדי לציין שטקסט הקלט הוא חלק מאוסף המסמכים שמבוצע בו חיפוש.

משימות דומות:

דמיון סמנטי: משתמשים ב-task_type= SEMANTIC_SIMILARITY לשני טקסטים קלט כדי להעריך את הדמיון במשמעות הכוללת שלהם.

הערה: SEMANTIC_SIMILARITY לא מיועד לתרחישי שימוש של אחזור, כמו חיפוש מסמכים ואחזור מידע. בתרחישים האלה, משתמשים בערכים RETRIEVAL_DOCUMENT, RETRIEVAL_QUERY, QUESTION_ANSWERING ו-FACT_VERIFICATION.

parameters שדות
autoTruncate	bool (אופציונלי) אם הערך מוגדר כ-True, הטקסט שמוזן ייחתך. אם הערך הוא false, תוצג שגיאה אם הטקסט שמוזן ארוך יותר מהאורך המקסימלי שהמודל תומך בו. ברירת המחדל היא True.
outputDimensionality	int (אופציונלי) משמש לציון גודל ההטמעה של הפלט. אם מציינים ערך, ההטמעות של הפלט ייחתכו לגודל שצוין.

גוף הבקשה

{
  "instances": [
    {
      "task_type": "RETRIEVAL_DOCUMENT",
      "title": "document title",
      "content": "I would like embeddings for this text!"
    },
  ]
}

גוף התשובה

{
  "predictions": [
    {
      "embeddings": {
        "statistics": {
          "truncated": boolean,
          "token_count": integer
        },
        "values": [ number ]
      }
    }
  ]
}

רכיבי התגובה
predictions	רשימה של אובייקטים עם השדות הבאים: ‫embeddings: התוצאה שנוצרה מטקסט הקלט. הוא מכיל את השדות הבאים: values statistics

embeddings שדות
values	רשימה של float. השדה values מכיל קידוד מספרי (וקטור הטמעה) של התוכן הסמנטי שמופיע בטקסט הקלט הנתון.
statistics	הנתונים הסטטיסטיים שחושבו מטקסט הקלט. התכונות הנכללות: ‫truncated: מציין אם הטקסט שהוזן נחתך כי הוא ארוך יותר ממספר הטוקנים המקסימלי שמותר לפי המודל. ‫token_count: מספר האסימונים של טקסט הקלט.

דוגמה לתשובה

{
  "predictions": [
    {
      "embeddings": {
        "values": [
          0.0058424929156899452,
          0.011848051100969315,
          0.032247550785541534,
          -0.031829461455345154,
          -0.055369812995195389,
          ...
        ],
        "statistics": {
          "token_count": 4,
          "truncated": false
        }
      }
    }
  ]
}

דוגמאות

הטמעה של מחרוזת טקסט

בדוגמה הבאה אפשר לראות איך מקבלים את ההטמעה של מחרוזת טקסט.

REST

אחרי הגדרת הסביבה, אפשר להשתמש ב-REST כדי לבדוק הנחיית טקסט. בדוגמה הבאה נשלחת בקשה לנקודת הקצה של מודל בעל התוכן הדיגיטלי.

לפני שמשתמשים בנתוני הבקשה, צריך להחליף את הנתונים הבאים:

• ‫PROJECT_ID: מזהה הפרויקט.
• ‫TEXT: הטקסט שרוצים ליצור לו הטמעות. מגבלה: חמישה טקסטים של עד 2,048 טוקנים לכל טקסט בכל המודלים, למעט textembedding-gecko@001. אורך הטוקן המקסימלי של הקלט עבור textembedding-gecko@001 הוא 3,072. במקרה של gemini-embedding-001, כל בקשה יכולה לכלול רק קלט טקסט אחד. מידע נוסף זמין במאמר בנושא מגבלות על הטמעת טקסט.
• ‫AUTO_TRUNCATE: אם הערך הוא false, בקשות עם טקסט שחורג ממגבלת האסימון ייכשלו. ערך ברירת המחדל הוא true.

ה-method של ה-HTTP וכתובת ה-URL:

POST https://us-central1-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/publishers/google/models/gemini-embedding-001:predict

גוף בקשת JSON:

{
  "instances": [
    { "content": "TEXT"}
  ],
  "parameters": { 
    "autoTruncate": AUTO_TRUNCATE 
  }
}

כדי לשלוח את הבקשה עליכם לבחור אחת מהאפשרויות הבאות:

curl

הערה: הפקודה הבאה מבוססת על ההנחה שנכנסתם ל-CLI של gcloud באמצעות חשבון המשתמש שלכם, על ידי הרצת gcloud init או gcloud auth login, או באמצעות Cloud Shell שמחבר אתכם אוטומטית ל-CLI של gcloud. כדי לבדוק איזה חשבון פעיל, אפשר להריץ את הפקודה gcloud auth list.

שומרים את גוף הבקשה בקובץ בשם request.json ומריצים את הפקודה הבאה:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://us-central1-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/publishers/google/models/gemini-embedding-001:predict"

PowerShell

הערה: הפקודה הבאה מבוססת על ההנחה שנכנסתם ל-CLI של gcloud באמצעות חשבון המשתמש שלכם, על ידי הרצת gcloud init או gcloud auth login. כדי לבדוק איזה חשבון פעיל, אפשר להריץ את הפקודה gcloud auth list.

שומרים את גוף הבקשה בקובץ בשם request.json ומריצים את הפקודה הבאה:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://us-central1-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/publishers/google/models/gemini-embedding-001:predict" | Select-Object -Expand Content

אתם אמורים לקבל תגובת JSON שדומה לזו: שימו לב שהערך values קוצר כדי לחסוך במקום.

תשובה

{
  "predictions": [
    {
      "embeddings": {
        "statistics": {
          "truncated": false,
          "token_count": 6
        },
        "values": [ ... ]
      }
    }
  ]
}

שימו לב לפרטים הבאים בכתובת ה-URL של הדוגמה הזו:

• משתמשים בשיטה generateContent כדי לבקש שהתשובה תוחזר אחרי שהיא נוצרה במלואה. כדי לצמצם את תפיסת זמן האחזור בקרב קהל אנושי, צריך להזרים את התשובה בזמן שהיא נוצרת באמצעות השיטה streamGenerateContent.
• מזהה המודל הרב-אופני מופיע בסוף כתובת ה-URL לפני השיטה (לדוגמה, gemini-2.0-flash). יכול להיות שהדוגמה הזו תתמוך גם במודלים אחרים.
• כשמשתמשים בנקודת קצה אזורית ל-API (לדוגמה, us-central1), האזור מכתובת ה-URL של נקודת הקצה קובע איפה הבקשה תעובד. המערכת מתעלמת מכל מיקום שיוצר התנגשות בנתיב המשאב.

Python

במאמר התקנת Vertex AI SDK ל-Python מוסבר איך להתקין או לעדכן את Vertex AI SDK ל-Python. מידע נוסף מופיע ב מאמרי העזרה של Python API.

from __future__ import annotations

from vertexai.language_models import TextEmbeddingInput, TextEmbeddingModel


def embed_text() -> list[list[float]]:
    """Embeds texts with a pre-trained, foundational model.

    Returns:
        A list of lists containing the embedding vectors for each input text
    """

    # A list of texts to be embedded.
    texts = ["banana muffins? ", "banana bread? banana muffins?"]
    # The dimensionality of the output embeddings.
    dimensionality = 3072
    # The task type for embedding. Check the available tasks in the model's documentation.
    task = "RETRIEVAL_DOCUMENT"

    model = TextEmbeddingModel.from_pretrained("gemini-embedding-001")
    kwargs = dict(output_dimensionality=dimensionality) if dimensionality else {}

    embeddings = []
    # gemini-embedding-001 takes one input at a time
    for text in texts:
        text_input = TextEmbeddingInput(text, task)
        embedding = model.get_embeddings([text_input], **kwargs)
        print(embedding)
        # Example response:
        # [[0.006135190837085247, -0.01462465338408947, 0.004978656303137541, ...]]
        embeddings.append(embedding[0].values)

    return embeddings

Go

לפני שמנסים את הדוגמה הזו, צריך לפעול לפי Goהוראות ההגדרה במאמר Vertex AI quickstart using client libraries. מידע נוסף מופיע במאמרי העזרה של Vertex AI Go API.

כדי לבצע אימות ב-Vertex AI, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לסביבת פיתוח מקומית.

import (
	"context"
	"fmt"
	"io"

	aiplatform "cloud.google.com/go/aiplatform/apiv1"
	"cloud.google.com/go/aiplatform/apiv1/aiplatformpb"

	"google.golang.org/api/option"
	"google.golang.org/protobuf/types/known/structpb"
)

// embedTexts shows how embeddings are set for gemini-embedding-001 model
func embedTexts(w io.Writer, project, location string) error {
	// location := "us-central1"
	ctx := context.Background()

	apiEndpoint := fmt.Sprintf("%s-aiplatform.googleapis.com:443", location)
	dimensionality := 3072
	model := "gemini-embedding-001"
	texts := []string{"banana muffins? ", "banana bread? banana muffins?"}

	client, err := aiplatform.NewPredictionClient(ctx, option.WithEndpoint(apiEndpoint))
	if err != nil {
		return err
	}
	defer client.Close()

	endpoint := fmt.Sprintf("projects/%s/locations/%s/publishers/google/models/%s", project, location, model)
	allEmbeddings := make([][]float32, 0, len(texts))
	// gemini-embedding-001 takes 1 input at a time
	for _, text := range texts {
		instances := make([]*structpb.Value, 1)
		instances[0] = structpb.NewStructValue(&structpb.Struct{
			Fields: map[string]*structpb.Value{
				"content":   structpb.NewStringValue(text),
				"task_type": structpb.NewStringValue("QUESTION_ANSWERING"),
			},
		})

		params := structpb.NewStructValue(&structpb.Struct{
			Fields: map[string]*structpb.Value{
				"outputDimensionality": structpb.NewNumberValue(float64(dimensionality)),
			},
		})

		req := &aiplatformpb.PredictRequest{
			Endpoint:   endpoint,
			Instances:  instances,
			Parameters: params,
		}
		resp, err := client.Predict(ctx, req)
		if err != nil {
			return err
		}

		// Process the prediction for the single text
		// The response will contain one prediction because we sent one instance.
		if len(resp.Predictions) == 0 {
			return fmt.Errorf("no predictions returned for text \"%s\"", text)
		}

		prediction := resp.Predictions[0]
		embeddingValues := prediction.GetStructValue().Fields["embeddings"].GetStructValue().Fields["values"].GetListValue().Values

		currentEmbedding := make([]float32, len(embeddingValues))
		for j, value := range embeddingValues {
			currentEmbedding[j] = float32(value.GetNumberValue())
		}
		allEmbeddings = append(allEmbeddings, currentEmbedding)
	}

	if len(allEmbeddings) > 0 {
		fmt.Fprintf(w, "Dimensionality: %d. Embeddings length: %d", len(allEmbeddings[0]), len(allEmbeddings))
	} else {
		fmt.Fprintln(w, "No texts were processed.")
	}
	return nil
}

Java

לפני שמנסים את הדוגמה הזו, צריך לפעול לפי Javaהוראות ההגדרה במאמר Vertex AI quickstart using client libraries. מידע נוסף מופיע במאמרי העזרה של Vertex AI Java API.

כדי לבצע אימות ב-Vertex AI, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לסביבת פיתוח מקומית.

import static java.util.stream.Collectors.toList;

import com.google.cloud.aiplatform.v1.EndpointName;
import com.google.cloud.aiplatform.v1.PredictRequest;
import com.google.cloud.aiplatform.v1.PredictResponse;
import com.google.cloud.aiplatform.v1.PredictionServiceClient;
import com.google.cloud.aiplatform.v1.PredictionServiceSettings;
import com.google.protobuf.Struct;
import com.google.protobuf.Value;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.OptionalInt;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class PredictTextEmbeddingsSample {
  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    // Details about text embedding request structure and supported models are available in:
    // https://cloud.google.com/vertex-ai/docs/generative-ai/embeddings/get-text-embeddings
    String endpoint = "us-central1-aiplatform.googleapis.com:443";
    String project = "YOUR_PROJECT_ID";
    String model = "gemini-embedding-001";
    predictTextEmbeddings(
        endpoint,
        project,
        model,
        List.of("banana bread?", "banana muffins?"),
        "QUESTION_ANSWERING",
        OptionalInt.of(3072));
  }

  // Gets text embeddings from a pretrained, foundational model.
  public static List<List<Float>> predictTextEmbeddings(
      String endpoint,
      String project,
      String model,
      List<String> texts,
      String task,
      OptionalInt outputDimensionality)
      throws IOException {
    PredictionServiceSettings settings =
        PredictionServiceSettings.newBuilder().setEndpoint(endpoint).build();
    Matcher matcher = Pattern.compile("^(?<Location>\\w+-\\w+)").matcher(endpoint);
    String location = matcher.matches() ? matcher.group("Location") : "us-central1";
    EndpointName endpointName =
        EndpointName.ofProjectLocationPublisherModelName(project, location, "google", model);

    List<List<Float>> floats = new ArrayList<>();
    // You can use this prediction service client for multiple requests.
    try (PredictionServiceClient client = PredictionServiceClient.create(settings)) {
      // gemini-embedding-001 takes one input at a time.
      for (int i = 0; i < texts.size(); i++) {
        PredictRequest.Builder request = 
            PredictRequest.newBuilder().setEndpoint(endpointName.toString());
        if (outputDimensionality.isPresent()) {
          request.setParameters(
              Value.newBuilder()
                  .setStructValue(
                      Struct.newBuilder()
                          .putFields(
                              "outputDimensionality", valueOf(outputDimensionality.getAsInt()))
                          .build()));
        }
        request.addInstances(
            Value.newBuilder()
                .setStructValue(
                    Struct.newBuilder()
                        .putFields("content", valueOf(texts.get(i)))
                        .putFields("task_type", valueOf(task))
                        .build()));
        PredictResponse response = client.predict(request.build());

        for (Value prediction : response.getPredictionsList()) {
          Value embeddings = prediction.getStructValue().getFieldsOrThrow("embeddings");
          Value values = embeddings.getStructValue().getFieldsOrThrow("values");
          floats.add(
              values.getListValue().getValuesList().stream()
                  .map(Value::getNumberValue)
                  .map(Double::floatValue)
                  .collect(toList()));
        }
      }
      return floats;
    }
  }

  private static Value valueOf(String s) {
    return Value.newBuilder().setStringValue(s).build();
  }

  private static Value valueOf(int n) {
    return Value.newBuilder().setNumberValue(n).build();
  }
}

Node.js

לפני שמנסים את הדוגמה הזו, צריך לפעול לפי Node.jsהוראות ההגדרה במאמר Vertex AI quickstart using client libraries. מידע נוסף מופיע במאמרי העזרה של Vertex AI Node.js API.

כדי לבצע אימות ב-Vertex AI, צריך להגדיר את Application Default Credentials. מידע נוסף זמין במאמר הגדרת אימות לסביבת פיתוח מקומית.

async function main(
  project,
  model = 'gemini-embedding-001',
  texts = 'banana bread?;banana muffins?',
  task = 'QUESTION_ANSWERING',
  dimensionality = 0,
  apiEndpoint = 'us-central1-aiplatform.googleapis.com'
) {
  const aiplatform = require('@google-cloud/aiplatform');
  const {PredictionServiceClient} = aiplatform.v1;
  const {helpers} = aiplatform; // helps construct protobuf.Value objects.
  const clientOptions = {apiEndpoint: apiEndpoint};
  const location = 'us-central1';
  const endpoint = `projects/${project}/locations/${location}/publishers/google/models/${model}`;

  async function callPredict() {
    const instances = texts
      .split(';')
      .map(e => helpers.toValue({content: e, task_type: task}));

    const client = new PredictionServiceClient(clientOptions);
    const parameters = helpers.toValue(
      dimensionality > 0 ? {outputDimensionality: parseInt(dimensionality)} : {}
    );
    const allEmbeddings = []
    // gemini-embedding-001 takes one input at a time.
    for (const instance of instances) {
      const request = {endpoint, instances: [instance], parameters};
      const [response] = await client.predict(request);
      const predictions = response.predictions;

      const embeddings = predictions.map(p => {
        const embeddingsProto = p.structValue.fields.embeddings;
        const valuesProto = embeddingsProto.structValue.fields.values;
        return valuesProto.listValue.values.map(v => v.numberValue);
      });

      allEmbeddings.push(embeddings[0])
    }


    console.log('Got embeddings: \n' + JSON.stringify(allEmbeddings));
  }

  callPredict();
}

שפות טקסט נתמכות

כל המודלים להטמעת טקסט תומכים בטקסט באנגלית ונבדקו על טקסט באנגלית. מודל text-multilingual-embedding-002 תומך גם בשפות הבאות, ועבר הערכה בשפות האלה:

• השפות שנבדקו: Arabic (ar), Bengali (bn), English (en), Spanish (es), German (de), Persian (fa), Finnish (fi), French (fr), Hindi (hi), Indonesian (id), Japanese (ja), Korean (ko), Russian (ru), Swahili (sw), Telugu (te), Thai (th), Yoruba (yo), Chinese (zh)
• שפות נתמכות: Afrikaans, Albanian, Amharic, Arabic, Armenian, Azerbaijani, Basque, Belarusiasn, Bengali, Bulgarian, Burmese, Catalan, Cebuano, Chichewa, Chinese, Corsican, Czech, Danish, Dutch, English, Esperanto, Estonian, Filipino, Finnish, French, Galician, Georgian, German, Greek, Gujarati, Haitian Creole, Hausa, Hawaiian, Hebrew, Hindi, Hmong, Hungarian, Icelandic, Igbo, Indonesian, Irish, Italian, Japanese, Javanese, Kannada, Kazakh, Khmer, Korean, Kurdish, Kyrgyz, Lao, Latin, Latvian, Lithuanian, Luxembourgish, Macedonian, Malagasy, Malay, Malayalam, Maltese, Maori, Marathi, Mongolian, Nepali, Norwegian, Pashto, Persian, Polish, Portuguese, Punjabi, Romanian, Russian, Samoan, Scottish Gaelic, Serbian, Shona, Sindhi, Sinhala, Slovak, Slovenian, Somali, Sotho, Spanish, Sundanese, Swahili, Swedish, Tajik, Tamil, Telugu, Thai, Turkish, Ukrainian, Urdu, Uzbek, Vietnamese, Welsh, West Frisian, Xhosa, Yiddish, Yoruba, Zulu.

מודל gemini-embedding-001 תומך בשפות הבאות:

‫Arabic, ‏ Bengali, ‏ Bulgarian, ‏ Chinese (Simplified and Traditional), ‏ Croatian, ‏ Czech, ‏ Danish, ‏ Dutch, ‏ English, ‏ Estonian, ‏ Finnish, ‏ French, ‏ German, ‏ Greek, ‏ Hebrew, ‏ Hindi, ‏ Hungarian, ‏ Indonesian, ‏ Italian, ‏ Japanese, ‏ Korean, ‏ Latvian, ‏ Lithuanian, ‏ Norwegian, ‏ Polish, ‏ Portuguese, ‏ Romanian, ‏ Russian, ‏ Serbian, ‏ Slovak, ‏ Slovenian, ‏ Spanish, ‏ Swahili, ‏ Swedish, ‏ Thai, ‏ Turkish, ‏ Ukrainian, ‏ Vietnamese, ‏ Afrikaans, ‏ Amharic, ‏ Assamese, ‏ Azerbaijani, ‏ Belarusian, ‏ Bosnian, ‏ Catalan, ‏ Cebuano, ‏ Corsican, ‏ Welsh, ‏ Dhivehi, ‏ Esperanto, ‏ Basque, ‏ Persian, ‏ Filipino (Tagalog), ‏ Frisian, ‏ Irish, ‏ Scots Gaelic, ‏ Galician, ‏ Gujarati, ‏ Hausa, ‏ Hawaiian, ‏ Hmong, ‏ Haitian Creole, ‏ Armenian, ‏ Igbo, ‏ Icelandic, ‏ Javanese, ‏ Georgian, ‏ Kazakh, ‏ Khmer, ‏ Kannada, ‏ Krio, ‏ Kurdish, ‏ Kyrgyz, ‏ Latin, ‏ Luxembourgish, ‏ Lao, ‏ Malagasy, ‏ Maori, ‏ Macedonian, ‏ Malayalam, ‏ Mongolian, ‏ Meiteilon (Manipuri), ‏ Marathi, ‏ Malay, ‏ Maltese, ‏ Myanmar (Burmese), ‏ Nepali, ‏ Nyanja (Chichewa), ‏ Odia (Oriya), ‏ Punjabi, ‏ Pashto, ‏ Sindhi, ‏ Sinhala (Sinhalese), ‏ Samoan, ‏ Shona, ‏ Somali, ‏ Albanian, ‏ Sesotho, ‏ Sundanese, ‏ Tamil, ‏ Telugu, ‏ Tajik, ‏ Uyghur, ‏ Urdu, ‏ Uzbek, ‏ Xhosa, ‏ Yiddish, ‏ Yoruba, ‏ Zulu.

גרסאות המודלים

כדי להשתמש במודל יציב עדכני, מציינים את מספר גרסת המודל, לדוגמה gemini-embedding-001. לא מומלץ לציין מודל ללא מספר גרסה, כי זה רק מצביע מדור קודם למודל אחר ולא יציב.

מידע נוסף זמין במאמר גרסאות של מודלים ומחזור החיים שלהם.

המאמרים הבאים

לעיון בתיעוד מפורט:

• הטמעות טקסט