Video anlama

Video oluşturma hakkında bilgi edinmek için Gemini Omni Flash rehberine bakın.

Gemini modelleri, videoları işleyebilir. Bu sayede, geçmişte alana özel modeller gerektiren birçok yeni geliştirici kullanım alanı mümkün olur. Gemini'ın bazı görme özellikleri arasında videoları açıklama, segmentlere ayırma ve videolardan bilgi ayıklama, video içeriğiyle ilgili soruları yanıtlama ve videodaki belirli zaman damgalarına başvurma yer alır.

Gemini'a giriş olarak aşağıdaki yöntemlerle video sağlayabilirsiniz:

Giriş yöntemi Maks. boyut Önerilen kullanım alanı
File API 20 GB (ücretli) / 2 GB (ücretsiz) Büyük dosyalar (100 MB'tan büyük), uzun videolar (10 dakikadan uzun), yeniden kullanılabilir dosyalar.
Cloud Storage Kaydı 2 GB (dosya başına, depolama alanı sınırı yok) Büyük dosyalar (100 MB'tan büyük), uzun videolar (10 dakikadan uzun), kalıcı ve yeniden kullanılabilir dosyalar.
Satır İçi Veriler < 100MB Küçük dosyalar (<100 MB), kısa süre (<1 dakika), tek seferlik girişler.
YouTube URL'leri Yok Herkese açık YouTube videoları.

Not: File API, özellikle 100 MB'tan büyük dosyalar için veya dosyayı birden fazla istekte yeniden kullanmak istediğinizde çoğu kullanım alanı için önerilir.

Harici URL'leri veya Google Cloud'da depolanan dosyaları kullanma gibi diğer dosya giriş yöntemleri hakkında bilgi edinmek için Dosya giriş yöntemleri kılavuzuna bakın.

Video dosyası yükleme

Aşağıdaki kod, örnek bir videoyu indirir, Files API'yi kullanarak yükler, işlenmesini bekler ve ardından yüklenen dosya referansını kullanarak videoyu özetler.

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 java.util.Arrays;
import java.util.List;

Client client = new Client();

Content textContent = TextContent.builder().text("Summarize the key events in this video.").build();
Content videoContent =
    VideoContent.builder()
        .uri("gs://cloud-samples-data/generative-ai/video/pixel8.mp4")
        .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(""));

REST

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

Toplam istek boyutu (dosya, metin istemi, sistem talimatları vb. dahil) 20 MB'tan büyükse, video süresi uzunsa veya aynı videoyu birden fazla istemde kullanmayı planlıyorsanız her zaman Files API'yi kullanın. File API, video dosyası biçimlerini doğrudan kabul eder.

Medya dosyalarıyla çalışma hakkında daha fazla bilgi edinmek için Files API'yi inceleyin.

Video verilerini satır içi olarak iletme

Dosya API'sini kullanarak video dosyası yüklemek yerine, daha küçük videoları doğrudan istekte iletebilirsiniz. Bu, toplam istek boyutu 20 MB'tan küçük olan kısa videolar için uygundur.

Satır içi video verileri sağlama örneğini burada bulabilirsiniz:

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.util.Arrays;
import java.util.List;

Client client = new Client();

Content textContent = TextContent.builder().text("Summarize the key events in this video.").build();
Content videoContent =
    VideoContent.builder()
        .uri("gs://cloud-samples-data/generative-ai/video/pixel8.mp4")
        .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(""));

REST

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

YouTube URL'lerini iletme

YouTube URL'lerini, isteğinizin bir parçası olarak doğrudan Gemini API'ye aşağıdaki şekilde iletebilirsiniz:

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.interactions.VideoContentMimeType;
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("Summarize the key events in this video.").build();
Content videoContent =
    VideoContent.builder()
        .uri("gs://cloud-samples-data/generative-ai/video/pixel8.mp4")
        .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(""));

REST

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

Sınırlamalar:

  • Ücretsiz katmanda, günde 8 saatten fazla YouTube videosu yükleyemezsiniz.
  • Ücretli katmanda video uzunluğuna göre bir sınırlama yoktur.
  • Gemini 2.5'ten önceki modellerde, istek başına yalnızca 1 video yükleyebilirsiniz. Gemini 2.5 ve sonraki modellerde, istek başına en fazla 10 video yükleyebilirsiniz.
  • Yalnızca herkese açık videoları (gizli veya liste dışı videoları değil) yükleyebilirsiniz.

