מדריך למפתחים בנושא Gemini 4 Argon

‫Gemini 4 Argon הוא מודל פורץ דרך של Google, שמצטיין בעבודה מעמיקה במשימות מורכבות בעולם האמיתי בתחומים כמו תכנות, פיננסים, משפטים, אבטחת סייבר ומדע. זהו המודל הראשון במשפחת Gemini 4.

במאמר הזה נסביר מה חדש בגרסה 4 Argon, מהן המוסכמות של ה-API שהיא אוכפת, איך עוברים אליה ואיך מתחילים לעבוד איתה במהירות. איך מתחילים לעבוד עם Gemini 4

מה חדש ב-Gemini 4 Argon?

  • מגבלה אחידה על טוקנים של קלט ופלט: ל-‎4 Argon יש מגבלה אחידה של 1,048,576 טוקנים, שכוללת גם טוקנים של קלט וגם טוקנים של פלט (הפלט כולל חשיבה, קריאה להפעלת פונקציות והתשובה הסופית).
  • פענוח ארוך של עד 1,048,576 טוקנים: הרחבת היצירה מעבר למגבלת הפלט של בקשה אחת (65,536 טוקנים, או 32,768 טוקנים לבקשות HTTP ישירות ללא סטרימינג) עד 1,048,576 טוקנים (פחות טוקני הקלט) ב-GenerateContent. ערכת Google Gen AI SDK מטפלת ב-continuation_token באופן אוטומטי בכל הבקשות, או שאתם יכולים לנהל את continuation_token בלולאת ההמשך שלכם.
  • רמות חשיבה: LOW,‏ MEDIUM (ברירת המחדל ב-gemini-4-argon) ו-HIGH (ברירת המחדל ב-gemini-4-argon-cyber-permissive).
  • שמירה במטמון באופן מרומז עם שמירה במטמון לטווח ארוך: שמירה במטמון באופן מרומז חלה באופן אוטומטי על קידומות משותפות של הנחיות עם 6,144 טוקנים או יותר, כאשר שמירה במטמון לטווח ארוך מופעלת כברירת מחדל. אין תמיכה בשמירת הקשר מפורשת במטמון.
  • הבנת וידאו מבוססת-סוכנים: זמינה לכלל המשתמשים (GA) וכבויה כברירת מחדל.

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

לפני שמתחילים, צריך לבצע אימות ב-Agent Platform באמצעות Application Default Credentials ‏ (ADC) או מפתח API. מידע נוסף זמין במאמר תחילת העבודה עם Gemini Enterprise Agent Platform.

בבלוקי הקוד הבאים, מחליפים את PROJECT_ID במזהה הפרויקט.

רוצה לנסות את זה ב-Agent Studio?

כדי לבדוק הנחיות ולהגדיר את gemini-4-argon בממשק המשתמש של Agent Studio:

  1. פותחים את Agent Studio בפרויקט ב- Cloud de Confiance by S3NS ובוחרים באפשרות gemini-4-argon בקבוצת Gemini.
  2. בקטע Model settings (הגדרות המודל), מגדירים:
    • רמת העמקה: בוחרים באפשרות Low, Medium (ברירת המחדל) או High.
    • אזור: בוחרים באפשרות Global,‏ us או eu.
    • ‫Output token limit: הגדירו ערך בין 32,768 ל-1,048,576 (ברירת המחדל היא 1,048,576). ‫Agent Studio מטפל באופן אוטומטי בטוקנים של המשך לתשובות שחורגות מהמגבלה של בקשה יחידה.

התקנה

משדרגים לגרסה העדכנית של Google Gen AI SDK (גרסה google-genai >= 2.30.1 ל-Python, גרסה @google/genai >= 2.29.1 ל-JavaScript, גרסה >= 1.74.0 ל-Go, גרסה >= 1.77.0 ל-Java, גרסה >= 1.26.0 ל-‎ .NET או גרסה >= 1.6.0 ל-Kotlin):

