Kuptimi i videos

Për të mësuar rreth gjenerimit të videove, shihni udhëzuesin Gemini Omni Flash .

Modelet Gemini mund të përpunojnë video, duke mundësuar shumë raste përdorimi të zhvilluesve të nivelit të lartë që historikisht do të kishin kërkuar modele specifike për domenin. Disa nga aftësitë e vizionit të Gemini përfshijnë aftësinë për të: përshkruar, segmentuar dhe nxjerrë informacion nga videot, për t'iu përgjigjur pyetjeve në lidhje me përmbajtjen e videos dhe për t'iu referuar afateve kohore specifike brenda një videoje.

Ju mund të ofroni video si të dhëna për Binjakët në mënyrat e mëposhtme:

Metoda e hyrjes Madhësia maksimale Rast përdorimi i rekomanduar
API-ja e skedarëve 20GB (me pagesë) / 2GB (falas) Skedarë të mëdhenj (100MB+), video të gjata (10min+), skedarë të ripërdorshëm.
Regjistrimi i ruajtjes në renë kompjuterike 2 GB (për skedar, pa kufizime ruajtjeje) Skedarë të mëdhenj (100MB+), video të gjata (10min+), skedarë të përhershëm, të ripërdorshëm.
Të dhëna të integruara < 100MB Skedarë të vegjël (<100MB), kohëzgjatje e shkurtër (<1min), hyrje të vetme.
URL-të e YouTube-it N/A Video publike në YouTube.

Shënim: API-ja e skedarëve rekomandohet për shumicën e rasteve të përdorimit, veçanërisht për skedarët më të mëdhenj se 100 MB ose kur dëshironi ta ripërdorni skedarin në kërkesa të shumëfishta.

Për të mësuar rreth metodave të tjera të futjes së skedarëve, siç është përdorimi i URL-ve të jashtme ose skedarëve të ruajtur në Google Cloud, shihni udhëzuesin e metodave të futjes së skedarëve .

Ngarko një skedar videoje

Kodi i mëposhtëm shkarkon një video shembull, e ngarkon atë duke përdorur API-n e Skedarëve , pret që të përpunohet dhe më pas përdor referencën e skedarit të ngarkuar për të përmbledhur videon.

Python 

from google import genai
import time

client = genai.Client()

myfile = client.files.upload(file="path/to/sample.mp4")

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

interaction = client.interactions.create(
    model="gemini-3.8-flash",
    input=[
        {"type": "video", "uri": myfile.uri, "mime_type": myfile.mime_type},
        {"type": "text", "text": "Summarize this video. Then create a quiz with an answer key based on the information in this video."}
    ]
)

print(interaction.output_text)

JavaScript 

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

const ai = new GoogleGenAI({});

async function main() {
  const myfile = await ai.files.upload({
    file: "path/to/sample.mp4",
    config: { mimeType: "video/mp4" },
  });

  let getFile = await ai.files.get({ name: myfile.name });
  while (getFile.state === 'PROCESSING') {
      getFile = await ai.files.get({ name: myfile.name });
      console.log(`current file status: ${getFile.state}`);
      console.log('File is still processing, retrying in 5 seconds');

      await new Promise((resolve) => {
          setTimeout(resolve, 5000);
      });
  }
  if (getFile.state === 'FAILED') {
      throw new Error('File processing failed.');
  }

  const interaction = await ai.interactions.create({
    model: "gemini-3.8-flash",
    input: [
      { type: "video", uri: myfile.uri, mime_type: myfile.mimeType },
      { type: "text", text: "Summarize this video. Then create a quiz with an answer key based on the information in this video." }
    ],
  });
  console.log(interaction.output_text);
}

await main();

Java 

import com.google.genai.Client;
import com.google.genai.gaos.models.interactions.Content;
import com.google.genai.gaos.models.interactions.CreateModelInteraction;
import com.google.genai.gaos.models.interactions.Interaction;
import com.google.genai.gaos.models.interactions.InteractionsInput;
import com.google.genai.gaos.models.interactions.Model;
import com.google.genai.gaos.models.interactions.TextContent;
import com.google.genai.gaos.models.interactions.VideoContent;
import com.google.genai.gaos.models.interactions.VideoContentMimeType;
import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
import com.google.genai.types.File;
import com.google.genai.types.FileState;
import com.google.genai.types.UploadFileConfig;
import java.util.Arrays;
import java.util.List;

Client client = new Client();

File myfile =
    client.files.upload(
        "path/to/sample.mp4", UploadFileConfig.builder().mimeType("video/mp4").build());

while (!myfile.state().isPresent()
    || myfile.state().get().knownEnum() != FileState.Known.ACTIVE) {
  System.out.println("Processing video...");
  Thread.sleep(5000);
  myfile = client.files.get(myfile.name().get(), null);
}

Content videoContent =
    VideoContent.builder()
        .uri(myfile.uri().get())
        .mimeType(VideoContentMimeType.of(myfile.mimeType().get()))
        .build();
