איך מתחילים להשתמש ב-Gemini 3

‫Gemini 3 הוא קבוצת המודלים הכי חכמים שלנו עד היום, שמבוססים על יכולות חשיבה רציונלית המתקדמות ביותר. הוא נועד להפוך כל רעיון למציאות באמצעות שליטה ב-Agentic Workflows, תכנות אוטונומי ומשימות מורכבות מולטי-מודאליות.

המדריך הזה מספק דרך מעשית ומרוכזת להתחיל לעבוד עם Gemini 3 ב-Gemini Enterprise Agent Platform, ומדגיש את התכונות העיקריות של Gemini 3 ואת השיטות המומלצות.

מדריך למתחילים

לפני שמתחילים, צריך לאמת את הזהות ב-Gemini Enterprise Agent Platform באמצעות מפתח API או פרטי כניסה שהוגדרו כברירת מחדל לאפליקציה (ADC). למידע נוסף, קראו על שיטות אימות.

התקנת Google Gen AI SDK

כדי להשתמש בתכונות של Gemini 3 API, צריך להתקין את Google Gen AI SDK ל-Python בגרסה 1.51.0 ואילך.

pip install --upgrade google-genai

הגדרת משתני סביבה לשימוש ב-Google Gen AI SDK עם Gemini Enterprise Agent Platform

מחליפים את הערך GOOGLE_CLOUD_PROJECT במזהה הפרויקט ב- Google Cloud . המודלים Gemini 3.1 Pro‏ gemini-3.1-pro-preview ו-Gemini 3 Flash‏ gemini-3-flash-preview זמינים רק בנקודות קצה (endpoints) גלובליות:

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

שליחת הבקשה הראשונה

כברירת מחדל, מודלים של Gemini 3 ו-Gemini 3 Flash משתמשים בחשיבה דינמית כדי לעבד הנחיות. כדי לקבל תשובות מהירות יותר עם זמן אחזור קצר יותר כשלא נדרשת חשיבה מורכבת, אפשר להגביל את thinking_level של המודל. רמת חשיבה נמוכה מתאימה למשימות עם תפוקה גבוהה שבהן המהירות היא הדבר הכי חשוב.

לתשובות מהירות עם זמן אחזור קצר:

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)

נסו משימות חשיבה מורכבות

‫Gemini 3 מצטיין בחשיבה רציונלית משופרת. למשימות מורכבות כמו תכנון בכמה שלבים, יצירת קוד מאומת או שימוש מעמיק בכלים, כדאי להשתמש ברמות חשיבה גבוהות. ההגדרות האלה מתאימות למשימות שבעבר דרשו מודלים ייעודיים של חשיבה רציונלית.

למשימות איטיות יותר שדורשות חשיבה מעמיקה:

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)

רמות העמקה אחרות

ב-Gemini 3 Flash יש שתי רמות חשיבה חדשות: MINIMAL ו-MEDIUM, שנותנות לכם עוד יותר שליטה על האופן שבו המודל מטפל במשימות חשיבה מורכבות.

ב-MINIMAL יש אפשרויות לתקציב חשיבה קרוב לאפס, למשימות שבהן חשוב יותר לקבל תשובה מהר מאשר לקבל תשובה מנומקת. ‫MEDIUM מאפשר איזון בין מהירות לבין הסקת מסקנות, כך שיש יכולת מסוימת להסקת מסקנות אבל עדיין יש עדיפות לפעולות עם זמן אחזור קצר.

תכונות חדשות ב-API

ב-Gemini 3 יש שיפורים משמעותיים ב-API ופרמטרים חדשים שנועדו לתת למפתחים שליטה מדויקת בביצועים (זמן אחזור, עלות), בהתנהגות המודל ובנאמנות למקור במולטימודאליות.

בטבלה הבאה מפורטים הפרמטרים והתכונות החדשות העיקריות, וקישורים ישירים למסמכי התיעוד המפורטים שלהם:

תכונה חדשה או שינוי ב-API מסמכים
הדגם: gemini-3.1-pro-preview כרטיס מודל
Gemini Enterprise Agent Platform Model Garden
רמת ההעמקה בתהליך חשיבה
רזולוציית המדיה הבנת תמונות
הבנת סרטונים
הבנת אודיו
הבנת מסמכים
חתימת מחשבה חתימות של מחשבות
טמפרטורה מאמרי העזרה של ה-API
תשובות מולטי-מודאליות לפונקציות קריאה להפעלת פונקציות: תגובות מולטי-מודאליות של פונקציות
קריאה להפעלת פונקציות בסטרימינג קריאה להפעלת פונקציות: קריאה להפעלת פונקציות בסטרימינג