pip install --upgrade "google-genai>=2.30.1"

בקשה בסיסית

Python ‏ (GenerateContent)

from google import genai
from google.genai import types

client = genai.Client(enterprise=True, project="PROJECT_ID", location="global")

response = client.models.generate_content(
    model="gemini-4-argon",
    contents="Design a lock-free ring buffer in Rust for multi-producer, single-consumer telemetry ingestion.",
    config=types.GenerateContentConfig(
        thinking_config=types.ThinkingConfig(
            thinking_level="MEDIUM",  # Default: "MEDIUM" (Valid: "LOW", "MEDIUM", "HIGH")
        ),
    ),
)
print(response.text)

‫Python‏ (Interactions API)

from google import genai

client = genai.Client(enterprise=True, project="PROJECT_ID", location="global")

# Turn 1: Initial request (stored server-side by default)
turn1 = client.interactions.create(
    model="gemini-4-argon",
    input="Design a lock-free ring buffer in Rust for multi-producer, single-consumer telemetry ingestion.",
    store=True,
)
print(turn1.output_text)

# Turn 2: Continue the conversation using previous_interaction_id
turn2 = client.interactions.create(
    model="gemini-4-argon",
    input="Add a bounded backpressure policy and unit tests for concurrent writers.",
    previous_interaction_id=turn1.id,
)
print(turn2.output_text)

REST

curl -X POST \
-H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
-H "Content-Type: application/json" \
"https://aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/global/publishers/google/models/gemini-4-argon:generateContent" \
-d '{
  "contents": [
    {
      "role": "user",
      "parts": [
        {
          "text": "Provide an architectural review of this Go interface."
        }
      ]
    }
  ],
  "generationConfig": {
    "thinkingConfig": {
      "thinkingLevel": "MEDIUM"
    }
  }
}'

פלט מובנה

from pydantic import BaseModel, Field
from google import genai
from google.genai import types

class ArchitectureReview(BaseModel):
    component: str = Field(description="Service or module name")
    bottlenecks: list[str] = Field(description="Throughput or latency bottlenecks")
    recommended_changes: list[str] = Field(description="Concrete refactoring steps")

client = genai.Client(enterprise=True, project="PROJECT_ID", location="global")

response = client.models.generate_content(
    model="gemini-4-argon",
    contents="Review a synchronous order-processing pipeline backed by a single primary database at 15,000 writes/sec.",
    config=types.GenerateContentConfig(
        response_mime_type="application/json",
        response_schema=ArchitectureReview,
        thinking_config=types.ThinkingConfig(thinking_level="HIGH"),
    ),
)
print(response.text)

פענוח ארוך

כברירת מחדל, בקשת API אחת יוצרת עד 65,536 טוקנים של פלט (או 32,768 טוקנים לבקשות HTTP ישירות שאינן סטרימינג), כאשר הפלט כולל חשיבה, בקשות להפעלת פונקציה והתגובה הסופית. כדי ליצור השלמות של עד 1,048,576 טוקנים ב-GenerateContent (v1beta1), צריך להגדיר את max_output_tokens לערך שגדול מ-65,536 לבקשות סטרימינג או לערך שגדול מ-32,768 לבקשות ללא סטרימינג (עד 1,048,576). ‫Google Gen AI SDK עוקב אחרי continuation_token באופן אוטומטי בין בקשות כש-finish_reason הוא CONTINUATION (אפשר להגדיר את automatic_continuation=False ב-GenerateContentConfig כדי להשבית את ההמשך האוטומטי), או שאפשר להעביר את continuation_token בלולאה בהתאמה אישית.

Python (SDK – מומלץ)

from google import genai
from google.genai import types

client = genai.Client(enterprise=True, project="PROJECT_ID", location="global")

