Gemini 3.8 Flash është tani në dispozicion. Provojeni .

Google përdor teknologjinë e IA-së për të përkthyer përmbajtjet në gjuhën tënde të preferuar. Përkthimet nga IA-ja mund të përmbajnë gabime.

Integrimet

Gemini API ofron modele të integrimit 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, është modeli i parë multimodal i integritetit në Gemini API. Ai hartëzon tekstin, imazhet, videot, audion dhe dokumentet në një hapësirë të unifikuar të integrimit, duke mundësuar kërkimin, klasifikimin dhe grupimin ndërmjet modaliteteve në mbi 100 gjuhë. Shiko seksionin e integrimeve shumëmodale 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 nëpërmjet përftimit të përmirësuar të informacionit (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 preferon të përdorësh një zgjidhje të menaxhuar RAG, ne kemi krijuar veglën Kërkimi në skedarë e cila e bën më të lehtë menaxhimin e RAG dhe më efikas nga ana e kostos.

Po gjenerohen integrimet

Përdor metodën embedContent për të gjeneruar përfaqësimet e tekstit:

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

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

QETËSI

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

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

Mund t'i përdorësh integrimet 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 integrimeve 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, të rekomandojmë shumë që të shtosh udhëzimet e detyrës në kërkesën tënde. Kjo mund të bëhet duke formatuar kërkesën dhe dokumentin me parashtesën e saktë të detyrës.

Kur gjeneron një futje të vetme të bazuar në hyrjen multimodale, në përgjithësi nuk rekomandojmë të vendosësh një prefiks në pjesën e tekstit të hyrjes me një udhëzim për detyrën. Në disa raste, ai përmirëson performancën, por në të tjera e zvogëlon performancën.

Tabelat e mëposhtme tregojnë shembuj se si të formatosh kërkesat dhe dokumentet për rastet e përdorimit simetrik dhe asimetrik duke përdorur modelin gemini-embedding-2.

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

Në rastet e përdorimit asimetrik, shto parashtesën e detyrës te kërkesa dhe zbato strukturën e dokumentit për përmbajtjet që dëshiron të integrosh dhe të marrësh.

Rasti i përdorimit	Struktura e kërkesës	Struktura e dokumentit
Kërko pyetjen	`task: search result \| query: {content}`	`title: {title} \| text: {content}` Nëse nuk ka titull, përdor `title: none`.
Përgjigjja e pyetjeve	`task: question answering \| query: {content}`	`title: {title} \| text: {content}`
Verifikimi i fakteve	`task: fact checking \| query: {content}`	`title: {title} \| text: {content}`
Marrja e 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ërdor të njëjtin formatim për pyetjen dhe dokumentin.

Rasti i përdorimit	Struktura e hyrjes
Klasifikimi	`task: classification \| query: {content}`
Grumbullimi	`task: clustering \| query: {content}`
Ngjashmëria semantike	`task: sentence similarity \| query: {content}` Mos e përdor këtë për kërkim ose marrje. Ai është menduar për ngjashmërinë semantike të tekstit.

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}', kërkesa duhet të jetë gjithashtu e integruar duke ndjekur këtë format detyre.

Llojet e detyrave me "Inkorporimet 1"

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

Shembulli i mëposhtëm tregon se si mund të përdorësh SEMANTIC_SIMILARITY për të kontrolluar se sa të ngjashme janë në kuptim 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();

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

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

QETËSI

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ë shfaqin se sa të ngjashme janë pjesët e ndryshme të tekstit me njëra-tjetrën kur ekzekutohen.

Llojet e mbështetura të detyrave

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