Content textContent =
    TextContent.builder()
        .text(
            "Summarize this video. Then create a quiz with an answer key based on the information in this video.")
        .build();

List<Content> contents = Arrays.asList(videoContent, textContent);

CreateModelInteraction params =
    CreateModelInteraction.builder()
        .model(Model.of("gemini-3.8-flash"))
        .input(InteractionsInput.ofContent(contents))
        .build();

Interaction interaction =
    client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();

System.out.println(interaction.outputText().orElse(""));

Shko 

package main

import (
    "context"
    "fmt"
    "log"
    "time"

    "google.golang.org/genai"
    "google.golang.org/genai/interactions/models/interactions"
    "google.golang.org/genai/interactions/models/operations"
)

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

    myfile, err := client.Files.UploadFromPath(ctx, "path/to/sample.mp4", &genai.UploadFileConfig{
        MIMEType: "video/mp4",
    })
    if err != nil {
        log.Fatal(err)
    }

    for myfile.State != genai.FileStateActive {
        fmt.Println("Processing video...")
        time.Sleep(5 * time.Second)
        myfile, err = client.Files.Get(ctx, myfile.Name, nil)
        if err != nil {
            log.Fatal(err)
        }
    }

    contents := []interactions.Content{
        interactions.NewContent(interactions.VideoContent{
            URI:      genai.Ptr(myfile.URI),
            MimeType: interactions.VideoContentMimeType(myfile.MIMEType).ToPointer(),
        }),
        interactions.NewContent(interactions.TextContent{
            Text: "Summarize this video. Then create a quiz with an answer key based on the information in this video.",
        }),
    }

    res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
        Body: operations.NewCreateInteractionRequestBody(interactions.CreateModelInteraction{
            Model: interactions.Model("gemini-3.8-flash"),
            Input: interactions.NewInteractionsInput(contents),
        }),
    })
    if err != nil {
        log.Fatal(err)
    }

    if res.Interaction.OutputText != nil {
        fmt.Println(*res.Interaction.OutputText)
    }
}

PUSHTIM 

VIDEO_PATH="path/to/sample.mp4"
MIME_TYPE=$(file -b --mime-type "${VIDEO_PATH}")
NUM_BYTES=$(wc -c < "${VIDEO_PATH}")
DISPLAY_NAME=VIDEO

tmp_header_file=upload-header.tmp

echo "Starting file upload..."
curl "https://generativelanguage.googleapis.com/upload/v1beta/files" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -D ${tmp_header_file} \
  -H "X-Goog-Upload-Protocol: resumable" \
  -H "X-Goog-Upload-Command: start" \
  -H "X-Goog-Upload-Header-Content-Length: ${NUM_BYTES}" \
  -H "X-Goog-Upload-Header-Content-Type: ${MIME_TYPE}" \
  -H "Content-Type: application/json" \
  -d "{'file': {'display_name': '${DISPLAY_NAME}'}}" 2> /dev/null

upload_url=$(grep -i "x-goog-upload-url: " "${tmp_header_file}" | cut -d" " -f2 | tr -d "\r")
rm "${tmp_header_file}"

echo "Uploading video data..."
curl "${upload_url}" \
  -H "Content-Length: ${NUM_BYTES}" \
  -H "X-Goog-Upload-Offset: 0" \
  -H "X-Goog-Upload-Command: upload, finalize" \
  --data-binary "@${VIDEO_PATH}" 2> /dev/null > file_info.json

file_uri=$(jq -r ".file.uri" file_info.json)
file_name=$(jq -r ".file.name" file_info.json)
echo file_uri=$file_uri

echo "File uploaded successfully. File URI: ${file_uri}"

# Polling loop
echo "Waiting for file to be processed..."
while true; do
  curl -s "https://generativelanguage.googleapis.com/v1beta/${file_name}" \
    -H "x-goog-api-key: $GEMINI_API_KEY" > file_status.json
  state=$(jq -r ".state" file_status.json)
  echo "Current state: $state"
  if [ "$state" == "ACTIVE" ]; then
    break
  elif [ "$state" == "FAILED" ]; then
    echo "File processing failed."
    exit 1
  fi
  sleep 5
done

echo "Generating content from video..."
curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
    -H "x-goog-api-key: $GEMINI_API_KEY" \
    -H 'Content-Type: application/json' \
    -d '{
      "model": "gemini-3.8-flash",
      "input": [
        {"type": "video", "uri": "'${file_uri}'", "mime_type": "'${MIME_TYPE}'"},
        {"type": "text", "text": "Summarize this video. Then create a quiz with an answer key based on the information in this video."}
      ]
    }' 2> /dev/null > response.json

jq ".steps[].content[0].text" response.json

Për të optimizuar efikasitetin dhe performancën e tokenëve, merrni në konsideratë përdorimin e përpunimit të videos Agentic .

Përdorni gjithmonë API-në e Skedarëve kur madhësia totale e kërkesës (duke përfshirë skedarin, kërkesën me tekst, udhëzimet e sistemit, etj.) është më e madhe se 20 MB, kohëzgjatja e videos është e konsiderueshme ose nëse keni ndërmend të përdorni të njëjtën video në kërkesa të shumta. API-ja e Skedarëve pranon drejtpërdrejt formatet e skedarëve video.

