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

client = genai.Client()

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

response = client.models.generate_content(
    model="gemini-3.8-flash", contents=[myfile, "Summarize this video. Then create a quiz with an answer key based on the information in this video."]
)

print(response.text)

JavaScript

import {
  GoogleGenAI,
  createUserContent,
  createPartFromUri,
} 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" },
  });

  const response = await ai.models.generateContent({
    model: "gemini-3.8-flash",
    contents: createUserContent([
      createPartFromUri(myfile.uri, myfile.mimeType),
      "Summarize this video. Then create a quiz with an answer key based on the information in this video.",
    ]),
  });
  console.log(response.text);
}

await main();

Go

uploadedFile, _ := client.Files.UploadFromPath(ctx, "path/to/sample.mp4", nil)

parts := []*genai.Part{
    genai.NewPartFromText("Summarize this video. Then create a quiz with an answer key based on the information in this video."),
    genai.NewPartFromURI(uploadedFile.URI, uploadedFile.MIMEType),
}

contents := []*genai.Content{
    genai.NewContentFromParts(parts, genai.RoleUser),
}

result, _ := client.Models.GenerateContent(
    ctx,
    "gemini-3.8-flash",
    contents,
    nil,
)

fmt.Println(result.Text())

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)
echo file_uri=$file_uri

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

