מדריך למפתחים: Gemini 4 Carbon

‫Gemini 4 Carbon הוא מודל פורץ דרך של Google, שמצטיין בעבודה מעמיקה במשימות מורכבות בעולם האמיתי בתחומים כמו תכנות, פיננסים, משפטים, אבטחת סייבר ומדע. הוא חלק ממשפחת Gemini 4. ‫Gemini 4 Carbon הוא מודל פורץ דרך של Google שכפוף לסעיף 34 בתנאים הספציפיים לשירות (לפרטים, ראו מעקב אחרי התנהלות פוגעת).

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

היכולות העיקריות של Gemini 4 Carbon

‫Gemini 4 Carbon כולל את היכולות הבאות:

• מגבלה אחידה על טוקנים של קלט ופלט: ב-‎4 Carbon יש מגבלה אחידה של 1,048,576 טוקנים שכוללת גם טוקנים של קלט וגם טוקנים של פלט (הפלט כולל חשיבה, קריאות להפעלת פונקציות והתשובה הסופית).
• פענוח ארוך של עד 1,048,576 טוקנים: גרסה 4 Carbon מרחיבה את היצירה מעבר לפלח חזיתי יחיד (65,536 טוקנים בסטרימינג, או 32,768 טוקנים ללא סטרימינג) עד ל-1,048,576 טוקנים (פחות טוקני הקלט) גם ב-Interactions API וגם ב-GenerateContent (v1beta1). ערכת Google Gen AI SDK מטפלת ב-continuation_token באופן אוטומטי בין פלחים, או שאפשר להריץ פענוח אסינכרוני ברקע בניהול השרת (background=true) או לנהל את continuation_token בלולאת המשך מותאמת אישית.
• רמות חשיבה: מודל ‎4 Carbon תומך ברמות LOW,‏ MEDIUM (ברירת המחדל ב-gemini-4-carbon) ו-HIGH (ברירת המחדל ב-gemini-4-carbon-cyber-permissive).
• שמירה במטמון באופן משתמע עם שמירה עמידה במטמון: שמירה במטמון באופן משתמע חלה באופן אוטומטי על תחיליות משותפות של הנחיות עם 4,096 טוקנים או יותר, והשמירה העמידה במטמון מופעלת כברירת מחדל. אין תמיכה בשמירת הקשר מפורשת במטמון.
• קלט של קובצי Office ו-OpenDocument: בנוסף ל-PDF ולטקסט פשוט, מודל ‎4 Carbon מקבל קובצי Microsoft Office (.docx,‏ .dotx,‏ .doc,‏ .pptx,‏ .ppt,‏ .xlsx,‏ .xls) וקובצי OpenDocument (.odt,‏ .odp,‏ .ods) מוטמעים או מ-Cloud Storage, גם ב-GenerateContent וגם ב-Interactions API.
• הבנת וידאו מבוססת-סוכן: התכונה זמינה לכלל המשתמשים (GA) ומושבתת כברירת מחדל.

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

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

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

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

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

1. פותחים את Agent Studio בפרויקט Cloud de Confiance by S3NS ובוחרים באפשרות gemini-4-carbon בקבוצה 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. כדי להמשיך באופן אוטומטי ב-Interactions API, צריך את google-genai >= 2.34.0 ל-Python, את @google/genai >= 2.32.0 ל-JavaScript או ל-TypeScript, את >= 1.77.0 ל-Go או את >= 1.80.0 ל-Java (ב-GenerateContent, כדי להמשיך באופן אוטומטי צריך את >= 2.30.1 ל-Python, את >= 2.29.1 ל-JavaScript או ל-TypeScript, את >= 1.74.0 ל-Go, את >= 1.77.0 ל-Java, את >= 1.26.0 ל-‎ .NET או את >= 1.6.0 ל-Kotlin):

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

בקשה בסיסית

שולחים בקשה אל gemini-4-carbon באמצעות Google Gen AI SDK או REST:

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-carbon",
    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)

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-carbon",
    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-carbon",
    input="Add a bounded backpressure policy and unit tests for concurrent writers.",
    previous_interaction_id=turn1.id,
)
print(turn2.output_text)

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-carbon:generateContent" \
-d '{
  "contents": [
    {
      "role": "user",
      "parts": [
        {
          "text": "Provide an architectural review of this Go interface."
        }
      ]
    }
  ],
  "generationConfig": {
    "thinkingConfig": {
      "thinkingLevel": "MEDIUM"
    }
  }
}'

פלט מובנה

כדי ליצור פלט JSON שתואם לסכימה, מגדירים את response_mime_type ו-response_schema:

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-carbon",
    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 טוקנים של פלט ללא סטרימינג. הפלט כולל חשיבה, קריאות להפעלת פונקציות ואת התשובה הסופית. כדי ליצור השלמות של עד 1,048,576 טוקנים (בניכוי טוקני הקלט), השתמשו בפענוחים ארוכים ב-Interactions API או ב-GenerateContent. במאמר פענוחים ארוכים מפורטות אפשרויות ההמשך, מעברי הסטטוס וכללי האימות.

