Mulai menggunakan Gemini 3

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

Panduan ini memberikan jalur praktis dan terpadu untuk mulai menggunakan Gemini 3 di Gemini Enterprise Agent Platform, dengan menyoroti fitur utama dan praktik terbaik Gemini 3.

Panduan Memulai

Sebelum memulai, Anda harus melakukan autentikasi ke Gemini Enterprise Agent Platform 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 Google Gen AI SDK untuk Python versi 1.51.0 atau yang lebih baru.

pip install --upgrade google-genai

Menetapkan variabel lingkungan untuk menggunakan Google Gen AI SDK dengan Gemini Enterprise Agent Platform

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

export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT
export GOOGLE_CLOUD_LOCATION=global
export GOOGLE_GENAI_USE_ENTERPRISE=True

Membuat permintaan pertama Anda

Secara default, model Gemini 3 dan Gemini 3 Flash menggunakan penalaran dinamis untuk memproses perintah. Untuk respons yang lebih cepat dan latensi lebih rendah saat penalaran kompleks tidak diperlukan, Anda dapat membatasi thinking_level model. Penalaran rendah ideal untuk tugas dengan throughput tinggi yang mengutamakan kecepatan.

Untuk respons yang cepat dan berlatensi rendah:

from google import genai
from google.genai import types

client = genai.Client()

response = client.models.generate_content(
   model="gemini-3.6-flash",
   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 canggih. Untuk tugas kompleks seperti perencanaan multilangkah, pembuatan kode terverifikasi, atau penggunaan alat yang mendalam, gunakan tingkat penalaran tinggi. Gunakan konfigurasi ini untuk tugas yang sebelumnya memerlukan model penalaran khusus.

Untuk tugas yang lebih lambat dan memerlukan 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.6-flash",
  contents=prompt,
  config=types.GenerateContentConfig(
      thinking_config=types.ThinkingConfig(
          thinking_level=types.ThinkingLevel.HIGH # Dynamic thinking for high reasoning tasks
      )
  ),
)
print(response.text)

Tingkat penalaran lainnya

Gemini 3 Flash memperkenalkan dua level penalaran baru: MINIMAL dan MEDIUM untuk memberi Anda kontrol yang lebih besar atas cara model menangani tugas penalaran yang kompleks.

MINIMAL menawarkan opsi anggaran penalaran yang mendekati nol untuk tugas yang dioptimalkan untuk throughput, bukan penalaran. MEDIUM memungkinkan keseimbangan antara kecepatan dan penalaran yang memungkinkan beberapa kemampuan penalaran, tetapi tetap memprioritaskan operasi latensi rendah.

Fitur API baru

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

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

Fitur Baru/Perubahan API Dokumentasi
Model: gemini-3.1-pro-preview Kartu model
Model Garden Gemini Enterprise Agent Platform
Tingkat penalaran Penalaran
Resolusi media Pemahaman gambar
Pemahaman video
Pemahaman audio
Pemahaman dokumen
Tanda tangan penalaran Tanda tangan penalaran
Temperatur Referensi API
Respons fungsi multimodal Pemanggilan fungsi: Respons fungsi multimodal
Pemanggilan fungsi streaming Pemanggilan fungsi: Pemanggilan fungsi streaming

Tingkat penalaran

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

  • MINIMAL: (Khusus Gemini 3 Flash dan Gemini 3.1 Flash-Lite) Membatasi model untuk menggunakan token sesedikit mungkin untuk berpikir dan paling cocok digunakan untuk tugas dengan kompleksitas rendah yang tidak akan mendapatkan manfaat dari penalaran yang ekstensif. MINIMAL sedekat mungkin dengan anggaran nol untuk penalaran, tetapi masih memerlukan tanda tangan pemikiran.
  • LOW: Membatasi model untuk menggunakan lebih sedikit token untuk penalaran dan cocok untuk tugas yang lebih sederhana yang tidak memerlukan penalaran ekstensif. LOW ideal untuk tugas dengan throughput tinggi yang mengutamakan kecepatan.
  • MEDIUM: (Khusus Gemini 3 Flash, Gemini 3.1 Pro, dan Gemini 3.1 Flash-Lite) Menawarkan pendekatan yang seimbang dan cocok untuk tugas dengan kompleksitas sedang yang memerlukan penalaran, tetapi tidak memerlukan perencanaan mendalam dan multilangkah. Model ini memberikan kemampuan penalaran yang lebih baik daripada LOW, sekaligus mempertahankan latensi yang lebih rendah daripada HIGH.
  • HIGH: Memungkinkan model menggunakan lebih banyak token untuk berpikir dan cocok untuk perintah kompleks yang memerlukan penalaran mendalam, seperti perencanaan multi-langkah, pembuatan kode terverifikasi, atau skenario panggilan fungsi lanjutan. Ini adalah tingkat default untuk model Gemini 3 dan Gemini 3 Flash. Gunakan konfigurasi ini saat mengganti tugas yang sebelumnya mungkin Anda andalkan pada model penalaran khusus.