Ajan tabanlı video anlama

Varsayılan olarak, video girişlerinde statik işleme (saniyede 1 kare çıkarma) kullanılır. Gemini 3.8 Flash, 3.7 Flash, 3.6 Flash ve 3.5 Flash Lite modelleri de agentic video understanding özelliğini destekler. Bu özellik sayesinde model, video zaman çizelgesini dinamik olarak keşfeder, transkriptleri seçici bir şekilde inceler ve isteme göre kare hızlarını ve çözünürlüğü anında uyarlar.

Mod Açıklama Desteklenen modeller
Statik (varsayılan) Kareleri sabit bir hızda (1 FPS) ayıklar ve tek bir geçişte bağlam içinde yerleştirir. Kısa klipler için uygundur. Tüm Gemini modelleri
Temsilci tabanlı çözümler Model, video zaman çizelgesinde dinamik olarak gezinir ve yalnızca isteme göre ihtiyaç duyduğu içeriği yükler. Uzun içeriklerde% 88'e kadar daha fazla jeton verimliliği ve yaklaşık% 7 daha yüksek kalite. Gemini 3.8 Flash, 3.7 Flash, 3.6 Flash, 3.5 Flash Lite

İşleme modu seçme

Genel bir kural olarak, özellikle yanıt kalitesi veya jeton verimliliği için optimizasyon yaparken agentic moduyla başlayın.

  • Etkileşimli: Belirli anları hedefleyen uzun videolar veya sorgular. Model, bağlam penceresini doldurmadan bağlamsal olarak alakalı bilgileri hedeflemek için zaman çizelgesinde dinamik olarak gezinir.
  • Statik: Kısa kliplerdeki (5 dakikadan kısa) gecikmeye duyarlı sorgular veya klibin tamamında kare düzeyinde hassasiyetin gerektiği durumlar.

Not: Aracı işlemlemenin daha fazla zaman aldığı uzun videolar veya karmaşık komut istemleri için akış (stream=True) veya arka plan yürütme (background=True) kullanın. Bu, bağlantıyı aktif tutar, ara akıl yürütme adımlarını ortaya çıkarır ve bağlantı veya kimlik doğrulama zaman aşımını önler.

İşleme modunu ayarlama

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

REST

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

Not: Aracılı işleme kullanıldığını doğrulamak için interaction.steps öğesini inceleyin. processing_call ve processing_result'in varlığı, modelin videoda dinamik olarak gezindiğini gösterir.

Yanıt adımları

Aracılı işlem, steps dizisine iki yeni adım türü ekler:

  • processing_call: Model, id ile tanımlanan bir video kesiti veya ses kaydı metni talep etti.
  • processing_result: call_id ile bağlantılı olan bu yüklemenin sonucu.

Bunlar, özetler etkinleştirildiğinde thought adımlarıyla iç içe görünür ve son model_output adımından önce gelir. Bunlar, kullanıcı arayüzünüzde ilerleme durumunu göstermek için kullanılabilir ancak yanıt gerektirmez.

Aşağıdaki örnek, ardışık işlem adımlarına sahip yanıt yükünü göstermektedir:

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

Videolar arasında farklı işleme modlarını karıştırın.

Aynı istek içindeki her video için farklı işleme modları ayarlayabilirsiniz:

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

REST

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

Çok turlu video görüşmeleri

Video içeriği, konuşma içindeki farklı zaman dilimlerinde de korunmaktadır. Aracılı işlemeyi kullanırken:

  • Durum bilgisi içeren mod (previous_interaction_id kullanılarak): Sunucu video bağlamını korur. Ek bir işleme gerek yoktur.
  • Durumsuz mod (step_list kullanılarak): Durumsuz modda, yanıt, video bağlamını kodlayan processing_call ve processing_result adımları içerir. Video içeriğini korumak için, bir sonraki isteğinizin step_list bölümüne yanıttaki tüm adımları eklemelisiniz. Şu anda bunların atlanması bir API hatası döndürmese de, video bağlamı kaybolur ve bu da takip sorularına verilen yanıt kalitesini önemli ölçüde düşürür. Sonraki isteklerde gönderilen geri dönen adımların, girdi belirteç sayısına katkıda bulunduğunu unutmayın.

İçerikteki zaman damgalarına bakın.