# Automatic continuation is enabled by default in google-genai >= 2.30.1.
# Chunks across all continuation requests are yielded as a single stream.
for chunk in client.models.generate_content_stream(
    model="gemini-4-argon",
    contents="Write a complete formal proof of the prime number theorem.",
    config=types.GenerateContentConfig(
        max_output_tokens=256000,
        thinking_config=types.ThinkingConfig(thinking_level="HIGH"),
    ),
):
    print(chunk.text, end="")

# Set automatic_continuation=False to disable automatic continuation.
for chunk in client.models.generate_content_stream(
    model="gemini-4-argon",
    contents="Write a complete formal proof of the prime number theorem.",
    config=types.GenerateContentConfig(
        thinking_config=types.ThinkingConfig(thinking_level="HIGH"),
        automatic_continuation=False,
    ),
):
    print(chunk.text, end="")

‫REST (לולאת המשך בהתאמה אישית)

# Request 1: Initial request with maxOutputTokens > 32,768
curl -s -X POST \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  -H "Content-Type: application/json" \
  "https://aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/global/publishers/google/models/gemini-4-argon:generateContent" \
  -d '{
    "contents": [{
      "role": "user",
      "parts": [{"text": "Write a complete formal proof of the prime number theorem."}]
    }],
    "generationConfig": {
      "maxOutputTokens": 131072,
      "thinkingConfig": {"thinkingLevel": "HIGH"}
    }
  }'

# Request 2: Resend the original request with top-level continuationToken
# from Request 1 (candidates[0].continuationToken)
curl -s -X POST \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  -H "Content-Type: application/json" \
  "https://aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/global/publishers/google/models/gemini-4-argon:generateContent" \
  -d '{
    "contents": [{
      "role": "user",
      "parts": [{"text": "Write a complete formal proof of the prime number theorem."}]
    }],
    "continuationToken": "CONTINUATION_TOKEN_FROM_REQUEST_1",
    "generationConfig": {
      "maxOutputTokens": 131072,
      "thinkingConfig": {"thinkingLevel": "HIGH"}
    }
  }'

כללי API מחייבים ומוסכמות התנהגותיות

