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

כדי לראות דוגמאות לשימוש בחתימות חשיבה, הריצו את ה-notebooks הבאים בסביבה לבחירתכם:

• "מבוא לחתימות מחשבה":

  פתיחה ב-Colab | פתיחה ב-Colab Enterprise | פתיחה ב-Agent Platform Workbench | הצגה ב-GitHub

• "מבוא לחתימות מחשבה עם API בארכיטקטורת REST":

  פתיחה ב-Colab | פתיחה ב-Colab Enterprise | פתיחה ב-Agent Platform Workbench | הצגה ב-GitHub

• "שימוש בספריות של OpenAI עם Gemini ב-Gemini Enterprise Agent Platform":

  פתיחה ב-Colab | פתיחה ב-Colab Enterprise | פתיחה ב-Agent Platform Workbench | הצגה ב-GitHub

חתימות חשיבה הן ייצוגים מוצפנים של תהליך החשיבה הפנימי של המודל. חתימות החשיבה שומרות על מצב החשיבה של Gemini במהלך שיחות עם כמה שלבים וסבבים, וזה יכול להיות שימושי כשמשתמשים בקריאה להפעלת פונקציות. התשובות יכולות לכלול שדה thought_signature בכל חלק של התוכן (למשל, text, functionCall).

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

למרות ש-Gemini 3 Pro Image לא אוכף את האימות הזה, כדי לוודא שהמודל שומר על ההקשר המלא לאורך כמה שלבים בשיחה, עדיין צריך להחזיר את חתימות החשיבה מהתשובות הקודמות בבקשות הבאות. אם לא מוחזרת חתימת חשיבה, Gemini 3 Pro Image לא מחזיר שגיאת 400. במאמר דוגמה לעריכת תמונות בכמה שלבים באמצעות חתימות חשיבה יש דוגמאות קוד שקשורות לעריכת תמונות בכמה שלבים באמצעות Gemini 3 Pro Image.

אם אתם משתמשים ב-Google Gen AI SDK הרשמי של Google (ב-Python, ב-Node.js, ב-Go או ב-Java) ובתכונות של צ'אט ברירת המחדל, או מוסיפים את התשובה המלאה של המודל להיסטוריה, חתימות החשיבה מטופלות באופן אוטומטי.

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

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

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

שימור תהליכי חשיבה

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

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

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

מודלים של Flash-Lite לא יכולים לקרוא מחשבות שנוצרו על ידי מודלים שהם לא Flash-Lite. אם בקשה למודל Flash-Lite כוללת חתימות מחשבה שנוצרו על ידי מודל שהוא לא Flash-Lite, הבקשה לא נכשלת. במקום זאת, השירות מסיר את המחשבות האלה מההקשר של המודל. לדוגמה, זה קורה כששולחים בקשה למודל Flash-Lite עם היסטוריה ממודל Gemini Flash או Pro.

פניות ושלבים

תהליך שיחה רב-שלבית עם קריאה להפעלת פונקציות ותגובות.

בהקשר של קריאה להפעלת פונקציות, חשוב להבין את ההבדל בין תורות לשלבים:

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

איך משתמשים בחתימות מחשבה

הדרך הכי פשוטה לטפל בחתימות של מחשבות היא לכלול את כל ה-Part מכל ההודעות הקודמות בהיסטוריית השיחה כששולחים בקשה חדשה, בדיוק כמו שהמודל החזיר אותן.

אם אתם לא משתמשים באחת מערכות ה-Google Gen AI SDK, או אם אתם צריכים לשנות או לקצר את היסטוריית השיחות, אתם צריכים לוודא שחתימות המחשבה נשמרות ונשלחות בחזרה למודל.

כשמשתמשים ב-Google Gen AI SDK (מומלץ)

כשמשתמשים בתכונות של היסטוריית הצ'אט בערכות ה-SDK או מוסיפים את האובייקט content של המודל מהתשובה הקודמת ל-contents של הבקשה הבאה, החתימות מטופלות באופן אוטומטי.

בדוגמה הבאה ב-Python מוצג טיפול אוטומטי:

from google import genai
from google.genai.types import Content, FunctionDeclaration, GenerateContentConfig, Part, ThinkingConfig, Tool

client = genai.Client()