Për të mësuar më shumë rreth punës me skedarët mediatikë, shihni API-n e Skedarëve .

Kaloni të dhënat e videos në linjë

Në vend që të ngarkoni një skedar video duke përdorur File API, mund të kaloni video më të vogla direkt në kërkesë. Kjo është e përshtatshme për video më të shkurtra me madhësi totale kërkese nën 20MB.

Ja një shembull i ofrimit të të dhënave video të integruara:

Python 

from google import genai
import base64

video_file_name = "/path/to/your/video.mp4"
video_bytes = open(video_file_name, 'rb').read()

client = genai.Client()
interaction = client.interactions.create(
    model='gemini-3.8-flash',
    input=[
        {"type": "text", "text": "Please summarize the video in 3 sentences."},
        {
            "type": "video",
            "data": base64.b64encode(video_bytes).decode('utf-8'),
            "mime_type": "video/mp4"
        }
    ]
)
print(interaction.output_text)

JavaScript 

import { GoogleGenAI } from "@google/genai";
import * as fs from "node:fs";

const ai = new GoogleGenAI({});
const base64VideoFile = fs.readFileSync("path/to/small-sample.mp4", {
  encoding: "base64",
});

const interaction = await ai.interactions.create({
  model: "gemini-3.8-flash",
  input: [
    { type: "text", text: "Please summarize the video in 3 sentences." },
    {
      type: "video",
      data: base64VideoFile,
      mime_type: "video/mp4",
    }
  ],
});
console.log(interaction.output_text);

Java 

import com.google.genai.Client;
import com.google.genai.gaos.models.interactions.Content;
import com.google.genai.gaos.models.interactions.CreateModelInteraction;
import com.google.genai.gaos.models.interactions.Interaction;
import com.google.genai.gaos.models.interactions.InteractionsInput;
import com.google.genai.gaos.models.interactions.Model;
import com.google.genai.gaos.models.interactions.TextContent;
import com.google.genai.gaos.models.interactions.VideoContent;
import com.google.genai.gaos.models.interactions.VideoContentMimeType;
import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.Base64;
import java.util.List;

String videoFileName = "/path/to/your/video.mp4";
byte[] videoBytes = Files.readAllBytes(Paths.get(videoFileName));
String base64Video = Base64.getEncoder().encodeToString(videoBytes);

Client client = new Client();

Content textContent =
    TextContent.builder().text("Please summarize the video in 3 sentences.").build();
Content videoContent =
    VideoContent.builder()
        .data(base64Video)
        .mimeType(VideoContentMimeType.VIDEO_MP4)
        .build();

List<Content> contents = Arrays.asList(textContent, videoContent);

CreateModelInteraction params =
    CreateModelInteraction.builder()
        .model(Model.of("gemini-3.8-flash"))
        .input(InteractionsInput.ofContent(contents))
        .build();

Interaction interaction =
    client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();

System.out.println(interaction.outputText().orElse(""));

Shko 

package main

import (
    "context"
    "encoding/base64"
    "fmt"
    "log"
    "os"

    "google.golang.org/genai"
    "google.golang.org/genai/interactions/models/interactions"
    "google.golang.org/genai/interactions/models/operations"
)

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

    videoFileName := "/path/to/your/video.mp4"
    videoBytes, err := os.ReadFile(videoFileName)
    if err != nil {
        log.Fatal(err)
    }
    base64Video := base64.StdEncoding.EncodeToString(videoBytes)

    contents := []interactions.Content{
        interactions.NewContent(interactions.TextContent{
            Text: "Please summarize the video in 3 sentences.",
        }),
        interactions.NewContent(interactions.VideoContent{
            Data:     genai.Ptr(base64Video),
            MimeType: interactions.VideoContentMimeTypeVideoMp4.ToPointer(),
        }),
    }

    res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
        Body: operations.NewCreateInteractionRequestBody(interactions.CreateModelInteraction{
            Model: interactions.Model("gemini-3.8-flash"),
            Input: interactions.NewInteractionsInput(contents),
        }),
    })
    if err != nil {
        log.Fatal(err)
    }

    if res.Interaction.OutputText != nil {
        fmt.Println(*res.Interaction.OutputText)
    }
}

PUSHTIM

VIDEO_PATH=/path/to/your/video.mp4

if [[ "$(base64 --version 2>&1)" = *"FreeBSD"* ]]; then
  B64FLAGS="--input"
else
  B64FLAGS="-w0"
fi

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
    -H "x-goog-api-key: $GEMINI_API_KEY" \
    -H 'Content-Type: application/json' \
    -d '{
      "model": "gemini-3.8-flash",
      "input": [
        {"type": "text", "text": "Please summarize the video in 3 sentences."},
        {
          "type": "video",
          "data": "'$(base64 $B64FLAGS $VIDEO_PATH)'",
          "mime_type": "video/mp4"
        }
      ]
    }' 2> /dev/null

