Embeddings

API-ja Gemini ofron modele integrimi për të gjeneruar integrime për tekst, imazhe, video dhe përmbajtje të tjera. Këto integrime që rezultojnë mund të përdoren më pas për detyra të tilla si kërkimi semantik, klasifikimi dhe grupimi, duke ofruar rezultate më të sakta dhe të ndërgjegjshme për kontekstin sesa qasjet e bazuara në fjalë kyçe.

Modeli më i fundit, gemini-embedding-2-preview , është modeli i parë multimodal i ngulitur në Gemini API. Ai hartëzon tekstin, imazhet, videon, audion dhe dokumentet në një hapësirë ​​të unifikuar ngulitjeje, duke mundësuar kërkimin ndërmodal, klasifikimin dhe grupimin në mbi 100 gjuhë. Shihni seksionin e ngulitjeve multimodale për të mësuar më shumë. Për rastet e përdorimit vetëm me tekst, gemini-embedding-001 mbetet i disponueshëm.

Ndërtimi i sistemeve të Gjenerimit të Shtuar të Rikthimit (RAG) është një rast i zakonshëm përdorimi për produktet e IA-së. Integrimet luajnë një rol kyç në përmirësimin e ndjeshëm të rezultateve të modelit me saktësi faktike, koherencë dhe pasuri kontekstuale të përmirësuar. Nëse preferoni të përdorni një zgjidhje të menaxhuar RAG, ne kemi ndërtuar mjetin e Kërkimit të Skedarëve i cili e bën kryerjen e RAG më të lehtë për t'u menaxhuar dhe më efektiv nga ana e kostos.

Gjenerimi i ngulitjeve

Përdorni metodën embedContent për të gjeneruar ngulitje teksti:

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

Shko 

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

PUSHTIM 

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 '{
        "model": "models/gemini-embedding-001",
        "content": {
        "parts": [{
            "text": "What is the meaning of life?"
        }]
        }
    }'

Gjithashtu mund të gjeneroni ngulitje për disa pjesë njëkohësisht duke i kaluar ato si një listë vargjesh.

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

Shko 

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

PUSHTIM 

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 '{
    "content": {
        "parts": [
        {
            "text": "What is the meaning of life?"
        },
        {
            "text": "How much wood would a woodchuck chuck?"
        },
        {
            "text": "How does the brain work?"
        }
        ]
    },
    "taskType": "SEMANTIC_SIMILARITY"
    }'

Specifikoni llojin e detyrës për të përmirësuar performancën

Mund të përdorni ngulitje për një gamë të gjerë detyrash, nga klasifikimi deri te kërkimi i dokumenteve. Specifikimi i llojit të duhur të detyrës ndihmon në optimizimin e ngulitjeve për marrëdhëniet e synuara, duke maksimizuar saktësinë dhe efikasitetin.

Llojet e detyrave me Embeddings 2

Për detyrat vetëm me tekst me gemini-embedding-2-preview , ne ju rekomandojmë fuqimisht të shtoni udhëzimin e detyrës në kërkesën tuaj. Kjo mund të bëhet duke formatuar pyetjen dhe dokumentin me parashtesën e saktë të detyrës.

Tabelat e mëposhtme tregojnë shembuj se si të formatohen pyetjet dhe dokumentet për raste përdorimi simetrike dhe asimetrike duke përdorur modelin gemini-embedding-2-preview .

Rastet e përdorimit të rikuperimit (format asimetrik)

Në rastet e përdorimit asimetrik, shtoni parashtesën e detyrës në pyetje dhe aplikoni strukturën e dokumentit për përmbajtjen që dëshironi të ngulisni dhe të merrni.

Rast përdorimi Struktura e pyetjes Struktura e dokumentit
Kërkim i pyetjes task: search result | query: {content} title: {title} | text: {content}
Nëse nuk ka titull, përdorni title: none .
Përgjigje pyetjesh task: question answering | query: {content} title: {title} | text: {content}
Verifikimi i fakteve task: fact checking | query: {content} title: {title} | text: {content}
Rikthimi i kodit task: code retrieval | query: {content} title: {title} | text: {content}

Shembull përdorimi

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

Rastet e përdorimit me një hyrje të vetme (format simetrik)

