Embedding

Gemini API menawarkan model penyematan teks untuk menghasilkan penyematan kata, frasa, kalimat, dan kode. Sematan dasar ini mendukung tugas NLP lanjutan seperti penelusuran semantik, klasifikasi, dan pengelompokan, sehingga memberikan hasil yang lebih akurat dan sesuai konteks dibandingkan pendekatan berbasis kata kunci.

Membangun sistem Retrieval Augmented Generation (RAG) adalah kasus penggunaan umum untuk embedding. Penyematan memainkan peran penting dalam meningkatkan output model secara signifikan dengan akurasi faktual, koherensi, dan kekayaan kontekstual yang lebih baik. Mereka secara efisien mengambil informasi yang relevan dari pusat informasi, yang direpresentasikan oleh embedding, yang kemudian diteruskan sebagai konteks tambahan dalam perintah input ke model bahasa, sehingga memandunya untuk menghasilkan respons yang lebih berpengetahuan dan akurat.

Untuk aplikasi tingkat perusahaan dan workload bervolume tinggi, sebaiknya gunakan model sematan di Vertex AI.

Membuat embedding

Gunakan metode embedContent untuk membuat embedding teks:

Python

from google import genai

client = genai.Client()

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

print(result.embeddings)

JavaScript

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

async function main() {

    const ai = new GoogleGenAI({});

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

    console.log(response.embeddings);
}

main();

Go

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "log"

    "google.golang.org/genai"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, nil)
    if err != nil {
        log.Fatal(err)
    }

    contents := []*genai.Content{
        genai.NewContentFromText("What is the meaning of life?", genai.RoleUser),
    }
    result, err := client.Models.EmbedContent(ctx,
        "gemini-embedding-001",
        contents,
        nil,
    )
    if err != nil {
        log.Fatal(err)
    }

    embeddings, err := json.MarshalIndent(result.Embeddings, "", "  ")
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(string(embeddings))
}

REST

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-001:embedContent" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-H 'Content-Type: application/json' \
-d '{"model": "models/gemini-embedding-001",
     "content": {"parts":[{"text": "What is the meaning of life?"}]}
    }'

Anda juga dapat membuat sematan untuk beberapa potongan sekaligus dengan meneruskannya sebagai daftar string.

Python

from google import genai

client = genai.Client()

result = client.models.embed_content(
        model="gemini-embedding-001",
        contents= [
            "What is the meaning of life?",
            "What is the purpose of existence?",
            "How do I bake a cake?"
        ])

for embedding in result.embeddings:
    print(embedding)

JavaScript

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

async function main() {

    const ai = new GoogleGenAI({});

    const response = await ai.models.embedContent({
        model: 'gemini-embedding-001',
        contents: [
            'What is the meaning of life?',
            'What is the purpose of existence?',
            'How do I bake a cake?'
        ],
    });

    console.log(response.embeddings);
}

main();

Go

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "log"

    "google.golang.org/genai"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, nil)
    if err != nil {
        log.Fatal(err)
    }

    contents := []*genai.Content{
        genai.NewContentFromText("What is the meaning of life?"),
        genai.NewContentFromText("How does photosynthesis work?"),
        genai.NewContentFromText("Tell me about the history of the internet."),
    }
    result, err := client.Models.EmbedContent(ctx,
        "gemini-embedding-001",
        contents,
        nil,
    )
    if err != nil {
        log.Fatal(err)
    }

    embeddings, err := json.MarshalIndent(result.Embeddings, "", "  ")
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(string(embeddings))
}

REST

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-001:embedContent" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-H 'Content-Type: application/json' \
-d '{"model": "models/gemini-embedding-001",
     "content": [
        {"parts": [{"text": "What is the meaning of life?"}]},
        {"parts": [{"text": "What is the purpose of existence?"}]},
        {"parts": [{"text": "How do I bake a cake?"}]}
        ]
    }'

Tentukan jenis tugas untuk meningkatkan performa

