Kuptoni dhe numëroni shenjat

Gemini dhe modele të tjera të IA-së gjeneruese përpunojnë hyrjen dhe daljen në një shkallë të detajuar të quajtur token .

Për modelet Gemini, një token është ekuivalent me rreth 4 karaktere. 100 tokena janë të barabarta me rreth 60-80 fjalë në anglisht.

Rreth tokenëve

Shenjat mund të jenë karaktere të vetme si z ose fjalë të tëra si cat . Fjalët e gjata ndahen në disa shenja. Bashkësia e të gjitha shenjave të përdorura nga modeli quhet fjalor, dhe procesi i ndarjes së tekstit në shenja quhet tokenizim .

Kur faturimi është i aktivizuar, kostoja e një thirrjeje në Gemini API përcaktohet pjesërisht nga numri i tokenëve hyrës dhe dalës, kështu që të dish se si të numërosh tokenët mund të jetë e dobishme.

Mund të provosh numërimin e tokenëve në Colab-in tonë.

Shiko në ai.google.dev Provo një fletore shënimesh Colab Shiko fletoren në GitHub

Numëroni shenjat

Të gjitha të dhënat hyrëse dhe dalëse nga Gemini API janë të tokenizuara, duke përfshirë tekstin, skedarët e imazheve dhe modalitete të tjera jo-tekstuale.

Ju mund të numëroni shenjat në mënyrat e mëposhtme:

  • Thirrni count_tokens me të dhënat hyrëse të kërkesës.
    Kjo kthen numrin total të tokenëve vetëm në të dhënat hyrëse . Mund ta bëni këtë thirrje përpara se të dërgoni të dhënat hyrëse në model për të kontrolluar madhësinë e kërkesave tuaja.

  • Përdorni atributin usage_metadata në objektin response pas thirrjes generate_content .
    Kjo kthen numrin total të tokenëve si në të dhënat hyrëse ashtu edhe në të dhënat dalëse : total_token_count .
    Gjithashtu kthen numërimin e tokenëve të të dhënave hyrëse dhe dalëse veçmas: prompt_token_count (tokenët hyrës) dhe candidates_token_count (tokenët dalës).

    Nëse po përdorni një model të të menduarit , token-et e përdorura gjatë procesit të të menduarit kthehen në thoughts_token_count . Dhe nëse po përdorni ruajtjen në memorje të kontekstit , numri i token-eve të ruajtura në memorje do të jetë në cached_content_token_count .

Numëroni shenjat e tekstit

Nëse e thërrisni count_tokens me një input vetëm tekst, ai kthen numrin e token-ave të tekstit vetëm në input ( total_tokens ). Mund ta bëni këtë thirrje përpara se të thërrisni generate_content për të kontrolluar madhësinë e kërkesave tuaja.

Një tjetër mundësi është thirrja generate_content dhe më pas përdorimi i atributit usage_metadata në objektin response për të marrë sa vijon:

  • Numrat e veçantë të tokenëve të të dhënave hyrëse ( prompt_token_count ), përmbajtjes së ruajtur në memorje ( cached_content_token_count ) dhe të të dhënave dalëse ( candidates_token_count )
  • Numri i tokenëve për procesin e të menduarit ( thoughts_token_count )

  • Numri total i tokenëve si në hyrje ashtu edhe në dalje ( total_token_count )

Python 

from google import genai

client = genai.Client()
prompt = "The quick brown fox jumps over the lazy dog."

total_tokens = client.models.count_tokens(
    model="gemini-3-flash-preview", contents=prompt
)
print("total_tokens: ", total_tokens)

response = client.models.generate_content(
    model="gemini-3-flash-preview", contents=prompt
)

print(response.usage_metadata)

JavaScript 

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

const ai = new GoogleGenAI({});
const prompt = "The quick brown fox jumps over the lazy dog.";

async function main() {
  const countTokensResponse = await ai.models.countTokens({
    model: "gemini-3-flash-preview",
    contents: prompt,
  });
  console.log(countTokensResponse.totalTokens);

  const generateResponse = await ai.models.generateContent({
    model: "gemini-3-flash-preview",
    contents: prompt,
  });
  console.log(generateResponse.usageMetadata);
}

await main();

Shko 

ctx := context.Background()
client, err := genai.NewClient(ctx, nil)

// Convert prompt to a slice of *genai.Content using the helper.
contents := []*genai.Content{
  genai.NewContentFromText(prompt, genai.RoleUser),
}
countResp, err := client.Models.CountTokens(ctx, "gemini-3-flash-preview", contents, nil)
if err != nil {
  return err
}
fmt.Println("total_tokens:", countResp.TotalTokens)

