Mulai menggunakan Gemini 3

Gemini 3 adalah rangkaian model tercerdas kami hingga saat ini, yang dibangun berdasarkan penalaran canggih. Dirancang untuk mewujudkan ide apa pun dengan menguasai alur kerja agentik, coding otonom, dan tugas multimodal yang kompleks.

Panduan ini memberikan jalur praktis dan terpadu untuk mulai menggunakan Gemini 3 di Vertex AI, yang menyoroti fitur utama dan praktik terbaik Gemini 3.

Panduan Memulai

Sebelum memulai, Anda harus melakukan autentikasi ke Vertex AI menggunakan kunci API atau kredensial default aplikasi (ADC). Lihat metode autentikasi untuk mengetahui informasi selengkapnya.

Menginstal Google Gen AI SDK

Fitur Gemini 3 API memerlukan Gen AI SDK for Python versi 1.51.0 atau yang lebih baru.

pip install --upgrade google-genai

Tetapkan variabel lingkungan untuk menggunakan Gen AI SDK dengan Vertex AI

Ganti nilai GOOGLE_CLOUD_PROJECT dengan Google Cloud Project ID Anda. Model Pratinjau Gemini 3 Pro gemini-3-pro-preview hanya tersedia di endpoint global:

export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT
export GOOGLE_CLOUD_LOCATION=global
export GOOGLE_GENAI_USE_VERTEXAI=True

Membuat permintaan pertama Anda

Secara default, Gemini 3 Pro menggunakan pemikiran dinamis untuk memproses perintah. Untuk respons yang lebih cepat dan latensi yang lebih rendah saat penalaran yang kompleks tidak diperlukan, Anda dapat membatasi thinking_level model. Penalaran rendah ideal untuk tugas dengan throughput tinggi yang mengutamakan kecepatan, yang secara kasar cocok dengan profil latensi Gemini 2.5 Flash sekaligus memberikan kualitas respons yang lebih baik.

Untuk respons cepat dengan latensi rendah:

from google import genai
from google.genai import types

client = genai.Client()

response = client.models.generate_content(
   model="gemini-3-pro-preview",
   contents="How does AI work?",
   config=types.GenerateContentConfig(
       thinking_config=types.ThinkingConfig(
           thinking_level=types.ThinkingLevel.LOW # For fast and low latency response
       )
   ),
)
print(response.text)

Mencoba tugas penalaran yang kompleks

Gemini 3 unggul dalam penalaran tingkat lanjut. Untuk tugas kompleks seperti perencanaan multi-langkah, pembuatan kode terverifikasi, atau penggunaan alat yang mendalam, gunakan tingkat pemikiran tinggi. Gunakan konfigurasi ini untuk tugas yang sebelumnya memerlukan model penalaran khusus.

Untuk tugas yang lebih lambat dan membutuhkan penalaran tinggi:

from google import genai
from google.genai import types

client = genai.Client()

prompt = """
You are tasked with implementing the classic Thread-Safe Double-Checked Locking (DCL) Singleton pattern in modern C++. This task is non-trivial and requires specialized concurrency knowledge to prevent memory reordering issues.

Write a complete, runnable C++ program named `dcl_singleton.cpp` that defines a class `Singleton` with a private constructor and a static `getInstance()` method.

Your solution MUST adhere to the following strict constraints:
1. The Singleton instance pointer (`static Singleton*`) must be wrapped in `std::atomic` to correctly manage memory visibility across threads.
2. The `getInstance()` method must use `std::memory_order_acquire` when reading the instance pointer in the outer check.
3. The instance creation and write-back must use `std::memory_order_release` when writing to the atomic pointer.
4. A standard `std::mutex` must be used only to protect the critical section (the actual instantiation).
5. The `main` function must demonstrate safe, concurrent access by launching at least three threads, each calling `Singleton::getInstance()`, and printing the address of the returned instance to prove all threads received the same object.
"""

response = client.models.generate_content(
  model="gemini-3-pro-preview",
  contents=prompt,
  config=types.GenerateContentConfig(
      thinking_config=types.ThinkingConfig(
          thinking_level=types.ThinkingLevel.HIGH # Dynamic thinking for high reasoning tasks
      )
  ),
)
print(response.text)

Fitur API baru

Gemini 3 memperkenalkan peningkatan API yang canggih dan parameter baru yang didesain untuk memberi developer kontrol terperinci atas performa (latensi, biaya), perilaku model, dan kualitas multimodal.