שימוש בפענוחים ארוכים באמצעות Interactions API

ב-google-genai >= 2.34.0 (Python), ב-@google/genai >= 2.32.0 (JavaScript/TypeScript), ב-Go >= 1.77.0 וב-Java >= 1.80.0, הפונקציה interactions.create() עוקבת באופן אוטומטי אחרי continuation_token בין מקטעים בכל פעם שמקטע מחזיר status="requires_continuation". אפשר גם לבטל את ההסכמה (automatic_continuation=False) כדי להריץ לולאה מותאמת אישית עם שמירת מצב (store=True) או ללא שמירת מצב (store=False):

from google import genai

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

# Automatic continuation is enabled by default in google-genai >= 2.34.0.
# Unary calls merge all segments into one Interaction with summed usage.
interaction = client.interactions.create(
    model="gemini-4-carbon",
    input="Write a complete formal proof of the prime number theorem.",
    generation_config={
        "max_output_tokens": 256000,
        "thinking_level": "high",
    },
)
print(interaction.output_text)
print(f"Merged segment IDs: {interaction.continuation_ids}")
print(f"Initial input tokens: {interaction.usage.initial_input_tokens}")

# Optional: Delete each stored server segment (last segment first) before its 7-day TTL expires.
for segment_id in reversed(interaction.continuation_ids or [interaction.id]):
    client.interactions.delete(id=segment_id)

# Streaming yields events across all segments in order. Intermediate segments
# emit interaction.completed with status="requires_continuation".
stream = client.interactions.create(
    model="gemini-4-carbon",
    input="Write a complete formal proof of the prime number theorem.",
    stream=True,
    generation_config={
        "max_output_tokens": 256000,
        "thinking_level": "high",
    },
)
for event in stream:
    if event.event_type == "step.delta" and getattr(event.delta, "text", None):
        print(event.delta.text, end="", flush=True)
    elif (
        event.event_type == "interaction.completed"
        and event.interaction.status != "requires_continuation"
    ):
        print(f"\nFinal status: {event.interaction.status}")

# Set automatic_continuation=False to return after a single segment.
single_segment = client.interactions.create(
    model="gemini-4-carbon",
    input="Write a complete formal proof of the prime number theorem.",
    generation_config={"max_output_tokens": 256000, "thinking_level": "high"},
    automatic_continuation=False,
)

from google import genai

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

prompt = "Write a complete formal proof of the prime number theorem."

# Stored loop (store=True, default): chain previous_interaction_id + continuation_token
# without resending input.
segment = client.interactions.create(
    model="gemini-4-carbon",
    input=prompt,
    store=True,
    generation_config={"max_output_tokens": 131072, "thinking_level": "high"},
    automatic_continuation=False,
)
full_text = segment.output_text or ""

while segment.status == "requires_continuation" and segment.continuation_token:
    segment = client.interactions.create(
        model="gemini-4-carbon",
        previous_interaction_id=segment.id,
        continuation_token=segment.continuation_token,
        generation_config={"max_output_tokens": 131072, "thinking_level": "high"},
        automatic_continuation=False,
    )
    full_text += segment.output_text or ""

# If status == "incomplete", max_output_tokens was exhausted; raise max_output_tokens
# to continue (leaving default automatic_continuation=True lets the SDK finish remaining segments).
if segment.status == "incomplete" and segment.continuation_token:
    segment = client.interactions.create(
        model="gemini-4-carbon",
        previous_interaction_id=segment.id,
        continuation_token=segment.continuation_token,
        generation_config={"max_output_tokens": 256000, "thinking_level": "high"},
    )
    full_text += segment.output_text or ""

# Stateless loop (store=False): resend original input + continuation_token
# with no previous_interaction_id.
stateless_seg = client.interactions.create(
    model="gemini-4-carbon",
    input=prompt,
    store=False,
    generation_config={"max_output_tokens": 131072, "thinking_level": "high"},
    automatic_continuation=False,
)
stateless_text = stateless_seg.output_text or ""
while stateless_seg.status == "requires_continuation" and stateless_seg.continuation_token:
    stateless_seg = client.interactions.create(
        model="gemini-4-carbon",
        input=prompt,
        store=False,
        continuation_token=stateless_seg.continuation_token,
        generation_config={"max_output_tokens": 131072, "thinking_level": "high"},
        automatic_continuation=False,
    )
    stateless_text += stateless_seg.output_text or ""

# Segment 1: Start a stored interaction (store=true by default)
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/interactions" \
  -d '{
    "model": "gemini-4-carbon",
    "store": true,
    "input": "Write a complete formal proof of the prime number theorem.",
    "generation_config": {
      "max_output_tokens": 131072,
      "thinking_level": "high"
    }
  }'

