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.MINIMALsedekat 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.LOWideal 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 daripadaLOW, sekaligus mempertahankan latensi yang lebih rendah daripadaHIGH.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_effortdipetakan kethinking_level.none: dipetakan kethinking_levelminimal (khusus Gemini 3 Flash).medium: dipetakan ke tingkat sedangthinking_leveluntuk 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 | |
|---|---|---|---|
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 |
Setelan yang direkomendasikan
| 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:
- Petunjuk sistem
- Output terstruktur
- Pemanggilan fungsi
- Grounding dengan Google Penelusuran
- Eksekusi kode
- Konteks URL
- Penalaran
- Cache konteks
- Menghitung token
- Penyelesaian chat
- Prediksi batch
- Throughput yang Disediakan
- Bayar sesuai penggunaan standar
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 parametermedia_resolutionuntuk 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_leveluntuk 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 31.0untuk 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_resolutionyang dipilih. Oleh karena itu, hasil dari panggilan APIcount_tokensmungkin tidak cocok dengan token yang digunakan akhir. Penggunaan yang akurat untuk penagihan hanya tersedia setelah eksekusi dalamusage_metadatarespons. - 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 diusage_metadatadilaporkan 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
Di region mana
gemini-3.1-pro-previewtersedia Google Cloud? Global.Berapa batas jendela konteks? Model Gemini 3 mendukung jendela konteks input 1 juta token dan output hingga 64 ribu token.
Apakah
gemini-3.1-pro-previewmendukung output gambar? Tidak.Apakah
gemini-3.1-pro-previewmendukung Gemini Live API? Tidak.
Langkah berikutnya
Pelajari lebih lanjut Gemini 3.1 Pro.
Coba tutorial notebook Pengantar Gemini 3 Pro.
Pelajari Pemanggilan fungsi.
Pelajari Penalaran.