Kuptimi i videos

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

Modelet e Gemini mund të përpunojnë video, duke mundësuar shumë raste përdorimi të zhvilluesve të kufirit që historikisht do të kishin kërkuar modele specifike për domenin. Disa nga aftësitë e shikimit të Gemini përfshijnë aftësinë për të përshkruar, segmentuar dhe nxjerrë informacione nga videot, për t'u përgjigjur pyetjeve rreth përmbajtjes së videove dhe për t'iu referuar vulave specifike kohore brenda një videoje.

Mund të japësh video si hyrje për Gemini në mënyrat e mëposhtme:

Metoda e hyrjes Madhësia maksimale Rasti i rekomanduar i përdorimit
File API 20 GB (me pagesë) / 2 GB (falas) Skedarë të mëdhenj (100 MB+), video të gjata (10 min+), skedarë të ripërdorshëm.
Regjistrimi i Cloud Storage 2 GB (për skedar, pa kufij të hapësirës ruajtëse) Skedarë të mëdhenj (100 MB+), video të gjata (10 min+), skedarë të vazhdueshëm, të ripërdorshëm.
Të dhënat e integruara < 100MB Skedarë të vegjël (<100 MB), kohëzgjatje e shkurtër (<1 min.), hyrje të vetme.
URL-të e YouTube Nuk ka Videot publike në YouTube.

Shënim: File API 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ëshiron të ripërdorësh skedarin në disa kërkesa.

Për të mësuar rreth metodave të tjera të hyrjes së skedarëve, si p.sh. përdorimi i URL-ve ose skedarëve të jashtëm të ruajtur në Google Cloud, shiko udhëzuesin e Metodave të hyrjes 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ë ajo 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(""));

Go

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

QETËSI

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 kodeve, merr parasysh përdorimin e Përpunimit të videove me agjent.

Përdor 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 synon të përdorësh të njëjtën video në disa kërkesa. File API pranon drejtpërdrejt formatet e skedarëve të videos.

Për të mësuar më shumë rreth punës me skedarët e medias, shiko Files API.

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

Në vend që të ngarkosh një skedar videoje duke përdorur File API, mund të kalosh video më të vogla drejtpërdrejt në kërkesë. Kjo është e përshtatshme për video më të shkurtra me madhësi totale të kërkesës nën 20 MB.

Ja një shembull i dhënies së të dhënave të videos në linjë:

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

Go

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

QETËSI

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

Kaloni URL-të e YouTube

Mund t'i kalosh URL-të e YouTube drejtpërdrejt te Gemini API si pjesë e kërkesës sate 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(""));

Go

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

QETËSI

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

Kufizimet:

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

Kuptimi i videos nga agjenti

Si parazgjedhje, hyrjet e videos përdorin përpunimin statik (nxjerrjen e kuadrove me 1 FPS). Modelet Gemini 3.8 Flash, 3.6 Flash dhe 3.5 Flash Lite mbështesin gjithashtu kuptimin e videove nga agjentët, ku modeli eksploron në mënyrë dinamike kronologjinë e videos, duke inspektuar në mënyrë selektive transkriptet dhe duke rregulluar në mënyrë adaptive shpejtësinë e kuadrove dhe rezolucionin në momentin e duhur bazuar në kërkesë.

Modaliteti Përshkrimi Modelet e mbështetura
Statike (parazgjedhja) Nxjerr kuadrot me një shpejtësi të fiksuar (1 FPS) dhe i vendos ato në kontekst në një kalim të vetëm. Funksionon mirë për klipe të shkurtra. Të gjitha modelet e Gemini
Agentic Modeli navigon në mënyrë dinamike në kronologjinë e videos, duke ngarkuar vetëm përmbajtjen që i nevojitet bazuar në kërkesë. Deri në 88% më shumë efikasitet të kodeve dhe ~7% cilësi më e lartë në përmbajtjet e gjata. Gemini 3.8 Flash, 3.6 Flash, 3.5 Flash Lite

Zgjidh një modalitet përpunimi

Si udhëzim të përgjithshëm, fillo me modalitetin agjentik, sidomos kur optimizon për cilësinë e përgjigjes ose efikasitetin e kodeve.

  • Agjentike: Video ose pyetje të gjata që synojnë momente specifike. Modeli navigon në mënyrë dinamike nëpër kronologji për të synuar informacionet e përshtatshme për kontekstin pa mbushur dritaren e kontekstit.
  • Statike: Kërkesa të ndjeshme ndaj vonesës në klipe të shkurtra (nën 5 minuta) ose raste ku nevojitet saktësi në nivel kuadri në të gjithë klipin.