‫Gemini 4 Argon אוכף את המוסכמות הבאות:

  • רמות חשיבה: מודל ‎4 Argon תומך בשלושה ערכים של thinking_level (הערכים thinking_budget ו-MINIMAL מחזירים שגיאת אימות HTTP‏ 400):

    רמת ההעמקה עומסי עבודה מומלצים
    ‫HIGH (ברירת מחדל ב-gemini-4-argon-cyber-permissive) הנדסת תוכנה של כמה קבצים, הוכחות פורמליות, עיצוב ארכיטקטורה וגילוי נקודות חולשה.
    ‫MEDIUM (ברירת מחדל ב-gemini-4-argon) קידוד כללי, שימוש בכלי, שאלות ותשובות לגבי מסמכים והבנת סרטונים.
    LOW סיווג, סיכום וחילוץ מטא-נתונים.

  • מגבלת טוקנים אחידה לקלט ולפלט ומגבלות פלט לבקשה יחידה:

    • ‫1,048,576 הוא מגבלת הטוקנים הכוללת של המודל, והוא כולל גם טוקנים של קלט וגם טוקנים של פלט (כאשר הפלט כולל חשיבה, קריאות להפעלת פונקציות והתגובה הסופית). max_output_tokens קובע את מגבלת האסימונים של הפלט ליצירה (עד 1,048,576 פחות אסימוני הקלט). אם מגדירים את max_output_tokens לערך שגדול מ-1,048,576, מוחזרת שגיאת HTTP 400.
    • כדי למנוע תשובות ארוכות מדי, מגבלת ברירת המחדל לפלט של בקשה אחת (חשיבה + תשובת המודל) היא 65,536 אסימונים (או 32,768 אסימונים לבקשות HTTP ישירות ללא סטרימינג).

  • פענוח ארוך:

    • איך פועל פענוח ארוך: פענוח ארוך מפצל יצירה של עד 1,048,576 טוקנים על פני כמה GenerateContent הסקות. לדוגמה, אם משימה דורשת 256,000 טוקנים של פלט (כולל שלבים בתהליך החשיבה, קריאה להפעלת פונקציות והתשובה הסופית), הבקשה הראשונה של הסטרימינג יוצרת עד 65,536 טוקנים של פלט ופולטת finish_reason=CONTINUATION עם continuation_token מוצפן שמכיל גיבוב של הפרומפט המקורי ומצב היצירה עד לנקודה הזו. אם כוללים את continuation_token בבקשות הבאות עם ההנחיה המקורית, יצירת התוכן ממשיכה מהמקום שבו היא הפסיקה עד ש-continuation_token לא מופיע יותר ו-finish_reason=STOP. (ב-Agent Studio, אם מגדירים את מגבלת הטוקנים בפלט לערך שגדול מ-65,536 ועד 1,048,576, המערכת מטפלת בטוקנים להמשך באופן אוטומטי).
    • מתי להשתמש בפענוח ארוך: רוב הבקשות מסתיימות במסגרת המגבלה לכל בקשה (65,536 טוקנים, או 32,768 טוקנים לקריאות REST ללא סטרימינג). השתמשו בפענוח ארוך רק אם תשובה אחת צריכה פלט ארוך יותר. פענוח ארוך נותן למודל יותר מקום להסקת מסקנות, אבל לא מאריך את התשובות (אפשר להשתמש ב-thinking_level כדי לשלוט בעומק הסקת המסקנות).
    עומס עבודה להשתמש בפענוח ארוך? למה לבחור ב-
    מתמטיקה, מדע, מחקר והוכחות פורמליות ברמה גבוהה כן המודל יכול להשתמש ביותר מ-65,536 טוקנים כדי לבדוק את ההיגיון שלו.
    משימות התכנות והמשימות האג'נטיות הכי קשות כן יש משימות שדורשות יותר מ-65,536 טוקנים של חשיבה וקוד בתשובה אחת. רוב משימות התכנות והמשימות של הסוכנים מסתיימות עם פחות מ-65,536 טוקנים.
    כלי הערכה שעוצרים במגבלת הפלט כן הפענוח הארוך מונע תשובות קטועות כשהמודל משתמש בבקשה שלמה של 65,536 או 32,768 טוקנים כדי לחשוב.
    צ'אט, שאלות ותשובות, סיכום, סיווג וחילוץ לא המשימות האלה מסתיימות עם הרבה פחות מ-32,768 טוקנים.
    בקשות לאורך קבוע, כמו "תכתוב ספר באורך 700,000 מילים" לא המודל לא עומד ביעדי האורך.
    סוכנים שקוראים לכלים בהרבה תורות קצרות לא כל תור קצר. פלט גדול בכל תור ממלא במהירות את מגבלת הקלט והפלט המאוחדת של 1,048,576 טוקנים.
    הנחיות שמתקרבות למגבלת הקלט של 1,048,576 טוקנים לא הפלט יכול להשתמש רק ב-1,048,576 טוקנים פחות הקלט שלכם.
    בקשות שרגישות לזמן האחזור לא פענוח ארוך יכול להימשך כמה דקות.
    • בחירת אפשרות להמשך: בוחרים אחת משתי האפשרויות. רוב המפתחים משתמשים באפשרות 1. בכל האפשרויות יש אותה מגבלה של 1,048,576 טוקנים ב-gemini-4-argon וב-gemini-4-argon-cyber-permissive.
    מאפיין אפשרות 1: Google Gen AI SDK (מומלץ) אפשרות 2: לולאת סטרימינג משלכם (streamGenerateContent) אפשרות 2: לולאה משלכם שלא משודרת בסטרימינג (generateContent)
    מי מתחיל כל קטע ‫Google Gen AI SDKs: ‏ Python ‏ (google-genai) 2.30.1,‏ JavaScript ‏ (@google/genai) 2.29.1,‏ Go 1.74.0,‏ Java 1.77.0,‏ ‎.NET 1.26.0 ו-Kotlin 1.6.0. הגדרת את max_output_tokens. הקוד שלכם, בכל נקודת בדיקה או אחרי שידור שנכשל הקוד שלכם, כל 32,768 טוקנים
    טוקנים לכל בקשה עד 65,536 לכל פלח ‫65,536 לכל סטרימינג, עם נקודת ביקורת כל 5,000 טוקנים אחרי 32,768 ‫32,768 לכל בקשה
    מגבלת זמן לכל בקשה 20 דקות 20 דקות 20 דקות
    אחסון אין אחסון בשרת (תואם ל-ZDR) אין אחסון בשרת (תאימות ל-ZDR) אין אחסון בשרת (תואם ל-ZDR)
    מתאים במיוחד בשביל רוב האפליקציות מתקשרי REST ורתמות מותאמות אישית שמשדרות רתמות הערכה פשוטות
    • כללים ומגבלות להטמעה:
      • דרישת API של v1beta1 (בעיה מוכרת): פענוח ארוך (continuation_token) ב-GenerateContent (generateContent ו-streamGenerateContent) נתמך רק ב-API של v1beta1 (לא ב-v1). Google Gen AI SDK משתמש ב-v1beta1 כברירת מחדל, אלא אם צוין api_version='v1' ב-http_options. לקריאות REST ישירות, צריך להשתמש בנתיב נקודת הקצה של v1beta1. ‫Interactions API לא תומך בפענוח ארוך.
      • גרסאות SDK ותאימות ל-OpenAI: שדרגו לגרסה העדכנית של Google Gen AI SDK (גרסה google-genai >= 2.30.1 ל-Python, גרסה @google/genai >= 2.29.1 ל-JavaScript, גרסה >= 1.74.0 ל-Go, גרסה >= 1.77.0 ל-Java, גרסה >= 1.26.0 ל-‎ .NET או גרסה >= 1.6.0 ל-Kotlin). גרסאות ישנות יותר של SDK ושכבת התאימות ל-OpenAI לא יכולות לאחזר השלמות ארוכות באמצעות טוקנים של המשך. להטמעות של לקוחות בהתאמה אישית, עיינו בהטמעות לדוגמה של Google Gen AI SDK ב-Python וב-JavaScript/TypeScript.
      • שליחה מחדש של הבקשה המקורית עם continuation_token: בלולאה מותאמת אישית, מגדירים את max_output_tokens כערך שגדול מ-65,536 (סטרימינג) או מ-32,768 (אונארי) ועד 1,048,576, ושולחים מחדש את contents,‏ system_instruction ו-tools המקוריים בכל בקשת המשך יחד עם continuation_token העדכני (שדה ברמה העליונה ב-GenerateContentRequest ב-REST, או ב-GenerateContentConfig ב-Google Gen AI SDK). אל תוסיפו פלט חלקי של המודל ל-contents ואל תשלחו הנחיית המשך שבה תבקשו מהמודל להמשיך.
      • המשך בבקשות לחשיבה בלבד: לולאה בזמן ש-finish_reason הוא CONTINUATION ו-continuation_token קיים, גם אם בקשה השתמשה בכל 32,768 או 65,536 הטוקנים לחשיבה (parts: [{"text": ""}]). אם finish_reason הוא MAX_TOKENS כש-continuation_token קיים, היצירה הגיעה למגבלה המבוקשת של max_output_tokens – צריך להגדיל את max_output_tokens בבקשה. משלבים את החלקים שנצברו ל-model אחד להיסטוריה של שיחה עם כמה שלבים רק אחרי STOP.
      • ספירת טוקנים, דחיסה והנחה משתמעת של 95% על מטמון:
        • ב-Python Google Gen AI SDK (generate_content ו-generate_content_stream), התשובה הסופית או ה-usage_metadata של החלק צוברים את סך כל האסימונים שחויבו בבקשות ההמשך. בגלל שבכל בקשת המשך, ההשלמות החלקיות הקודמות ממולאות מראש כאסימוני קלט, הערך של prompt_token_count גדל באופן מצטבר בין בקשות ההמשך. אל תשתמשו ב-prompt_token_count כדי להפעיל דחיסת הקשר במעטפות אג'נטיות. במקום זאת, קראו את initial_prompt_token_count (ב-GenerateContentResponse או ב-usage_metadata), והמתינו עד להשלמת GenerateContent (ללא continuation_token) לפני הדחיסה.
        • בלולאות REST מותאמות אישית, הערך של usage_metadata הוא מצטבר בכל בקשה. צריך לסכום את הערכים הסופיים של prompt_token_count,‏ cached_content_token_count,‏ candidates_token_count ו-thoughts_token_count בכל הבקשות.
        • כל בקשת המשך ממלאת מראש את ההנחיה ואת האסימונים הקודמים שפוענחו, ומקבלת באופן אוטומטי את ההנחה המשתמעת של 95% על שמירת ההקשר במטמון (מינימום 6,144 אסימונים) כשהבקשות פועלות ברצף במסגרת זמן החיים (TTL) של המטמון, שנמשך 15-20 דקות.
        • הפונקציות streamGenerateContent ו-generateContent מחזירות את הערך usage_metadata בסוף כל בקשה (65,536 סטרימינג / 32,768 unary), והחיוב מתבצע בסוף הבקשה.

  • ‫Ignored sampling parameters (temperature, top_k, top_p): ה-backend מתעלם מערכים מותאמים אישית. אפשר לשלוט בעומק החשיבה באמצעות thinking_level ובפורמט הפלט באמצעות response_schema.

  • פרמטרים לא נתמכים (frequency_penalty, ‏ presence_penalty,‏ candidate_count): הפרמטרים האלה מחזירים שגיאת HTTP‏ 400. צריך להסיר אותם מהבקשות.

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

  • סרטון עם סוכן: סרטונים שמועלים מוגדרים כברירת מחדל כmedia_processing="static". מגדירים את media_processing="agentic" לערך true כדי להפעיל עיבוד וידאו באמצעות AI.

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

  • בקשה להפעלת פונקציה:

    • סימטריה סיבובית: כל FunctionResponse צריך להתאים ל-id, ל-name ולסדר של FunctionCall הקודם.
    • הרצה ברצף: עדיף להריץ את הכלים ברצף בלולאות של כלים עם כמה שלבים.

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

      {
  "name": "update",
  "description": "Update working notes before tool execution",
  "parameters": {
    "type": "OBJECT",
    "properties": {
      "previous_step": {"type": "STRING"},
      "plan": {"type": "STRING"},
      "next_step": {"type": "STRING"}
    },
    "required": ["previous_step", "plan", "next_step"]
  }
}

  • אימות רצף הצ'אט:

    • מטען ייעודי (payload) של היסטוריה לא יכול להסתיים בתור של תפקיד model.
    • אין תמיכה בתשובות מודל מאוכלסות מראש.