# 1. Define your tool
get_weather_declaration = 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 = 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.5-flash",
   contents=prompt,
   config=GenerateContentConfig(
       tools=[get_weather_tool],
       thinking_config=ThinkingConfig(include_thoughts=True)
   ),
)

# 3. 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 (for example, 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",
}

# 4. 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 = [
   Content(role="user", parts=[Part(text=prompt)]),
   response.candidates[0].content, # Signature preserved here
   Content(
     role="tool",
     parts=[
         Part.from_function_response(
             name=function_call.name,
             response=function_response_data,
         )
     ],
   )
]

response_2 = client.models.generate_content(
   model="gemini-3.5-flash",
   contents=history,
   config=GenerateContentConfig(
       tools=[get_weather_tool],
       thinking_config=ThinkingConfig(include_thoughts=True)
   ),
)

# 5. Get the final, natural-language answer
print(f"\nFinal model response: {response_2.text}")

כשמשתמשים ב-REST או בטיפול ידני

אם אתם משתמשים ב-API ישירות, אתם צריכים להטמיע טיפול בחתימות לפי הכללים הבאים של Gemini 3 Pro:

• קריאה להפעלת פונקציות:
  • אם התשובה של המודל מכילה חלק אחד או יותר של functionCall, נדרש thought_signature כדי שהעיבוד יתבצע בצורה נכונה.
  • במקרים של קריאות מקבילות לפונקציות בתשובה אחת, רק החלק הראשון של functionCall יכיל את thought_signature.
  • במקרים של קריאות עוקבות לפונקציות בכמה שלבים בתור, כל חלק של functionCall יכיל thought_signature.
  • כלל: כשיוצרים את הבקשה הבאה, צריך לכלול את part שמכיל את functionCall ואת thought_signature בדיוק כמו שהמודל החזיר אותם. בקריאה להפעלת פונקציות ברצף (בכמה שלבים), האימות מתבצע בכל השלבים בתור הנוכחי. אם משמיטים את הערך הנדרש של thought_signature בחלק הראשון של functionCall בכל שלב בתור הנוכחי, מתקבלת השגיאה 400. כל סבב מתחיל בהודעת המשתמש האחרונה שהיא לא functionResponse.
  • אם המודל מחזיר קריאה להפעלת פונקציות במקביל (לדוגמה, FC1+signature, FC2), התשובה צריכה להכיל את כל הבקשות להפעלת פונקציות ואחריהן את כל התשובות מהפונקציות (FC1+signature, FC2, FR1, FR2). אם התשובות משולבות (FC1+signature, FR1, FC2, FR2), תתקבל השגיאה 400. מחזירים את החלקים של functionResponse באותו סדר כמו החלקים התואמים של functionCall. ה-API מתאים בין התגובות של הפונקציות המקבילות לבין הקריאות להפעלת פונקציות לפי id (אם צוין ב-v1beta1), או לפי name והסדר הרציף במערך parts.
  • במקרים נדירים צריך לספק חלקי functionCall שלא נוצרו על ידי ה-API, ולכן אין להם חתימת מחשבה משויכת (לדוגמה, כשמעבירים היסטוריה ממודל שלא כולל חתימות מחשבה). אפשר להגדיר את thought_signature לערך skip_thought_signature_validator, אבל כדאי לעשות את זה רק אם אין ברירה, כי זה ישפיע לרעה על ביצועי המודל.
• ללא קריאה להפעלת פונקציות:
  • אם התשובה של המודל לא מכילה functionCall, יכול להיות שהיא תכלול thought_signature ב-part האחרון של התשובה (לדוגמה, החלק האחרון של text).
  • כלל: מומלץ לכלול את החתימה הזו בבקשה הבאה כדי לקבל את הביצועים הטובים ביותר, אבל אם לא תכללו אותה לא תהיה שגיאה. בזמן סטרימינג, יכול להיות שהחתימה הזו תוחזר בחלק עם תוכן טקסט ריק, אז חשוב לנתח את כל החלקים עד שהמודל יחזיר את finish_reason.

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

• תמיד צריך לשלוח את ה-thought_signature בחזרה למודל בתוך ה-Part המקורי שלו.
• אל תמזגו Part שמכיל חתימה עם Part שלא מכיל חתימה. זה פוגע בהקשר של המיקום של המחשבה.
• אל תשלבו שני אובייקטים מסוג Part ששניהם מכילים חתימות, כי אי אפשר למזג את מחרוזות החתימות.

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

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