URL-të e YouTube-it të kalimit

Ju mund t'i kaloni URL-të e YouTube direkt te Gemini API si pjesë e kërkesës suaj si më poshtë:

Python 

from google import genai

client = genai.Client()
interaction = client.interactions.create(
    model='gemini-3.8-flash',
    input=[
        {"type": "text", "text": "Please summarize the video in 3 sentences."},
        {
            "type": "video",
            "uri": "https://www.youtube.com/watch?v=9hE5-98ZeCg"
        }
    ]
)
print(interaction.output_text)

JavaScript 

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

const ai = new GoogleGenAI({});

const interaction = await ai.interactions.create({
  model: "gemini-3.8-flash",
  input: [
    { type: "text", text: "Please summarize the video in 3 sentences." },
    {
      type: "video",
      uri: "https://www.youtube.com/watch?v=9hE5-98ZeCg",
    }
  ],
});
console.log(interaction.output_text);

Java 

import com.google.genai.Client;
import com.google.genai.gaos.models.interactions.Content;
import com.google.genai.gaos.models.interactions.CreateModelInteraction;
import com.google.genai.gaos.models.interactions.Interaction;
import com.google.genai.gaos.models.interactions.InteractionsInput;
import com.google.genai.gaos.models.interactions.Model;
import com.google.genai.gaos.models.interactions.TextContent;
import com.google.genai.gaos.models.interactions.VideoContent;
import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
import java.util.Arrays;
import java.util.List;

Client client = new Client();

Content textContent =
    TextContent.builder().text("Please summarize the video in 3 sentences.").build();
Content videoContent =
    VideoContent.builder()
        .uri("https://www.youtube.com/watch?v=9hE5-98ZeCg")
        .build();

List<Content> contents = Arrays.asList(textContent, videoContent);

CreateModelInteraction params =
    CreateModelInteraction.builder()
        .model(Model.of("gemini-3.8-flash"))
        .input(InteractionsInput.ofContent(contents))
        .build();

Interaction interaction =
    client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();

System.out.println(interaction.outputText().orElse(""));

Shko 

package main

import (
    "context"
    "fmt"
    "log"

    "google.golang.org/genai"
    "google.golang.org/genai/interactions/models/interactions"
    "google.golang.org/genai/interactions/models/operations"
)

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

    contents := []interactions.Content{
        interactions.NewContent(interactions.TextContent{
            Text: "Please summarize the video in 3 sentences.",
        }),
        interactions.NewContent(interactions.VideoContent{
            URI: genai.Ptr("https://www.youtube.com/watch?v=9hE5-98ZeCg"),
        }),
    }

    res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
        Body: operations.NewCreateInteractionRequestBody(interactions.CreateModelInteraction{
            Model: interactions.Model("gemini-3.8-flash"),
            Input: interactions.NewInteractionsInput(contents),
        }),
    })
    if err != nil {
        log.Fatal(err)
    }

    if res.Interaction.OutputText != nil {
        fmt.Println(*res.Interaction.OutputText)
    }
}

PUSHTIM 

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
    -H "x-goog-api-key: $GEMINI_API_KEY" \
    -H 'Content-Type: application/json' \
    -d '{
      "model": "gemini-3.8-flash",
      "input": [
        {"type": "text", "text": "Please summarize the video in 3 sentences."},
        {
          "type": "video",
          "uri": "https://www.youtube.com/watch?v=9hE5-98ZeCg"
        }
      ]
    }' 2> /dev/null

Kufizime:

  • Për nivelin falas, nuk mund të ngarkoni më shumë se 8 orë video në YouTube në ditë.
  • Për nivelin me pagesë, nuk ka kufij bazuar në gjatësinë e videos.
  • Për modelet para Gemini 2.5, mund të ngarkoni vetëm 1 video për kërkesë. Për modelet Gemini 2.5 dhe më të reja, mund të ngarkoni maksimumi 10 video për kërkesë.
  • Mund të ngarkoni vetëm video publike (jo video private ose të palistuara).

Kuptimi i videos së agjentit

Si parazgjedhje, hyrjet e videos përdorin përpunim statik (nxjerrjen e kuadrove me 1 FPS). Modelet Gemini 3.8 Flash, 3.7 Flash, 3.6 Flash dhe 3.5 Flash Lite mbështesin gjithashtu kuptimin e videos agjentike , ku modeli eksploron dinamikisht vijën kohore të videos, duke inspektuar në mënyrë selektive transkriptet dhe duke rregulluar në mënyrë adaptive shpejtësinë e kuadrove dhe rezolucionin në lëvizje bazuar në kërkesën.

Modaliteti Përshkrimi Modelet e mbështetura
Statik (parazgjedhur) Nxjerr kuadro me një shpejtësi fikse (1 FPS) dhe i vendos ato në kontekst me një kalim të vetëm. Funksionon mirë për klipe të shkurtra. Të gjitha modelet Gemini
Agjent Modeli lundron në mënyrë dinamike në vijën kohore të videos, duke ngarkuar vetëm përmbajtjen që i nevojitet bazuar në njoftim. Deri në 88% më efikase me tokenët dhe ~7% cilësi më e lartë në përmbajtjen e gjatë. Blic Gemini 3.8, Blic 3.7, Blic 3.6, Blic 3.5 Lite