Tabel ini merangkum fitur dan parameter inti baru yang tersedia, beserta link langsung ke dokumentasi detailnya:

Fitur/Perubahan API Baru Dokumentasi
Model: gemini-3-pro-preview Kartu model Model Garden
Tingkat pemikiran Berpikir
Resolusi media Pemahaman gambar Pemahaman video Pemahaman audio Pemahaman dokumen
Tanda tangan pikiran Tanda tangan pikiran
Temperatur Referensi API
Respons fungsi multimodal Panggilan fungsi: Respons fungsi multimodal
Panggilan fungsi streaming Panggilan fungsi: Panggilan fungsi streaming

Tingkat pemikiran

Parameter thinking_level memungkinkan Anda menentukan anggaran penalaran untuk pembuatan respons model. Dengan memilih salah satu dari dua status, Anda dapat secara eksplisit menyeimbangkan kompromi antara kualitas respons dan kompleksitas penalaran serta latensi dan biaya.

  • Rendah: Meminimalkan latensi dan biaya. Paling cocok untuk mengikuti petunjuk atau melakukan chat.
  • Tinggi: Memaksimalkan kedalaman penalaran. Default. Pemikiran dinamis. Model mungkin memerlukan waktu yang jauh lebih lama untuk mencapai token pertama, tetapi outputnya akan diperiksa lebih menyeluruh.

Contoh Gen AI SDK

from google import genai
from google.genai import types

client = genai.Client()

response = client.models.generate_content(
   model="gemini-3-pro-preview",
   contents="Find the race condition in this multi-threaded C++ snippet: [code here]",
   config=types.GenerateContentConfig(
       thinking_config=types.ThinkingConfig(
           thinking_level=types.ThinkingLevel.HIGH # Default, dynamic thinking
       )
   ),
)
print(response.text)

Contoh kompatibilitas OpenAI

Untuk pengguna yang memanfaatkan lapisan kompatibilitas OpenAI, parameter standar akan dipetakan secara otomatis ke parameter yang setara dengan Gemini 3:

  • reasoning_effort dipetakan ke thinking_level.
  • Nilai reasoning_effort medium dipetakan ke thinking_level tinggi.
import openai
from google.auth import default
from google.auth.transport.requests import Request

credentials, _ = default(scopes=["https://www.googleapis.com/auth/cloud-platform"])

client = openai.OpenAI(
    base_url=f"https://aiplatform.googleapis.com/v1/projects/{PROJECT_ID}/locations/global/endpoints/openapi",
    api_key=credentials.token,
)

prompt = """
Write a bash script that takes a matrix represented as a string with
format '[1,2],[3,4],[5,6]' and prints the transpose in the same format.
"""

response = client.chat.completions.create(
    model="gemini-3-pro-preview",
    reasoning_effort="medium", # Map to thinking_level high.
    messages=[{"role": "user", "content": prompt}],
)

print(response.choices[0].message.content)

Resolusi media

Gemini 3 memperkenalkan kontrol terperinci atas pemrosesan visi multimodal menggunakan parameter media_resolution. Resolusi yang lebih tinggi meningkatkan kemampuan model untuk membaca teks kecil atau mengidentifikasi detail kecil, tetapi meningkatkan penggunaan token dan latensi. Parameter media_resolution menentukan jumlah maksimum token yang dialokasikan per gambar input, halaman PDF, atau frame video.

Anda dapat menyetel resolusi ke low, medium, atau high per bagian media individual atau secara global (menggunakan generation_config). Jika tidak ditentukan, model akan menggunakan default optimal berdasarkan jenis media.

Token
Image Video PDF
MEDIA_RESOLUTION_UNSPECIFIED (DEFAULT) 1120 70 560
MEDIA_RESOLUTION_LOW 280 70 280
MEDIA_RESOLUTION_MEDIUM 560 70 560
MEDIA_RESOLUTION_HIGH 1120 280 1120
Resolusi Media Token Maksimal Panduan Penggunaan
high 1120 Tugas analisis gambar untuk memastikan kualitas maksimum.
medium 560
low Gambar: 280 Video: 70 Cukup untuk sebagian besar tugas. Catatan: Untuk Video, low adalah maksimum 70 token per frame.

Menetapkan media_resolution per bagian individual

Anda dapat menetapkan media_resolution per bagian media individual:

from google import genai
from google.genai import types

client = genai.Client()