Lloji i detyrës	Përshkrimi	Shembuj
SEMANTIC_SIMILARITY	Inkorporimet e optimizuara për të vlerësuar ngjashmërinë e tekstit.	Sistemet e rekomandimeve, zbulimi i dublikatave
KLASIFIKIMI	Përfaqësimet numerike të optimizuara për të klasifikuar tekstet sipas etiketave të paravendosura.	Analiza e qëndrimit, zbulimi i mesazheve të bezdisshme
GRUPIMI	Integrimet e optimizuara për të grupuar tekstet bazuar në ngjashmëritë e tyre.	Organizimi i dokumenteve, kërkimi i tregut, zbulimi i anomalive
RETRIEVAL_DOCUMENT	Integrimet e optimizuara për kërkimin në dokumente.	Indeksimi i artikujve, librave ose faqeve të uebit për kërkimin.
RETRIEVAL_QUERY	Integrimet e optimizuara për kërkesat e përgjithshme të kërkimit. Përdor `RETRIEVAL_QUERY` për kërkesat; `RETRIEVAL_DOCUMENT` për dokumentet që do të merren.	Kërkimi i personalizuar
CODE_RETRIEVAL_QUERY	Inkorporimet e optimizuara për marrjen e blloqeve të kodit bazuar në kërkesat në gjuhë natyrale. Përdor `CODE_RETRIEVAL_QUERY` për pyetjet; `RETRIEVAL_DOCUMENT` për blloqet e kodit që do të merren.	Sugjerimet dhe kërkimi për kodin
QUESTION_ANSWERING	Inkorporimet për pyetjet në një sistem të përgjigjeve për pyetjet, të optimizuara për gjetjen e dokumenteve që i përgjigjen pyetjes. Përdor `QUESTION_ANSWERING` për pyetjet; `RETRIEVAL_DOCUMENT` për dokumentet që do të merren.	Kutia e bisedës
FACT_VERIFICATION	Integrimet për deklaratat që duhet të verifikohen, të optimizuara për marrjen e dokumenteve që përmbajnë prova që mbështesin ose kundërshtojnë deklaratën. Përdor `FACT_VERIFICATION` për tekstin e synuar; `RETRIEVAL_DOCUMENT` për dokumentet që do të merren	Sistemet e automatizuara të verifikimit të fakteve

Kontrollimi i madhësisë së integrimit

gemini-embedding-001 dhe gemini-embedding-2 janë trajnuar duke përdorur teknikën e "Mësimit të përfaqësimit të Matryoshka" (MRL) që i mëson një modeli të mësojë integrime me shumë dimensione që kanë segmente fillestare (ose parashtesa) që janë gjithashtu versione të dobishme dhe më të thjeshta të të njëjtave të dhëna.

Përdor parametrin output_dimensionality për të kontrolluar madhësinë e vektorit të integrimit të daljes. Zgjedhja e një përmase më të vogël të daljes mund të kursejë hapësirë ruajtëse dhe të rritë efikasitetin kompjuterik për aplikacionet në vazhdim, ndërkohë që sakrifikon pak në aspektin e cilësisë. Si parazgjedhje, të dyja modelet nxjerrin një përfaqësim 3072-dimensional, por mund ta shkurtoni atë në një madhësi më të vogël pa humbur cilësinë për të kursyer hapësirën ruajtëse. Ne rekomandojmë përdorimin e përmasave 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-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);

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

QETËSI

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

Shembulli i daljes nga fragmenti i kodit:

Length of embedding: 768

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

Ndërkohë që përfshirjet e parazgjedhura me 3072 dimensione normalizohen gjithmonë, Gemini Embedding 2 normalizon automatikisht edhe dimensionet e shkurtuara (p.sh. 768, 1536). Kjo siguron që ngjashmëria semantike të llogaritet nëpërmjet drejtimit të vektorit dhe jo nëpërmjet madhësisë, duke ofruar rezultate më të sakta që në fillim.

Modelet e vjetra: Nëse po përdor gemini-embedding-001, duhet të normalizosh manualisht dimensionet jo 3072 si më poshtë:

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

Shembulli i daljes nga ky fragment kodi:

Normed embedding length: 768
Norm of normed embedding: 1.000000

Tabela e mëposhtme tregon rezultatet e MTEB-së, një pikë referimi që përdoret zakonisht për përfaqësimet e vektorëve, për dimensione të ndryshme. Veçanërisht, rezultati tregon se performanca nuk është e lidhur ngushtësisht 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.

Përmasa e MRL-së	MTEB Score (Gemini Embedding 001)
2048	68.16
1536	68.17
768	67,99
512	67,55
256	66,19
128	63.31

Integrimet multimodale

Modeli gemini-embedding-2 mbështet hyrjen multimodale, duke të të lejuar që të integroni përmbajtje me imazhe, video, audio dhe dokumente bashkë me tekstin. Të gjitha modalitetet janë hartëzuar në të njëjtin hapësirë të integrimit, duke mundësuar kërkimin dhe krahasimin ndërmodal.