רמת ההעמקה

הפרמטר thinking_level מאפשר לציין מכסת חשיבה ליצירת התשובה של המודל. אתם יכולים לבחור אחד משני מצבים כדי לאזן בין איכות התשובה ומורכבות החשיבה לבין זמן האחזור והעלות.

  • ‫MINIMAL: (רק Gemini 3 Flash ו-Gemini 3.1 Flash-Lite) המודל מוגבל לשימוש בכמה שפחות טוקנים לחשיבה, ומומלץ להשתמש בו למשימות פשוטות שלא דורשות חשיבה מעמיקה. ‫MINIMAL הוא הערך הכי קרוב לאפס, אבל עדיין נדרשות חתימות חשיבה.
  • ‫LOW: המודל מוגבל לשימוש בפחות טוקנים לחשיבה, ומתאים למשימות פשוטות יותר שלא דורשות הסקת מסקנות נרחבת. ‫LOW מתאים במיוחד למשימות עם קצב העברת נתונים גבוה שבהן המהירות חיונית.
  • MEDIUM: (רק ב-Gemini 3 Flash,‏ Gemini 3.1 Pro ו-Gemini 3.1 Flash-Lite) גישה מאוזנת שמתאימה למשימות ברמת מורכבות בינונית, שדורשות חשיבה אבל לא דורשות תכנון מעמיק בכמה שלבים. הוא מספק יכולת חשיבה טובה יותר מ-LOW, תוך שמירה על זמן אחזור נמוך יותר מ-HIGH.
  • ‫HIGH: המודל יכול להשתמש ביותר טוקנים לתהליך החשיבה, ומתאים להנחיות מורכבות שדורשות חשיבה רציונלית מעמיקה, כמו תכנון בכמה שלבים, יצירת קוד מאומת או תרחישים מתקדמים של קריאה להפעלת פונקציות. זו רמת ברירת המחדל במודלים של Gemini 3 ו-Gemini 3 Flash. כדאי להשתמש בהגדרה הזו כשמחליפים משימות שאולי הסתמכתם בהן בעבר על מודלים ייעודיים של חשיבה רציונלית.

דוגמה ל-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)

דוגמה לתאימות ל-OpenAI

למשתמשים בשכבת התאימות ל-OpenAI, הפרמטרים הרגילים ממופים באופן אוטומטי לפרמטרים המקבילים ב-Gemini 3:

  • reasoning_effort ממופה אל thinking_level.
  • ‫none: ממפה ל-thinking_level מינימלי (Gemini 3 Flash בלבד).
  • ‫medium: ממפה ל-thinking_level בינוני לכל המודלים של 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)

רזולוציית המדיה

ב-Gemini 3 יש שליטה מפורטת על עיבוד הראייה המולטי-מודאלית באמצעות הפרמטר media_resolution. רזולוציות גבוהות יותר משפרות את היכולת של המודל לקרוא טקסט קטן או לזהות פרטים קטנים, אבל מגדילות את השימוש בטוקנים ואת זמן האחזור. הפרמטר media_resolution קובע את המספר המקסימלי של אסימונים שמוקצים לכל תמונה, דף PDF או פריים של סרטון בקלט.

אפשר להגדיר את הרזולוציה ל-low,‏ medium או high באופן גלובלי (באמצעות generation_config) או לקטעי מדיה ספציפיים. אפשר להגדיר את הרזולוציה ultra_high רק לקטעי מדיה נפרדים. אם לא מציינים ערך, המודל משתמש בערכי ברירת מחדל אופטימליים בהתאם לסוג המדיה.

מספר הטוקנים

בטבלה הזו מפורטים מספר האסימונים המשוער לכל ערך של media_resolution ולכל סוג מדיה.

רזולוציית המדיה תמונה וידאו PDF
‫UNSPECIFIED (ברירת מחדל) 1120 70 560
LOW 280 70 ‫280 + טקסט
MEDIUM 560 70 560 + Text
HIGH 1120 280 ‫1120 + טקסט
ULTRA_HIGH 2240 לא רלוונטי לא רלוונטי
רזולוציית המדיה מספר הטוקנים המקסימלי הנחיות לשימוש
ultra_high 2240 משימות שדורשות ניתוח של פרטים קטנים בתמונות, כמו עיבוד תמונות סטילס מהקלטת מסך או תמונות ברזולוציה גבוהה.
high 1120 משימות ניתוח תמונות כדי להבטיח איכות מקסימלית.
medium 560
low תמונה: 280, סרטון: 70 מספיק לרוב המשימות. הערה: ב-Video low, המקסימום הוא 70 טוקנים לכל פריים.