REST

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

תור 1, שלב 1 (בקשת המשתמש)

{
  "contents": [
    {
      "role": "user",
      "parts": [
        {
          "text": "Check flight status for AA100 and book a taxi 2 hours before if delayed."
        }
      ]
    }
  ],
  "tools": [
    {
      "functionDeclarations": [
        {
          "name": "check_flight",
          "description": "Gets the current status of a flight",
          "parameters": {
            "type": "object",
            "properties": {
              "flight": {
                "type": "string",
                "description": "The flight number to check"
              }
            },
            "required": [
              "flight"
            ]
          }
        },
        {
          "name": "book_taxi",
          "description": "Book a taxi",
          "parameters": {
            "type": "object",
            "properties": {
              "time": {
                "type": "string",
                "description": "time to book the taxi"
              }
            },
            "required": [
              "time"
            ]
          }
        }
      ]
    }
  ]
}

תור 1, שלב 1 (תשובה מהמודל)

{
"content": {
        "role": "model",
        "parts": [
          {
            "functionCall": {
              "name": "check_flight",
              "args": {
                "flight": "AA100"
              }
            },
            "thoughtSignature": "<SIGNATURE_A>"
          }
        ]
  }
}

סבב 1, שלב 2 (תגובת המשתמש – שליחת פלט של כלים)

מכיוון שהתור הזה של המשתמש מכיל רק functionResponse (בלי טקסט חדש), אנחנו עדיין בתור 1. צריך לשמור את <SIGNATURE_A>.

{
      "role": "user",
      "parts": [
        {
          "text": "Check flight status for AA100 and book a taxi 2 hours before if delayed."
        }
      ]
    },
    {
        "role": "model",
        "parts": [
          {
            "functionCall": {
              "name": "check_flight",
              "args": {
                "flight": "AA100"
              }
            },
            "thoughtSignature": "<SIGNATURE_A>"
          }
        ]
      },
      {
        "role": "user",
        "parts": [
          {
            "functionResponse": {
              "name": "check_flight",
              "response": {
                "status": "delayed",
                "departure_time": "12 PM"
                }
              }
            }
        ]
}

סבב 1, שלב 2 (תשובה מהמודל)

עכשיו המודל מחליט להזמין מונית על סמך הפלט הקודם של הכלי.

{
      "content": {
        "role": "model",
        "parts": [
          {
            "functionCall": {
              "name": "book_taxi",
              "args": {
                "time": "10 AM"
              }
            },
            "thoughtSignature": "<SIGNATURE_B>"
          }
        ]
      }
}

תור 1, שלב 3 (תגובת המשתמש – שליחת פלט של כלי)

כדי לשלוח את אישור ההזמנה של המונית, צריך לכלול חתימות לכל הקריאות להפעלת פונקציות בלולאה הזו (<SIGNATURE_A> ו-<SIGNATURE_B>).

{
      "role": "user",
      "parts": [
        {
          "text": "Check flight status for AA100 and book a taxi 2 hours before if delayed."
        }
      ]
    },
    {
        "role": "model",
        "parts": [
          {
            "functionCall": {
              "name": "check_flight",
              "args": {
                "flight": "AA100"
              }
            },
            "thoughtSignature": "<SIGNATURE_A>"
          }
        ]
      },
      {
        "role": "user",
        "parts": [
          {
            "functionResponse": {
              "name": "check_flight",
              "response": {
                "status": "delayed",
                "departure_time": "12 PM"
              }
              }
            }
        ]
      },
      {
        "role": "model",
        "parts": [
          {
            "functionCall": {
              "name": "book_taxi",
              "args": {
                "time": "10 AM"
              }
            },
            "thoughtSignature": "<SIGNATURE_B>"
          }
        ]
      },
      {
        "role": "user",
        "parts": [
          {
            "functionResponse": {
              "name": "book_taxi",
              "response": {
                "booking_status": "success"
              }
              }
            }
        ]
    }
}

השלמות צ'אט

הדוגמה הבאה ממחישה איך לטפל בחתימות של תהליכי חשיבה בכמה שלבים בתהליך עבודה של שרשרת קריאות להפעלת פונקציות באמצעות Chat Completions API.

תור 1, שלב 1 (בקשת המשתמש)