Në rastet e përdorimit simetrik, për të njëjtën detyrë, përdorni të njëjtin formatim për pyetjen dhe dokumentin.

Rast përdorimi Struktura e të dhënave
Klasifikimi task: classification | query: {content}
Grumbullimi task: clustering | query: {content}
Ngjashmëria semantike task: sentence similarity | query: {content}
Mos e përdorni këtë për kërkim ose rikthim. Është menduar për ngjashmëri semantike tekstuale.

Shembull përdorimi

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

Është e rëndësishme që detyra të përdoret në mënyrë të vazhdueshme. P.sh., nëse dokumentet janë të integruara me f'task: classification | query: {content}' , pyetja duhet të integrohet gjithashtu duke ndjekur këtë format detyre.

Llojet e detyrave me Embeddings 1

Për gemini-embedding-001 , mund të specifikoni task_type në metodën embedContent . Për një listë të plotë të llojeve të detyrave të mbështetura, shihni tabelën Llojet e detyrave të mbështetura .

Shembulli i mëposhtëm tregon se si mund ta përdorni SEMANTIC_SIMILARITY për të kontrolluar se sa të ngjashëm në kuptim janë vargjet e teksteve.

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

Shko 

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

PUSHTIM 

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

Fragmentet e kodit do të tregojnë se sa të ngjashme janë pjesët e ndryshme të tekstit me njëra-tjetrën kur ekzekutohen.

Llojet e detyrave të mbështetura

Llojet e detyrave të mbështetura për gemini-embedding-001 :

Lloji i detyrës Përshkrimi Shembuj
NGJASHMËRI_SEMANTIKE Integrimet janë optimizuar për të vlerësuar ngjashmërinë e tekstit. Sisteme rekomandimi, zbulim i dyfishuar
KLASIFIKIMI Integrimet janë optimizuar për të klasifikuar tekstet sipas etiketave të paracaktuara. Analiza e ndjenjës, zbulimi i spamit
GRUMBULLIM Integrimet janë optimizuar për të grupuar tekstet bazuar në ngjashmëritë e tyre. Organizimi i dokumenteve, hulumtimi i tregut, zbulimi i anomalive
RETRIEVAL_DOCUMENT Integrime të optimizuara për kërkimin e dokumenteve. Indeksimi i artikujve, librave ose faqeve të internetit për kërkim.
RETRIEVAL_QUERY Integrimet janë optimizuar për pyetje të përgjithshme kërkimi. Përdorni RETRIEVAL_QUERY për pyetjet; RETRIEVAL_DOCUMENT për dokumentet që do të merren. Kërkim i personalizuar
QUERY_MERRJE_KODI Integrime të optimizuara për rikuperimin e blloqeve të kodit bazuar në pyetje në gjuhën natyrore. Përdorni CODE_RETRIEVAL_QUERY për pyetjet; RETRIEVAL_DOCUMENT për blloqet e kodit që do të rikuperohen. Sugjerime kodi dhe kërkim
PËRGJIGJE_PYETJESH Përfshirje për pyetje në një sistem pyetje-përgjigjesh, të optimizuar për gjetjen e dokumenteve që i përgjigjen pyetjes. Përdorni QUESTION_ANSWERING për pyetjet; RETRIEVAL_DOCUMENT për dokumentet që do të merren. Kutia e bisedave
VERIFIKIMI I FAKTIT Vendosje për deklarata që duhen verifikuar, të optimizuara për marrjen e dokumenteve që përmbajnë prova që mbështesin ose hedhin poshtë deklaratën. Përdorni FACT_VERIFICATION për tekstin e synuar; RETRIEVAL_DOCUMENT për dokumentet që do të merren. Sisteme të automatizuara të verifikimit të fakteve

Kontrollimi i madhësisë së ngulitur

Si gemini-embedding-001 ashtu edhe gemini-embedding-2-preview trajnohen duke përdorur teknikën Matryoshka Representation Learning (MRL) e cila i mëson një modeli të mësojë ngulitje me dimensione të larta që kanë segmente fillestare (ose parashtesa) të cilat janë gjithashtu versione të dobishme dhe më të thjeshta të të njëjtave të dhëna.