# Segment 2: When status is "requires_continuation", pass previous_interaction_id
# and continuation_token without resending input
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/interactions" \
  -d '{
    "model": "gemini-4-carbon",
    "store": true,
    "previous_interaction_id": "SEGMENT_1_ID",
    "continuation_token": "CONTINUATION_TOKEN",
    "generation_config": {
      "max_output_tokens": 131072,
      "thinking_level": "high"
    }
  }'

# Segment 1: Stateless interaction (store=false)
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/interactions" \
  -d '{
    "model": "gemini-4-carbon",
    "store": false,
    "input": "Write a complete formal proof of the prime number theorem.",
    "generation_config": {
      "max_output_tokens": 131072,
      "thinking_level": "high"
    }
  }'

# Segment 2: Resend the original input and continuation_token (no previous_interaction_id)
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/interactions" \
  -d '{
    "model": "gemini-4-carbon",
    "store": false,
    "input": "Write a complete formal proof of the prime number theorem.",
    "continuation_token": "CONTINUATION_TOKEN",
    "generation_config": {
      "max_output_tokens": 131072,
      "thinking_level": "high"
    }
  }'

כדי להפעיל את המודל באופן אסינכרוני בניהול השרת (background=True עם store=True) או כדי לשחזר מנקודות ביקורת בסטרימינג (אירועי interaction.status_update שמופקים ב-32,768 טוקנים של פלט וכל 5,000 טוקנים לאחר מכן), משתמשים בתבניות הבאות:

import time
from google import genai

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

# Start a server-managed background long decode (requires store=True)
interaction = client.interactions.create(
    model="gemini-4-carbon",
    input="Write a complete formal proof of the prime number theorem.",
    background=True,
    store=True,
    generation_config={"max_output_tokens": 256000, "thinking_level": "high"},
)

while interaction.status in ("queued", "in_progress"):
    time.sleep(10)
    interaction = client.interactions.get(id=interaction.id)

print(f"Status: {interaction.status}")
print(interaction.output_text)

# Optional: Cancel an in-progress background interaction and resume later
# from its persisted checkpoint continuation_token (if >= 32,768 tokens decoded).
# cancelled = client.interactions.cancel(id=interaction.id)
# if cancelled.continuation_token:
#     resumed = client.interactions.create(
#         model="gemini-4-carbon",
#         previous_interaction_id=cancelled.id,
#         continuation_token=cancelled.continuation_token,
#         background=True,
#         generation_config={"max_output_tokens": 256000, "thinking_level": "high"},
#     )

# Start a server-managed background long decode (requires store=true)
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/interactions" \
  -d '{
    "model": "gemini-4-carbon",
    "background": true,
    "store": true,
    "input": "Write a complete formal proof of the prime number theorem.",
    "generation_config": {
      "max_output_tokens": 256000,
      "thinking_level": "high"
    }
  }'

# Poll the interaction until status reaches completed, incomplete, failed, or cancelled
curl -s -X GET \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  "https://aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/global/interactions/INTERACTION_ID"

# Optional: Cancel an in-progress background decode
curl -s -X POST \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  "https://aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/global/interactions/INTERACTION_ID/cancel"

# Optional: Resume a cancelled background decode from its checkpoint continuation_token
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/interactions" \
  -d '{
    "model": "gemini-4-carbon",
    "background": true,
    "store": true,
    "previous_interaction_id": "INTERACTION_ID",
    "continuation_token": "CONTINUATION_TOKEN",
    "generation_config": {
      "max_output_tokens": 256000,
      "thinking_level": "high"
    }
  }'

from google import genai
from google.genai import errors

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

# With default automatic_continuation=True, stream=True automatically
# reconnects from the latest interaction.status_update checkpoint (32,768
# output tokens, then every 5,000 tokens) if no output was yielded after the
# checkpoint. If a disconnect occurs after output was yielded since the last
# checkpoint, the SDK raises ContinuationInterruptedError so you can resume
# from err.continuation_token.
stream = client.interactions.create(
    model="gemini-4-carbon",
    input="Write a complete formal proof of the prime number theorem.",
    stream=True,
    store=True,
    generation_config={"max_output_tokens": 256000, "thinking_level": "high"},
)

try:
    for event in stream:
        if event.event_type == "step.delta" and getattr(event.delta, "text", None):
            print(event.delta.text, end="", flush=True)
except errors.ContinuationInterruptedError as err:
    # Resuming from a mid-segment checkpoint regenerates any output yielded
    # after that checkpoint.
    if err.interaction_id and err.continuation_token:
        resumed_stream = client.interactions.create(
            model="gemini-4-carbon",
            previous_interaction_id=err.interaction_id,
            continuation_token=err.continuation_token,
            stream=True,
            store=True,
            generation_config={"max_output_tokens": 256000, "thinking_level": "high"},
        )
        for event in resumed_stream:
            if event.event_type == "step.delta" and getattr(event.delta, "text", None):
                print(event.delta.text, end="", flush=True)