{
  "model": "google/gemini-3.1-pro-preview",
  "messages": [
    {
      "role": "user",
      "content": "Check flight status for AA100 and book a taxi 2 hours before if delayed."
    }
  ],
  "tools": [
    {
      "type": "function",
      "function": {
        "name": "check_flight",
        "description": "Gets the current status of a flight",
        "parameters": {
          "type": "object",
          "properties": {
            "flight": {
              "type": "string",
              "description": "The flight number to check."
            }
          },
          "required": [
            "flight"
          ]
        }
      }
    },
    {
      "type": "function",
      "function": {
        "name": "book_taxi",
        "description": "Book a taxi",
        "parameters": {
          "type": "object",
          "properties": {
            "time": {
              "type": "string",
              "description": "time to book the taxi"
            }
          },
          "required": [
            "time"
          ]
        }
      }
    }
  ]
}

תור 1, שלב 1 (תשובה מהמודל)

{
      "role": "model",
        "tool_calls": [
          {
            "extra_content": {
              "google": {
                "thought_signature": "<SIGNATURE_A>"
              }
            },
            "function": {
              "arguments": "{\"flight\":\"AA100\"}",
              "name": "check_flight"
            },
            "id": "function-call-1",
            "type": "function"
          }
        ]
    }

סבב 1, שלב 2 (תגובת המשתמש – שליחת פלט של כלים)

מכיוון שהתור הזה של המשתמש מכיל רק functionResponse (בלי טקסט חדש), אנחנו עדיין בתור 1. צריך לשמור את <SIGNATURE_A>.

"messages": [
    {
      "role": "user",
      "content": "Check flight status for AA100 and book a taxi 2 hours before if delayed."
    },
    {
      "role": "model",
        "tool_calls": [
          {
            "extra_content": {
              "google": {
                "thought_signature": "<SIGNATURE_A>"
              }
            },
            "function": {
              "arguments": "{\"flight\":\"AA100\"}",
              "name": "check_flight"
            },
            "id": "function-call-1",
            "type": "function"
          }
        ]
    },
    {
      "role": "tool",
      "name": "check_flight",
      "tool_call_id": "function-call-1",
      "content": "{\"status\":\"delayed\",\"departure_time\":\"12 PM\"}"
    }
  ]

סבב 1, שלב 2 (תשובה מהמודל)

עכשיו המודל מחליט להזמין מונית על סמך הפלט הקודם של הכלי.

{
"role": "model",
"tool_calls": [
{
"extra_content": {
"google": {
"thought_signature": "<SIGNATURE_B>"
}
            },
            "function": {
              "arguments": "{\"time\":\"10 AM\"}",
              "name": "book_taxi"
            },
            "id": "function-call-2",
            "type": "function"
          }
       ]
}

תור 1, שלב 3 (תגובת המשתמש – שליחת פלט של כלי)

כדי לשלוח את אישור ההזמנה של המונית, צריך לכלול חתימות לכל הקריאות להפעלת פונקציות בלולאה הזו (<SIGNATURE_A> ו-<SIGNATURE_B>).

"messages": [
    {
      "role": "user",
      "content": "Check flight status for AA100 and book a taxi 2 hours before if delayed."
    },
    {
      "role": "model",
        "tool_calls": [
          {
            "extra_content": {
              "google": {
                "thought_signature": "<SIGNATURE_A>"
              }
            },
            "function": {
              "arguments": "{\"flight\":\"AA100\"}",
              "name": "check_flight"
            },
            "id": "function-call-1d6a1a61-6f4f-4029-80ce-61586bd86da5",
            "type": "function"
          }
        ]
    },
    {
      "role": "tool",
      "name": "check_flight",
      "tool_call_id": "function-call-1d6a1a61-6f4f-4029-80ce-61586bd86da5",
      "content": "{\"status\":\"delayed\",\"departure_time\":\"12 PM\"}"
    },
    {
      "role": "model",
        "tool_calls": [
          {
            "extra_content": {
              "google": {
                "thought_signature": "<SIGNATURE_B>"
              }
            },
            "function": {
              "arguments": "{\"time\":\"10 AM\"}",
              "name": "book_taxi"
            },
            "id": "function-call-65b325ba-9b40-4003-9535-8c7137b35634",
            "type": "function"
          }
        ]
    },
    {
      "role": "tool",
      "name": "book_taxi",
      "tool_call_id": "function-call-65b325ba-9b40-4003-9535-8c7137b35634",
      "content": "{\"booking_status\":\"success\"}"
    }
  ]

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