Shënim. Për video të gjata ose kërkesa komplekse ku përpunimi nga agjenti kërkon më shumë kohë, përdor transmetimin (stream=True) ose ekzekutimin në sfond (background=True). Kjo e mban aktive lidhjen, shfaq hapat e ndërmjetëm të arsyetimit dhe shmang kohët e pritjes për lidhjen ose vërtetimin.

Cakto modalitetin e përpunimit

Për të përdorur kuptimin e videos nga agjenti, cakto "processing": "agentic" në pjesën e videos në vargun input.

Përpunimi i videove me agjent mund të zgjasë më shumë për videot e gjata sepse modeli kryen disa kalime inspektimi për të lundruar në kronologji. Për të shmangur humbjen e progresit nëse bie lidhja e rrjetit, ky shembull përdor background=True për të ekzekutuar detyrën në mënyrë asinkrone në server. Mund të ekzekutosh gjithashtu kërkesa në mënyrë sinkrone pa ekzekutim në sfond duke hequr parametrin background, i cili funksionon mirë për video më të shkurtra.

Për detaje mbi anketimin, marrjen e rezultateve dhe menaxhimin e detyrave në sfond, shiko udhëzuesin e ekzekutimit në sfond.

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 with background execution
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?"}
    ],
    background=True,
)

while interaction.status == "in_progress":
    time.sleep(5)
    interaction = client.interactions.get(interaction.id)

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 with background execution
let 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?" }
  ],
  background: true,
});

while (interaction.status === "in_progress") {
  await new Promise((resolve) => setTimeout(resolve, 5000));
  interaction = await ai.interactions.get(interaction.id);
}

console.log(interaction.output_text);

QETËSI

# 1. Start the interaction in the background
interaction=$(curl -s -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?"}
    ],
    "background": true
  }')

id=$(echo "$interaction" | jq -r '.id')

# 2. Poll until the interaction finishes
while [ "$(echo "$interaction" | jq -r '.status')" = "in_progress" ]; do
  sleep 5
  interaction=$(curl -s "https://generativelanguage.googleapis.com/v1beta/interactions/$id" \
    -H "x-goog-api-key: $GEMINI_API_KEY")
done

echo "$interaction" | jq '.'

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

Hapat e përgjigjes

Përpunimi me agjent shton dy lloje të reja hapash në vargun steps:

  • processing_call: modeli kërkoi një segment videoje ose transkript audio, të identifikuar nga id.
  • processing_result: rezultati i atij ngarkimi, i lidhur nga call_id.

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

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

{
  "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..."
        }
      ]
    }
  ]
}

Përzieni modalitetet e përpunimit nëpër video

Cakto modalitete të ndryshme të përpunimit për çdo video në të njëjtën kërkesë:

Python

import time
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")

# Use agentic processing with background execution
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."}
    ],
    background=True,
)

while interaction.status == "in_progress":
    time.sleep(5)
    interaction = client.interactions.get(interaction.id)

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

// Use agentic processing with background execution
let 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." }
  ],
  background: true,
});

while (interaction.status === "in_progress") {
  await new Promise((resolve) => setTimeout(resolve, 5000));
  interaction = await ai.interactions.get(interaction.id);
}

console.log(interaction.output_text);

QETËSI

# 1. Start the interaction in the background
interaction=$(curl -s -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."}
    ],
    "background": true
  }')

id=$(echo "$interaction" | jq -r '.id')

# 2. Poll until the interaction finishes
while [ "$(echo "$interaction" | jq -r '.status')" = "in_progress" ]; do
  sleep 5
  interaction=$(curl -s "https://generativelanguage.googleapis.com/v1beta/interactions/$id" \
    -H "x-goog-api-key: $GEMINI_API_KEY")
done

echo "$interaction" | jq '.'

Biseda me video me disa hapa