הגדרה של media_resolution לכל חלק בנפרד

אפשר להגדיר media_resolution לכל קטע מדיה בנפרד:

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)

הגדרת media_resolution באופן גלובלי

אפשר גם להגדיר את media_resolution באופן גלובלי (באמצעות 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)

חתימות של תהליך החשיבה

חתימות של תהליכי חשיבה הן אסימונים מוצפנים ששומרים על מצב החשיבה של המודל במהלך שיחות עם כמה פניות, במיוחד כשמשתמשים בקריאה להפעלת פונקציות.

כשהמודל מחליט להפעיל כלי חיצוני, הוא משהה את תהליך החשיבה הפנימי שלו. חתימת המחשבה פועלת כמו "מצב שמירה", ומאפשרת למודל להמשיך את שרשרת החשיבה שלו בצורה חלקה אחרי שאתם מספקים את תוצאת הפונקציה.

מידע נוסף זמין במאמר חתימות של מחשבות.

למה חתימות המחשבה חשובות?

בלי חתימות חשיבה, המודל "שוכח" את שלבי החשיבה הספציפיים שלו במהלך שלב הפעלת הכלי. העברת החתימה בחזרה מבטיחה:

  • המשכיות ההקשר: המודל שומר את הסיבה לקריאה לכלי.
  • הסקת מסקנות מורכבת: מאפשרת לבצע משימות עם כמה שלבים, שבהן הפלט של כלי אחד משמש כבסיס להסקת המסקנות של הכלי הבא.

איפה מופיעות חתימות המחשבה?

מודלים של Gemini 3 ו-Gemini 3 Flash אוכפים אימות מחמיר יותר וטיפול מעודכן בחתימות של תהליכי חשיבה, שהוצגו במקור ב-Gemini 2.5. כדי שהמודל ישמור על ההקשר לאורך כמה שלבים בשיחה, צריך להחזיר את חתימות החשיבה בבקשות הבאות.

  • תשובות של המודל עם בקשה להפעלת פונקציה תמיד יחזירו חתימת שלבים בתהליך החשיבה, גם כשמשתמשים ברמת החשיבה MINIMAL.
  • כשיש קריאות להפעלת פונקציות במקביל, החלק הראשון של הקריאה להפעלת פונקציה שמוחזר בתגובה של המודל יכלול חתימת חשיבה.
  • כשיש שרשרת קריאות להפעלת פונקציות (כמה שלבים), לכל קריאה להפעלת פונקציה תהיה חתימה והלקוחות צפויים להעביר את החתימה בחזרה
  • תשובות מהמודל שלא כוללות קריאה להפעלת פונקציה יחזירו חתימת חשיבה בחלק האחרון שהמודל מחזיר.

איך להתמודד עם חתימות מחשבה?

יש שתי דרכים עיקריות לטפל בחתימות מחשבה: באופן אוטומטי באמצעות ערכות ה-Google Gen AI SDK או OpenAI API, או באופן ידני אם אתם יוצרים אינטראקציה עם ה-API ישירות.

טיפול אוטומטי (מומלץ)

אם אתם משתמשים בערכות Google Gen AI SDK (‏Python, ‏ Node.js, ‏ Go,‏ Java) או ב-OpenAI Chat Completions API, ומשתמשים בתכונות הרגילות של היסטוריית הצ'אט או מוסיפים את התשובה המלאה של המודל, thought_signatures מטופלים באופן אוטומטי. אתם לא צריכים לבצע שינויים בקוד.

דוגמה לקריאה ידנית להפעלת פונקציה

כשמשתמשים ב-Google Gen AI SDK, חתימות החשיבה מטופלות באופן אוטומטי על ידי הוספת התגובה המלאה של המודל בבקשות עוקבות למודל:

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}")
דוגמה לקריאה אוטומטית להפעלת פונקציות

כשמשתמשים ב-Google Gen AI SDK בקריאה אוטומטית לפונקציות, חתימות החשיבה מטופלות באופן אוטומטי:


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
דוגמה לתאימות ל-OpenAI

כשמשתמשים ב-OpenAI Chat Completions API, חתימות החשיבה מטופלות באופן אוטומטי על ידי הוספת התגובה המלאה של המודל בבקשות עוקבות למודל:

...
# 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)

דוגמה לקוד המלא

טיפול ידני

אם אתם מקיימים אינטראקציה ישירה עם ה-API או מנהלים מטען ייעודי (payload) גולמי של JSON, אתם צריכים לטפל בצורה נכונה ב-thought_signature שנכלל בתור של המודל.

חובה להחזיר את החתימה הזו בדיוק בחלק שבו היא התקבלה כששולחים בחזרה את היסטוריית השיחות.

אם לא יוחזרו חתימות תקינות, Gemini 3 יחזיר שגיאה 400 "<Function Call> in the <index of contents array> content block is missing a thought_signature".

תשובות מולטי-מודאליות לפונקציות

התכונה "קריאה להפעלת פונקציות מולטי-מודאליות" מאפשרת למשתמשים לקבל תשובות לפונקציות שמכילות אובייקטים מולטי-מודאליים, וכך לנצל טוב יותר את יכולות הקריאה להפעלת פונקציות של המודל. קריאה רגילה לפונקציות תומכת רק בתגובות פונקציה מבוססות-טקסט:

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

קריאה להפעלת פונקציות בסטרימינג

כדי לשפר את חוויית הסטרימינג בשימוש בכלים, אתם יכולים להשתמש בארגומנטים חלקיים של בקשה להפעלת פונקציה בסטרימינג. כדי להפעיל את התכונה הזו, צריך להגדיר באופן מפורש את stream_function_call_arguments לערך true:

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

דוגמה לתשובה מהמודל:

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

טמפרטורה

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

ב-Gemini 3, מומלץ מאוד להשאיר את הפרמטר temperature בערך ברירת המחדל שלו, 1.0.

במודלים קודמים, שינוי הטמפרטורה עזר לשלוט ברמת היצירתיות לעומת הדטרמיניזם, אבל יכולות החשיבה של Gemini 3 מותאמות להגדרת ברירת המחדל.

שינוי הטמפרטורה (הגדרה של פחות מ-1.0) עלול להוביל להתנהגות לא צפויה, כמו לולאות או ביצועים נמוכים, במיוחד במשימות מתמטיות או במשימות חשיבה מורכבות.

התכונות הנתמכות

המודלים של Gemini 3 תומכים גם בתכונות הבאות:

שיטות מומלצות להנדסת פרומפטים

‫Gemini 3 הוא מודל חשיבה רציונלית, ולכן צריך לכתוב את ההנחיות בצורה שונה.

  • הוראות מדויקות: נסחו הנחיות קצרות וקולעות. ‫Gemini 3 מגיב הכי טוב להוראות ישירות וברורות. הוא עלול לנתח יותר מדי טכניקות מורכבות או ארוכות של הנדסת פרומפטים שמתאימות למודלים ישנים יותר.
  • אורך הפלט: כברירת מחדל, Gemini 3 מספק תשובות קצרות, ישירות ויעילות. אם התרחיש לדוגמה שלכם דורש פרסונה יותר שיחתית או "פטפטנית", אתם צריכים להנחות את המודל באופן מפורש בהנחיה (לדוגמה, "הסבר את זה בתור עוזר ידידותי ודברן").
  • ביסוס: בתרחישי שימוש של ביסוס, מומלץ להשתמש בהוראות הבאות למפתחים: 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.
  • שימוש בכלי חיפוש Google: כשמשתמשים בכלי חיפוש Google, ‏Gemini 3 Flash עלול לפעמים להתבלבל בין התאריך או השעה הנוכחיים לבין אירועים שהתרחשו ב-2024. כתוצאה מכך, המודל עלול לנסח שאילתות חיפוש לשנה הלא נכונה. כדי לוודא שהמודל משתמש בתקופה הנכונה, צריך לציין במפורש את התאריך הנוכחי ב-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.
  • תאריך סף הידע: בשאילתות מסוימות, Gemini 3 Flash פועל טוב יותר אם מציינים במפורש את תאריך סף הידע. זה קורה כשכלי חיפוש Google מושבת, והשאילתה דורשת מהמודל לזהות את תאריך הסף בידע הפרמטרי. המלצה: הוספת הסעיף הבא אל system instructions: Your knowledge cutoff date is January 2025.
  • שימוש ב-media_resolution: משתמשים בפרמטר media_resolution כדי לקבוע את מספר הטוקנים המקסימלי שהמודל משתמש בהם כדי לייצג תמונה או פריימים בסרטונים. רזולוציה גבוהה תאפשר למודל לזהות פרטים בתמונה, ויכול להיות שהוא ישתמש ביותר אסימונים לכל פריים. לעומת זאת, רזולוציה נמוכה יותר מאפשרת לבצע אופטימיזציה של העלות וזמן האחזור בתמונות עם פחות פרטים חזותיים.
  • שיפור ניתוח הסרטונים: השתמשו בתדירות דגימה גבוהה יותר של פריימים לשנייה (FPS) בסרטונים שדורשים ניתוח זמני מפורט, כמו הבנה של פעולות מהירות או מעקב תנועה במהירות גבוהה.