מעבר מ-‎3.1 Pro ל-‎4 Argon

ההתנהגות הבאה שונה מ-gemini-3.1-pro-preview:

  • ‫4 ל-Argon יש מגבלת טוקנים מאוחדת של 1,048,576 לכל הקלט והפלט (כאשר הפלט כולל חשיבה, קריאה להפעלת פונקציות והתגובה הסופית), במקום מגבלות נפרדות לקלט ולפלט. הפלט של בקשה יחידה מוגבל ל-65,536 טוקנים (או ל-32,768 טוקנים לבקשות HTTP ישירות שלא מועברות בסטרימינג), ואפשר להרחיב אותו עד ל-1,048,576 טוקנים באמצעות פענוח ארוך ב-GenerateContent (הטיפול מתבצע באופן אוטומטי ב-Google Gen AI SDK, או באמצעות continuation_token בלולאות בהתאמה אישית).
  • ‫thinking_budget מחזירה שגיאת HTTP 400 במקום להיות ממופה לרמת חשיבה. גם הפונקציה MINIMAL מחזירה שגיאה.
  • אין תמיכה בשמירת הקשר מפורשת במטמון.
  • כל טוקן שהמודל מעבד מחויב, כולל הוראות מערכת של כלים פנימיים והצהרות על פונקציות כשמשתמשים ב-grounding.