Modalitetet e mbështetura dhe kufijtë

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

Modaliteti	Specifikimet dhe kufijtë
Mesazh me tekst	Mbështet deri në 8192 kode qasjeje.
Imazh	Maksimumi 6 imazhe për kërkesë. Formatet e mbështetura: PNG, JPEG.
Audioja	Kohëzgjatja maksimale prej 180 sekondash. Formatet e mbështetura: MP3, WAV.
Video	Kohëzgjatja maksimale prej 120 sekondash. Formatet e mbështetura: MP4, MOV. Kodekët e mbështetur: H264, H265, AV1, VP9. Sistemi përpunon maksimumi 32 kuadro për video: videot e shkurtra (≤32 sekonda) marrin shembuj me 1 fps, ndërsa videot më të gjata marrin shembuj në mënyrë uniforme në 32 kuadro. Pjesët zanore nuk përpunohen në skedarët e videos.
Dokumente (PDF)	Maksimumi 1 skedar për kërkesë, deri në 6 faqe.

Po integrohen imazhet

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

Imazhet mund të ofrohen si të dhëna të ndërfutura ose si skedarë të ngarkuar nëpërmjet API-së së 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',
    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));

QETËSI

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

Përmbledhja e integrimit

Kur punon me përmbajtje shumëmodale, mënyra se si e strukturon hyrjen ndikon te dalja e integrimit:

Pjesë të shumta (të përmbledhura): Shtimi i shumë hyrjeve drejtpërdrejt te parametri contents prodhon një integrim të përmbledhur për të gjitha hyrjet.
Disa objekte Content (të veçanta): Mbështjellja e çdo hyrjeje në një objekt Content dhe kalimi i tyre në parametrin contents kthen veçime të veçanta për çdo hyrje.
Përfaqësimi në nivel postimi: Për objekte komplekse si postimet në rrjetet sociale me disa artikuj të mediave, ne rekomandojmë të mbledhësh përfaqësime të veçanta të vektorëve (për shembull, duke llogaritur mesataren) për të krijuar një përfaqësim koherent në nivel postimi.

Shembulli i mëposhtëm tregon se si të krijosh një integrim të përmbledhur për hyrjen e tekstit dhe imazhit. Thjesht shto disa hyrje te parametri 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()));
}

QETËSI

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

Nga ana tjetër, nëse përdor objekte Content brenda parametrit contents, ai kthen integrime të veçanta. Ky shembull krijon disa paraqitje në një thirrje të vetme të paraqitjes:

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

QETËSI

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

Audioja po integrohet

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

Skedarët audio mund të ofrohen si të dhëna të integruara ose si skedarë të ngarkuar nëpërmjet API-së së 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',
    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));

QETËSI

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

Po integrohet videoja

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

Videot mund të ofrohen si të dhëna të integruara ose si skedarë të ngarkuar nëpërmjet 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()));

QETËSI

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

Nëse duhet të integrosh video >120 sekonda, mund ta ndash videon në segmente të mbivendosura dhe t'i integrosh ato segmente individualisht.

Dokumentet po integrohen

Dokumentet në format PDF mund të integrohen drejtpërdrejt. Modeli përpunon përmbajtjen vizuale dhe tekstuale të çdo faqeje.

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

Si i përpunon modeli skedarët PDF

Kur integrosh një PDF, modeli e përpunon dokumentin duke përdorur veçoritë vizuale dhe të tekstit:

Përfaqësimi vizual: Modeli e paraqet çdo faqe si një imazh, i cili konsumon 258 kode për faqe.
Nxjerrja e tekstit: Modeli nxjerr tekstin nga dokumenti. Për skedarët PDF të natyrshëm (që përmbajnë tekst dixhital), modeli e nxjerr tekstin drejtpërdrejt. Për skedarët PDF të skanuar (që përmbajnë imazhe të tekstit), modeli ekzekuton automatikisht njohjen optike të karaktereve (OCR) për të nxjerrë tekstin.

Për të llogaritur numrin total të kodeve për një skedar PDF, shto kodet vizuale (258 për faqe) te kodet e tekstit. Hyrjet e tua duhet të përshtaten brenda kufirit prej 8 192 token-ësh të modelit (të ndarë në të gjitha modalitetet). Sistemi i shkurton në heshtje hyrjet që e tejkalojnë këtë kufi.