# Start a streaming interaction; save interaction.id from interaction.created
# and the latest continuation_token from interaction.status_update SSE events
curl -N -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/interactions" \
  -d '{
    "model": "gemini-4-carbon",
    "stream": true,
    "store": true,
    "input": "Write a complete formal proof of the prime number theorem.",
    "generation_config": {
      "max_output_tokens": 256000,
      "thinking_level": "high"
    }
  }'

# Resume a dropped stream from the last saved checkpoint continuation_token
# (for store=false, resend the original input instead of previous_interaction_id)
curl -N -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/interactions" \
  -d '{
    "model": "gemini-4-carbon",
    "stream": true,
    "store": true,
    "previous_interaction_id": "SEGMENT_ID",
    "continuation_token": "CHECKPOINT_CONTINUATION_TOKEN",
    "generation_config": {
      "max_output_tokens": 256000,
      "thinking_level": "high"
    }
  }'

שימוש בפענוחים ארוכים עם GenerateContent

ב-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 בלולאה מותאמת אישית:

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-carbon",
    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-carbon",
    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="")

# 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-carbon: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-carbon:generateContent" \
  -d '{
    "contents": [{
      "role": "user",
      "parts": [{"text": "Write a complete formal proof of the prime number theorem."}]
    }],
    "continuationToken": "CONTINUATION_TOKEN",
    "generationConfig": {
      "maxOutputTokens": 131072,
      "thinkingConfig": {"thinkingLevel": "HIGH"}
    }
  }'

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

‫4 Carbon אוכף את המוסכמות שמפורטות בסעיפים הבאים לגבי רמות חשיבה, מגבלות טוקנים, שמירה במטמון, פרמטרים ליצירת תוכן והפעלת כלים בכמה שלבים.

רמות ההעמקה

‫4 Carbon תומך בשלושה ערכי thinking_level (thinking_budget ו-MINIMAL מחזירים שגיאת אימות HTTP 400). צריך להעביר ערכים באותיות רישיות ("LOW", "MEDIUM", "HIGH") ב-GenerateContent וערכים באותיות קטנות ("low", "medium", "high") ב-Interactions API. בטבלה הבאה מפורטות רמות החשיבה ועומסי העבודה המומלצים לכל אחת מהן:

מגבלות על טוקנים, שמירה במטמון וחיוב

‫4 Carbon מחיל את הכללים הבאים לגבי אסימונים, מטמון, מדיה וחיוב:

• מגבלת טוקנים אחידה לקלט ולפלט ותקציבי פלט שמוגדרים כברירת מחדל: תקציבי הטוקנים ומגבלות הסגמנטים בחזית פועלים באופן הבא:
  • מגבלת הטוקנים הכוללת של המודל היא 1,048,576 טוקנים, והיא כוללת גם טוקנים של קלט וגם טוקנים של פלט (הפלט כולל חשיבה, קריאות להפעלת פונקציות והתשובה הסופית). max_output_tokens קובע את מגבלת הטוקנים של הפלט ליצירה (עד 1,048,576 פחות טוקני הקלט). אם מגדירים את max_output_tokens לערך שגדול מ-1,048,576, תוחזר שגיאת HTTP 400.
  • אם משמיטים את max_output_tokens ב-GenerateContent או ב-Interactions API, תקציב הפלט הכולל שמוגדר כברירת מחדל (חשיבה, קריאות להפעלת פונקציות ותשובה) הוא 65,536 אסימונים. מקטע חזיתי אחד יוצר עד 65,536 טוקנים בסטרימינג או 32,768 טוקנים בלי סטרימינג, ולכן Google Gen AI SDK (v1beta1) משרשר באופן אוטומטי שני מקטעים של 32,768 טוקנים בקריאות בלי סטרימינג לפי הצורך, ואילו בקשת REST אחת בלי סטרימינג נעצרת אחרי מקטע חזיתי אחד של 32,768 טוקנים. ב-Agent Studio, מגבלת האסימונים לפלט מוגדרת כברירת מחדל ל-1,048,576 עם המשך אוטומטי.