Konteksti i videos ruhet nëpër radhët në një bisedë. Kur përdor përpunimin me agjent:

  • Modaliteti me gjendje (duke përdorur previous_interaction_id): Serveri ruan kontekstin e videos. Nuk nevojitet trajtim shtesë.
  • Modaliteti pa gjendje (duke përdorur step_list): Në modalitetin pa gjendje, përgjigjja përfshin processing_call dhe processing_result hapa që enkodojnë kontekstin e videos. Duhet të përfshish të gjithë hapat nga përgjigjja në kërkesën tënde të radhës për step_list për të ruajtur kontekstin e videos. Megjithëse heqja e tyre nuk shkakton aktualisht një gabim të API-së, konteksti i videos humbet, duke zvogëluar ndjeshëm cilësinë e përgjigjes për pyetjet vijuese. Ki parasysh se hapat e kthyer të dërguar në kërkesat vijuese kontribuojnë në numrin e kodeve hyrëse.

Referoju vulave kohore në përmbajtje

Mund të bësh pyetje për pika specifike në kohë brenda videos duke përdorur vula kohore në formën 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?";

Go

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

QETËSI

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

Nxirr statistika të detajuara nga videoja

Modelet e Gemini ofrojnë aftësi të fuqishme për të kuptuar përmbajtjen e videos duke përpunuar informacionet nga transmetimet audio dhe vizuale. Kjo të lejon të nxjerrësh një grup të pasur detajesh, duke përfshirë gjenerimin e përshkrimeve të asaj që po ndodh në një video dhe t'u përgjigjesh pyetjeve për përmbajtjen e saj.

Për përshkrimet vizuale, modeli merr shembuj të videos me një shpejtësi prej 1 kuadri për sekondë (FPS). Kjo normë e parazgjedhur e marrjes së mostrave funksionon mirë për shumicën e përmbajtjeve, por ki parasysh se mund të humbasë detaje në video 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.";

Go

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

QETËSI

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 të personalizosh përpunimin e videos në Gemini API duke caktuar intervalet e klipeve ose duke ofruar marrjen e mostrave të personalizuara të shpejtësisë së kuadrove. Këto opsione personalizimi mbështeten vetëm kur përpunohet videoja në modalitetin "static".

Cakto intervalet e klipeve

Mund të krijosh klipe nga 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);

QETËSI

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 të personalizuar të kuadrove

Mund të caktosh marrjen e mostrave të personalizuara të shpejtësisë së kuadrove duke kaluar një argument fps 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",
                "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);

QETËSI

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 mbështetura të videos

Gemini mbështet llojet e mëposhtme të MIME-s të formateve të videove:

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

Detajet teknike rreth videove

  • Modelet e mbështetura dhe konteksti: Të gjitha modelet e Gemini mund të përpunojnë të dhënat e videove.
    • Modelet me një dritare kontekstuale me 1 milion tokenë 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.6 Flash, 3.5 Flash Lite dhe modelet e mëvonshme mbështesin dy modalitete të përpunimit të videove:
    • Statike: Kuadrot nxirren në 1 FPS dhe vendosen në kontekst (parazgjedhja për të gjitha modelet). Audioja përpunohet në 1 Kbps (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 p.sh. për inspektim kuadër pas kuadri). Ki parasysh se sekuencat e shpejta të veprimit mund të humbasin detaje për shkak të shpejtësisë së kampionimit prej 1 FPS.
    • Agjentike: Modeli navigon në mënyrë dinamike në video, duke ngarkuar transkriptin dhe/ose kuadrot dhe/ose audion sipas kërkesës. Kjo përdor deri në 88% më pak kode për përmbajtjet me metrazh të gjatë, megjithëse navigimi mund të rritë pak kohën për kodin e parë (TTFT) në klipe të shkurtra (<5 minuta) për shkak të arsyetimit të brendshëm dhe udhëtimeve vajtje-ardhje të veglës para se të fillojë gjenerimi. Më e mira për video të gjata për të optimizuar kostot e kodeve dhe cilësinë e përgjigjeve. Mbështetet në Gemini 3.8 Flash, 3.6 Flash dhe 3.5 Flash Lite. Shiko Kuptimi i videos nga agjenti për detaje.
  • Llogaritja e tokenëve (modaliteti statik): Çdo sekondë e videos tokenizohet si më poshtë:
    • Kuadrot individuale (të marra në 1 FPS):
      • Nëse media_resolution është caktuar në "E ulët", kuadrot tokenizohen në 66 tokena për kuadër.
      • Në rast të kundërt, kuadrot tokenizohen në 258 kode për kuadër.
    • Audio: 32 kode për sekondë.
    • Përfshihen gjithashtu metadatat.
    • Totali: Përafërsisht 100 kode për sekondë videoje në rezolucionin e parazgjedhur (të ulët) të medias ose përafërsisht 300 kode për sekondë videoje në rezolucionin e lartë të medias.
  • Llogaritja e tokenëve (modaliteti i agjentit): Përdorimi i tokenëve ndryshon në bazë të kompleksitetit të përmbajtjes dhe strategjisë së navigimit të modelit. Argumentet e arsyetimit të navigimit të gjeneruara gjatë eksplorimit të videos llogariten si argumente të mendimit (total_thought_tokens), ndërsa kuadrot, audioja dhe transkripti i ngarkuar sipas kërkesës llogariten si argumente të përdorimit të veglave (total_tool_use_tokens). Përpunimi me agjent përdor zakonisht deri në 88% më pak argumente në total se përpunimi statik për përmbajtjet e gjata sepse modeli ngarkon vetëm transkriptin dhe/ose kuadrot dhe/ose audion që i nevojiten për t'iu përgjigjur kërkesës (shiko udhëzuesin për argumentet).
  • Rezolucioni i medias: Gemini 3 prezanton kontrollin e detajuar mbi përpunimin multimodal të shikimit me parametrin media_resolution. Parametri media_resolution përcakton numrin maksimal të kodeve të caktuara për imazh hyrës ose kuadër video. Rezolucionet më të larta përmirësojnë aftësinë e modelit për të lexuar tekstet e imëta ose për të identifikuar detajet e vogla, por rritin përdorimin e kodeve dhe vonesën. Parametrat media_resolution dhe processing janë të pavarur: mund t'i caktosh të dyja në të njëjtën hyrje videoje.