MM:SS biçimindeki zaman damgalarını kullanarak videodaki belirli zaman noktaları hakkında sorular sorabilirsiniz.

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

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.util.Arrays;
import java.util.List;

Client client = new Client();

Content textContent = TextContent.builder().text("Summarize the key events in this video.").build();
Content videoContent =
    VideoContent.builder()
        .uri("gs://cloud-samples-data/generative-ai/video/pixel8.mp4")
        .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(""));

REST

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

Videodan ayrıntılı bilgiler çıkarın

Gemini modelleri, hem kaynak hem de dijital ortamdan gelen bilgileri işleyerek video içeriğini anlama konusunda güçlü yetenekler sunar.ses ve görüntü akarsular. Bu sayede, bir videoda neler olup bittiğine dair açıklamalar oluşturmak ve içeriğiyle ilgili soruları yanıtlamak da dahil olmak üzere, zengin bir detay seti elde edebilirsiniz.

Görsel tanımlamalar için model, videoyu belirli bir oranda örnekler.Saniyede 1 kare (FPS). Bu varsayılan örnekleme hızı çoğu içerik için iyi sonuç verir, ancak hızlı hareket veya hızlı sahne değişiklikleri içeren videolarda ayrıntıları kaçırabileceğini unutmayın.

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

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.util.Arrays;
import java.util.List;

Client client = new Client();

Content textContent = TextContent.builder().text("Summarize the key events in this video.").build();
Content videoContent =
    VideoContent.builder()
        .uri("gs://cloud-samples-data/generative-ai/video/pixel8.mp4")
        .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(""));

REST

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

Video işlemeyi özelleştirin

Gemini API'sinde kırpma aralıkları ayarlayarak veya özel kare hızı örneklemesi sağlayarak video işlemeyi özelleştirebilirsiniz. Bu özelleştirme seçenekleri yalnızca video "static" modunda işlenirken desteklenir.

Kırpma aralıklarını ayarlayın

processing yapılandırma nesnesinde start_offset ve end_offset belirterek videoyu kırpabilirsiniz.

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

REST

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

Özel bir kare hızı ayarlayın.

processing yapılandırma nesnesinde fps bağımsız değişkenini geçirerek özel kare hızı örneklemesi ayarlayabilirsiniz.

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

REST

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

Desteklenen video biçimleri

Gemini aşağıdaki video formatı MIME türlerini desteklemektedir:

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