Zgjidhni një modalitet përpunimi

Si udhëzues i përgjithshëm, filloni me modalitetin agjent , veçanërisht kur optimizoni për cilësinë e përgjigjes ose efikasitetin e token-ave.

  • Agjent: Video ose pyetje të gjata që synojnë momente specifike. Modeli lundron në mënyrë dinamike në vijën kohore për të synuar informacione të rëndësishme kontekstuale pa mbushur dritaren e kontekstit.
  • Statik: Pyetje të ndjeshme ndaj vonesës në klipe të shkurtra (nën 5 minuta), ose raste kur nevojitet precizion në nivel kuadri në të gjithë klipin.

Shënim: Për video të gjata ose kërkesa komplekse ku përpunimi agjentik kërkon më shumë kohë, përdorni transmetimin ( stream=True ) ose ekzekutimin në sfond ( background=True ). Kjo e mban lidhjen aktive, nxjerr në pah hapat e ndërmjetëm të arsyetimit dhe shmang skadimin e kohës së lidhjes ose të vërtetimit.

Vendosni modalitetin e përpunimit

Python 

import time
from google import genai

client = genai.Client()

# Upload a long video
video_file = client.files.upload(file="path/to/lecture.mp4")

while video_file.state.name == "PROCESSING":
    time.sleep(2)
    video_file = client.files.get(name=video_file.name)

# Use agentic processing
interaction = client.interactions.create(
    model="gemini-3.8-flash",
    input=[
        {
            "type": "video",
            "uri": video_file.uri,
            "mime_type": video_file.mime_type,
            "processing": "agentic"
        },
        {"type": "text", "text": "What are the three main arguments presented?"}
    ]
)
print(interaction.output_text)

JavaScript 

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

const ai = new GoogleGenAI({});

// Upload a long video
let videoFile = await ai.files.upload({
  file: "path/to/lecture.mp4",
  config: { mimeType: "video/mp4" }
});

while (videoFile.state === "PROCESSING") {
  await new Promise((resolve) => setTimeout(resolve, 2000));
  videoFile = await ai.files.get({ name: videoFile.name });
}

// Use agentic processing
const interaction = await ai.interactions.create({
  model: "gemini-3.8-flash",
  input: [
    {
      type: "video",
      uri: videoFile.uri,
      mime_type: videoFile.mimeType,
      processing: "agentic"
    },
    { type: "text", text: "What are the three main arguments presented?" }
  ]
});
console.log(interaction.output_text);

PUSHTIM 

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "gemini-3.8-flash",
    "input": [
      {
        "type": "video",
        "uri": "'${file_uri}'",
        "mime_type": "video/mp4",
        "processing": "agentic"
      },
      {"type": "text", "text": "What are the three main arguments presented?"}
    ]
  }' 2> /dev/null

Shënim: Për të verifikuar nëse është përdorur përpunimi agjent, inspektoni interaction.steps . Prania e processing_call dhe processing_result tregon që modeli ka lundruar në video në mënyrë dinamike.

Hapat e reagimit

Përpunimi agjentik shton dy lloje të reja hapash në vargun e steps :

  • processing_call : modeli kërkoi një segment video ose transkript audio, i identifikuar nga id .
  • processing_result : rezultati i asaj ngarkese, i lidhur nga call_id .

Këto shfaqen të ndërthurura me hapat thought (kur përmbledhjet janë të aktivizuara) dhe i paraprijnë hapit përfundimtar model_output . Ato mund të përdoren për të treguar një gjurmë progresi në ndërfaqen tuaj të përdoruesit, por nuk kërkojnë një përgjigje.

Shembulli i mëposhtëm tregon ngarkesën e përgjigjes me hapa përpunimi të ndërthurur: 

{
  "steps": [
    {
      "type": "thought",
      "signature": "sig_thought_1",
      "summary": [
        {
          "type": "text",
          "text": "Inspecting transcript for key discussion topics..."
        }
      ]
    },
    {
      "type": "processing_call",
      "id": "call_01",
      "signature": "sig_call_01"
    },
    {
      "type": "processing_result",
      "call_id": "call_01",
      "signature": "sig_result_01"
    },
    {
      "type": "thought",
      "signature": "sig_thought_2",
      "summary": [
        {
          "type": "text",
          "text": "Loading visual frames to verify slide content..."
        }
      ]
    },
    {
      "type": "processing_call",
      "id": "call_02",
      "signature": "sig_call_02"
    },
    {
      "type": "processing_result",
      "call_id": "call_02",
      "signature": "sig_result_02"
    },
    {
      "type": "thought",
      "signature": "sig_thought_3",
      "summary": [
        {
          "type": "text",
          "text": "Synthesizing answer from gathered evidence..."
        }
      ]
    },
    {
      "type": "model_output",
      "content": [
        {
          "type": "text",
          "text": "The three main arguments presented in the lecture are..."
        }
      ]
    }
  ]
}