Për më shumë detaje mbi llogaritjet e kodeve, shiko udhëzuesin e kodeve.

  • Formati i vulës kohore: Kur i referohesh momenteve specifike në një video brenda kërkesës sate, përdor formatin MM:SS (p.sh. 01:15 për 1 minutë dhe 15 sekonda).
  • Vendosja e kërkesës: Nëse kombinon tekstin dhe një video të vetme, vendos kërkesën me tekst pas pjesës së videos në vargun input.
  • Kohëzgjatjet për kërkesat e gjata: Për videot që kërkojnë kohë të zgjatur përpunimi ose arsyetim kompleks me shumë hapa, përdor transmetimin (stream=True) ose ekzekutimin në sfond (background=True). Kërkesat sinkrone, jo të transmetimit që hasin riprovime në sistemin fundor nën kërkesë të lartë mund të tejkalojnë dritaret e vlefshmërisë së lidhjes ose të kodit të vërtetimit, gjë që mund të shfaqet si gabime të papritura 401 Unauthorized ose të kohëzgjatjes. Transmetimi e mban aktive lidhjen dhe shfaq arsyetimin ndërmjetësues dhe progresin e thirrjes së veglës.

Çfarë ka më pas

  • Rezolucioni i medias: Kontrollo rezolucionin e kuadrove të videos për të balancuar cilësinë dhe përdorimin e kodeve.
  • Tokenat: Kupto se si përmbajtja e videos tokenizohet në modalitetet e përpunimit statik dhe me agjent.
  • Ekzekutimi në sfond: Ekzekuto detyrat e kuptimit të videove që zgjasin për një kohë të gjatë në mënyrë asinkrone për të shmangur kohët e pritjes për lidhjen.
  • Udhëzimet e sistemit: Udhëzimet e sistemit të lejojnë të drejtosh sjelljen e modelit bazuar në nevojat dhe rastet e tua specifike të përdorimit.
  • Files API: Mëso më shumë rreth ngarkimit dhe menaxhimit të skedarëve për përdorim me Gemini.
  • Strategjitë e kërkesave për skedarët: Gemini API mbështet kërkesat me të dhëna tekstesh, imazhesh, audiosh dhe videosh, të njohura gjithashtu si kërkesa multimodale.
  • Udhëzimet për sigurinë: Ndonjëherë, modelet e IA-së gjeneruese prodhojnë rezultate të papritura, si p.sh. rezultate që janë të pasakta, të njëanshme ose fyese. Përpunimi pas përpunimit dhe vlerësimi manual janë thelbësorë për të kufizuar rrezikun e dëmtimit nga rezultate të tilla.