Videolarla ilgili teknik detaylar

  • Desteklenen modeller ve bağlam: Tüm Gemini modelleri video verilerini işleyebilir.
    • 1 MB'lık bağlam penceresine sahip modeller, varsayılan olarak (düşük medya çözünürlüğünde) 3 saate kadar veya yüksek medya çözünürlüğünde 1 saate kadar uzunluktaki videoları işleyebilir.
  • İşleme modları: Gemini 3.8 Flash, 3.7 Flash, 3.6 Flash, 3.5 Flash Lite ve sonraki modeller iki video işleme modunu destekler:
    • Statik: Kareler 1 FPS hızında çıkarılır ve bağlam içine yerleştirilir (tüm modeller için varsayılan değer). Ses, 1 Kbps hızında (tek kanal) işlenir. Zaman damgaları her saniye eklenir. Kısa videolar veya her karenin önemli olduğu durumlarda (örneğin kare kare inceleme) en iyisidir. Hızlı aksiyon sahnelerinde, 1 FPS örnekleme hızı nedeniyle detay kaybı yaşanabileceğini lütfen unutmayın.
    • Ajantik: Model, videoda dinamik olarak gezinir, isteğe bağlı olarak transkripti ve/veya kareleri ve/veya sesi yükler. Bu yöntem, uzun içeriklerde %88'e kadar daha az belirteç kullanır; ancak, oluşturma başlamadan önce gerçekleşen dahili mantık ve araç gidiş-dönüşleri nedeniyle, kısa videolarda (<5 dakika) gezinme, İlk Belirteç Süresini (TTFT) biraz artırabilir. Uzun videolar için en uygunudur; jeton maliyetlerini ve yanıt kalitesini optimize eder. Gemini 3.8 Flash, 3.7 Flash, 3.6 Flash ve 3.5 Flash Lite sürümlerinde desteklenmektedir. Ayrıntılar için Ajans video anlayışı bölümüne bakın.
  • Token hesaplaması (statik mod): Videonun her saniyesi aşağıdaki gibi tokenleştirilir:
    • Tek tek kareler (1 FPS'de örneklenmiştir):
      • media_resolution düşük olarak ayarlanırsa, kareler kare başına 66 belirteç olacak şekilde belirteçlere ayrılır.
      • Aksi takdirde, çerçeveler çerçeve başına 258 belirteç üzerinden belirteçlere ayrılır.
    • Ses: Saniyede 32 belirteç.
    • Meta veriler de dahildir.
    • Toplam: Varsayılan (düşük) medya çözünürlüğünde saniyede yaklaşık 100 token, yüksek medya çözünürlüğünde ise saniyede yaklaşık 300 token video.
  • Token hesaplaması (ajan modu): Token kullanımı, içerik karmaşıklığına ve modelin gezinme stratejisine bağlı olarak değişir. Video keşfi sırasında oluşturulan gezinme akıl yürütme belirteçleri düşünce belirteçleri (total_thought_tokens) olarak, isteğe bağlı olarak yüklenen kareler, ses ve transkript ise araç kullanım belirteçleri (total_tool_use_tokens) olarak sayılır. Ajan tabanlı işlem, uzun biçimli içerik için statik işlemeye göre genellikle% 88'e kadar daha az toplam belirteç kullanır çünkü model yalnızca istemi yanıtlamak için ihtiyaç duyduğu transkripti ve/veya kareleri ve/veya sesi yükler (bkz. belirteç kılavuzu).
  • Medya çözünürlüğü: Gemini 3, media_resolution parametresiyle çok modlu görüntü işleme üzerinde ayrıntılı kontrol sunar. media_resolution parametresi, giriş görüntüsü veya video karesi başına ayrılan maksimum belirteç sayısını belirler. Daha yüksek çözünürlükler, modelin ince metinleri okuma veya küçük ayrıntıları belirleme yeteneğini geliştirir, ancak belirteç kullanımını ve gecikmeyi artırır. media_resolution ve processing parametreleri birbirinden bağımsızdır: ikisini de aynı video girişinde ayarlayabilirsiniz.

Jeton hesaplamaları hakkında daha fazla bilgi için jetonlar kılavuzuna bakın.

  • Zaman damgası biçimi: İsteminizde bir videodaki belirli anlardan bahsederken MM:SS biçimini kullanın (ör. 1 dakika 15 saniye için 01:15).
  • İstem yerleşimi: Metin ve tek bir video birleştiriliyorsa metin istemini input dizisinde video bölümünden sonra yerleştirin.
  • Uzun istekler için zaman aşımları: Uzun işlem süresi veya karmaşık çok adımlı akıl yürütme gerektiren videolar için akışı (stream=True) veya arka planda yürütmeyi (background=True) kullanın. Yüksek talep nedeniyle arka uçta yeniden denemelerle karşılaşan eşzamanlı, akış olmayan istekler, bağlantı veya kimlik doğrulama jetonu geçerlilik sürelerini aşabilir. Bu durum, beklenmedik 401 Unauthorized veya zaman aşımı hataları olarak ortaya çıkabilir. Yayın, bağlantıyı etkin tutar ve ara muhakeme ile araç çağrısı ilerleme durumunu gösterir.

Sırada ne var?

  • Medya çözünürlüğü: Kalite ile jeton kullanımı arasında denge kurmak için video karelerinin çözünürlüğünü kontrol edin.
  • Token'lar: Video içeriğinin hem statik hem de yapay zeka destekli işleme modlarında nasıl token'lara dönüştürüldüğünü anlayın.
  • Sistem talimatları: Sistem talimatları, modelin davranışını özel ihtiyaçlarınıza ve kullanım alanlarınıza göre yönlendirmenizi sağlar.
  • Files API: Gemini ile kullanılacak dosyaları yükleme ve yönetme hakkında daha fazla bilgi edinin.
  • Dosya istemi stratejileri: Gemini API, çok formatlı istem olarak da bilinen metin, resim, ses ve video verileriyle istem oluşturmayı destekler.
  • Güvenlikle ilgili rehberlik: Üretken yapay zeka modelleri bazen yanlış, taraflı veya rahatsız edici gibi beklenmedik çıktılar üretebilir. Bu tür çıkışlardan kaynaklanan zarar riskini sınırlamak için sonradan işleme ve insan değerlendirmesi gereklidir.