Anda dapat menggunakan embedding untuk berbagai tugas, mulai dari klasifikasi hingga penelusuran dokumen. Menentukan jenis tugas yang tepat akan membantu mengoptimalkan embedding untuk hubungan yang diinginkan, sehingga memaksimalkan akurasi dan efisiensi. Untuk mengetahui daftar lengkap jenis tugas yang didukung, lihat tabel Jenis tugas yang didukung.

Contoh berikut menunjukkan cara menggunakan SEMANTIC_SIMILARITY untuk memeriksa seberapa mirip makna string teks.

Python

from google import genai
from google.genai import types
import numpy as np
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 = [
    np.array(e.values) for e in client.models.embed_content(
        model="gemini-embedding-001",
        contents=texts, 
        config=types.EmbedContentConfig(task_type="SEMANTIC_SIMILARITY")).embeddings
]

# Calculate cosine similarity. Higher scores = greater semantic similarity.

embeddings_matrix = np.array(result)
similarity_matrix = cosine_similarity(embeddings_matrix)

for i, text1 in enumerate(texts):
    for j in range(i + 1, len(texts)):
        text2 = texts[j]
        similarity = similarity_matrix[i, j]
        print(f"Similarity between '{text1}' and '{text2}': {similarity:.4f}")

JavaScript

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

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

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

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

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

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

main();

Go

package main

import (
    "context"
    "fmt"
    "log"
    "math"

    "google.golang.org/genai"
)

// cosineSimilarity calculates the similarity between two vectors.
func cosineSimilarity(a, b []float32) (float64, error) {
    if len(a) != len(b) {
        return 0, fmt.Errorf("vectors must have the same length")
    }

    var dotProduct, aMagnitude, bMagnitude float64
    for i := 0; i < len(a); i++ {
        dotProduct += float64(a[i] * b[i])
        aMagnitude += float64(a[i] * a[i])
        bMagnitude += float64(b[i] * b[i])
    }

    if aMagnitude == 0 || bMagnitude == 0 {
        return 0, nil
    }

    return dotProduct / (math.Sqrt(aMagnitude) * math.Sqrt(bMagnitude)), nil
}

func main() {
    ctx := context.Background()
    client, _ := genai.NewClient(ctx, nil)
    defer client.Close()

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

    var contents []*genai.Content
    for _, text := range texts {
        contents = append(contents, genai.NewContentFromText(text, genai.RoleUser))
    }

    result, _ := client.Models.EmbedContent(ctx,
        "gemini-embedding-001",
        contents,
        &genai.EmbedContentRequest{TaskType: genai.TaskTypeSemanticSimilarity},
    )

    embeddings := result.Embeddings

    for i := 0; i < len(texts); i++ {
        for j := i + 1; j < len(texts); j++ {
            similarity, _ := cosineSimilarity(embeddings[i].Values, embeddings[j].Values)
            fmt.Printf("Similarity between '%s' and '%s': %.4f\n", texts[i], texts[j], similarity)
        }
    }
}

REST

curl -X POST "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-001:embedContent" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-H 'Content-Type: application/json' \
-d '{
    "contents": [
        {"parts": [{"text": "What is the meaning of life?"}]},
        {"parts": [{"text": "What is the purpose of existence?"}]},
        {"parts": [{"text": "How do I bake a cake?"}]}
    ],
    "embedding_config": {
        "task_type": "SEMANTIC_SIMILARITY"
    }
}'

Berikut contoh output dari cuplikan kode ini:

Similarity between 'What is the meaning of life?' and 'What is the purpose of existence?': 0.9481

Similarity between 'What is the meaning of life?' and 'How do I bake a cake?': 0.7471

Similarity between 'What is the purpose of existence?' and 'How do I bake a cake?': 0.7371

Jenis tugas yang didukung