בדוגמה הבאה מוצגת קריאה להפעלת פונקציות במקביל, שבה המשתמש מבקש "Check weather in Paris and London".

REST

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

תור 1, שלב 1 (בקשת המשתמש)

{
  "contents": [
    {
      "role": "user",
      "parts": [
        {
          "text": "Check the weather in Paris and London."
        }
      ]
    }
  ],
  "tools": [
    {
      "functionDeclarations": [
        {
          "name": "get_current_temperature",
          "description": "Gets the current temperature for a given location.",
          "parameters": {
            "type": "object",
            "properties": {
              "location": {
                "type": "string",
                "description": "The city name, e.g. San Francisco"
              }
            },
            "required": [
              "location"
            ]
          }
        }
      ]
    }
  ]
}

תור 1, שלב 1 (תשובה מהמודל)

{
  "content": {
    "parts": [
      {
        "functionCall": {
          "name": "get_current_temperature",
          "args": {
            "location": "Paris"
          }
        },
        "thoughtSignature": "<SIGNATURE_A>"
      },
      {
        "functionCall": {
          "name": "get_current_temperature",
          "args": {
            "location": "London"
          }
        }
      }
    ]
  }
}

סבב 1, שלב 2 (תגובת המשתמש – שליחת פלט של כלים)

צריך לשמור על <SIGNATURE_A> בחלק הראשון בדיוק כמו שהוא התקבל.

[
  {
    "role": "user",
    "parts": [
      {
        "text": "Check the weather in Paris and London."
      }
    ]
  },
  {
    "role": "model",
    "parts": [
      {
        "functionCall": {
          "name": "get_current_temperature",
          "args": {
            "city": "Paris"
          }
        },
        "thought_signature": "<SIGNATURE_A>"
      },
      {
        "functionCall": {
          "name": "get_current_temperature",
          "args": {
            "city": "London"
          }
        }
      }
    ]
  },
  {
    "role": "user",
    "parts": [
      {
        "functionResponse": {
          "name": "get_current_temperature",
          "response": {
            "temp": "15C"
          }
        }
      },
      {
        "functionResponse": {
          "name": "get_current_temperature",
          "response": {
            "temp": "12C"
          }
        }
      }
    ]
  }
]

השלמות צ'אט

הדוגמה הבאה ממחישה איך לטפל בחתימות של תהליכי חשיבה בתהליך עבודה של קריאה להפעלת פונקציות במקביל באמצעות Chat Completions API.

תור 1, שלב 1 (בקשת המשתמש)

{
  "contents": [
    {
      "role": "user",
      "parts": [
        {
          "text": "Check the weather in Paris and London."
        }
      ]
    }
  ],
  "tools": [
    {
      "functionDeclarations": [
        {
          "name": "get_current_temperature",
          "description": "Gets the current temperature for a given location.",
          "parameters": {
            "type": "object",
            "properties": {
              "location": {
                "type": "string",
                "description": "The city name, e.g. San Francisco"
              }
            },
            "required": [
              "location"
            ]
          }
        }
      ]
    }
  ]
}

תור 1, שלב 1 (תשובה מהמודל)

{
"role": "assistant",
        "tool_calls": [
          {
            "extra_content": {
              "google": {
                "thought_signature": "<SIGNATURE_A>"
              }
            },
            "function": {
              "arguments": "{\"location\":\"Paris\"}",
              "name": "get_current_temperature"
            },
            "id": "function-call-f3b9ecb3-d55f-4076-98c8-b13e9d1c0e01",
            "type": "function"
          },
          {
            "function": {
              "arguments": "{\"location\":\"London\"}",
              "name": "get_current_temperature"
            },
            "id": "function-call-335673ad-913e-42d1-bbf5-387c8ab80f44",
            "type": "function"
          }
        ]
}

סבב 1, שלב 2 (תגובת המשתמש – שליחת פלט של כלים)

צריך לשמור על <SIGNATURE_A> בחלק הראשון בדיוק כמו שהוא התקבל.