Kufijtë e PDF-së

Skedarët për kërkesë: Mund të dërgosh maksimumi 1 skedar PDF.
Kufiri i faqeve: Mund të dërgosh maksimumi 6 faqe për skedar. Për cilësinë më të mirë, ne rekomandojmë fuqishëm përdorimin e 1 faqeje për PDF.

Shembulli i mëposhtëm tregon se si të integrosh një skedar PDF duke përdorur 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));

QETËSI

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

Rastet e përdorimit

Paraqitjet e tekstit janë thelbësore për një sërë rastesh të zakonshme përdorimi të IA-së, si p.sh.:

Gjenerimi i zgjeruar me marrje (RAG): Integrimet përmirësojnë cilësinë e tekstit të gjeneruar duke marrë dhe duke përfshirë informacione të përshtatshme në kontekstin e një modeli.
Marrja e informacioneve: Kërko për tekstin ose dokumentet më të ngjashme semantikisht duke pasur parasysh një pjesë të tekstit hyrës.

Udhëzuesi i kërkimit të dokumenteve
Rirenditja e kërkimit: U jep përparësi artikujve më të përshtatshëm duke i vlerësuar semantikisht rezultatet fillestare në lidhje me kërkesën.

Udhëzuesi i rirenditjes së kërkimit
Zbulimi i anomalive: Krahasimi i grupeve të përfaqësimeve mund të ndihmojë për të identifikuar tendencat e fshehura ose vlerat e pazakonta.

Udhëzuesi i zbulimit të anomalive
Klasifikimi: Kategorizo automatikisht tekstin bazuar në përmbajtjen e tij, si p.sh. analiza e opinioneve ose zbulimi i përmbajtjeve të bezdisshme

Udhëzuesi i klasifikimit
Grupimi: Kupto në mënyrë efektive marrëdhëniet komplekse duke krijuar grupe dhe vizualizime të integrimeve të tua.

Udhëzuesi i vizualizimit të grupimit

Po ruhen integrimet

Ndërsa i çon integrimet në prodhim, është e zakonshme të përdorësh bazat e të dhënave të vektorëve për të ruajtur, indeksuar dhe marrë në mënyrë efikase integrimet me shumë dimensione. Google Cloud ofron shërbime të menaxhuara të të dhënave që mund të përdoren për këtë qëllim, duke përfshirë Kërkimin me vektorë 2.0 të platformës së agjentit të Gemini Enterprise, BigQuery, AlloyDB dhe Cloud SQL.

Udhëzuesit e mëposhtëm tregojnë se si të përdorësh bazat e tjera të të dhënave të vektorëve të palëve të treta me Gemini Embedding.

Versionet e modelit

Gemini Embedding 2

Prona	Përshkrimi
Kodi i modelit	Gemini API `gemini-embedding-2`
Llojet e të dhënave të mbështetura për	Hyrja Tekst, imazh, video, audio, PDF Rezultati Paraqitjet e tekstit
Kufijtë e kodeve qasëse^[*]	Kufiri i tokenëve të hyrjes 8,192 Madhësia e dimensionit të daljes Fleksibël, mbështet: 128 - 3072, Rekomandohet: 768, 1536, 3072
Versionet	Lexo modelet e versioneve për më shumë detaje. E qëndrueshme: `gemini-embedding-2`
Përditësimi i fundit	Prill 2026

Integrimi i Gemini

Prona	Përshkrimi
Kodi i modelit	Gemini API `gemini-embedding-001`
Llojet e të dhënave të mbështetura për	Hyrja Teksti Rezultati Paraqitjet e tekstit
Kufijtë e kodeve qasëse^[*]	Kufiri i tokenëve të hyrjes 2,048 Madhësia e dimensionit të daljes Fleksibël, mbështet: 128 - 3072, Rekomandohet: 768, 1536, 3072
Versionet	Lexo modelet e versioneve për më shumë detaje. E qëndrueshme: `gemini-embedding-001`
Përditësimi i fundit	Qershor 2025

Për modelet e zhvlerësuara të "Integrimeve", vizito faqen e Zhvlerësimeve

Migrimi nga gemini-embedding-001