Përdorni parametrin output_dimensionality për të kontrolluar madhësinë e vektorit të ngulitur të daljes. Zgjedhja e një dimensionaliteti më të vogël të daljes mund të kursejë hapësirë ​​ruajtjeje dhe të rrisë efikasitetin llogaritës për aplikacionet pasuese, ndërkohë që sakrifikon pak për sa i përket cilësisë. Si parazgjedhje, të dy modelet nxjerrin një ngulitur 3072-dimensional, por ju mund ta shkurtoni atë në një madhësi më të vogël pa humbur cilësinë për të kursyer hapësirë ​​ruajtjeje. Ne rekomandojmë përdorimin e dimensioneve të daljes 768, 1536 ose 3072.

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',
        contents: 'What is the meaning of life?',
        config: { outputDimensionality: 768 },
    });

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

main();

Shko 

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

PUSHTIM 

curl -X POST "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-001: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
    }'

Shembull rezultati nga fragmenti i kodit: 

Length of embedding: 768

Sigurimi i cilësisë për dimensione më të vogla

Vendosja e dimensionit 3072 është e normalizuar. Vendosjet e normalizuara prodhojnë ngjashmëri semantike më të saktë duke krahasuar drejtimin vektorial, jo madhësinë. Për dimensione të tjera, duke përfshirë 768 dhe 1536, duhet të normalizoni vendosjet si më poshtë:

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

Shembull rezultati nga ky fragment kodi: 

Normed embedding length: 768
Norm of normed embedding: 1.000000

Tabela e mëposhtme tregon rezultatet e MTEB, një pikë referimi e përdorur zakonisht për integrimet, për dimensione të ndryshme. Veçanërisht, rezultati tregon se performanca nuk është e lidhur ngushtë me madhësinë e dimensionit të integrimit, me dimensionet më të ulëta që arrijnë rezultate të krahasueshme me homologët e tyre me dimensione më të larta.

Dimensioni MRL Rezultati MTEB (Gemini Embedding 001)
2048 68.16
1536 68.17
768 67.99
512 67.55
256 66.19
128 63.31

Integrime multimodale

Modeli gemini-embedding-2-preview mbështet të dhënat multimodale, duke ju lejuar të ngulitni përmbajtje imazhesh, video, audio dhe dokumentesh së bashku me tekstin. Të gjitha modalitetet janë hartëzuar në të njëjtën hapësirë ​​ngulitjeje, duke mundësuar kërkimin dhe krahasimin ndërmodal.

Modalitetet dhe kufizimet e mbështetura

Limiti maksimal i përgjithshëm i tokenëve të hyrjes është 8192 tokenë.

Modaliteti Specifikimet dhe kufizimet
Tekst Mbështet deri në 8,192 tokenë.
Imazh Maksimumi 6 imazhe për kërkesë. Formatet e mbështetura: PNG, JPEG.
Audio Kohëzgjatja maksimale prej 80 sekondash. Formatet e mbështetura: MP3, WAV.
Video Kohëzgjatja maksimale është 120 sekonda. Formatet e mbështetura: MP4, MOV. Kodekët e mbështetur: H264, H265, AV1, VP9.
Sistemi përpunon një maksimum prej 32 kuadrosh për video: videot e shkurtra (≤32s) merren si mostra me 1 kuadro për sekondë, ndërsa videot më të gjata merren si mostra në mënyrë uniforme në 32 kuadro. Gjurmët audio nuk përpunohen në skedarët video.
Dokumente (PDF) Maksimumi 6 faqe.

Imazhe të integruara

Shembulli i mëposhtëm tregon se si të ngulitni një imazh duke përdorur gemini-embedding-2-preview .

Imazhet mund të ofrohen si të dhëna të brendshme ose si skedarë të ngarkuar përmes API-t të Skedarëve .

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-preview',
    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-preview',
        contents: [{
            inlineData: {
                mimeType: 'image/png',
                data: imgBase64,
            },
        }],
    });

    console.log(response.embeddings);
}

main();

PUSHTIM 

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

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-2-preview: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}"'"
                }
            }]
        }
    }'

Grumbullimi i integrimit

