‫Google משתמשת בטכנולוגיית AI כדי לתרגם תוכן לשפה המועדפת עליך. בתרגומים כאלו עשויות להיות שגיאות.

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

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

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

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

לפני שמתחילים, צריך לבצע אימות ב-Gemini Enterprise Agent Platform באמצעות מפתח API או Application Default Credentials ‏ (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 זמינים רק בנקודות קצה גלובליות:

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`	כרטיס מודל 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 maps to thinking_level.
‫none: מיפוי למינימלי (Gemini 3 Flash בלבד).thinking_level
‫medium: מיפוי ל-thinking_level medium לכל המודלים של 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 + טקסט
`HIGH`	1120	280	‫1120 + טקסט
`ULTRA_HIGH`	2240	לא רלוונטי	לא רלוונטי

הגדרות מומלצות

רזולוציית המדיה	מספר הטוקנים המקסימלי	הנחיות לשימוש
`ultra_high`	2240	משימות שדורשות ניתוח של פרטים קטנים בתמונות, כמו עיבוד של תמונות סטילס מהקלטת מסך או תמונות ברזולוציה גבוהה.
`high`	1120	משימות ניתוח תמונות כדי להבטיח איכות מקסימלית.
`medium`	560
`low`	תמונה: 280 סרטון: 70	מספיק לרוב המשימות. הערה: בסרטון `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.
כשמתבצעות קריאות מקבילות לפונקציות, לחלק הראשון של הקריאה לפונקציה שמוחזר בתגובת המודל תהיה חתימת מחשבה.
כשמבצעים קריאות רצופות לפונקציות (כמה שלבים), לכל קריאה לפונקציה יש חתימה, והלקוחות צריכים להעביר את החתימה בחזרה.
תשובות של מודלים בלי קריאה לפונקציה יחזירו חתימה של מחשבה בחלק האחרון שהוחזר על ידי המודל.

איך מטפלים בחתימות של מחשבות?

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

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

אם אתם משתמשים ב-Google Gen AI SDKs (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

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

...
# 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> בבלוק התוכן <index of contents array> חסרה 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) בסרטונים שנדרש בהם ניתוח זמני גרנולרי, כמו הבנת פעולה מהירה או מעקב תנועה במהירות גבוהה.

שיקולים לגבי מיגרציה

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

‫Thinking level: במודלים של Gemini 3 נעשה שימוש בפרמטר thinking_level כדי לשלוט בכמות החשיבה הפנימית שהמודל מבצע (low או high) וכדי לאזן בין איכות התשובה, מורכבות החשיבה הרציונלית, זמן האחזור והעלות.
הגדרות רמת אקראיות: אם הקוד הקיים מגדיר באופן מפורש את 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 בתשובות של פונקציות.

שאלות נפוצות

באילו אזורים gemini-3.1-pro-preview זמין ב-Google Cloud? גלובלי.
מהן המגבלות של חלון ההקשר? מודלים של Gemini 3 תומכים בחלון הקשר של מיליון טוקנים של קלט ועד 64 אלף טוקנים של פלט.
האם gemini-3.1-pro-preview תומך בפלט של תמונות? לא.
האם gemini-3.1-pro-preview תומך ב-Gemini Live API? לא.

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

מידע נוסף על Gemini 3.1 Pro
כדאי לנסות את המדריך למחברת בנושא Gemini 3 Pro.
מידע על הפעלת פונקציות
מידע נוסף על Thinking

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

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

התקנה של Google Gen AI SDK

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

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

רמות חשיבה אחרות

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

רמת ההעמקה

דוגמה ל-Google Gen AI SDK

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

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

מספר הטוקנים

הגדרות מומלצות

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

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

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

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

איפה מוחזרות חתימות מחשבה?

איך מטפלים בחתימות של מחשבות?

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

דוגמה לבקשה להפעלת פונקציה באופן ידני

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

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

טיפול ידני

תשובות של פונקציות מרובות מצבים

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

טמפרטורה

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

שיטות מומלצות לכתיבת הנחיות

שיקולים לגבי מיגרציה

שאלות נפוצות

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

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

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

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