# --- 3. Generate content using the uploaded video file ---
echo "Generating content from video..."
curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.8-flash:generateContent" \
    -H "x-goog-api-key: $GEMINI_API_KEY" \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{
      "contents": [{
        "parts":[
          {"file_data":{"mime_type": "'"${MIME_TYPE}"'", "file_uri": "'"${file_uri}"'"}},
          {"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 -r ".candidates[].content.parts[].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ë te generateContent. 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
from google.genai import types

# Only for videos of size <20Mb
video_file_name = "/path/to/your/video.mp4"
video_bytes = open(video_file_name, 'rb').read()

client = genai.Client()
response = client.models.generate_content(
    model='gemini-3.8-flash',
    contents=types.Content(
        parts=[
            types.Part(
                inline_data=types.Blob(data=video_bytes, mime_type='video/mp4')
            ),
            types.Part(text='Please summarize the video in 3 sentences.')
        ]
    )
)
print(response.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 contents = [
  {
    inlineData: {
      mimeType: "video/mp4",
      data: base64VideoFile,
    },
  },
  { text: "Please summarize the video in 3 sentences." }
];

const response = await ai.models.generateContent({
  model: "gemini-3.8-flash",
  contents: contents,
});
console.log(response.text);

QETËSI

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

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

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.8-flash:generateContent" \
    -H "x-goog-api-key: $GEMINI_API_KEY" \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{
      "contents": [{
        "parts":[
            {
              "inline_data": {
                "mime_type":"video/mp4",
                "data": "'$(base64 $B64FLAGS $VIDEO_PATH)'"
              }
            },
            {"text": "Please summarize the video in 3 sentences."}
        ]
      }]
    }' 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
from google.genai import types

client = genai.Client()
response = client.models.generate_content(
    model='gemini-3.8-flash',
    contents=types.Content(
        parts=[
            types.Part(
                file_data=types.FileData(file_uri='https://www.youtube.com/watch?v=9hE5-98ZeCg')
            ),
            types.Part(text='Please summarize the video in 3 sentences.')
        ]
    )
)
print(response.text)

JavaScript

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

const ai = new GoogleGenAI({});

const contents = [
  {
    fileData: {
      fileUri: "https://www.youtube.com/watch?v=9hE5-98ZeCg",
    },
  },
  { text: "Please summarize the video in 3 sentences." }
];

const response = await ai.models.generateContent({
  model: "gemini-3.8-flash",
  contents: contents,
});
console.log(response.text);

Go

package main

import (
  "context"
  "fmt"
  "os"
  "google.golang.org/genai"
)

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

  parts := []*genai.Part{
      genai.NewPartFromText("Please summarize the video in 3 sentences."),
      genai.NewPartFromURI("https://www.youtube.com/watch?v=9hE5-98ZeCg","video/mp4"),
  }

  contents := []*genai.Content{
      genai.NewContentFromParts(parts, genai.RoleUser),
  }

  result, _ := client.Models.GenerateContent(
      ctx,
      "gemini-3.8-flash",
      contents,
      nil,
  )

  fmt.Println(result.Text())
}

QETËSI

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.8-flash:generateContent" \
    -H "x-goog-api-key: $GEMINI_API_KEY" \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{
      "contents": [{
        "parts":[
            {"text": "Please summarize the video in 3 sentences."},
            {
              "file_data": {
                "file_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 (client.models.generate_content_stream). 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

Python

import time
from google import genai
from google.genai import types

client = genai.Client()

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)

response = client.models.generate_content(
    model="gemini-3.8-flash",
    contents=[
        types.Part.from_uri(
            file_uri=video_file.uri,
            mime_type=video_file.mime_type,
            media_processing="AGENTIC",
        ),
        "What are the three main arguments presented?",
    ],
)
print(response.text)

JavaScript

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

const ai = new GoogleGenAI({});

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

const response = await ai.models.generateContent({
  model: "gemini-3.8-flash",
  contents: [
    {
      role: "user",
      parts: [
        {
          fileData: {
            fileUri: videoFile.uri,
            mimeType: videoFile.mimeType,
          },
          mediaProcessing: "AGENTIC",
        },
        { text: "What are the three main arguments presented?" },
      ],
    },
  ],
});
console.log(response.text);

Go

uploadedFile, _ := client.Files.UploadFromPath(ctx, "path/to/lecture.mp4", nil)
parts := []*genai.Part{
    {
        FileData: &genai.FileData{
            FileURI:  uploadedFile.URI,
            MIMEType: uploadedFile.MIMEType,
        },
        MediaProcessing: genai.MediaProcessingAgentic,
    },
    genai.NewPartFromText("What are the three main arguments presented?"),
}
contents := []*genai.Content{
    genai.NewContentFromParts(parts, genai.RoleUser),
}
result, _ := client.Models.GenerateContent(
    ctx,
    "gemini-3.8-flash",
    contents,
    nil,
)
fmt.Println(result.Text())

QETËSI

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.8-flash:generateContent?key=$GEMINI_API_KEY" \
  -H 'Content-Type: application/json' \
  -d '{
    "contents": [{
      "parts": [
        {
          "file_data": {
            "file_uri": "'${file_uri}'",
            "mime_type": "video/mp4"
          },
          "media_processing": "AGENTIC"
        },
        {"text": "What are the three main arguments presented?"}
      ]
    }]
  }'

Shënim. Për të verifikuar që është përdorur përpunimi me agjent, inspekto response.candidates[0].content.parts. Prania e tool_call dhe tool_response pjesëve me llojin e veglës MEDIA_PROCESSING tregon se modeli ka naviguar në mënyrë dinamike në video.

Shënim. Ndryshe nga veglat e tjera në anën e serverit (si p.sh. "Kërko në Google" ose konteksti i URL-së), videoja me agjent nuk kërkon cilësimin include_server_side_tool_invocations=True në ToolConfig që thirrjet e veglave dhe rezultatet të kthehen ose transmetohen. Pjesët tool_call dhe tool_response për navigimin e videos kthehen automatikisht kur media_processing="AGENTIC" është caktuar në çdo pjesë hyrëse.

Struktura e përgjigjes

Kur përpunimi me agjent është i aktivizuar, përgjigjja përfshin pjesë shtesë që ekspozojnë gjurmën e navigimit të brendshëm:

  • tool_call pjesë (tool_type: "MEDIA_PROCESSING"): lëshohen sa herë që modeli kërkon një segment videoje ose transkript audio.
  • tool_response pjesë (tool_type: "MEDIA_PROCESSING"): rezultati i çdo operacioni ngarkimi.

Nuk është e nevojshme t'i menaxhosh ose t'u përgjigjesh manualisht këtyre pjesëve: kalo përsëri përgjigjen e plotë si historik bisede dhe ato menaxhohen automatikisht.

Nëse include_thoughts=True është caktuar në ThinkingConfig, hapat e arsyetimit shfaqen si thought: true pjesë të ndërthurura me çiftet e thirrjeve/përgjigjeve të veglës. Me mendimet e çaktivizuara, teksti i mendimeve hiqet, por pjesët e veglës janë përsëri të pranishme.

Shembulli i mëposhtëm tregon ngarkesën e përgjigjes me pjesët e ndërthurura të thirrjes së veglës dhe përgjigjes:

{
  "candidates": [
    {
      "content": {
        "role": "model",
        "parts": [
          {
            "thought": true,
            "text": "Inspecting transcript for key discussion topics..."
          },
          {
            "thought_signature": "sig_A",
            "tool_call": {
              "tool_type": "MEDIA_PROCESSING"
            }
          },
          {
            "thought_signature": "sig_B",
            "tool_response": {
              "tool_type": "MEDIA_PROCESSING"
            }
          },
          {
            "thought": true,
            "text": "Loading visual frames to verify slide content..."
          },
          {
            "thought_signature": "sig_C",
            "tool_call": {
              "tool_type": "MEDIA_PROCESSING"
            }
          },
          {
            "thought_signature": "sig_D",
            "tool_response": {
              "tool_type": "MEDIA_PROCESSING"
            }
          },
          {
            "thought": true,
            "text": "Synthesizing answer from gathered evidence..."
          },
          {
            "text": "The three main arguments presented in the lecture are...",
            "thought_signature": "sig_E"
          }
        ]
      }
    }
  ]
}

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

Mund të caktosh mënyra të ndryshme përpunimi për çdo pjesë të videos në të njëjtën kërkesë:

Python

from google import genai
from google.genai import types

client = genai.Client()

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

response = client.models.generate_content(
    model="gemini-3.8-flash",
    contents=[
        types.Part.from_uri(
            file_uri=lecture.uri,
            mime_type=lecture.mime_type,
            media_processing="AGENTIC",  # Use agentic video understanding
        ),
        types.Part.from_uri(
            file_uri=experiment.uri,
            mime_type=experiment.mime_type,
            media_processing="STATIC",  # Use static processing
        ),
        "Compare the lecture content with the experiment results.",
    ],
)
print(response.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 response = await ai.models.generateContent({
  model: "gemini-3.8-flash",
  contents: [
    {
      role: "user",
      parts: [
        {
          fileData: {
            fileUri: lecture.uri,
            mimeType: lecture.mimeType,
          },
          mediaProcessing: "AGENTIC", // Use agentic video understanding
        },
        {
          fileData: {
            fileUri: experiment.uri,
            mimeType: experiment.mimeType,
          },
          mediaProcessing: "STATIC", // Use static processing
        },
        { text: "Compare the lecture content with the experiment results." },
      ],
    },
  ],
});
console.log(response.text);

Go

lecturePart := &genai.Part{
    FileData: &genai.FileData{
        FileURI:  lectureFile.URI,
        MIMEType: lectureFile.MIMEType,
    },
    MediaProcessing: genai.MediaProcessingAgentic, // Use agentic
}
experimentPart := &genai.Part{
    FileData: &genai.FileData{
        FileURI:  experimentFile.URI,
        MIMEType: experimentFile.MIMEType,
    },
    MediaProcessing: genai.MediaProcessingStatic, // Use static
}
parts := []*genai.Part{
    lecturePart,
    experimentPart,
    genai.NewPartFromText("Compare the lecture content with the experiment results."),
}
contents := []*genai.Content{
    genai.NewContentFromParts(parts, genai.RoleUser),
}
result, _ := client.Models.GenerateContent(ctx, "gemini-3.8-flash", contents, nil)
fmt.Println(result.Text())

QETËSI

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.8-flash:generateContent?key=$GEMINI_API_KEY" \
  -H 'Content-Type: application/json' \
  -d '{
    "contents": [{
      "parts": [
        {
          "file_data": {
            "file_uri": "'${lecture_uri}'",
            "mime_type": "video/mp4"
          },
          "media_processing": "AGENTIC"
        },
        {
          "file_data": {
            "file_uri": "'${experiment_uri}'",
            "mime_type": "video/mp4"
          },
          "media_processing": "STATIC"
        },
        {"text": "Compare the lecture content with the experiment results."}
      ]
    }]
  }'

Përdor ruajtjen në memorien specifike për videot e gjata

Për videot më të gjata se 10 minuta, ose kur planifikon të bësh disa kërkesa kundër të njëjtit skedar video, përdor ruajtjen në ndërmemorie të kontekstit për të zvogëluar kostot dhe për të përmirësuar vonesën. Ruajtja në memorien specifike e kontekstit të lejon të përpunosh videon një herë dhe të ripërdorësh kodet për kërkesat vijuese, duke e bërë atë ideale për seancat e bisedës ose analizën e përsëritur të përmbajtjes së formës së gjatë.

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

response = client.models.generate_content(
    model="gemini-3.8-flash",
    contents=[
        myfile,
        "What are the examples given at 00:05 and 00:10 supposed to show us?",
    ],
)
print(response.text)

JavaScript

const response = await ai.models.generateContent({
  model: "gemini-3.8-flash",
  contents: [
    myfile,
    "What are the examples given at 00:05 and 00:10 supposed to show us?",
  ],
});
console.log(response.text);

Go

parts := []*genai.Part{
    genai.NewPartFromURI(uploadedFile.URI, uploadedFile.MIMEType),
    genai.NewPartFromText("What are the examples given at 00:05 and 00:10 supposed to show us?"),
}

result, _ := client.Models.GenerateContent(
    ctx,
    "gemini-3.8-flash",
    []*genai.Content{genai.NewContentFromParts(parts, genai.RoleUser)},
    nil,
)
fmt.Println(result.Text())

QETËSI

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.8-flash:generateContent" \
    -H "x-goog-api-key: $GEMINI_API_KEY" \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{
      "contents": [{
        "parts":[
          {"file_data": {"file_uri": "'"${file_uri}"'", "mime_type": "'"${MIME_TYPE}"'"}},
          {"text": "What are the examples given at 00:05 and 00:10 supposed to show us?"}
        ]
      }]
    }' 2> /dev/null

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. Për përmbajtje të tilla me lëvizje të shpejtë, merr parasysh caktimin e një shpejtësie të personalizuar të kuadrove.

Python

response = client.models.generate_content(
    model="gemini-3.8-flash",
    contents=[
        myfile,
        "Describe the key events in this video, providing both audio and visual details. Include timestamps for salient moments.",
    ],
)
print(response.text)

JavaScript

const response = await ai.models.generateContent({
  model: "gemini-3.8-flash",
  contents: [
    myfile,
    "Describe the key events in this video, providing both audio and visual details. Include timestamps for salient moments.",
  ],
});
console.log(response.text);

Go

parts := []*genai.Part{
    genai.NewPartFromURI(uploadedFile.URI, uploadedFile.MIMEType),
    genai.NewPartFromText("Describe the key events in this video, providing both audio and visual details. " +
        "Include timestamps for salient moments."),
}

result, _ := client.Models.GenerateContent(
    ctx,
    "gemini-3.8-flash",
    []*genai.Content{genai.NewContentFromParts(parts, genai.RoleUser)},
    nil,
)
fmt.Println(result.Text())

QETËSI

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.8-flash:generateContent" \
    -H "x-goog-api-key: $GEMINI_API_KEY" \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{
      "contents": [{
        "parts":[
          {"file_data": {"file_uri": "'"${file_uri}"'", "mime_type": "'"${MIME_TYPE}"'"}},
          {"text": "Describe the key events in this video, providing both audio and visual details. Include timestamps for salient moments."}
        ]
      }]
    }' 2> /dev/null

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 videoMetadata me zhvendosjet e fillimit dhe të përfundimit.

Python

from google import genai
from google.genai import types

client = genai.Client()
response = client.models.generate_content(
    model='models/gemini-3.8-flash',
    contents=types.Content(
        parts=[
            types.Part(
                file_data=types.FileData(file_uri='https://www.youtube.com/watch?v=XEzRZ35urlk'),
                video_metadata=types.VideoMetadata(
                    start_offset='1250s',
                    end_offset='1570s'
                )
            ),
            types.Part(text='Please summarize the video in 3 sentences.')
        ]
    )
)

JavaScript

import { GoogleGenAI } from '@google/genai';
const ai = new GoogleGenAI({});
const model = 'gemini-3.8-flash';

async function main() {
const contents = [
  {
    role: 'user',
    parts: [
      {
        fileData: {
          fileUri: 'https://www.youtube.com/watch?v=9hE5-98ZeCg',
          mimeType: 'video/*',
        },
        videoMetadata: {
          startOffset: '40s',
          endOffset: '80s',
        }
      },
      {
        text: 'Please summarize the video in 3 sentences.',
      },
    ],
  },
];

const response = await ai.models.generateContent({
  model,
  contents,
});

console.log(response.text)

}

await main();

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 te videoMetadata.

Python

from google import genai
from google.genai import types

# Only for videos of size <20Mb
video_file_name = "/path/to/your/video.mp4"
video_bytes = open(video_file_name, 'rb').read()

client = genai.Client()
response = client.models.generate_content(
    model='models/gemini-3.8-flash',
    contents=types.Content(
        parts=[
            types.Part(
                inline_data=types.Blob(
                    data=video_bytes,
                    mime_type='video/mp4'),
                video_metadata=types.VideoMetadata(fps=5)
            ),
            types.Part(text='Please summarize the video in 3 sentences.')
        ]
    )
)

JavaScript

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

const ai = new GoogleGenAI({});

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

const response = await ai.models.generateContent({
  model: "gemini-3.8-flash",
  contents: [
    {
      fileData: {
        fileUri: myfile.uri,
        mimeType: myfile.mimeType,
      },
      videoMetadata: {
        fps: 5,
      },
    },
    "Please summarize the video in 3 sentences.",
  ],
});

console.log(response.text);

Si parazgjedhje, nga videoja merret 1 kuadër për sekondë (FPS). Mund të duash të caktosh FPS të ulët (< 1) për video të gjata. Kjo është veçanërisht e dobishme për videot kryesisht statike (p.sh. leksionet). Përdor një FPS më të lartë për videot që kërkojnë analizë të detajuar kohore, si p.sh. për të kuptuar veprimet e shpejta ose për gjurmimin e lëvizjeve me shpejtësi të lartë.

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/quicktime
  • 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. Përgjigjet përfshijnë MEDIA_PROCESSING pjesë të thirrjes dhe përgjigjes së veglës për të ruajtur kontekstin e arsyetimit nëpër radhë. 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 Kuptimin e videove nga agjentët 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. Shenjat e arsyetimit të navigimit të gjeneruara gjatë eksplorimit të videos llogariten si shenja të të menduarit (thoughts_token_count), ndërsa kuadrot, audiot dhe transkriptet e ngarkuara sipas kërkesës llogariten si shenja të kërkesave të veglave (tool_use_prompt_token_count). Përpunimi me agjent përdor zakonisht deri në 88% më pak shenja 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 shenjat).
  • 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 media_processing janë të pavarur: mund t'i caktosh të dy në të njëjtën pjesë të videos.

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 contents.
  • 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 (client.models.generate_content_stream). 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, të cilat mund të shfaqen 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.
  • 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.