Jenis tugas Deskripsi Contoh
SEMANTIC_SIMILARITY Embedding dioptimalkan untuk menilai kemiripan teks. Sistem rekomendasi, deteksi duplikat
KLASIFIKASI Penyematan dioptimalkan untuk mengklasifikasikan teks menurut label preset. Analisis sentimen, deteksi spam
PENGELOMPOKAN Embedding dioptimalkan untuk mengelompokkan teks berdasarkan kesamaannya. Pengaturan dokumen, riset pasar, deteksi anomali
RETRIEVAL_DOCUMENT Penyematan yang dioptimalkan untuk penelusuran dokumen. Mengindeks artikel, buku, atau halaman web untuk penelusuran.
RETRIEVAL_QUERY Penyematan yang dioptimalkan untuk kueri penelusuran umum. Gunakan RETRIEVAL_QUERY untuk kueri; RETRIEVAL_DOCUMENT untuk dokumen yang akan diambil. Penelusuran khusus
CODE_RETRIEVAL_QUERY Embedding yang dioptimalkan untuk pengambilan blok kode berdasarkan kueri bahasa alami. Gunakan CODE_RETRIEVAL_QUERY untuk kueri; RETRIEVAL_DOCUMENT untuk blok kode yang akan diambil. Saran dan penelusuran kode
QUESTION_ANSWERING Penyematan untuk pertanyaan dalam sistem tanya jawab, yang dioptimalkan untuk menemukan dokumen yang menjawab pertanyaan. Gunakan QUESTION_ANSWERING untuk pertanyaan; RETRIEVAL_DOCUMENT untuk dokumen yang akan diambil. Kotak chat
FACT_VERIFICATION Penyematan untuk pernyataan yang perlu diverifikasi, dioptimalkan untuk mengambil dokumen yang berisi bukti yang mendukung atau menyangkal pernyataan tersebut. Gunakan FACT_VERIFICATION untuk teks target; RETRIEVAL_DOCUMENT untuk dokumen yang akan diambil Sistem pengecekan fakta otomatis

Mengontrol Ukuran Embedding

Model penyematan Gemini, gemini-embedding-001, dilatih menggunakan teknik Matryoshka Representation Learning (MRL) yang mengajarkan model untuk mempelajari penyematan berdimensi tinggi yang memiliki segmen awal (atau awalan) yang juga merupakan versi data yang sama yang berguna dan lebih sederhana. Anda dapat memilih untuk menggunakan sematan 3072 dimensi penuh, atau memangkasnya ke ukuran yang lebih kecil tanpa mengurangi kualitas untuk menghemat ruang penyimpanan. Untuk kualitas terbaik, sebaiknya gunakan 768 dan 1536 pertama.

Dengan menggunakan parameter output_dimensionality, pengguna dapat mengontrol ukuran vektor sematan output. Memilih dimensi output yang lebih kecil dapat menghemat ruang penyimpanan dan meningkatkan efisiensi komputasi untuk aplikasi hilir, sekaligus sedikit mengorbankan kualitas.

Python

from google import genai
from google.genai import types

client = genai.Client()

result = client.models.embed_content(
    model="gemini-embedding-001",
    contents="What is the meaning of life?",
    config=types.EmbedContentConfig(output_dimensionality=768)
)

[embedding_obj] = result.embeddings
embedding_length = len(embedding_obj.values)

print(f"Length of embedding: {embedding_length}")

JavaScript

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

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

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

    const embeddingLength = response.embedding.values.length;
    console.log(`Length of embedding: ${embeddingLength}`);
}

main();

Go

package main

import (
    "context"
    "fmt"
    "log"

    "google.golang.org/genai"
)

func main() {
    ctx := context.Background()
    // The client uses Application Default Credentials.
    // Authenticate with 'gcloud auth application-default login'.
    client, err := genai.NewClient(ctx, nil)
    if err != nil {
        log.Fatal(err)
    }
    defer client.Close()

    contents := []*genai.Content{
        genai.NewContentFromText("What is the meaning of life?", genai.RoleUser),
    }

    result, err := client.Models.EmbedContent(ctx,
        "gemini-embedding-001",
        contents,
        &genai.EmbedContentRequest{OutputDimensionality: 768},
    )
    if err != nil {
        log.Fatal(err)
    }

    embedding := result.Embeddings[0]
    embeddingLength := len(embedding.Values)
    fmt.Printf("Length of embedding: %d\n", embeddingLength)
}