להשוואה בטבלה, קראו את המאמר מעבר מ-Gemini 3.1 Pro.

 client = genai.Client(
     enterprise=True,
     project="PROJECT_ID",
     location="global", # Supports "global", "us", and "eu"
 )

 response = client.models.generate_content(
-    model="gemini-3.1-pro-preview",
+    model="gemini-4-argon",
     contents=prompt,
     config=types.GenerateContentConfig(
-        temperature=0.0,
-        cached_content="projects/.../cachedContents/...", # Explicit caching unsupported
         thinking_config=types.ThinkingConfig(
-            thinking_budget=16384, # Returns HTTP 400 instead of mapping silently
-            thinking_level="MINIMAL", # MINIMAL unsupported on Gemini 4 Argon
+            thinking_level="MEDIUM", # Valid: "LOW", "MEDIUM" (default), "HIGH"
         ),
     ),
 )

כדי להעביר נתונים מ-gemini-3.1-pro-preview:

  1. מעדכנים את מזהה המודל ל-gemini-4-argon (או ל-gemini-4-argon-cyber-permissive לעומסי עבודה של אבטחת סייבר שאושרו על ידי Fairwind).
  2. שדרוג לגרסה העדכנית של Google Gen AI SDK והתחשבות במגבלת הטוקנים המאוחדת לקלט ולפלט: שדרגו לגרסה google-genai >= 2.30.1 (Python),‏ @google/genai >= 2.29.1 (JavaScript) או לגרסה העדכנית המקבילה של Google Gen AI SDK. טוקנים של קלט ופלט (כולל חשיבה וקריאה להפעלת פונקציות) חולקים את המגבלה המאוחדת של 1,048,576 טוקנים. כדי לקבל פלט של יותר מ-65,536 טוקנים (עד 1,048,576 טוקנים) ב-GenerateContent, צריך להגדיר את max_output_tokens כערך גדול מ-65,536 כדי ש-Google Gen AI SDK ימשיך אוטומטית את הבקשות (או לטפל ב-continuation_token בלולאת REST משלכם).
  3. החלפת הפרמטר של מכסת החשיבה: מחליפים את thinking_budget ו-MINIMAL ב-thinking_level שמוגדר ל-LOW, ל-MEDIUM (ברירת המחדל ב-gemini-4-argon) או ל-HIGH (ברירת המחדל ב-gemini-4-argon-cyber-permissive).
  4. הסירו את השמירה המפורשת במטמון וטענו מראש תוכן סטטי של הנחיות (6,144 טוקנים או יותר) לשמירה אוטומטית במטמון באופן משתמע.
  5. הסרת פרמטרים שלא משפיעים או שלא נתמכים:
    • הסרה של temperature,‏ top_p ו-top_k, שהמערכת מתעלמת מהם.
    • הסרה של candidate_count, frequency_penalty ו-presence_penalty.
    • מסירים מהיסטוריית השיחות את כל תשובות המודל המאוישות מראש.

רשימת ביקורת למפתחים

בעיות מוכרות

  • פענוח ארוך ב-GenerateContent דורש v1beta1: פענוח ארוך (continuation_token) ב-API של GenerateContent (generateContent ו-streamGenerateContent) נתמך רק ב-API של v1beta1 (לא ב-v1). כברירת מחדל, Google Gen AI SDK משתמש ב-v1beta1, אלא אם api_version='v1' מוגדר ב-http_options. לקריאות ישירות ל-REST, משתמשים בנתיב של נקודת הקצה v1beta1.

מקורות מידע נוספים