Contoh Google Gen AI SDK

from google import genai
from google.genai import types

client = genai.Client()

response = client.models.generate_content(
   model="gemini-3.6-flash",
   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

Bagi pengguna yang menggunakan lapisan kompatibilitas OpenAI, parameter standar akan otomatis dipetakan ke parameter yang setara di Gemini 3:

  • reasoning_effort dipetakan ke thinking_level.
  • none: dipetakan ke thinking_level minimal (khusus Gemini 3 Flash).
  • medium: dipetakan ke tingkat sedang thinking_level untuk semua model Gemini 3.
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.6-flash",
    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 halus 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 menetapkan resolusi ke low, medium, atau high secara global (menggunakan generation_config) atau untuk setiap bagian media. Resolusi ultra_high hanya dapat ditetapkan untuk setiap bagian media. Jika tidak ditentukan, model akan menggunakan default yang optimal berdasarkan jenis media.

Jumlah token

Tabel ini merangkum perkiraan jumlah token untuk setiap nilai media_resolution dan jenis media.

Resolusi Media Gambar Video PDF
UNSPECIFIED (Default) 1120 70 560
LOW 280 70 280 + Text
MEDIUM 560 70 560 + Teks
HIGH 1120 280 1120 + Teks
ULTRA_HIGH 2240 T/A T/A
Resolusi Media Token Maksimum Panduan Penggunaan
ultra_high 2240 Tugas yang memerlukan analisis detail halus dalam gambar, seperti memproses gambar diam rekaman layar atau foto beresolusi tinggi.
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:

from google import genai
from google.genai import types

client = genai.Client()

response = client.models.generate_content(
  model="gemini-3.6-flash",
  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.6-flash",
  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 penalaran

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

Saat model penalaran memutuskan untuk memanggil alat eksternal, model tersebut akan menjeda proses penalaran internalnya. Tanda tangan pemikiran bertindak sebagai "status simpan", yang memungkinkan model melanjutkan chain of thought-nya dengan lancar setelah Anda memberikan hasil fungsi.

Untuk mengetahui informasi selengkapnya, lihat Tanda tangan pemikiran.

Mengapa tanda tangan pemikiran itu penting?

Tanpa tanda tangan pemikiran, model akan "melupakan" langkah-langkah penalaran spesifiknya selama fase eksekusi alat. Meneruskan kembali tanda tangan akan memastikan:

  • Kontinuitas konteks: Model mempertahankan alasan alat dipanggil.
  • Penalaran kompleks: Memungkinkan tugas multi-langkah, dengan output dari satu alat menjadi dasar penalaran untuk alat berikutnya.

Di mana tanda tangan pemikiran ditampilkan?

Model Gemini 3 dan Gemini 3 Flash menerapkan validasi yang lebih ketat dan penanganan yang diperbarui pada signature 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, bahkan saat menggunakan tingkat penalaran MINIMAL.
  • Jika ada panggilan fungsi paralel, bagian panggilan fungsi pertama yang ditampilkan oleh respons model akan memiliki tanda tangan pemikiran.
  • Jika ada panggilan fungsi berurutan (beberapa 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 pemikiran?

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

Pemrosesan otomatis (direkomendasikan)

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

Contoh panggilan fungsi manual

Saat menggunakan Google 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.6-flash",
   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="user",
        parts=[
            types.Part.from_function_response(
                name=function_call.name,
                response=function_response_data,
            )
        ],
    )
]

response_2 = client.models.generate_content(
   model="gemini-3.6-flash",
   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 Google Gen AI SDK dalam pemanggilan fungsi otomatis, tanda tangan pemikiran akan 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.6-flash",
    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": "user",
        "tool_call_id": tool_call_1.id,
        "content": json.dumps(result_1),
    }
)

response2 = client.chat.completions.create(
    model="gemini-3.6-flash",
    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 tempat tanda tangan tersebut diterima saat mengirim 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

Pemanggilan fungsi multimodal memungkinkan pengguna memiliki respons fungsi yang berisi objek multimodal sehingga memungkinkan peningkatan pemanfaatan kemampuan pemanggilan fungsi model. Pemanggilan 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.6-flash",
    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="user",
    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.6-flash",
  contents=history,
  config=types.GenerateContentConfig(
      tools=[tool_config],
      thinking_config=types.ThinkingConfig(include_thoughts=True)
  ),
)

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

Pemanggilan fungsi streaming

Anda dapat menggunakan argumen panggilan fungsi parsial streaming untuk meningkatkan pengalaman streaming pada penggunaan 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.6-flash",
   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, sangat disarankan untuk mempertahankan parameter temperature pada nilai defaultnya, yaitu 1.0.

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

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

Fitur yang didukung

Model Gemini 3 juga mendukung fitur berikut:

Praktik terbaik dalam memberikan perintah

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

  • Petunjuk yang tepat: Buat perintah input yang ringkas. Gemini 3 merespons paling baik terhadap petunjuk yang langsung dan jelas. Model ini mungkin terlalu menganalisis teknik rekayasa perintah yang panjang atau terlalu kompleks yang digunakan untuk model lama.
  • Panjang respons output: Secara default, Gemini 3 memberikan respons yang lebih singkat dan lebih memilih memberikan jawaban langsung yang efisien. Jika kasus penggunaan Anda memerlukan persona yang lebih komunikatif atau "banyak bicara", Anda harus secara eksplisit mengarahkan model dalam prompt (misalnya, "Jelaskan ini sebagai asisten yang ramah dan banyak bicara").
  • Grounding: Untuk kasus penggunaan grounding, sebaiknya gunakan petunjuk developer berikut: You are a strictly grounded assistant limited to the information provided in the User Context. In your answers, rely **only** on the facts that are directly mentioned in that context. You must **not** access or utilize your own knowledge or common sense to answer. Do not assume or infer from the provided facts; simply report them exactly as they appear. Your answer must be factual and fully truthful to the provided text, leaving absolutely no room for speculation or interpretation. Treat the provided context as the absolute limit of truth; any facts or details that are not directly mentioned in the context must be considered **completely untruthful** and **completely unsupported**. If the exact answer is not explicitly written in the context, you must state that the information is not available.
  • Menggunakan alat Google Penelusuran: Saat menggunakan alat Google Penelusuran, Gemini 3 Flash terkadang dapat membingungkan tanggal/waktu saat ini untuk peristiwa pada tahun 2024. Hal ini dapat menyebabkan model merumuskan kueri penelusuran untuk tahun yang salah. Untuk memastikan model menggunakan jangka waktu yang benar, perkuat tanggal saat ini secara eksplisit di system instructions: For time-sensitive user queries that require up-to-date information, you MUST follow the provided current time (date and year) when formulating search queries in tool calls. Remember it is 2025 this year.
  • Batas informasi: Untuk kueri tertentu, Gemini 3 Flash akan memberikan hasil yang lebih baik jika diberi tahu batas informasinya secara eksplisit. Hal ini terjadi jika alat Google Penelusuran dinonaktifkan dan kueri secara eksplisit mengharuskan model dapat mengidentifikasi data batas dalam pengetahuan parametrik. Rekomendasi: Menambahkan klausa berikut ke system instructions: Your knowledge cutoff date is January 2025.
  • Menggunakan media_resolution: Gunakan parameter media_resolution untuk mengontrol jumlah maksimum token yang digunakan model untuk merepresentasikan gambar atau frame dalam video. Resolusi tinggi akan memungkinkan model menangkap detail dalam gambar, dan dapat menggunakan lebih banyak token per frame, sedangkan resolusi yang lebih rendah memungkinkan pengoptimalan biaya dan latensi untuk gambar dengan detail visual yang lebih sedikit.
  • Meningkatkan analisis video: Gunakan frekuensi sampling Frame Per Detik (FPS) yang lebih tinggi untuk video yang memerlukan analisis temporal terperinci, seperti pemahaman tindakan cepat atau pelacakan gerakan berkecepatan tinggi.

Pertimbangan migrasi

Pertimbangkan fitur dan batasan berikut saat melakukan migrasi:

  • Thinking level: Model Gemini 3 menggunakan parameter thinking_level untuk mengontrol jumlah penalaran internal yang dilakukan model (low atau high) 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 pengulangan atau penurunan performa pada tugas yang kompleks.
  • Tanda tangan pemikiran: Untuk model Gemini 3, jika tanda tangan pemikiran diharapkan dalam giliran tetapi tidak diberikan, model akan menampilkan error, bukan peringatan.
  • Resolusi dan tokenisasi media: Model Gemini 3 menggunakan panjang urutan variabel untuk tokenisasi media, bukan Pan and Scan, serta memiliki resolusi default dan biaya token baru untuk gambar, PDF, dan video.
  • Penghitungan token untuk input multimodalitas: Jumlah token untuk input multimodal (gambar, video, audio) adalah estimasi berdasarkan media_resolution yang dipilih. Oleh karena itu, hasil dari panggilan API count_tokens mungkin tidak cocok dengan token yang digunakan akhir. Penggunaan yang akurat untuk penagihan hanya tersedia setelah eksekusi dalam usage_metadata respons.
  • Pemakaian token: Migrasi ke setelan default Gemini 3 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 yang berkelanjutan. Untuk model Gemini 3, jumlah token PDF di usage_metadata dilaporkan dalam modalitas IMAGE, bukan DOCUMENT.
  • Segmentasi gambar: Segmentasi gambar tidak didukung oleh model Gemini 3. Untuk workload yang memerlukan segmentasi gambar bawaan, sebaiknya terus gunakan Gemini 2.5 Flash dengan penalaran dinonaktifkan.
  • Respons fungsi multimodal: Untuk model Gemini 3, Anda dapat menyertakan data gambar dan PDF dalam respons fungsi.

FAQ

  1. Di region mana gemini-3.1-pro-preview tersedia Google Cloud? Global.

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

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

  4. Apakah gemini-3.1-pro-preview mendukung Gemini Live API? Tidak.

Langkah berikutnya