"messages": [
    {
      "role": "user",
      "content": "Check the weather in Paris and London."
    },
    {
      "role": "assistant",
        "tool_calls": [
          {
            "extra_content": {
              "google": {
                "thought_signature": "<SIGNATURE_A>"
              }
            },
            "function": {
              "arguments": "{\"location\":\"Paris\"}",
              "name": "get_current_temperature"
            },
            "id": "function-call-f3b9ecb3-d55f-4076-98c8-b13e9d1c0e01",
            "type": "function"
          },
          {
            "function": {
              "arguments": "{\"location\":\"London\"}",
              "name": "get_current_temperature"
            },
            "id": "function-call-335673ad-913e-42d1-bbf5-387c8ab80f44",
            "type": "function"
          }
        ]
    },
    {
      "role":"tool",
      "name": "get_current_temperature",
      "tool_call_id": "function-call-f3b9ecb3-d55f-4076-98c8-b13e9d1c0e01",
      "content": "{\"temp\":\"15C\"}"
    },
    {
      "role":"tool",
      "name": "get_current_temperature",
      "tool_call_id": "function-call-335673ad-913e-42d1-bbf5-387c8ab80f44",
      "content": "{\"temp\":\"12C\"}"
    }
  ]

חתימות בPartים שאינם functionCall

יכול להיות ש-Gemini יחזיר thought_signature גם ב-Part האחרון של התשובה, גם אם אין בקשה להפעלת פונקציה.

• התנהגות: התוכן הסופי Part (text,‏ inlineData וכו') שהמודל מחזיר יכול להכיל thought_signature.
• דרישה: מומלץ להחזיר את החתימה הזו כדי לוודא שהמודל שומר על חשיבה איכותית, במיוחד במקרים של מעקב אחרי הוראות מורכבות או תהליכי עבודה של Agentic Workflows.
• אימות: ה-API לא אוכף אימות של חתימות בחלקים שהם לא functionCall. אם תשמיטו אותם, לא תקבלו הודעת שגיאה שמונעת את המשך הפעולה, אבל יכול להיות שהביצועים יהיו פחות טובים.

דוגמה לתשובה מהמודל עם חתימה בחלק של הטקסט:

בדוגמאות הבאות מוצגת תשובה של מודל שבה thought_signature נכלל ב-Part שאינו functionCall, ואיך לטפל בזה בבקשה הבאה.

תור 1, שלב 1 (תשובה מהמודל)

{
  "role": "model",
  "parts": [
    {
      "text": "I need to calculate the risk. Let me think step-by-step...",
      "thought_signature": "<SIGNATURE_C>" // OPTIONAL (Recommended)
    }
  ]
}

תור 2, שלב 1 (משתמש)

[
  { "role": "user", "parts": [{ "text": "What is the risk?" }] },
  {
    "role": "model",
    "parts": [
      {
        "text": "I need to calculate the risk. Let me think step-by-step...",
        // If you omit <SIGNATURE_C> here, no error will occur.
      }
    ]
  },
  { "role": "user", "parts": [{ "text": "Summarize it." }] }
]

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

הדוגמאות הבאות ממחישות איך לאחזר ולהעביר חתימות מחשבה במהלך יצירה ועריכה של תמונות בכמה שלבים באמצעות Gemini 3 Pro Image.

שלב 1: מקבלים את התשובה ושומרים את הנתונים שכוללים חתימות של תהליכי חשיבה

chat = client.chats.create(
   model="gemini-3-pro-image-preview",
   config=types.GenerateContentConfig(
       response_modalities=['TEXT', 'IMAGE']
   )
)
message = "Create an image of a clear perfume bottle sitting on a vanity."
response = chat.send_message(message)
data = b''
for part in response.candidates[0].content.parts:
   if part.text:
       display(Markdown(part.text))
   if part.inline_data:
       data = part.inline_data.data
       display(Image(data=data, width=500))

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

response = chat.send_message(
   message=[
       types.Part.from_bytes(
           data=data,
           mime_type="image/png",
       ),
       "Make the perfume bottle purple and add a vase of hydrangeas next to the bottle.",
   ],
)
for part in response.candidates[0].content.parts:
   if part.text:
       display(Markdown(part.text))
   if part.inline_data:
       display(Image(data=part.inline_data.data, width=500))

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

סקירה כללית

בתהליך חשיבה

מידע ולמידה על יכולות החשיבה של Gemini ואיך להגדיר את רמות החשיבה.

מדריך

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

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

מדריך

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

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