• פענוחים ארוכים: קטע אחד בחזית יוצר עד 65,536 טוקנים של פלט בסטרימינג, או 32,768 טוקנים של פלט לא בסטרימינג. כדי להרחיב את הפלט של פנייה אחת עד 1,048,576 טוקנים (פחות טוקנים של קלט) ב-Interactions API או ב-GenerateContent (v1beta1), קראו את המאמר פענוחים ארוכים.
• שמירת הקשר במטמון: אין תמיכה בשמירת הקשר מפורשת במטמון. שמירה במטמון באופן משתמע (עם שמירה במטמון לטווח ארוך שמופעלת כברירת מחדל) חלה באופן אוטומטי על תחיליות משותפות של הנחיות עם 4,096 טוקנים או יותר, לכן כדאי להוסיף תוכן סטטי בתחילת ההנחיה.
• קובצי קלט של Office ו-OpenDocument: אפשר להעביר קובצי Word‏ (application/vnd.openxmlformats-officedocument.wordprocessingml.document,‏ application/vnd.openxmlformats-officedocument.wordprocessingml.template,‏ application/msword,‏ application/vnd.oasis.opendocument.text), קובצי PowerPoint‏ (application/vnd.openxmlformats-officedocument.presentationml.presentation,‏ application/vnd.ms-powerpoint,‏ application/vnd.oasis.opendocument.presentation) וקובצי גיליונות אלקטרוניים של Excel או OpenDocument‏ (application/vnd.openxmlformats-officedocument.spreadsheetml.sheet,‏ application/vnd.ms-excel,‏ application/vnd.oasis.opendocument.spreadsheet) בתוך השורה או באמצעות URI של Cloud Storage‏ (gs://) באמצעות inlineData או fileData בקלט של GenerateContent ו-document (כולל תוצאות של כלים) ב-Interactions API.
• סרטון עם סוכן: סרטונים שהועלו מוגדרים כברירת מחדל ל-media_processing="static". מגדירים את media_processing="agentic" כדי להפעיל עיבוד וידאו מבוסס-סוכנים.
• ספירת טוקנים וחיוב: כל טוקן שהמודל מעבד נספר ומחויב, כולל טוקנים של חשיבה, הוראות מערכת של כלים פנימיים והצהרות על פונקציות כשמשתמשים ב-grounding. גם החיוב על עיגון באמצעות חיפוש Google נשאר לפי שאילתה.

פרמטרים, קריאה להפעלת פונקציות ואימות צ'אט

‫4 Carbon אוכף את הכללים הבאים לגבי פרמטרים של יצירה, קריאות API לכלים והיסטוריית צ'אטים:

• ‫Ignored sampling parameters (temperature, top_k, top_p): המערכת מתעלמת מערכים מותאמים אישית. אפשר לשלוט בעומק החשיבה באמצעות thinking_level ובפורמט הפלט באמצעות response_schema.
• פרמטרים לא נתמכים (frequency_penalty,‏ presence_penalty ו-candidate_count גדולים מ-1): העברת frequency_penalty,‏ presence_penalty או candidate_count גדולים מ-1 (candidateCount קבוע ב-1) מחזירה שגיאת HTTP 400. צריך להסיר את הפרמטרים האלה מהבקשות.

• קריאה להפעלת פונקציות: הצהרות על כלים וסבבי הרצה פועלים לפי הכללים הבאים:

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

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

    {
      "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.
  • אין תמיכה בתשובות מודל מאוכלסות מראש.

פענוח ארוך

בפענוח ארוך,היצירה מחולקת לעד 1,048, 576 טוקנים (פחות טוקני הקלט) בכמה קטעים ב-Interactions API או ב-GenerateContent (v1beta1). ב-Interactions API,כל קטע בחזית יוצר עד 65,536 טוקני פלט בסטרימינג (stream=true) או 32,768 טוקני פלט ללא סטרימינג (stream=false) ומחזיר את status="requires_continuation" עם continuation_token מוצפן. אפשר גם להגדיר את background=true (store=true) כדי שהשרת יריץ את לולאת ההמשך באופן אסינכרוני ויאחסן את הפלט הממוזג ב-Interaction אחד. ב-GenerateContent, קטעי סטרימינג יוצרים עד 65,536 טוקנים של פלט וקטעים שהם לא סטרימינג יוצרים עד 32,768 טוקנים של פלט לפני שהם פולטים את finish_reason=CONTINUATION עם continuation_token, וממשיכים עד finish_reason=STOP. ב-Agent Studio, אם מגדירים את מגבלת הטוקנים של הפלט ליותר מ-65,536 ועד 1,048,576, המערכת מטפלת בטוקנים של המשך באופן אוטומטי. במדריך למתחילים בנושא פענוח ארוך יש דוגמאות קוד שאפשר להריץ.

מתי כדאי להשתמש בפענוח ארוך

רוב הבקשות מסתיימות במסגרת תקציב הפלט שמוגדר כברירת מחדל, 65,536 טוקנים (או קטע אחד של 32,768 טוקנים בחזית, לא בסטרימינג, דרך REST). השתמשו בפענוח ארוך רק אם תשובה אחת דורשת פלט ארוך יותר. פענוח ארוך נותן למודל יותר מקום לחשיבה, אבל לא מאריך את התשובות (כדי לשלוט בעומק החשיבה, משתמשים ב-thinking_level).

בחירת אפשרות להמשך

בוחרים תבנית המשך בהתאם לממשק ה-API, למצב האחסון ולסביבת זמן הריצה. כל האפשרויות בטבלה הבאה מגיעות לאותה מגבלה של 1,048,576 טוקנים (פחות טוקנים של קלט) ב-gemini-4-carbon וב-gemini-4-carbon-cyber-permissive.

דרישות לגבי גרסת ה-API וערכת ה-SDK

כדי להשתמש בפענוח ארוך, צריך את גרסת ה-API הבאה ואת גרסאות ה-SDK המינימליות הבאות:

• דרישת API של v1beta1 (בעיה ידועה): פענוח ארוך (continuation_token) גם ב-Interactions API וגם ב-GenerateContent (generateContent ו-streamGenerateContent) נתמך רק ב-API של v1beta1 (לא ב-v1) ב-Agent Platform. כברירת מחדל, Google Gen AI SDK משתמש ב-v1beta1, אלא אם צוין api_version='v1' ב-http_options (או ב-api_version="v1" ב-interactions.create). לקריאות REST ישירות, צריך להשתמש בנתיב נקודת הקצה (endpoint) של /v1beta1/.
• גרסאות SDK ותאימות ל-OpenAI: כדי להמשיך באופן אוטומטי ב-Interactions API, שדרגו ל-Python google-genai >= 2.34.0, ל-JavaScript או ל-TypeScript @google/genai >= 2.32.0, ל-Go >= 1.77.0 או ל-Java >= 1.80.0 (בשפות אחרות ב-Interactions API, צריך לשלוח קריאה ישירות ל-REST API באמצעות background=true או לולאת המשך בהתאמה אישית). כדי להמשיך להשתמש ב-GenerateContent באופן אוטומטי, צריך לשדרג לגרסאות הבאות: Python >= 2.30.1,‏ JavaScript/TypeScript >= 2.29.1,‏ Go >= 1.74.0,‏ Java >= 1.77.0,‏ ‎.NET >= 1.26.0 או Kotlin >= 1.6.0. בגרסאות קודמות של ה-SDK ובשכבת התאימות ל-OpenAI אי אפשר לאחזר השלמות ארוכות באמצעות אסימוני המשך.

כללי ההמשך של Interactions API

הכללים הבאים לגבי שינויי סטטוס, שרשור ופעולות אחסון חלים על פענוחים ארוכים ב-Interactions API.

ערכי סטטוס ותקציב טוקנים לפלט

אם משמיטים את generation_config.max_output_tokens בבקשת Interactions API, תקציב הפלט הכולל מוגדר כברירת מחדל ל-65,536 טוקנים (כך שקריאה ללא סטרימינג נעצרת ב-32,768 טוקנים עם status="requires_continuation", וקטע שני יכול ליצור את 32,768 הטוקנים הנותרים). מגדירים את generation_config.max_output_tokens עד לערך 1,048,576 (פחות טוקנים של קלט) לפענוחים ארוכים יותר במצב background=true ובמצב חזית. השרת מחזיר את ערכי הסטטוס הבאים:

• ‫requires_continuation: הגעתם למגבלת הפלט לכל פלח (32,768 ללא סטרימינג או 65,536 עם סטרימינג) לפני max_output_tokens. כדי להמשיך בפענוח, צריך להעביר את הערך של continuation_token שהוחזר בבקשה הבאה.
• ‫incomplete: התקציב הכולל של max_output_tokens נגמר. אם ממשיכים עם continuation_token בלי להגדיל את max_output_tokens, מוחזרת שגיאת HTTP‏ 400 (max_output_tokens has already been exhausted). כדי להמשיך בפענוח, צריך להגדיל את max_output_tokens בבקשה הבאה.
• ‫completed: היצירה הסתיימה באופן טבעי והשדה continuation_token נמחק.

שרשור, החלפת מצבים ואחסון פלחים

בקשות המשך ב-Interactions API כפופות לכללים הבאים:

• המשך מאוחסן (store=true, ברירת מחדל): מעבירים את previous_interaction_id שמוגדר לקטע id שהנפיק את continuation_token יחד עם continuation_token, ומשמיטים את input (הקטע המאוחסן כבר מכיל את הקלט של התור). תמיד צריך להתאים בין כל continuation_token לבין ה-previous_interaction_id של הפלח שהנפיק אותו. אם מעבירים continuation_token באינטראקציה שכבר completed, מוחזרת שגיאת HTTP ‏400.
• המשך בלי שמירת מצב (store=false): משמיטים את previous_interaction_id ושולחים מחדש את input המקורי לצד continuation_token בכל מקטע.
• מעבר בין מצבי store בין מקטעים: אפשר לעבור ממצב שמור (store=true) למצב בלי שמירת מצב (store=false) באמצע הפענוח על ידי השמטת previous_interaction_id ושליחה מחדש של input המקורי עם continuation_token. אי אפשר לעבור מאינטראקציה ללא שמירת מצב (store=false) לאינטראקציה עם שמירת מצב (store=true) כי אין אינטראקציה ראשית (parent) עם שמירת מצב בשביל previous_interaction_id.
• מעבר בין מצבי חזית וbackground=true והסתעפות: המשכים מאוחסנים (store=true) יכולים לעבור בין הפעלה בחזית (background=false) וברקע (background=true) בין מקטעים, כולל המשך אינטראקציה מבוטלת של background=true מנקודת הבדיקה שלה continuation_token (נשמרת אחרי 32,768 טוקנים של פלט) במצב רקע או במצב חזית. שימוש חוזר באותם previous_interaction_id ו-continuation_token יוצר המשכים מסתעפים נפרדים.
• אכיפת גבולות הפנייה: אם מתחילים פנייה חדשה של משתמש (previous_interaction_id עם input חדש וללא continuation_token) מקטע שהסטטוס שלו הוא requires_continuation או incomplete, מוחזרת שגיאת HTTP 400. צריך לסיים את פענוח ה-completed, או להתחיל את התור הבא מהאינטראקציה האחרונה של completed. כשהקטע האחרון מגיע אל completed, העברת הערך id של הקטע האחרון בתור previous_interaction_id משחזרת את כל היסטוריית השיחה בכל הקטעים הקודמים.
• עקביות של פרמטרים בין קטעים: שינוי של model,‏ system_instruction או הצהרות פונקציה (tools) בקטע המשך מחזיר שגיאת HTTP‏ 400. גם thinking_level והכלים המובנים צריכים להישאר ללא שינוי בכל הפלחים (ראו בעיות מוכרות).
• התנהגות של פלח יחיד ב-get, ב-list וב-delete: במצב חזית (background=false), כל פלח מאוחסן כמשאב Interaction נפרד (interactions.get(id) מחזיר רק את הפלח הזה, interactions.list() מציג כל פלח בנפרד ו-interactions.delete(id) מוחק רק את הפלח הזה. כשמוחקים שרשרת של פלחים, צריך למחוק בסדר הפוך, מהפלח האחרון אחורה). ב-Google Gen AI SDK עם automatic_continuation=True (stream=False), הפונקציה interactions.create() ממזגת את כל הקטעים בהחזרה ומאכלסת את interaction.continuation_ids במזהי הקטעים לפי הסדר (שמסתיים ב-interaction.id). אם קטע מאוחר יותר נכשל, חורג מ-timeout מספרי לכל קריאה או נמחק באמצע הסטרימינג אחרי שהתקדמתם מעבר לנקודת בדיקה שניתן להמשיך ממנה, ערכת ה-SDK מעלה את ContinuationInterruptedError עם partial_interaction, continuation_token, interaction_id ו-continuation_ids כדי שתוכלו להמשיך מ-continuation_token.

כללי לולאה מותאמים אישית של GenerateContent

בלולאת המשך מותאמת אישית של GenerateContent, צריך לפעול לפי הכללים הבאים:

• מגדירים את 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 בבקשה הבאה.
• שילוב חלקים שנצברו לסיבוב model יחיד להיסטוריה של כמה סיבובים רק אחרי STOP.

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

הנה הסבר על האופן שבו מתבצעים החשבון והשמירה במטמון של טוקנים בקטעי המשך:

• ב-Interactions API, קריאות interactions.create() ללא סטרימינג עם automatic_continuation=True ואינטראקציות background=true בניהול השרת מסכמות את ספירת הטוקנים בכל הקטעים ב-usage (total_input_tokens,‏ total_cached_tokens,‏ total_output_tokens,‏ total_thought_tokens,‏ total_tokens), תוך שמירה על ספירת ההנחיות של הקטע הראשון ב-usage.initial_input_tokens. בלולאות מותאמות אישית שפועלות בחזית ובאירועי interaction.completed בסטרימינג, השדה usage של כל פלח מדווח רק על הדלתא של אותו פלח, ולכן צריך לסכם את השדות usage בכל הפלחים כדי לקבל את סך כל הטוקנים שחויבו.
• ב-GenerateContent, ‏Python Google Gen AI SDK (generate_content ו-generate_content_stream) צובר את סך האסימונים לחיוב בכל הקטעים ב-usage_metadata הסופי ושומר על initial_prompt_token_count. בלולאות REST בהתאמה אישית, סוכמים את הערכים הסופיים של prompt_token_count,‏ cached_content_token_count,‏ candidates_token_count ו-thoughts_token_count בכל הפלחים.
• בגלל שכל קטע המשך בחזית ממלא מראש את השיחה ואת האסימונים שנוצרו בעבר כקלט, usage.total_input_tokens (ב-Interactions API) ו-prompt_token_count (ב-GenerateContent) גדלים בין הקטעים. אל תשתמשו בספירות קלט מצטברות כדי להפעיל דחיסת הקשר במעטפות אג'נטיות. במקום זאת, בדקו את usage.initial_input_tokens (או את initial_prompt_token_count ב-GenerateContent) ודחסו רק אחרי שהתור מסתיים (status="completed" או בלי continuation_token).
• כל קטע המשך ממלא מראש את ההנחיה ואת האסימונים שכבר פוענחו, ועומד באופן אוטומטי בדרישות של שמירת הקשר במטמון באופן משתמע (מינימום 4,096 אסימונים, עם שמירה עמידה במטמון שמופעלת כברירת מחדל) כשמריצים קטעים ברצף. החיוב על קטעים שהושלמו מתבצע בסוף כל קטע, גם אם קטע מאוחר יותר נכשל או בוטל.

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

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

• ל-‎4 Carbon יש מגבלה אחידה של 1,048,576 טוקנים לקלט ולפלט (כשהפלט כולל את תהליך החשיבה, קריאה להפעלת פונקציות והתשובה הסופית), במקום מגבלות נפרדות לקלט ולפלט. בקטע אחד בחזית יש מגבלה של 65,536 טוקנים בסטרימינג (או 32,768 טוקנים בלי סטרימינג), ואפשר להרחיב את הפלט עד 1,048,576 טוקנים באמצעות פענוחים ארוכים ב-Interactions API או ב-GenerateContent (המערכת מטפלת בזה באופן אוטומטי ב-Google Gen AI SDK, באמצעות background=true ב-Interactions API או באמצעות 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" ("global" and "us" for cyber)
 )

 response = client.models.generate_content(
-    model="gemini-3.1-pro-preview",
+    model="gemini-4-carbon",
     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 Carbon
+            thinking_level="MEDIUM", # Valid: "LOW", "MEDIUM" (default), "HIGH"
         ),
     ),
 )

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