Kombinoni mënyrat e përpunimit në të gjitha videot

Mund të caktoni mënyra të ndryshme përpunimi për secilën video në të njëjtën kërkesë:

Python 

from google import genai

client = genai.Client()

lecture = client.files.upload(file="path/to/long-lecture.mp4")
experiment = client.files.upload(file="path/to/short-experiment.mp4")

interaction = client.interactions.create(
    model="gemini-3.8-flash",
    input=[
        {
            "type": "video",
            "uri": lecture.uri,
            "mime_type": lecture.mime_type,
            "processing": "agentic"  # Use agentic video understanding
        },
        {
            "type": "video",
            "uri": experiment.uri,
            "mime_type": experiment.mime_type,
            "processing": "static"  # Use static processing
        },
        {"type": "text", "text": "Compare the lecture content with the experiment results."}
    ]
)
print(interaction.output_text)

JavaScript 

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

const ai = new GoogleGenAI({});

const lecture = await ai.files.upload({
  file: "path/to/long-lecture.mp4",
  config: { mimeType: "video/mp4" }
});
const experiment = await ai.files.upload({
  file: "path/to/short-experiment.mp4",
  config: { mimeType: "video/mp4" }
});

const interaction = await ai.interactions.create({
  model: "gemini-3.8-flash",
  input: [
    {
      type: "video",
      uri: lecture.uri,
      mime_type: lecture.mimeType,
      processing: "agentic" // Use agentic video understanding
    },
    {
      type: "video",
      uri: experiment.uri,
      mime_type: experiment.mimeType,
      processing: "static" // Use static processing
    },
    { type: "text", text: "Compare the lecture content with the experiment results." }
  ]
});
console.log(interaction.output_text);

PUSHTIM 

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "gemini-3.8-flash",
    "input": [
      {
        "type": "video",
        "uri": "'${lecture_uri}'",
        "mime_type": "video/mp4",
        "processing": "agentic"
      },
      {
        "type": "video",
        "uri": "'${experiment_uri}'",
        "mime_type": "video/mp4",
        "processing": "static"
      },
      {"type": "text", "text": "Compare the lecture content with the experiment results."}
    ]
  }' 2> /dev/null

Biseda video me shumë kthesa

Konteksti i videos ruhet në të gjitha kthesat e një bisede. Kur përdorni përpunimin agjent:

  • Modaliteti i gjendjes (duke përdorur previous_interaction_id ): Serveri ruan kontekstin e videos. Nuk nevojitet asnjë trajtim shtesë.
  • Modaliteti pa gjendje (duke përdorur step_list ): Në modalitetin pa gjendje, përgjigjja përfshin hapat processing_call dhe processing_result që kodojnë kontekstin e videos. Ju duhet të përfshini të gjithë hapat nga përgjigjja në step_list të kërkesës suaj të ardhshme për të ruajtur kontekstin e videos. Ndërsa heqja e tyre aktualisht nuk kthen një gabim API, konteksti i videos humbet, duke ulur ndjeshëm cilësinë e përgjigjes në pyetjet pasuese. Vini re se hapat e kthyer të dërguar në kërkesat pasuese kontribuojnë në numërimin e tokenëve të hyrjes.

Referojuni vulave kohore në përmbajtje

Mund të bësh pyetje në lidhje me pika specifike kohore brenda videos duke përdorur vula kohore të formës MM:SS .

Python 

prompt = "What are the examples given at 00:05 and 00:10 supposed to show us?"

JavaScript 

const prompt = "What are the examples given at 00:05 and 00:10 supposed to show us?";

Java 

String prompt = "What are the examples given at 00:05 and 00:10 supposed to show us?";

Shko 

prompt := "What are the examples given at 00:05 and 00:10 supposed to show us?"

PUSHTIM 

PROMPT="What are the examples given at 00:05 and 00:10 supposed to show us?"

Nxirrni të dhëna të hollësishme nga videoja

Modelet Gemini ofrojnë aftësi të fuqishme për të kuptuar përmbajtjen e videos duke përpunuar informacion si nga transmetimet audio ashtu edhe nga ato vizuale . Kjo ju lejon të nxirrni një sërë të pasur detajesh, duke përfshirë gjenerimin e përshkrimeve të asaj që po ndodh në një video dhe përgjigjen e pyetjeve rreth përmbajtjes së saj.

Për përshkrimet vizuale, modeli merr mostra nga videoja me një shpejtësi prej 1 kuadri për sekondë (FPS). Kjo shpejtësi e parazgjedhur e marrjes së mostrave funksionon mirë për shumicën e përmbajtjes, por vini re se mund të humbasë detajet në videot me lëvizje të shpejtë ose ndryshime të shpejta të skenave.

Python 

prompt = "Describe the key events in this video, providing both audio and visual details. Include timestamps for salient moments."

JavaScript 