Kur punoni me përmbajtje multimodale, mënyra se si e strukturoni të dhënat hyrëse ndikon në rezultatet e ngulitura:

  • Hyrje e vetme përmbajtjeje: Dorëzimi i pjesëve të shumëfishta (për shembull, tekst dhe një imazh) brenda një hyrjeje të vetme përmbajtjeje prodhon një ngulitje të përgjithshme për të gjitha modalitetet brenda asaj hyrjeje.
  • Hyrje të shumëfishta: Dërgimi i hyrjeve të shumëfishta në vargun e contents kthen ngulitje të ndara për secilin hyrje.
  • Përfaqësimi në nivel pasues: Për objekte komplekse si postimet në mediat sociale me artikuj të shumtë mediatikë, ne rekomandojmë grumbullimin e ngulitjeve të ndara (për shembull, duke mesatarizuar) për të krijuar një përfaqësim koherent në nivel pasues.

Shembulli i mëposhtëm tregon se si të krijoni një ngulitje të përmbledhur për futjen e tekstit dhe imazhit. Përdorni fushën e parts për të kombinuar hyrje të shumëfishta:

Python 

from google import genai
from google.genai import types

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

result = client.models.embed_content(
    model='gemini-embedding-2-preview',
    contents=[
        types.Content(
            parts=[
                types.Part(text="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-preview',
        contents: {
            parts: [
                { text: 'An image of a dog' },
                { inlineData: { mimeType: 'image/png', data: imgBase64 } },
            ],
        },
    });

    console.log(response.embeddings);
}

main();

PUSHTIM 

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

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-2-preview: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}"'"
                    }
                }
            ]
        }
    }'

Nga ana tjetër, ky shembull krijon ngulitje të shumëfishta në një thirrje ngulitjeje:

Python 

from google import genai
from google.genai import types

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

result = client.models.embed_content(
    model='gemini-embedding-2-preview',
    contents=[
        "The dog is cute",
        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-preview',
        contents: [
            'The dog is cute',
            {
                inlineData: {
                    mimeType: 'image/png',
                    data: imgBase64,
                },
            },
        ],
    });

    console.log(response.embeddings);
}

main();

PUSHTIM 

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

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

Integrimi i audios

Shembulli i mëposhtëm tregon se si të ngulitni një skedar audio duke përdorur gemini-embedding-2-preview .

Skedarët audio mund të ofrohen si të dhëna të integruara ose si skedarë të ngarkuar përmes API-t të Skedarëve .

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-preview',
    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-preview',
        contents: [{
            inlineData: {
                mimeType: 'audio/mpeg',
                data: audioBase64,
            },
        }],
    });

    console.log(response.embeddings);
}

main();

PUSHTIM 

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

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-2-preview: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}"'"
                }
            }]
        }
    }'

Vendosja e videos

Shembulli i mëposhtëm tregon se si të integrohet një video duke përdorur gemini-embedding-2-preview .

Videot mund të ofrohen si të dhëna të integruara ose si skedarë të ngarkuar përmes API-t të Skedarëve .

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-preview',
    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-preview',
        contents: [{
            inlineData: {
                mimeType: 'video/mp4',
                data: videoBase64,
            },
        }],
    });

    console.log(response.embeddings);
}

main();

PUSHTIM 

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

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-2-preview: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}"'"
                }
            }]
        }
    }'

Nëse keni nevojë të ngulini video >120 sekonda, mund ta ndani videon në segmente që mbivendosen dhe t'i ngulisni ato pjesë individualisht.

Vendosja e dokumenteve

Dokumentet në formatin PDF mund të integrohen direkt. Modeli përpunon përmbajtjen vizuale dhe tekstuale të secilës faqe.

PDF-të mund të ofrohen si të dhëna të integruara ose si skedarë të ngarkuar përmes API-t të Skedarëve .

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-preview',
    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-preview',
        contents: [{
            inlineData: {
                mimeType: 'application/pdf',
                data: pdfBase64,
            },
        }],
    });

    console.log(response.embeddings);
}

main();

PUSHTIM 

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

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-2-preview: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}"'"
                }
            }]
        }
    }'

Rastet e përdorimit

Integrimet e tekstit janë thelbësore për një sërë rastesh të zakonshme përdorimi të IA-së, siç janë:

Ruajtja e ngulitjeve

Ndërsa i çoni ngulitje-t në prodhim, është e zakonshme të përdorni baza të dhënash vektoriale për të ruajtur, indeksuar dhe rikuperuar në mënyrë efikase ngulitje-dimensionale të larta. Google Cloud ofron shërbime të të dhënave të menaxhuara që mund të përdoren për këtë qëllim, duke përfshirë Vertex AI Vector Search 2.0 , BigQuery , AlloyDB dhe Cloud SQL .

Tutorialet e mëposhtme tregojnë se si të përdorni baza të dhënash vektoriale të palëve të treta me Gemini Embedding.

Versionet e modelit

Pamje paraprake e Gemini Embedding 2

Pronë Përshkrimi
Kodi i modelit të

API-ja e Gemini-t

gemini-embedding-2-preview

llojet e të dhënave të mbështetura

Hyrje

Tekst, imazh, video, audio, PDF

Prodhimi

Vendosja e tekstit

Limitet token-it [*]

Limiti i tokenit të hyrjes

8,192

Madhësia e dimensionit të daljes

Fleksibël, mbështet: 128 - 3072, i rekomanduar: 768, 1536, 3072

Versione
Lexoni modelet e versionit të modelit për më shumë detaje.
  • Parapamje: gemini-embedding-2-preview
Përditësimi më i fundit Nëntor 2025

Vendosja e Binjakëve

Pronë Përshkrimi
Kodi i modelit të

API-ja e Gemini-t

gemini-embedding-001

llojet e të dhënave të mbështetura

Hyrje

Tekst

Prodhimi

Vendosja e tekstit

Limitet token-it [*]

Limiti i tokenit të hyrjes

2,048

Madhësia e dimensionit të daljes

Fleksibël, mbështet: 128 - 3072, i rekomanduar: 768, 1536, 3072

Versione
Lexoni modelet e versionit të modelit për më shumë detaje.
  • Stabile: gemini-embedding-001
Përditësimi më i fundit Qershor 2025

Për modelet e vjetëruara të Embeddings, vizitoni faqen e vjetërimeve

Migrimi nga gemini-embedding-001

Hapësirat e ngulitjes midis gemini-embedding-001 dhe gemini-embedding-2-preview janë të papajtueshme . Kjo do të thotë që nuk mund të krahasoni drejtpërdrejt ngulitjet e gjeneruara nga një model me ngulitjet e gjeneruara nga tjetri. Nëse po përditësoni në gemini-embedding-2-preview , duhet të ringulitni të gjitha të dhënat tuaja ekzistuese.

Vendosje në grup

Nëse vonesa nuk është shqetësuese, provoni të përdorni modelet Gemini Embeddings me Batch API . Kjo lejon një rendiment shumë më të lartë me 50% të çmimit të parazgjedhur të Embedding. Gjeni shembuj se si të filloni në librin e gatimit të Batch API .

Njoftim për përdorim të përgjegjshëm

Ndryshe nga modelet gjeneruese të IA-së që krijojnë përmbajtje të re, modeli Gemini Embedding ka për qëllim vetëm të transformojë formatin e të dhënave tuaja hyrëse në një përfaqësim numerik. Ndërsa Google është përgjegjës për ofrimin e një modeli integrimi që transformon formatin e të dhënave tuaja hyrëse në formatin numerik të kërkuar, përdoruesit mbajnë përgjegjësi të plotë për të dhënat që ata futin dhe integrimet që rezultojnë. Duke përdorur modelin Gemini Embedding, ju konfirmoni se keni të drejtat e nevojshme për çdo përmbajtje që ngarkoni. Mos gjeneroni përmbajtje që shkel të drejtat e pronësisë intelektuale ose të privatësisë së të tjerëve. Përdorimi juaj i këtij shërbimi i nënshtrohet Politikës sonë të Përdorimit të Ndaluar dhe Kushteve të Shërbimit të Google .

Filloni ndërtimin me integrime

Shikoni fletoren e nisjes së shpejtë të ngulitjeve për të eksploruar aftësitë e modelit dhe për të mësuar se si të personalizoni dhe vizualizoni ngulitjete tuaja.