שיקולים בנוגע להעברה

כשמבצעים את ההעברה, חשוב להביא בחשבון את התכונות והאילוצים הבאים:

  • רמת החשיבה: מודלים של Gemini 3 משתמשים בפרמטר thinking_level כדי לשלוט בכמות החשיבה הפנימית שהמודל מבצע (נמוכה או גבוהה) וכדי לאזן בין איכות התשובה, מורכבות החשיבה, זמן האחזור והעלות.
  • הגדרות טמפרטורה: אם הקוד הקיים מגדיר באופן מפורש את temperature (במיוחד לערכים נמוכים לפלטים דטרמיניסטיים), מומלץ להסיר את הפרמטר הזה ולהשתמש בערך ברירת המחדל של Gemini 3, שהוא 1.0, כדי למנוע בעיות פוטנציאליות של לולאות או פגיעה בביצועים במשימות מורכבות.
  • חתימות של תהליכי חשיבה: במודלים של Gemini 3, אם צפויה חתימה של תהליך חשיבה בתור מסוים אבל היא לא מסופקת, המודל מחזיר שגיאה במקום אזהרה.
  • רזולוציית מדיה וטוקניזציה: מודלים של Gemini 3 משתמשים באורך משתנה של רצף לטוקניזציה של מדיה במקום ב-Pan and Scan, ויש להם רזולוציות ברירת מחדל חדשות ועלויות טוקנים חדשות לתמונות, לקובצי PDF ולסרטונים.
  • ספירת טוקנים לקלט מולטי-מודאלי: ספירת הטוקנים לקלט מולטי-מודאלי (תמונות, וידאו, אודיו) היא הערכה שמבוססת על ה-media_resolution שנבחר. לכן, יכול להיות שהתוצאה מהקריאה ל-API של count_tokens לא תתאים לאסימונים הסופיים שנוצלו. השימוש המדויק לצורכי חיוב זמין רק אחרי ההפעלה, בתוך usage_metadata של התגובה.
  • צריכת טוקנים: המעבר להגדרות ברירת המחדל של Gemini 3 עשוי להגדיל את השימוש בטוקנים לתמונות ולקובצי PDF, אבל להקטין את השימוש בטוקנים לסרטונים. אם הבקשות חורגות עכשיו מחלון ההקשר בגלל רזולוציות ברירת מחדל גבוהות יותר, מומלץ להפחית באופן מפורש את הרזולוציה של המדיה.
  • הבנת מסמכים וקובצי PDF: רזולוציית ברירת המחדל של OCR בקובצי PDF השתנתה. אם הסתמכתם על התנהגות ספציפית לניתוח מסמכים צפופים, בדקו את ההגדרה החדשה של media_resolution: "high" כדי לוודא שהדיוק נמשך. במודלים של Gemini 3, מספר הטוקנים של קובצי PDF ב-usage_metadata מדווחים במודאליות IMAGE במקום DOCUMENT.
  • חלוקת תמונות למקטעים: מודלים של Gemini 3 לא תומכים בחלוקת תמונות למקטעים. לעומסי עבודה שדורשים חלוקת תמונות למקטעים, מומלץ להמשיך להשתמש ב-Gemini 2.5 Flash כשהחשיבה מושבתת.
  • תשובות פונקציה מולטימודליות: במודלים של Gemini 3, אתם יכולים לכלול נתוני תמונות וקובצי PDF בתשובות הפונקציה.

שאלות נפוצות

  1. באילו אזורים אפשר להשתמש ב- gemini-3.1-pro-preview ? Google Cloud בכל רחבי העולם.

  2. מהן המגבלות של חלון ההקשר? המודלים של Gemini 3 תומכים בחלון הקשר של מיליון טוקנים בקלט ועד 64,000 טוקנים בפלט.

  3. האם gemini-3.1-pro-preview תומך בפלט של תמונות? לא.

  4. האם gemini-3.1-pro-preview תומך ב-Gemini Live API? לא.

המאמרים הבאים