1. מעדכנים את מזהה המודל ל-gemini-4-carbon (או ל-gemini-4-carbon-cyber-permissive לעומסי עבודה של אבטחת סייבר שאושרו במסגרת תוכנית Fairwind).
2. משדרגים לגרסה העדכנית של Google Gen AI SDK ומביאים בחשבון את מגבלת האסימונים המאוחדת לקלט ולפלט: משדרגים לגרסה google-genai >= 2.34.0 (Python),‏ @google/genai >= 2.32.0 (JavaScript/TypeScript),‏ Go >= 1.77.0 או Java >= 1.80.0 להמשך אוטומטי של Interactions API (או >= 2.30.1 Python /‏ >= 2.29.1 JavaScript ב-GenerateContent). אסימוני קלט ופלט (כולל חשיבה וקריאה להפעלת פונקציות) חולקים את המגבלה המאוחדת של 1,048,576 אסימונים. אם הפלט חורג מ-65,536 טוקנים (עד 1,048,576 טוקנים) ב-Interactions API או ב-GenerateContent, מגדירים את max_output_tokens לערך שגדול מ-65,536 כדי ש-Google Gen AI SDK ימשיך באופן אוטומטי בין הקטעים (או משתמשים ב-background=true או בלולאת continuation_token בהתאמה אישית).
3. החלפת הפרמטר של מכסת החשיבה: מחליפים את thinking_budget ואת MINIMAL ב-thinking_level שמוגדר ל-LOW, ל-MEDIUM (ברירת המחדל ב-gemini-4-carbon) או ל-HIGH (ברירת המחדל ב-gemini-4-carbon-cyber-permissive) (משתמשים באותיות קטנות "low", "medium" או "high" ב-Interactions API).
4. הסירו את השמירה המפורשת במטמון וטענו מראש תוכן סטטי של הנחיות (4,096 טוקנים או יותר) לשמירה אוטומטית משתמעת במטמון.
5. הסרת פרמטרים שלא משפיעים או שלא נתמכים: מסירים שדות יצירה שנדחו או שמתעלמים מהם, באופן הבא:
   • צריך להסיר את temperature, top_p ו-top_k, כי המערכת מתעלמת מהם.
   • מסירים את frequency_penalty,‏ presence_penalty וכל ערך של candidate_count שגדול מ-1.
   • להסיר מהיסטוריית השיחות תשובות מודל מאוכלסות מראש.