response = client.models.generate_content(
  model="gemini-3-pro-preview",
  contents=[
      types.Part(
          file_data=types.FileData(
              file_uri="gs://cloud-samples-data/generative-ai/image/a-man-and-a-dog.png",
              mime_type="image/jpeg",
          ),
          media_resolution=types.PartMediaResolution(
              level=types.PartMediaResolutionLevel.MEDIA_RESOLUTION_HIGH # High resolution
          ),
      ),
      Part(
          file_data=types.FileData(
             file_uri="gs://cloud-samples-data/generative-ai/video/behind_the_scenes_pixel.mp4",
            mime_type="video/mp4",
          ),
          media_resolution=types.PartMediaResolution(
              level=types.PartMediaResolutionLevel.MEDIA_RESOLUTION_LOW # Low resolution
          ),
      ),
      "When does the image appear in the video? What is the context?",
  ],
)
print(response.text)

Menetapkan media_resolution secara global

Anda juga dapat menetapkan media_resolution secara global (menggunakan GenerateContentConfig):

from google import genai
from google.genai import types

client = genai.Client()

response = client.models.generate_content(
  model="gemini-3-pro-preview",
  contents=[
      types.Part(
          file_data=types.FileData(
              file_uri="gs://cloud-samples-data/generative-ai/image/a-man-and-a-dog.png",
              mime_type="image/jpeg",
          ),
      ),
      "What is in the image?",
  ],
  config=types.GenerateContentConfig(
      media_resolution=types.MediaResolution.MEDIA_RESOLUTION_LOW, # Global setting
  ),
)
print(response.text)

Tanda tangan pikiran

Tanda tangan pemikiran adalah token terenkripsi yang mempertahankan status penalaran model selama percakapan multi-giliran, khususnya saat menggunakan panggilan fungsi.

Saat memutuskan untuk memanggil alat eksternal, model pemikiran akan menjeda proses penalaran internalnya. Tanda tangan pemikiran berfungsi sebagai "status penyimpanan", yang memungkinkan model melanjutkan rantai pemikirannya dengan lancar setelah Anda memberikan hasil fungsi.

Untuk mengetahui informasi selengkapnya, lihat Tanda tangan pikiran.

Mengapa tanda tangan pikiran penting?

Tanpa tanda tangan pemikiran, model "melupakan" langkah-langkah penalarannya yang spesifik selama fase eksekusi alat. Mengirimkan kembali tanda tangan memastikan:

  • Kontinuitas konteks: Model mempertahankan alasan mengapa alat dipanggil.
  • Penalaran kompleks: Memungkinkan tugas multi-langkah di mana output dari satu alat menginformasikan penalaran untuk alat berikutnya.

Di mana tanda tangan pikiran ditampilkan?

Gemini 3 Pro menerapkan validasi yang lebih ketat dan penanganan yang diperbarui pada tanda tangan pemikiran yang awalnya diperkenalkan di Gemini 2.5. Untuk memastikan model mempertahankan konteks di beberapa giliran percakapan, Anda harus menampilkan tanda tangan pemikiran dalam permintaan berikutnya.

  • Respons model dengan panggilan fungsi akan selalu menampilkan tanda tangan pemikiran.
  • Jika ada panggilan fungsi paralel, bagian panggilan fungsi pertama yang ditampilkan oleh respons model akan memiliki tanda tangan pemikiran.
  • Jika ada panggilan fungsi berurutan (multi-langkah), setiap panggilan fungsi akan memiliki tanda tangan dan klien diharapkan untuk meneruskan tanda tangan kembali
  • Respons model tanpa panggilan fungsi akan menampilkan tanda tangan pemikiran di dalam bagian terakhir yang ditampilkan oleh model.

Bagaimana cara menangani tanda tangan pikiran?

Ada dua cara utama untuk menangani tanda tangan pemikiran: secara otomatis menggunakan SDK AI Generatif atau OpenAI API, atau secara manual jika Anda berinteraksi dengan API secara langsung.

Jika Anda menggunakan Google Gen AI SDK (Python, Node.js, Go, Java) atau OpenAI Chat Completions API, dan memanfaatkan fitur histori chat standar atau menambahkan respons model lengkap, thought_signatures akan ditangani secara otomatis. Anda tidak perlu melakukan perubahan apa pun pada kode.

Contoh panggilan fungsi manual

Saat menggunakan Gen AI SDK, tanda tangan pemikiran ditangani secara otomatis dengan menambahkan respons model lengkap dalam permintaan model berurutan:

from google import genai
from google.genai import types

client = genai.Client()

# 1. Define your tool
get_weather_declaration = types.FunctionDeclaration(
   name="get_weather",
   description="Gets the current weather temperature for a given location.",
   parameters={
       "type": "object",
       "properties": {"location": {"type": "string"}},
       "required": ["location"],
   },
)
get_weather_tool = types.Tool(function_declarations=[get_weather_declaration])

# 2. Send a message that triggers the tool
prompt = "What's the weather like in London?"
response = client.models.generate_content(
   model="gemini-3-pro-preview",
   contents=prompt,
   config=types.GenerateContentConfig(
       tools=[get_weather_tool],
       thinking_config=types.ThinkingConfig(include_thoughts=True)
   ),
)

# 4. Handle the function call
function_call = response.function_calls[0]
location = function_call.args["location"]
print(f"Model wants to call: {function_call.name}")

# Execute your tool (e.g., call an API)
# (This is a mock response for the example)
print(f"Calling external tool for: {location}")
function_response_data = {
   "location": location,
   "temperature": "30C",
}

# 5. Send the tool's result back
# Append this turn's messages to history for a final response.
# The `content` object automatically attaches the required thought_signature behind the scenes.
history = [
    types.Content(role="user", parts=[types.Part(text=prompt)]),
    response.candidates[0].content, # Signature preserved here
    types.Content(
        role="tool",
        parts=[
            types.Part.from_function_response(
                name=function_call.name,
                response=function_response_data,
            )
        ],
    )
]

response_2 = client.models.generate_content(
   model="gemini-3-pro-preview",
   contents=history,
   config=types.GenerateContentConfig(
        tools=[get_weather_tool],
        thinking_config=types.ThinkingConfig(include_thoughts=True)
   ),
)

# 6. Get the final, natural-language answer
print(f"\nFinal model response: {response_2.text}")
Contoh panggilan fungsi otomatis

Saat menggunakan Gen AI SDK dalam panggilan fungsi otomatis, tanda tangan pemikiran ditangani secara otomatis:


from google import genai
from google.genai import types

def get_current_temperature(location: str) -> dict:
    """Gets the current temperature for a given location.

    Args:
        location: The city and state, for example San Francisco, CA

    Returns:
        A dictionary containing the temperature and unit.
    """
    # ... (implementation) ...
    return {"temperature": 25, "unit": "Celsius"}

client = genai.Client()

response = client.models.generate_content(
    model="gemini-3-pro-preview",
    contents="What's the temperature in Boston?",
    config=types.GenerateContentConfig(
            tools=[get_current_temperature],
    )
)

print(response.text) # The SDK handles the function call and thought signature, and returns the final text
Contoh kompatibilitas OpenAI

Saat menggunakan OpenAI Chat Completions API, tanda tangan pemikiran ditangani secara otomatis dengan menambahkan respons model lengkap dalam permintaan model berurutan:

...
# Append user prompt and assistant response including thought signatures
messages.append(response1.choices[0].message)

# Execute the tool
tool_call_1 = response1.choices[0].message.tool_calls[0]
result_1 = get_current_temperature(**json.loads(tool_call_1.function.arguments))

# Append tool response to messages
messages.append(
    {
        "role": "tool",
        "tool_call_id": tool_call_1.id,
        "content": json.dumps(result_1),
    }
)

response2 = client.chat.completions.create(
    model="gemini-3-pro-preview",
    messages=messages,
    tools=tools,
    extra_body={
        "extra_body": {
            "google": {
                "thinking_config": {
                    "include_thoughts": True,
                },
            },
        },
    },
)

print(response2.choices[0].message.tool_calls)

Lihat contoh kode lengkap.

Penanganan manual

Jika Anda berinteraksi dengan API secara langsung atau mengelola payload JSON mentah, Anda harus menangani thought_signature yang disertakan dalam giliran model dengan benar.

Anda harus menampilkan tanda tangan ini di bagian yang sama persis dengan saat tanda tangan diterima saat mengirimkan kembali histori percakapan.

Jika tanda tangan yang tepat tidak ditampilkan, Gemini 3 akan menampilkan Error 400 "<Function Call> di blok konten <index of contents array> tidak memiliki thought_signature".

Respons fungsi multimodal

Panggilan fungsi multimodal memungkinkan pengguna memiliki respons fungsi yang berisi objek multimodal sehingga meningkatkan pemanfaatan kemampuan panggilan fungsi model. Panggilan fungsi standar hanya mendukung respons fungsi berbasis teks:

from google import genai
from google.genai import types

client = genai.Client()

# This is a manual, two turn multimodal function calling workflow:

# 1. Define the function tool
get_image_declaration = types.FunctionDeclaration(
   name="get_image",
   description="Retrieves the image file reference for a specific order item.",
   parameters={
       "type": "object",
       "properties": {
            "item_name": {
                "type": "string",
                "description": "The name or description of the item ordered (e.g., 'green shirt')."
            }
       },
       "required": ["item_name"],
   },
)
tool_config = types.Tool(function_declarations=[get_image_declaration])

# 2. Send a message that triggers the tool
prompt = "Show me the green shirt I ordered last month."
response_1 = client.models.generate_content(
    model="gemini-3-pro-preview",
    contents=[prompt],
    config=types.GenerateContentConfig(
        tools=[tool_config],
    )
)

# 3. Handle the function call
function_call = response_1.function_calls[0]
requested_item = function_call.args["item_name"]
print(f"Model wants to call: {function_call.name}")

# Execute your tool (e.g., call an API)
# (This is a mock response for the example)
print(f"Calling external tool for: {requested_item}")

function_response_data = {
  "image_ref": {"$ref": "dress.jpg"},
}

function_response_multimodal_data = types.FunctionResponsePart(
   file_data=types.FunctionResponseFileData(
      mime_type="image/png",
      display_name="dress.jpg",
      file_uri="gs://cloud-samples-data/generative-ai/image/dress.jpg",
   )
)

# 4. Send the tool's result back
# Append this turn's messages to history for a final response.
history = [
  types.Content(role="user", parts=[types.Part(text=prompt)]),
  response_1.candidates[0].content,
  types.Content(
    role="tool",
    parts=[
        types.Part.from_function_response(
            name=function_call.name,
            response=function_response_data,
            parts=[function_response_multimodal_data]
        )
    ],
  )
]

response_2 = client.models.generate_content(
  model="gemini-3-pro-preview",
  contents=history,
  config=types.GenerateContentConfig(
      tools=[tool_config],
      thinking_config=types.ThinkingConfig(include_thoughts=True)
  ),
)

print(f"\nFinal model response: {response_2.text}")

Panggilan fungsi streaming

Anda dapat menggunakan argumen panggilan fungsi parsial streaming untuk meningkatkan pengalaman streaming saat menggunakan alat. Fitur ini dapat diaktifkan dengan menetapkan stream_function_call_arguments ke true secara eksplisit:

from google import genai
from google.genai import types

client = genai.Client()

get_weather_declaration = types.FunctionDeclaration(
  name="get_weather",
  description="Gets the current weather temperature for a given location.",
  parameters={
      "type": "object",
      "properties": {"location": {"type": "string"}},
      "required": ["location"],
  },
)
get_weather_tool = types.Tool(function_declarations=[get_weather_declaration])


for chunk in client.models.generate_content_stream(
   model="gemini-3-pro-preview",
   contents="What's the weather in London and New York?",
   config=types.GenerateContentConfig(
       tools=[get_weather_tool],
       tool_config = types.ToolConfig(
           function_calling_config=types.FunctionCallingConfig(
               mode=types.FunctionCallingConfigMode.AUTO,
               stream_function_call_arguments=True,
           )
       ),
   ),
):
   function_call = chunk.function_calls[0]
   if function_call and function_call.name:
       print(f"{function_call.name}")
       print(f"will_continue={function_call.will_continue}")

Contoh respons model:

{
  "candidates": [
    {
      "content": {
        "role": "model",
        "parts": [
          {
            "functionCall": {
              "name": "get_weather",
              "willContinue": true
            }
          }
        ]
      }
    }
  ]
}

Temperatur

  • Range for Gemini 3: 0.0 - 2.0 (default: 1.0)

Untuk Gemini 3, sebaiknya pertahankan parameter temperature pada nilai defaultnya, yaitu 1.0.

Meskipun model sebelumnya sering kali diuntungkan dengan menyesuaikan suhu untuk mengontrol kreativitas versus determinisme, kemampuan penalaran Gemini 3 dioptimalkan untuk setelan default.

Mengubah suhu (menyetelnya ke kurang dari 1.0) dapat menyebabkan perilaku yang tidak terduga, seperti perulangan atau penurunan performa, terutama dalam tugas matematika atau penalaran yang kompleks.

Fitur yang didukung