response, err := client.Models.GenerateContent(ctx, "gemini-3-flash-preview", contents, nil)
if err != nil {
  log.Fatal(err)
}
usageMetadata, err := json.MarshalIndent(response.UsageMetadata, "", "  ")
if err != nil {
  log.Fatal(err)
}
fmt.Println(string(usageMetadata))
    ```

Numëroni tokenët me shumë kthesa (bisedë)

Nëse e thërret count_tokens me historikun e bisedës, ajo kthen numrin total të tokenëve të tekstit nga secili rol në bisedë ( total_tokens ).

Një tjetër mundësi është thirrja send_message dhe më pas përdorimi i atributit usage_metadata në objektin response për të marrë sa vijon:

  • Numrat e veçantë të tokenëve të të dhënave hyrëse ( prompt_token_count ), përmbajtjes së ruajtur në memorje ( cached_content_token_count ) dhe të të dhënave dalëse ( candidates_token_count )
  • Numri i tokenëve për procesin e të menduarit ( thoughts_token_count )
  • Numri total i tokenëve si në hyrje ashtu edhe në dalje ( total_token_count )

Për të kuptuar se sa i madh do të jetë kthesa juaj e ardhshme e bisedës, duhet ta shtoni atë në histori kur thirrni count_tokens .

Python 

from google import genai
from google.genai import types

client = genai.Client()

chat = client.chats.create(
    model="gemini-3-flash-preview",
    history=[
        types.Content(
            role="user", parts=[types.Part(text="Hi my name is Bob")]
        ),
        types.Content(role="model", parts=[types.Part(text="Hi Bob!")]),
    ],
)

print(
    client.models.count_tokens(
        model="gemini-3-flash-preview", contents=chat.get_history()
    )
)

response = chat.send_message(
    message="In one sentence, explain how a computer works to a young child."
)
print(response.usage_metadata)

extra = types.UserContent(
    parts=[
        types.Part(
            text="What is the meaning of life?",
        )
    ]
)
history = [*chat.get_history(), extra]
print(client.models.count_tokens(model="gemini-3-flash-preview", contents=history))

JavaScript 

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

const ai = new GoogleGenAI({});

async function main() {
  const history = [
    { role: "user", parts: [{ text: "Hi my name is Bob" }] },
    { role: "model", parts: [{ text: "Hi Bob!" }] },
  ];
  const chat = ai.chats.create({
    model: "gemini-3-flash-preview",
    history: history,
  });

  const countTokensResponse = await ai.models.countTokens({
    model: "gemini-3-flash-preview",
    contents: chat.getHistory(),
  });
  console.log(countTokensResponse.totalTokens);

  const chatResponse = await chat.sendMessage({
    message: "In one sentence, explain how a computer works to a young child.",
  });
  console.log(chatResponse.usageMetadata);

  const extraMessage = {
    role: "user",
    parts: [{ text: "What is the meaning of life?" }],
  };
  const combinedHistory = [...chat.getHistory(), extraMessage];
  const combinedCountTokensResponse = await ai.models.countTokens({
    model: "gemini-3-flash-preview",
    contents: combinedHistory,
  });
  console.log(
    "Combined history token count:",
    combinedCountTokensResponse.totalTokens,
  );
}

await main();

Shko 

ctx := context.Background()
client, err := genai.NewClient(ctx, nil)

history := []*genai.Content{
  {Role: genai.RoleUser, Parts: []*genai.Part({Text: "Hi my name is Bob"})},
  {Role: genai.RoleModel, Parts: []*genai.Part({Text: "Hi Bob!"})},
}
chat, err := client.Chats.Create(ctx, "gemini-3-flash-preview", nil, history)
if err != nil {
  log.Fatal(err)
}

firstTokenResp, err := client.Models.CountTokens(ctx, "gemini-3-flash-preview", chat.History(false), nil)
if err != nil {
  log.Fatal(err)
}
fmt.Println(firstTokenResp.TotalTokens)

resp, err := chat.SendMessage(ctx, genai.NewPartFromText("In one sentence, explain how a computer works to a young child."))
if err != nil {
  log.Fatal(err)
}
fmt.Printf("%#v\n", resp.UsageMetadata)

extra := genai.NewContentFromText("What is the meaning of life?", genai.RoleUser)
hist := chat.History(false)
hist = append(hist, extra)

secondTokenResp, err := client.Models.CountTokens(ctx, "gemini-3-flash-preview", hist, nil)
if err != nil {
  log.Fatal(err)
}
fmt.Println(secondTokenResp.TotalTokens)

Numëroni tokenët multimodalë

Të gjitha të dhënat hyrëse në Gemini API janë të tokenizuara, duke përfshirë tekstin, skedarët e imazheve dhe modalitete të tjera jo-tekstuale. Vini re pikat kryesore të mëposhtme në lidhje me tokenizimin e të dhënave hyrëse multimodale gjatë përpunimit nga Gemini API:

  • Imazhet e futura me të dy dimensionet <=384 piksel llogariten si 258 tokena. Imazhet më të mëdha në njërën ose të dy dimensionet priten dhe shkallëzohen sipas nevojës në pllaka prej 768x768 pikselësh, secila llogaritet si 258 tokena.

  • Skedarët video dhe audio konvertohen në tokena me çmimet fikse të mëposhtme: video me 263 tokena për sekondë dhe audio me 32 tokena për sekondë.

Rezolutat e medias

Modelet Gemini 3 Pro dhe 3 Flash Preview prezantojnë kontroll të detajuar mbi përpunimin e vizionit multimodal me parametrin media_resolution . Parametri media_resolution përcakton numrin maksimal të tokenëve të alokuar për imazh hyrës ose kuadër video. Rezolucionet më të larta përmirësojnë aftësinë e modelit për të lexuar tekst të imët ose për të identifikuar detaje të vogla, por rrisin përdorimin e tokenëve dhe vonesën.

Për më shumë detaje rreth parametrit dhe se si mund të ndikojë në llogaritjet e tokenëve, shihni udhëzuesin e rezolucionit të medias .

Skedarët e imazheve

Nëse e thërrisni count_tokens me një input tekst-dhe-imazh, ai kthen numrin e kombinuar të token-eve të tekstit dhe imazhit vetëm në input ( total_tokens ). Mund ta bëni këtë thirrje përpara se të thërrisni generate_content për të kontrolluar madhësinë e kërkesave tuaja. Gjithashtu, mund të thërrisni opsionalisht count_tokens në tekst dhe skedar veçmas.

Një tjetër mundësi është thirrja generate_content dhe më pas përdorimi i atributit usage_metadata në objektin response për të marrë sa vijon:

  • Numrat e veçantë të tokenëve të të dhënave hyrëse ( prompt_token_count ), përmbajtjes së ruajtur në memorje ( cached_content_token_count ) dhe të të dhënave dalëse ( candidates_token_count )
  • Numri i tokenëve për procesin e të menduarit ( thoughts_token_count )
  • Numri total i tokenëve si në hyrje ashtu edhe në dalje ( total_token_count )

Shembull që përdor një imazh të ngarkuar nga File API:

Python 

from google import genai

client = genai.Client()
prompt = "Tell me about this image"
your_image_file = client.files.upload(file=media / "organ.jpg")

print(
    client.models.count_tokens(
        model="gemini-3-flash-preview", contents=[prompt, your_image_file]
    )
)

response = client.models.generate_content(
    model="gemini-3-flash-preview", contents=[prompt, your_image_file]
)
print(response.usage_metadata)

JavaScript 

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

const ai = new GoogleGenAI({});
const prompt = "Tell me about this image";

async function main() {
  const organ = await ai.files.upload({
    file: path.join(media, "organ.jpg"),
    config: { mimeType: "image/jpeg" },
  });

  const countTokensResponse = await ai.models.countTokens({
    model: "gemini-3-flash-preview",
    contents: createUserContent([
      prompt,
      createPartFromUri(organ.uri, organ.mimeType),
    ]),
  });
  console.log(countTokensResponse.totalTokens);

  const generateResponse = await ai.models.generateContent({
    model: "gemini-3-flash-preview",
    contents: createUserContent([
      prompt,
      createPartFromUri(organ.uri, organ.mimeType),
    ]),
  });
  console.log(generateResponse.usageMetadata);
}

await main();

Shko 

ctx := context.Background()
client, err := genai.NewClient(ctx, nil)

file, err := client.Files.UploadFromPath(
  ctx, 
  filepath.Join(getMedia(), "organ.jpg"), 
  &genai.UploadFileConfig{
    MIMEType : "image/jpeg",
  },
)
if err != nil {
  log.Fatal(err)
}
parts := []*genai.Part{
  genai.NewPartFromText("Tell me about this image"),
  genai.NewPartFromURI(file.URI, file.MIMEType),
}
contents := []*genai.Content{
  genai.NewContentFromParts(parts, genai.RoleUser),
}

tokenResp, err := client.Models.CountTokens(ctx, "gemini-3-flash-preview", contents, nil)
if err != nil {
  log.Fatal(err)
}
fmt.Println("Multimodal image token count:", tokenResp.TotalTokens)

response, err := client.Models.GenerateContent(ctx, "gemini-3-flash-preview", contents, nil)
if err != nil {
  log.Fatal(err)
}
usageMetadata, err := json.MarshalIndent(response.UsageMetadata, "", "  ")
if err != nil {
  log.Fatal(err)
}
fmt.Println(string(usageMetadata))

Shembull që ofron imazhin si të dhëna të brendshme:

Python 

from google import genai
import PIL.Image

client = genai.Client()
prompt = "Tell me about this image"
your_image_file = PIL.Image.open(media / "organ.jpg")

print(
    client.models.count_tokens(
        model="gemini-3-flash-preview", contents=[prompt, your_image_file]
    )
)

response = client.models.generate_content(
    model="gemini-3-flash-preview", contents=[prompt, your_image_file]
)
print(response.usage_metadata)

JavaScript 

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

const ai = new GoogleGenAI({});
const prompt = "Tell me about this image";
const imageBuffer = fs.readFileSync(path.join(media, "organ.jpg"));

const imageBase64 = imageBuffer.toString("base64");

const contents = createUserContent([
  prompt,
  createPartFromBase64(imageBase64, "image/jpeg"),
]);

async function main() {
  const countTokensResponse = await ai.models.countTokens({
    model: "gemini-3-flash-preview",
    contents: contents,
  });
  console.log(countTokensResponse.totalTokens);

  const generateResponse = await ai.models.generateContent({
    model: "gemini-3-flash-preview",
    contents: contents,
  });
  console.log(generateResponse.usageMetadata);
}

await main();

Shko 

ctx := context.Background()
client, err := genai.NewClient(ctx, nil)

imageBytes, err := os.ReadFile("organ.jpg")
if err != nil {
    log.Fatalf("Failed to read image file: %v", err)
}
parts := []*genai.Part{
  genai.NewPartFromText("Tell me about this image"),
  {
        InlineData: &genai.Blob{
              MIMEType: "image/jpeg",
              Data:     imageBytes,
        },
  },
}
contents := []*genai.Content{
  genai.NewContentFromParts(parts, genai.RoleUser),
}

tokenResp, err := client.Models.CountTokens(ctx, "gemini-3-flash-preview", contents, nil)
if err != nil {
  log.Fatal(err)
}
fmt.Println("Multimodal image token count:", tokenResp.TotalTokens)

response, err := client.Models.GenerateContent(ctx, "gemini-3-flash-preview", contents, nil)
if err != nil {
  log.Fatal(err)
}
usageMetadata, err := json.MarshalIndent(response.UsageMetadata, "", "  ")
if err != nil {
  log.Fatal(err)
}
fmt.Println(string(usageMetadata))

Skedarët video ose audio

Audioja dhe videoja konvertohen secila në tokena me çmimet fikse të mëposhtme:

  • Video: 263 tokena për sekondë
  • Audio: 32 tokena për sekondë

Nëse e thërrisni count_tokens me një input tekst-dhe-video/audio, ai kthen numrin e kombinuar të token-eve të tekstit dhe skedarit video/audio vetëm në input ( total_tokens ). Mund ta bëni këtë thirrje përpara se të thërrisni generate_content për të kontrolluar madhësinë e kërkesave tuaja. Gjithashtu, mund të thërrisni opsionalisht count_tokens në tekst dhe skedar veçmas.

Një tjetër mundësi është thirrja generate_content dhe më pas përdorimi i atributit usage_metadata në objektin response për të marrë sa vijon:

  • Numrat e veçantë të tokenëve të të dhënave hyrëse ( prompt_token_count ), përmbajtjes së ruajtur në memorje ( cached_content_token_count ) dhe të të dhënave dalëse ( candidates_token_count )
  • Numri i tokenëve për procesin e të menduarit ( thoughts_token_count )

  • Numri total i tokenëve si në të dhënat hyrëse ashtu edhe në të dhënat dalëse ( total_token_count ).

Python 

from google import genai
import time

client = genai.Client()
prompt = "Tell me about this video"
your_file = client.files.upload(file=media / "Big_Buck_Bunny.mp4")

while not your_file.state or your_file.state.name != "ACTIVE":
    print("Processing video...")
    print("File state:", your_file.state)
    time.sleep(5)
    your_file = client.files.get(name=your_file.name)

print(
    client.models.count_tokens(
        model="gemini-3-flash-preview", contents=[prompt, your_file]
    )
)

response = client.models.generate_content(
    model="gemini-3-flash-preview", contents=[prompt, your_file]
)
print(response.usage_metadata)

JavaScript 

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

const ai = new GoogleGenAI({});
const prompt = "Tell me about this video";

async function main() {
  let videoFile = await ai.files.upload({
    file: path.join(media, "Big_Buck_Bunny.mp4"),
    config: { mimeType: "video/mp4" },
  });

  while (!videoFile.state || videoFile.state.toString() !== "ACTIVE") {
    console.log("Processing video...");
    console.log("File state: ", videoFile.state);
    await sleep(5000);
    videoFile = await ai.files.get({ name: videoFile.name });
  }

  const countTokensResponse = await ai.models.countTokens({
    model: "gemini-3-flash-preview",
    contents: createUserContent([
      prompt,
      createPartFromUri(videoFile.uri, videoFile.mimeType),
    ]),
  });
  console.log(countTokensResponse.totalTokens);

  const generateResponse = await ai.models.generateContent({
    model: "gemini-3-flash-preview",
    contents: createUserContent([
      prompt,
      createPartFromUri(videoFile.uri, videoFile.mimeType),
    ]),
  });
  console.log(generateResponse.usageMetadata);
}

await main();

Shko 

ctx := context.Background()
client, err := genai.NewClient(ctx, nil)

file, err := client.Files.UploadFromPath(
  ctx,
  filepath.Join(getMedia(), "Big_Buck_Bunny.mp4"),
  &genai.UploadFileConfig{
    MIMEType : "video/mp4",
  },
)
if err != nil {
  log.Fatal(err)
}

for file.State == genai.FileStateUnspecified || file.State != genai.FileStateActive {
  fmt.Println("Processing video...")
  fmt.Println("File state:", file.State)
  time.Sleep(5 * time.Second)

  file, err = client.Files.Get(ctx, file.Name, nil)
  if err != nil {
    log.Fatal(err)
  }
}

parts := []*genai.Part{
  genai.NewPartFromText("Tell me about this video"),
  genai.NewPartFromURI(file.URI, file.MIMEType),
}
contents := []*genai.Content{
  genai.NewContentFromParts(parts, genai.RoleUser),
}

tokenResp, err := client.Models.CountTokens(ctx, "gemini-3-flash-preview", contents, nil)
if err != nil {
  log.Fatal(err)
}
fmt.Println("Multimodal video/audio token count:", tokenResp.TotalTokens)
response, err := client.Models.GenerateContent(ctx, "gemini-3-flash-preview", contents, nil)
if err != nil {
  log.Fatal(err)
}
usageMetadata, err := json.MarshalIndent(response.UsageMetadata, "", "  ")
if err != nil {
  log.Fatal(err)
}
fmt.Println(string(usageMetadata))

Dritaret e kontekstit

Modelet e disponueshme përmes Gemini API kanë dritare konteksti që maten në tokena. Dritarja e kontekstit përcakton se sa të dhëna hyrëse mund të jepni dhe sa të dhëna dalëse mund të gjenerojë modeli. Mund të përcaktoni madhësinë e dritares së kontekstit duke thirrur models.get endpoint ose duke parë dokumentacionin e modeleve .

Python 

from google import genai

client = genai.Client()
model_info = client.models.get(model="gemini-3-flash-preview")
print(f"{model_info.input_token_limit=}")
print(f"{model_info.output_token_limit=}")

JavaScript 

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

const ai = new GoogleGenAI({});

async function main() {
  const modelInfo = await ai.models.get({model: 'gemini-3-flash-preview'});
  console.log(modelInfo.inputTokenLimit);
  console.log(modelInfo.outputTokenLimit);
}

await main();

Shko 

ctx := context.Background()
client, err := genai.NewClient(ctx, nil)
if err != nil {
  log.Fatal(err)
}
modelInfo, err := client.ModelInfo(ctx, "models/gemini-3-flash-preview")
if err != nil {
  log.Fatal(err)
}
fmt.Println("input token limit:", modelInfo.InputTokenLimit)
fmt.Println("output token limit:", modelInfo.OutputTokenLimit)