REST

curl -X POST "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-001:embedContent" \
-H "x-goog-api-key: YOUR_GEMINI_API_KEY" \
-H 'Content-Type: application/json' \
-d '{
    "contents": [
        {"parts": [{"text": "What is the meaning of life?"}]}
    ],
    "embedding_config": {
        "output_dimensionality": 768
    }
}'

Contoh Output:

Length of embedding: 768

Embedding 3072 dimensi dinormalisasi. Embedding yang dinormalisasi menghasilkan kemiripan semantik yang lebih akurat dengan membandingkan arah vektor, bukan besarnya. Untuk dimensi lain, termasuk 768 dan 1536, Anda perlu menormalisasi sematan sebagai berikut:

Python

import numpy as np
from numpy.linalg import norm

embedding_values_np = np.array(embedding_obj.values)
normed_embedding = embedding_values_np / np.linalg.norm(embedding_values_np)

print(f"Normed embedding length: {len(normed_embedding)}")
print(f"Norm of normed embedding: {np.linalg.norm(normed_embedding):.6f}") # Should be very close to 1

Contoh Output:

Normed embedding length: 768
Norm of normed embedding: 1.000000

Kasus penggunaan

Embedding teks sangat penting untuk berbagai kasus penggunaan AI umum, seperti:

  • Retrieval-Augmented Generation (RAG): Embedding meningkatkan kualitas teks yang dihasilkan dengan mengambil dan menggabungkan informasi yang relevan ke dalam konteks model.

  • Pengambilan Informasi: Gunakan embedding untuk menelusuri teks atau dokumen yang mirip secara semantik berdasarkan bagian teks input.

    Tutorial penelusuran dokumen

  • Deteksi anomali: Membandingkan grup embedding dapat membantu mengidentifikasi tren atau pencilan tersembunyi.

    Tutorial deteksi anomali

  • Klasifikasi: Mengategorikan teks secara otomatis berdasarkan kontennya, seperti analisis sentimen atau deteksi spam

    Tutorial klasifikasi

  • Pengelompokan: Cara efektif untuk memahami hubungan adalah dengan membuat cluster dan visualisasi penyematan Anda.

    Tutorial visualisasi pengelompokan

Menyimpan embedding

Saat Anda menggunakan embedding untuk produksi, biasanya Anda akan menggunakan database vektor untuk menyimpan, mengindeks, dan mengambil embedding berdimensi tinggi secara efisien. Google Cloud menawarkan layanan data terkelola yang dapat digunakan untuk tujuan ini, termasuk BigQuery, AlloyDB, dan Cloud SQL.

Tutorial berikut menunjukkan cara menggunakan database vektor pihak ketiga lainnya dengan Gemini Embedding.

Model embedding

Model yang tersedia secara umum

Model lama

  • embedding-001 (Tidak digunakan lagi pada 14 Agustus 2025)
  • text-embedding-004 (Tidak digunakan lagi mulai 14 Januari 2026)

Menggunakan penyematan

Tidak seperti model AI generatif yang membuat konten baru, model Embedding Gemini hanya ditujukan untuk mengubah format data input Anda menjadi representasi numerik. Meskipun Google bertanggung jawab untuk menyediakan model penyematan yang mengubah format data input Anda ke format numerik yang diminta, pengguna tetap bertanggung jawab sepenuhnya atas data yang mereka masukkan dan penyematan yang dihasilkan. Dengan menggunakan model Sematan Gemini, Anda mengonfirmasi bahwa Anda memiliki hak yang diperlukan atas konten apa pun yang Anda upload. Jangan membuat konten yang melanggar hak kekayaan intelektual atau hak privasi orang lain. Penggunaan layanan ini oleh Anda tunduk pada Kebijakan Penggunaan Terlarang dan Persyaratan Layanan Google kami.

Mulai membangun dengan embedding

Lihat notebook panduan memulai penyematan untuk mempelajari kemampuan model dan mempelajari cara menyesuaikan serta memvisualisasikan penyematan.