const prompt = "Describe the key events in this video, providing both audio and visual details. Include timestamps for salient moments.";

Java 

String prompt =
    "Describe the key events in this video, providing both audio and visual details. Include timestamps for salient moments.";

Shko 

prompt := "Describe the key events in this video, providing both audio and visual details. Include timestamps for salient moments."

PUSHTIM 

PROMPT="Describe the key events in this video, providing both audio and visual details. Include timestamps for salient moments."

Personalizo përpunimin e videos

Mund ta personalizoni përpunimin e videos në Gemini API duke vendosur intervale prerjeje ose duke ofruar mostrim të personalizuar të shpejtësisë së kuadrove. Këto opsione personalizimi mbështeten vetëm kur videoja përpunohet në modalitetin "static" .

Cakto intervalet e prerjes

Mund të presësh video duke specifikuar start_offset dhe end_offset në objektin e konfigurimit processing .

Python 

interaction = client.interactions.create(
    model="gemini-3.8-flash",
    input=[
        {
            "type": "video",
            "uri": video_file.uri,
            "mime_type": video_file.mime_type,
            "processing": {
                "type": "static",
                "start_offset": 1200,
                "end_offset": 1500,
            },
        },
        {"type": "text", "text": "Summarize this section of the video."},
    ],
)
print(interaction.output_text)

JavaScript 

const interaction = await ai.interactions.create({
  model: "gemini-3.8-flash",
  input: [
    {
      type: "video",
      uri: videoFile.uri,
      mime_type: videoFile.mimeType,
      processing: {
        type: "static",
        start_offset: 1200,
        end_offset: 1500,
      },
    },
    { type: "text", text: "Summarize this section of the video." },
  ],
});
console.log(interaction.output_text);

PUSHTIM 

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "gemini-3.8-flash",
    "input": [
      {
        "type": "video",
        "uri": "'${file_uri}'",
        "mime_type": "video/mp4",
        "processing": {
          "type": "static",
          "start_offset": 1200,
          "end_offset": 1500
        }
      },
      {"type": "text", "text": "Summarize this section of the video."}
    ]
  }' 2> /dev/null

Cakto një shpejtësi kuadrosh të personalizuar

Mund të caktoni marrjen e mostrave të shpejtësisë së kuadrove me porosi duke kaluar një argument fps në objektin e konfigurimit të processing .

Python 

interaction = client.interactions.create(
    model="gemini-3.8-flash",
    input=[
        {
            "type": "video",
            "uri": video_file.uri,
            "mime_type": video_file.mime_type,
            "processing": {
                "type": "static",
                "fps": 0.5,  # Sample 1 frame every 2 seconds
            },
        },
        {"type": "text", "text": "Describe the scene changes in this video."},
    ],
)
print(interaction.output_text)

JavaScript 

const interaction = await ai.interactions.create({
  model: "gemini-3.8-flash",
  input: [
    {
      type: "video",
      uri: videoFile.uri,
      mime_type: videoFile.mimeType,
      processing: {
        type: "static",
        fps: 0.5, // Sample 1 frame every 2 seconds
      },
    },
    { type: "text", text: "Describe the scene changes in this video." },
  ],
});
console.log(interaction.output_text);

PUSHTIM 

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "gemini-3.8-flash",
    "input": [
      {
        "type": "video",
        "uri": "'${file_uri}'",
        "mime_type": "video/mp4",
        "processing": {
          "type": "static",
          "fps": 0.5
        }
      },
      {"type": "text", "text": "Describe the scene changes in this video."}
    ]
  }' 2> /dev/null

Formatet e videos të mbështetura

Gemini mbështet llojet e mëposhtme të formateve MIME të videos:

  • video/mp4
  • video/mpeg
  • video/mov
  • video/avi
  • video/x-flv
  • video/mpg
  • video/webm
  • video/wmv
  • video/3gpp