רשימת משימות מסכמת למפתחים

הכנו רשימת משימות שתעזור לכם לבדוק את השילוב של 4 Carbon:

בעיות מוכרות

הבעיות הבאות רלוונטיות לפענוח של 4 Carbon:

• פענוח ארוך דורש את v1beta1: פענוח ארוך (continuation_token) גם ב-Interactions API וגם ב-GenerateContent API (generateContent ו-streamGenerateContent) נתמך רק ב-v1beta1 API (לא ב-v1) ב-Agent Platform. כברירת מחדל, Google Gen AI SDK משתמש ב-v1beta1, אלא אם api_version='v1' מוגדר ב-http_options (או ב-api_version="v1" ב-interactions.create). בקריאות REST ישירות, צריך להשתמש בנתיב של נקודת הקצה /v1beta1/.
• שינויים בפרמטרים בקטעי ההמשך של Interactions API: שינוי של model,‏ system_instruction או הצהרות על פונקציות בקטעי ההמשך מחזיר שגיאת HTTP‏ 400, אבל שינויים באמצע הפענוח של generation_config.thinking_level או של כלים מובנים (google_search,‏ code_execution,‏ url_context) לא נדחים על ידי אימות השרת. חשוב להשאיר את thinking_level ואת הכלים המובנים ללא שינוי בכל החלקים של לולאת ההמשך.

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

מידע נוסף על 4 Carbon זמין במקורות המידע הבאים:

• דף המודל Gemini 4 Carbon
• איך מתחילים לעבוד עם Gemini 4
• תיקיית Notebook למתחילים
• ‫Gemini 4 Carbon לסייבר