Hapësirat e integruara midis gemini-embedding-001 dhe gemini-embedding-2 janë të papajtueshme. Kjo do të thotë që nuk mund t'i krahasosh drejtpërdrejt integrimet e gjeneruara nga një model me integrimet e gjeneruara nga modeli tjetër. Nëse po kalon në gemini-embedding-2, duhet të riintegrosh të gjitha të dhënat e tua ekzistuese.

Përveç papajtueshmërisë, ka disa dallime të tjera të rëndësishme midis dy modeleve:

Specifikimi i llojit të detyrës: Me gemini-embedding-001, ti specifikon llojin e detyrës duke përdorur parametrin task_type (p.sh. SEMANTIC_SIMILARITY, RETRIEVAL_DOCUMENT). Me gemini-embedding-2, parametri task_type nuk mbështetet. Në vend të kësaj, duhet të përfshish udhëzimet e detyrës drejtpërdrejt në kërkesë për detyrat vetëm me tekst. Shiko Llojet e detyrave me "Paraqitjet 2" për detaje se si të formatosh kërkesat për raste të ndryshme përdorimi.
Përmbledhja e integrimit: gemini-embedding-001 gjeneron integrime individuale për çdo varg në një listë hyrjesh. Në të kundërt, gemini-embedding-2 prodhon një paraqitje të vetme të përmbledhur kur ofrohen disa hyrje (si teksti dhe imazhet) drejtpërdrejt në një kërkesë të vetme. Për të gjeneruar integrime të veçanta për hyrjet individuale, mbështill çdo hyrje në një objekt Content ose përdor API-në e grupeve. Shiko Përmbledhja e integrimit për më shumë informacione.
Normalizimi: Nëse përdor output_dimensionality për të kërkuar integrime me më pak se 3072 dimensione, gemini-embedding-2 i normalizon automatikisht këto integrime të shkurtuara. Me gemini-embedding-001, duhet të kryesh normalizimin manual për përmasa të tjera përveç 3072. Shiko Sigurimi i cilësisë për përmasa më të vogla për detaje.

Integrimet në grup

Nëse vonesa nuk është një problem, provo të përdorësh modelet e "Paraqitjeve të Gemini" me Batch API. Kjo lejon një kapacitet shumë më të lartë me 50% të çmimit të parazgjedhur të "Integrimit". Gjej shembuj se si të fillosh në Udhëzuesin e API-së së grupeve.

Njoftim për përdorimin e përgjegjshëm

Ndryshe nga modelet e IA-së gjeneruese që krijojnë përmbajtje të reja, modeli Gemini Embedding synon vetëm të transformojë formatin e të dhënave të tua hyrëse në një përfaqësim numerik. Ndërkohë që Google është përgjegjës për ofrimin e një modeli të integrimit që transformon formatin e të dhënave të tua hyrëse në formatin numerik të kërkuar, përdoruesit mbajnë përgjegjësinë e plotë për të dhënat që futin dhe për integrimet që rezultojnë. Duke përdorur modelin e Gemini Embedding, ti konfirmon që ke të drejtat e nevojshme për çdo përmbajtje që ngarkon. Mos gjenero përmbajtje që shkel të drejtat e privatësisë ose të pronësisë intelektuale të të tjerëve. Përdorimi i këtij shërbimi nga ana jote është objekt i Politikës sonë të përdorimit të ndaluar dhe i "Kushteve të shërbimit" të Google.

Fillo të krijosh me integrimet

Shiko bllokun e shënimeve të fillimit të shpejtë të përfaqësimeve numerike për të eksploruar aftësitë e modelit dhe për të mësuar se si të personalizosh dhe të vizualizosh përfaqësimet e tua numerike.

Rasti i përdorimit	Struktura e kërkesës	Struktura e dokumentit
Kërko pyetjen	`task: search result \| query: {content}`	`title: {title} \| text: {content}` Nëse nuk ka titull, përdor `title: none`.
Përgjigjja e pyetjeve	`task: question answering \| query: {content}`	`title: {title} \| text: {content}`
Verifikimi i fakteve	`task: fact checking \| query: {content}`	`title: {title} \| text: {content}`
Marrja e kodit	`task: code retrieval \| query: {content}`	`title: {title} \| text: {content}`