Detajet teknike rreth videove

  • Modelet dhe konteksti i mbështetur : Të gjitha modelet Gemini mund të përpunojnë të dhëna video.
    • Modelet me një dritare konteksti 1M mund të përpunojnë video deri në 3 orë të gjata si parazgjedhje (në rezolucion të ulët të medias) ose deri në 1 orë të gjata në rezolucion të lartë të medias.
  • Modalitetet e përpunimit : Gemini 3.8 Flash, 3.7 Flash, 3.6 Flash, 3.5 Flash Lite dhe modelet e mëvonshme mbështesin dy modalitete të përpunimit të videos:
    • Statik : Kuadrot nxirren me 1 FPS dhe vendosen në kontekst (parazgjedhur për të gjitha modelet). Audio përpunohet me 1Kbps (një kanal i vetëm). Vulat kohore shtohen çdo sekondë. Më e mira për klipe të shkurtra ose kur çdo kuadër ka rëndësi (siç është inspektimi kuadër pas kuadri). Vini re se sekuencat e veprimit të shpejtë mund të humbasin detaje për shkak të shkallës së marrjes së mostrave prej 1 FPS.
    • Agentic : Modeli navigon në mënyrë dinamike videon, duke ngarkuar transkriptin dhe/ose kuadro dhe/ose audio sipas kërkesës. Kjo përdor deri në 88% më pak tokena për përmbajtje të gjatë, megjithëse navigimi mund të rrisë pak Kohën deri te Tokeni i Parë (TTFT) në klipe të shkurtra (<5 minuta) për shkak të arsyetimit të brendshëm dhe udhëtimeve vajtje-ardhje të mjetit para se të fillojë gjenerimi. Më e mira për videot e gjata për të optimizuar kostot e tokenave dhe cilësinë e përgjigjes. Mbështetet në Gemini 3.8 Flash, 3.7 Flash, 3.6 Flash dhe 3.5 Flash Lite. Shihni Kuptimi i videos Agentic për detaje.
  • Llogaritja e tokenëve (modaliteti statik) : Çdo sekondë e videos tokenizohet si më poshtë:
    • Korniza individuale (të marra si mostër në 1 FPS):
      • Nëse media_resolution është vendosur në të ulët, kornizat tokenizohen me 66 tokena për kornizë.
      • Përndryshe, kornizat tokenizohen me 258 tokena për kornizë.
    • Audio: 32 tokena për sekondë.
    • Metadatat janë gjithashtu të përfshira.
    • Totali: Përafërsisht 100 tokenë për sekondë video me rezolucion të parazgjedhur (të ulët) të medias, ose afërsisht 300 tokenë për sekondë video me rezolucion të lartë të medias.
  • Llogaritja e tokenëve (modaliteti agjent) : Përdorimi i tokenëve ndryshon në bazë të kompleksitetit të përmbajtjes dhe strategjisë së navigimit të modelit. Tokenët e arsyetimit të navigimit të gjeneruar gjatë eksplorimit të videos llogariten si tokena mendimi ( total_thought_tokens ), ndërsa kornizat, audioja dhe transkripti i ngarkuar sipas kërkesës llogariten si tokena përdorimi të mjeteve ( total_tool_use_tokens ). Përpunimi agjent zakonisht përdor deri në 88% më pak tokena totale sesa përpunimi statik për përmbajtje me formë të gjatë, sepse modeli ngarkon vetëm transkriptin dhe/ose kornizat dhe/ose audion që i nevojitet për t'iu përgjigjur kërkesës (shih udhëzuesin e tokenëve ).
  • Rezolucioni i medias : Gemini 3 prezanton 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 kornizë 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. Parametrat media_resolution dhe processing janë të pavarur: mund t'i vendosni të dyja në të njëjtën hyrje video.

Për më shumë detaje mbi llogaritjet e tokenëve, shihni udhëzuesin e tokenëve .

  • Formati i vulës kohore : Kur i referoheni momenteve specifike në një video brenda kërkesës suaj, përdorni formatin MM:SS (p.sh., 01:15 për 1 minutë e 15 sekonda).
  • Vendosja e kërkesës : Nëse kombinoni tekst dhe një video të vetme, vendoseni kërkesën e tekstit pas pjesës së videos në matricën input .
  • Afatet e pritjes për kërkesa të gjata : Për videot që kërkojnë kohë të zgjatur përpunimi ose arsyetim kompleks me shumë hapa, përdorni transmetim ( stream=True ) ose ekzekutim në sfond ( background=True ). Kërkesat sinkrone, jo-transmetuese që përjetojnë ripërpjekje në prapavijë nën kërkesë të lartë mund të tejkalojnë dritaret e vlefshmërisë së tokenit të lidhjes ose të vërtetimit, të cilat mund të shfaqen si gabime të papritura 401 Unauthorized ose të afatit të pritjes. Transmetimi e mban lidhjen aktive dhe shfaq arsyetimin e ndërmjetëm dhe progresin e thirrjes së mjetit.

Çfarë vjen më pas

  • Rezolucioni i medias : Kontrolloni rezolucionin e kuadrove të videos për të balancuar cilësinë dhe përdorimin e tokenëve.
  • Tokenat : Kuptoni se si tokenizohet përmbajtja video si në modalitetet statike ashtu edhe në ato të përpunimit agjentik.
  • Udhëzimet e sistemit : Udhëzimet e sistemit ju lejojnë të drejtoni sjelljen e modelit bazuar në nevojat dhe rastet tuaja specifike të përdorimit.
  • API-t e skedarëve : Mësoni më shumë rreth ngarkimit dhe menaxhimit të skedarëve për përdorim me Gemini.
  • Strategjitë e nxitjes së skedarëve : API Gemini mbështet nxitjen me të dhëna teksti, imazhi, audio dhe video, të njohura edhe si nxitje multimodale.
  • Udhëzime për sigurinë : Ndonjëherë modelet gjeneruese të IA-së prodhojnë rezultate të papritura, të tilla si rezultate që janë të pasakta, të anshme ose fyese. Përpunimi pasues dhe vlerësimi njerëzor janë thelbësorë për të kufizuar rrezikun e dëmtimit nga rezultate të tilla.