Gemini 3 Pro juga mendukung fitur berikut:

Praktik terbaik pembuatan perintah

Gemini 3 adalah model penalaran, yang mengubah cara Anda memberikan perintah.

  • Petunjuk yang presisi: Berikan perintah input yang ringkas. Gemini 3 merespons dengan baik petunjuk yang langsung dan jelas. Model ini dapat menganalisis secara berlebihan teknik pembuatan perintah yang panjang atau terlalu kompleks yang digunakan untuk model lama.
  • Panjang output: Secara default, Gemini 3 tidak terlalu panjang dan lebih memilih memberikan jawaban yang langsung dan efisien. Jika kasus penggunaan Anda memerlukan persona yang lebih komunikatif atau "ramah", Anda harus secara eksplisit mengarahkan model dalam perintah (misalnya, "Jelaskan ini sebagai asisten yang ramah dan suka berbicara").

Pertimbangan migrasi

Pertimbangkan fitur dan batasan berikut saat melakukan migrasi:

  • Tingkat pemikiran: Model Gemini 3 Pro dan yang lebih baru menggunakan parameter thinking_level untuk mengontrol jumlah penalaran internal yang dilakukan model (rendah atau tinggi) dan untuk menyeimbangkan kualitas respons, kompleksitas penalaran, latensi, dan biaya.
  • Setelan suhu: Jika kode yang ada secara eksplisit menetapkan temperature (terutama ke nilai rendah untuk output deterministik), sebaiknya hapus parameter ini dan gunakan default Gemini 3 1.0 untuk menghindari potensi masalah perulangan atau penurunan performa pada tugas yang kompleks.
  • Tanda tangan pemikiran: Untuk model Gemini 3 Pro dan yang lebih baru, jika tanda tangan pemikiran diharapkan dalam giliran, tetapi tidak diberikan, model akan menampilkan error, bukan peringatan.
  • Resolusi media dan tokenisasi: Model Gemini 3 Pro dan yang lebih baru menggunakan panjang urutan variabel untuk tokenisasi media, bukan Pan dan Scan, serta memiliki resolusi default dan biaya token baru untuk gambar, PDF, dan video.
  • Penghitungan token untuk input multimodal: Jumlah token untuk input multimodal (gambar, video, audio) adalah perkiraan berdasarkan media_resolution yang dipilih. Oleh karena itu, hasil dari panggilan API count_tokens mungkin tidak sesuai dengan token yang digunakan pada akhirnya. Penggunaan yang akurat untuk penagihan hanya tersedia setelah eksekusi dalam usage_metadata respons.
  • Penggunaan token: Bermigrasi ke setelan default Gemini 3 Pro dapat meningkatkan penggunaan token untuk gambar dan PDF, tetapi menurunkan penggunaan token untuk video. Jika permintaan kini melebihi jendela konteks karena resolusi default yang lebih tinggi, sebaiknya kurangi resolusi media secara eksplisit.
  • Pemahaman PDF & dokumen: Resolusi OCR default untuk PDF telah berubah. Jika Anda mengandalkan perilaku tertentu untuk penguraian dokumen padat, uji setelan media_resolution: "high" baru untuk memastikan akurasi berkelanjutan. Untuk model Gemini 3 Pro dan yang lebih baru, jumlah token PDF di usage_metadata dilaporkan dalam modalitas IMAGE, bukan DOCUMENT.
  • Segmentasi gambar: Segmentasi gambar tidak didukung oleh model Gemini 3 Pro dan yang lebih baru. Untuk workload yang memerlukan segmentasi gambar bawaan, sebaiknya terus gunakan Gemini 2.5 Flash dengan penalaran dinonaktifkan.
  • Respons fungsi multimodal: Untuk model Gemini 3 Pro dan yang lebih baru, Anda dapat menyertakan data gambar dan PDF dalam respons fungsi.

FAQ

  1. Berapa batas waktu pengetahuan untuk Gemini 3 Pro? Gemini 3 memiliki batas pengetahuan hingga Januari 2025.

  2. Region mana yang gemini-3-pro-preview tersedia di Google Cloud? Global.

  3. Berapa batas jendela konteks? Gemini 3 Pro mendukung jendela konteks input 1 juta token dan output hingga 64 ribu token.

  4. Apakah gemini-3-pro-preview mendukung output gambar? Tidak.

  5. Apakah gemini-3-pro-preview mendukung Gemini Live API? Tidak.

Langkah berikutnya