העמקה

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

תהליך החשיבה מופעל כברירת מחדל בכל המודלים של Gemini. כשמשתמשים ב-Agent Studio בפלטפורמת Gemini Enterprise Agent, אפשר לראות את כל תהליך החשיבה יחד עם התשובה שהמודל יצר.

מודלים נתמכים

התכונה 'חשיבה' נתמכת בדגמים הבאים:

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

• ‫Gemini Omni Flash תצוגה מקדימה
• ‫Gemini Omni 1.1 Flash תצוגה מקדימה
• ‫Gemini 3.8 Flash
• ‫Gemini 3.7 Flash
• ‫Gemini 3.6 Flash
• ‫Gemini 3.5 Flash-Lite
• ‫Gemini 3.5 Flash
• ‫Gemini 3.1 Pro preview
• תמונה של Gemini 3.1 Flash-Lite (Nano Banana 2 Lite)
• ‫Gemini 3.1 Flash-Lite
• ‫Gemini 3.1 Flash Image
• ‫Gemini 3 Pro Image
• ‫Gemini 3 Flash תצוגה מקדימה
• ‫Gemini 2.5 Pro
• ‫Gemini 2.5 Flash-Lite
• ‫Gemini 2.5 Flash

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

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

מודלים של Gemini 3 ומודלים מתקדמים יותר

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

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

דגם	ערכים נתמכים של thinking_level	ברירת מחדל
Gemini 3.8 Flash	LOW, MEDIUM, HIGH	MEDIUM
Gemini 3.7 Flash	LOW, MEDIUM, HIGH	MEDIUM
Gemini 3.6 Flash	MINIMAL,‏ LOW,‏ MEDIUM,‏ HIGH	MEDIUM
Gemini 3.5 Flash-Lite	MINIMAL,‏ LOW,‏ MEDIUM,‏ HIGH	MINIMAL
Gemini 3.5 Flash	MINIMAL,‏ LOW,‏ MEDIUM,‏ HIGH	MEDIUM
‫Gemini 3.1 Pro preview	LOW, MEDIUM, HIGH	HIGH
תמונה של Gemini 3.1 Flash-Lite‏ (Nano Banana 2 Lite)	MINIMAL, HIGH	MINIMAL
Gemini 3.1 Flash-Lite	MINIMAL,‏ LOW,‏ MEDIUM,‏ HIGH	MINIMAL
תמונה של Gemini 3.1 Flash	MINIMAL, HIGH	MINIMAL
‫Gemini 3 Pro Image	HIGH	HIGH
‫Gemini 3 Flash תצוגה מקדימה	MINIMAL,‏ LOW,‏ MEDIUM,‏ HIGH	HIGH

• ‫MINIMAL: המודל מוגבל לשימוש במספר הטוקנים הנמוך ביותר האפשרי לצורך חשיבה, והוא מתאים במיוחד למשימות פשוטות שלא דורשות חשיבה רציונלית מורכבת. זו רמת ברירת המחדל של Gemini 3.1 Flash-Lite. MINIMAL קרוב ככל האפשר לתקציב אפס למחשבה, אבל עדיין נדרשים חתימות מחשבה. אם לא מספקים בבקשה חתימות של מחשבות, המודל מחזיר שגיאה 400. מידע נוסף זמין במאמר בנושא חתימות של מחשבות.

  from google import genai
  from google.genai import types
  
  client = genai.Client()
  
  response = client.models.generate_content(
      model="gemini-3-flash-preview",
      contents="How does AI work?",
      config=types.GenerateContentConfig(
          thinking_config=types.ThinkingConfig(
              thinking_level=types.ThinkingLevel.MINIMAL
          )
      ),
  )
  print(response.text)
  

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

  from google import genai
  from google.genai import types
  
  client = genai.Client()
  
  response = client.models.generate_content(
      model="gemini-3.5-flash",
      contents="How does AI work?",
      config=types.GenerateContentConfig(
          thinking_config=types.ThinkingConfig(
              thinking_level=types.ThinkingLevel.LOW
          )
      ),
  )
  print(response.text)
  

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

  from google import genai
  from google.genai import types
  
  client = genai.Client()
  
  response = client.models.generate_content(
      model="gemini-3-flash-preview",
      contents="How does AI work?",
      config=types.GenerateContentConfig(
          thinking_config=types.ThinkingConfig(
              thinking_level=types.ThinkingLevel.MEDIUM
          )
      ),
  )
  print(response.text)
  

• ‫HIGH: מאפשר למודל להשתמש ביותר טוקנים לחשיבה, ומתאים לפרומפטים מורכבים שדורשים חשיבה רציונלית מעמיקה, כמו תכנון רב-שלבי, יצירת קוד מאומת או תרחישים מתקדמים של קריאה להפעלת פונקציות. זו רמת ברירת המחדל למודלים של Gemini 3 Pro ו-Gemini 3 Flash. כדאי להשתמש בהגדרה הזו כשמחליפים משימות שאולי הסתמכתם בעבר על מודלים מיוחדים של הסקת מסקנות:

  from google import genai
  from google.genai import types
  
  client = genai.Client()
  
  response = client.models.generate_content(
      model="gemini-3.5-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
          )
      ),
  )
  print(response.text)
  

אי אפשר להשבית את המצב 'חשיבה' ב-Gemini 3 Pro וב-Gemini 3.1 Pro.

אם מציינים גם thinking_level וגם thinking_budget באותה בקשה למודל Gemini 3, המודל מחזיר שגיאה.

‫Gemini 2.5 ומודלים קודמים

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

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

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

דגם	סכום מינימלי של טוקנים	כמות הטוקנים המקסימלית	ברירת מחדל
Gemini ‎2.5 Flash	1	24,576	אוטומטי (עד 8,192 טוקנים)
Gemini ‎2.5 Pro	128	32,768	אוטומטי (עד 8,192 טוקנים)
Gemini 2.5 Flash-Lite	512	24,576	אוטומטי (עד 8,192 טוקנים)

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

אם משתמשים בפרמטר thinking_level עם מודל מגרסה קודמת ל-Gemini 3, המודל מחזיר שגיאה.

המסוף

1. פותחים את Agent Studio > יצירת הנחיה.
2. בחלונית מודל, לוחצים על החלפת מודל ובוחרים אחד מהמודלים הנתמכים מהתפריט.
3. בתפריט הנפתח תקציב חשיבה, בוחרים באפשרות ידני, ואז משתמשים בסרגל ההזזה כדי לשנות את מגבלת תקציב החשיבה.

Python

התקנה

pip install --upgrade google-genai

מידע נוסף מופיע ב מאמרי העזרה בנושא SDK.

מגדירים משתני סביבה כדי להשתמש ב-Google Gen AI SDK עם Vertex AI:

# Replace the `GOOGLE_CLOUD_PROJECT` and `GOOGLE_CLOUD_LOCATION` values
# with appropriate values for your project.
export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT
export GOOGLE_CLOUD_LOCATION=global
export GOOGLE_GENAI_USE_ENTERPRISE=True

from google import genai
from google.genai.types import GenerateContentConfig, ThinkingConfig

client = genai.Client()

response = client.models.generate_content(
    model="gemini-3.5-flash",
    contents="solve x^2 + 4x + 4 = 0",
    config=GenerateContentConfig(
        thinking_config=ThinkingConfig(
            thinking_budget=1024,  # Use `0` to turn off thinking
        )
    ),
)

print(response.text)
# Example response:
#     To solve the equation $x^2 + 4x + 4 = 0$, you can use several methods:
#     **Method 1: Factoring**
#     1.  Look for two numbers that multiply to the constant term (4) and add up to the coefficient of the $x$ term (4).
#     2.  The numbers are 2 and 2 ($2 \times 2 = 4$ and $2 + 2 = 4$).
#     ...
#     ...
#     All three methods yield the same solution. This quadratic equation has exactly one distinct solution (a repeated root).
#     The solution is **x = -2**.

# Token count for `Thinking`
print(response.usage_metadata.thoughts_token_count)
# Example response:
#     886

# Total token count
print(response.usage_metadata.total_token_count)
# Example response:
#     1525

Node.js

התקנה

npm install @google/genai

מידע נוסף מופיע ב מאמרי העזרה בנושא SDK.

מגדירים משתני סביבה כדי להשתמש ב-Google Gen AI SDK עם Vertex AI:

# Replace the `GOOGLE_CLOUD_PROJECT` and `GOOGLE_CLOUD_LOCATION` values
# with appropriate values for your project.
export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT
export GOOGLE_CLOUD_LOCATION=global
export GOOGLE_GENAI_USE_ENTERPRISE=True

const {GoogleGenAI} = require('@google/genai');

const GOOGLE_CLOUD_PROJECT = process.env.GOOGLE_CLOUD_PROJECT;
const GOOGLE_CLOUD_LOCATION = process.env.GOOGLE_CLOUD_LOCATION || 'global';

async function generateWithThoughts(
  projectId = GOOGLE_CLOUD_PROJECT,
  location = GOOGLE_CLOUD_LOCATION
) {
  const client = new GoogleGenAI({
    vertexai: true,
    project: projectId,
    location: location,
  });

  const response = await client.models.generateContent({
    model: 'gemini-2.5-flash',
    contents: 'solve x^2 + 4x + 4 = 0',
    config: {
      thinkingConfig: {
        thinkingBudget: 1024,
      },
    },
  });

  console.log(response.text);
  // Example response:
  //  To solve the equation $x^2 + 4x + 4 = 0$, you can use several methods:
  //  **Method 1: Factoring**
  //  1.  Look for two numbers that multiply to the constant term (4) and add up to the coefficient of the $x$ term (4).
  //  2.  The numbers are 2 and 2 ($2 \times 2 = 4$ and $2 + 2 = 4$).
  //  ...
  //  ...
  //  All three methods yield the same solution. This quadratic equation has exactly one distinct solution (a repeated root).
  //  The solution is **x = -2**.

  // Token count for `Thinking`
  console.log(response.usageMetadata.thoughtsTokenCount);
  // Example response:
  //  886

  // Total token count
  console.log(response.usageMetadata.totalTokenCount);
  // Example response:
  //  1525
  return response.text;
}

Go

כך מתקינים או מעדכנים את Go.

מידע נוסף מופיע ב מאמרי העזרה בנושא SDK.

מגדירים משתני סביבה כדי להשתמש ב-Google Gen AI SDK עם Vertex AI:

# Replace the `GOOGLE_CLOUD_PROJECT` and `GOOGLE_CLOUD_LOCATION` values
# with appropriate values for your project.
export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT
export GOOGLE_CLOUD_LOCATION=global
export GOOGLE_GENAI_USE_ENTERPRISE=True

import (
	"context"
	"fmt"
	"io"

	"google.golang.org/genai"
)

// generateThinkingBudgetContentWithText demonstrates how to generate text including the model's thought process.
func generateThinkingBudgetContentWithText(w io.Writer) error {
	ctx := context.Background()

	client, err := genai.NewClient(ctx, &genai.ClientConfig{
		HTTPOptions: genai.HTTPOptions{APIVersion: "v1"},
	})
	if err != nil {
		return fmt.Errorf("failed to create genai client: %w", err)
	}

	modelName := "gemini-2.5-flash"
	thinkingBudget := int32(1024) //Use `0` to turn off thinking
	contents := []*genai.Content{
		{
			Parts: []*genai.Part{
				{Text: "solve x^2 + 4x + 4 = 0"},
			},
			Role: "user",
		},
	}

	resp, err := client.Models.GenerateContent(ctx,
		modelName,
		contents,
		&genai.GenerateContentConfig{
			ThinkingConfig: &genai.ThinkingConfig{
				ThinkingBudget: &thinkingBudget,
			},
		},
	)
	if err != nil {
		return fmt.Errorf("generate content failed: %w", err)
	}

	if resp.UsageMetadata != nil {
		fmt.Fprintf(w, "Thoughts token count: %d\n", resp.UsageMetadata.ThoughtsTokenCount)
		//Example response:
		//  908
		fmt.Fprintf(w, "Total token count: %d\n", resp.UsageMetadata.TotalTokenCount)
		//Example response:
		//  1364
	}

	fmt.Fprintln(w, resp.Text())

	// Example response:
	//    To solve the equation $x^2 + 4x + 4 = 0$, you can use several methods:
	//    **Method 1: Factoring**
	//    1.  Look for two numbers that multiply to the constant term (4) and add up to the coefficient of the $x$ term (4).
	//    2.  The numbers are 2 and 2 ($2 \times 2 = 4$ and $2 + 2 = 4$).
	//    ...
	//    ...
	//    Both methods yield the same result.
	//    The solution to the equation $x^2 + 4x + 4 = 0$ is **$x = -2$**.

	return nil
}

Java

כך מתקינים או מעדכנים את Java.

מידע נוסף מופיע ב מאמרי העזרה בנושא SDK.

מגדירים משתני סביבה כדי להשתמש ב-Google Gen AI SDK עם Vertex AI:

# Replace the `GOOGLE_CLOUD_PROJECT` and `GOOGLE_CLOUD_LOCATION` values
# with appropriate values for your project.
export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT
export GOOGLE_CLOUD_LOCATION=global
export GOOGLE_GENAI_USE_ENTERPRISE=True

import com.google.genai.Client;
import com.google.genai.types.GenerateContentConfig;
import com.google.genai.types.GenerateContentResponse;
import com.google.genai.types.HttpOptions;
import com.google.genai.types.ThinkingConfig;

public class ThinkingBudgetWithTxt {

  public static void main(String[] args) {
    // TODO(developer): Replace these variables before running the sample.
    String modelId = "gemini-2.5-flash";
    generateContent(modelId);
  }

  // Generates text controlling the thinking budget
  public static String generateContent(String modelId) {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (Client client =
        Client.builder()
            .location("global")
            .vertexAI(true)
            .httpOptions(HttpOptions.builder().apiVersion("v1").build())
            .build()) {

      GenerateContentConfig contentConfig =
          GenerateContentConfig.builder()
              .thinkingConfig(ThinkingConfig.builder().thinkingBudget(1024).build())
              .build();

      GenerateContentResponse response =
          client.models.generateContent(modelId, "solve x^2 + 4x + 4 = 0", contentConfig);

      System.out.println(response.text());
      // Example response:
      // To solve the equation $x^2 + 4x + 4 = 0$, we can use several methods:
      //
      // **Method 1: Factoring (Recognizing a Perfect Square Trinomial)**
      //
      // Notice that the left side of the equation is a perfect square trinomial. It fits the form
      // $a^2 + 2ab + b^2 = (a+b)^2$...
      // ...
      // The solution is $x = -2$.

      response
          .usageMetadata()
          .ifPresent(
              metadata -> {
                System.out.println("Token count for thinking: " + metadata.thoughtsTokenCount());
                System.out.println("Total token count: " + metadata.totalTokenCount());
              });
      // Example response:
      // Token count for thinking: Optional[885]
      // Total token count: Optional[1468]
      return response.text();
    }
  }
}

צפייה בסיכומי המחשבות

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

ב-Agent Studio, סיכומי המחשבות מופעלים כברירת מחדל ואפשר לראות אותם על ידי הרחבת החלונית מחשבות.

כשמשתמשים ב-API, אפשר להפעיל סיכומי מחשבות על ידי הגדרת include_thoughts=True ב-ThinkingConfig:

המסוף

סיכומי המחשבות מופעלים כברירת מחדל ב-Agent Studio. אפשר להרחיב את החלונית Thoughts כדי לראות סיכום של תהליך החשיבה של המודל.

Python

התקנה

pip install --upgrade google-genai

מידע נוסף מופיע ב מאמרי העזרה בנושא SDK.

מגדירים משתני סביבה כדי להשתמש ב-Google Gen AI SDK עם Vertex AI:

# Replace the `GOOGLE_CLOUD_PROJECT` and `GOOGLE_CLOUD_LOCATION` values
# with appropriate values for your project.
export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT
export GOOGLE_CLOUD_LOCATION=global
export GOOGLE_GENAI_USE_ENTERPRISE=True

from google import genai
from google.genai.types import GenerateContentConfig, ThinkingConfig

client = genai.Client()
response = client.models.generate_content(
    model="gemini-3.1-pro-preview",
    contents="solve x^2 + 4x + 4 = 0",
    config=GenerateContentConfig(
        thinking_config=ThinkingConfig(include_thoughts=True)
    ),
)

print(response.text)
# Example Response:
#     Okay, let's solve the quadratic equation x² + 4x + 4 = 0.
#     ...
#     **Answer:**
#     The solution to the equation x² + 4x + 4 = 0 is x = -2. This is a repeated root (or a root with multiplicity 2).

for part in response.candidates[0].content.parts:
    if part and part.thought:  # show thoughts
        print(part.text)
# Example Response:
#     **My Thought Process for Solving the Quadratic Equation**
#
#     Alright, let's break down this quadratic, x² + 4x + 4 = 0. First things first:
#     it's a quadratic; the x² term gives it away, and we know the general form is
#     ax² + bx + c = 0.
#
#     So, let's identify the coefficients: a = 1, b = 4, and c = 4. Now, what's the
#     most efficient path to the solution? My gut tells me to try factoring; it's
#     often the fastest route if it works. If that fails, I'll default to the quadratic
#     formula, which is foolproof. Completing the square? It's good for deriving the
#     formula or when factoring is difficult, but not usually my first choice for
#     direct solving, but it can't hurt to keep it as an option.
#
#     Factoring, then. I need to find two numbers that multiply to 'c' (4) and add
#     up to 'b' (4). Let's see... 1 and 4 don't work (add up to 5). 2 and 2? Bingo!
#     They multiply to 4 and add up to 4. This means I can rewrite the equation as
#     (x + 2)(x + 2) = 0, or more concisely, (x + 2)² = 0. Solving for x is now
#     trivial: x + 2 = 0, thus x = -2.
#
#     Okay, just to be absolutely certain, I'll run the quadratic formula just to
#     double-check. x = [-b ± √(b² - 4ac)] / 2a. Plugging in the values, x = [-4 ±
#     √(4² - 4 * 1 * 4)] / (2 * 1). That simplifies to x = [-4 ± √0] / 2. So, x =
#     -2 again – a repeated root. Nice.
#
#     Now, let's check via completing the square. Starting from the same equation,
#     (x² + 4x) = -4. Take half of the b-value (4/2 = 2), square it (2² = 4), and
#     add it to both sides, so x² + 4x + 4 = -4 + 4. Which simplifies into (x + 2)²
#     = 0. The square root on both sides gives us x + 2 = 0, therefore x = -2, as
#      expected.
#
#     Always, *always* confirm! Let's substitute x = -2 back into the original
#     equation: (-2)² + 4(-2) + 4 = 0. That's 4 - 8 + 4 = 0. It checks out.
#
#     Conclusion: the solution is x = -2. Confirmed.

Node.js

התקנה

npm install @google/genai

מידע נוסף מופיע ב מאמרי העזרה בנושא SDK.

מגדירים משתני סביבה כדי להשתמש ב-Google Gen AI SDK עם Vertex AI:

# Replace the `GOOGLE_CLOUD_PROJECT` and `GOOGLE_CLOUD_LOCATION` values
# with appropriate values for your project.
export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT
export GOOGLE_CLOUD_LOCATION=global
export GOOGLE_GENAI_USE_ENTERPRISE=True

const {GoogleGenAI} = require('@google/genai');

const GOOGLE_CLOUD_PROJECT = process.env.GOOGLE_CLOUD_PROJECT;
const GOOGLE_CLOUD_LOCATION = process.env.GOOGLE_CLOUD_LOCATION || 'global';

async function generateWithThoughts(
  projectId = GOOGLE_CLOUD_PROJECT,
  location = GOOGLE_CLOUD_LOCATION
) {
  const client = new GoogleGenAI({
    vertexai: true,
    project: projectId,
    location: location,
  });

  const response = await client.models.generateContent({
    model: 'gemini-2.5-pro',
    contents: 'solve x^2 + 4x + 4 = 0',
    config: {
      thinkingConfig: {
        includeThoughts: true,
      },
    },
  });

  console.log(response.text);
  // Example Response:
  //  Okay, let's solve the quadratic equation x² + 4x + 4 = 0.
  //  ...
  //  **Answer:**
  //  The solution to the equation x² + 4x + 4 = 0 is x = -2. This is a repeated root (or a root with multiplicity 2).

  for (const part of response.candidates[0].content.parts) {
    if (part && part.thought) {
      console.log(part.text);
    }
  }

  // Example Response:
  // **My Thought Process for Solving the Quadratic Equation**
  //
  // Alright, let's break down this quadratic, x² + 4x + 4 = 0. First things first:
  // it's a quadratic; the x² term gives it away, and we know the general form is
  // ax² + bx + c = 0.
  //
  // So, let's identify the coefficients: a = 1, b = 4, and c = 4. Now, what's the
  // most efficient path to the solution? My gut tells me to try factoring; it's
  // often the fastest route if it works. If that fails, I'll default to the quadratic
  // formula, which is foolproof. Completing the square? It's good for deriving the
  // formula or when factoring is difficult, but not usually my first choice for
  // direct solving, but it can't hurt to keep it as an option.
  //
  // Factoring, then. I need to find two numbers that multiply to 'c' (4) and add
  // up to 'b' (4). Let's see... 1 and 4 don't work (add up to 5). 2 and 2? Bingo!
  // They multiply to 4 and add up to 4. This means I can rewrite the equation as
  // (x + 2)(x + 2) = 0, or more concisely, (x + 2)² = 0. Solving for x is now
  // trivial: x + 2 = 0, thus x = -2.
  //
  // Okay, just to be absolutely certain, I'll run the quadratic formula just to
  // double-check. x = [-b ± √(b² - 4ac)] / 2a. Plugging in the values, x = [-4 ±
  // √(4² - 4 * 1 * 4)] / (2 * 1). That simplifies to x = [-4 ± √0] / 2. So, x =
  // -2 again – a repeated root. Nice.
  //
  // Now, let's check via completing the square. Starting from the same equation,
  // (x² + 4x) = -4. Take half of the b-value (4/2 = 2), square it (2² = 4), and
  // add it to both sides, so x² + 4x + 4 = -4 + 4. Which simplifies into (x + 2)²
  // = 0. The square root on both sides gives us x + 2 = 0, therefore x = -2, as
  //  expected.
  //
  // Always, *always* confirm! Let's substitute x = -2 back into the original
  // equation: (-2)² + 4(-2) + 4 = 0. That's 4 - 8 + 4 = 0. It checks out.
  //
  // Conclusion: the solution is x = -2. Confirmed.

  return response.text;
}

Go

כך מתקינים או מעדכנים את Go.

מידע נוסף מופיע ב מאמרי העזרה בנושא SDK.

מגדירים משתני סביבה כדי להשתמש ב-Google Gen AI SDK עם Vertex AI:

# Replace the `GOOGLE_CLOUD_PROJECT` and `GOOGLE_CLOUD_LOCATION` values
# with appropriate values for your project.
export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT
export GOOGLE_CLOUD_LOCATION=global
export GOOGLE_GENAI_USE_ENTERPRISE=True

import (
	"context"
	"fmt"
	"io"

	"google.golang.org/genai"
)

// generateContentWithThoughts demonstrates how to generate text including the model's thought process.
func generateContentWithThoughts(w io.Writer) error {
	ctx := context.Background()

	client, err := genai.NewClient(ctx, &genai.ClientConfig{
		HTTPOptions: genai.HTTPOptions{APIVersion: "v1"},
	})
	if err != nil {
		return fmt.Errorf("failed to create genai client: %w", err)
	}

	modelName := "gemini-2.5-pro"
	contents := []*genai.Content{
		{
			Parts: []*genai.Part{
				{Text: "solve x^2 + 4x + 4 = 0"},
			},
			Role: "user",
		},
	}

	resp, err := client.Models.GenerateContent(ctx,
		modelName,
		contents,
		&genai.GenerateContentConfig{
			ThinkingConfig: &genai.ThinkingConfig{
				IncludeThoughts: true,
			},
		},
	)
	if err != nil {
		return fmt.Errorf("failed to generate content: %w", err)
	}

	if len(resp.Candidates) == 0 || resp.Candidates[0].Content == nil {
		return fmt.Errorf("no content was generated")
	}

	// The response may contain both the final answer and the model's thoughts.
	// Iterate through the parts to print them separately.
	fmt.Fprintln(w, "Answer:")
	for _, part := range resp.Candidates[0].Content.Parts {
		if part.Text != "" && !part.Thought {
			fmt.Fprintln(w, part.Text)
		}
	}
	fmt.Fprintln(w, "\nThoughts:")
	for _, part := range resp.Candidates[0].Content.Parts {
		if part.Thought {
			fmt.Fprintln(w, part.Text)
		}
	}

	// Example response:
	//  Answer:
	//	Of course! We can solve this quadratic equation in a couple of ways.
	//
	//### Method 1: Factoring (the easiest method for this problem)
	//
	//1.  **Recognize the pattern.** The expression `x² + 4x + 4` is a perfect square trinomial. It fits the pattern `a² + 2ab + b² = (a + b)²`. In this case, `a = x` and `b = 2`.
	//
	//2.  **Factor the equation.**
	//    `x² + 4x + 4 = (x + 2)(x + 2) = (x + 2)²`
	//
	//3.  **Solve for x.** Now set the factored expression to zero:
	//    `(x + 2)² = 0`
	//
	//    Take the square root of both sides:
	//    `x + 2 = 0`
	//
	//    Subtract 2 from both sides:
	//    `x = -2`
	//
	//This type of solution is called a "repeated root" or a "double root" because the factor `(x+2)` appears twice.
	//
	//---
	//
	//### Method 2: Using the Quadratic Formula
	//
	//You can use the quadratic formula for any equation in the form `ax² + bx + c = 0`.
	//
	//The formula is: `x = [-b ± sqrt(b² - 4ac)] / 2a`
	//
	//1.  **Identify a, b, and c.**
	//    *   a = 1
	//    *   b = 4
	//    *   c = 4
	//
	//2.  **Plug the values into the formula.**
	//    `x = [-4 ± sqrt(4² - 4 * 1 * 4)] / (2 * 1)`
	//
	//3.  **Simplify.**
	//    `x = [-4 ± sqrt(16 - 16)] / 2`
	//    `x = [-4 ± sqrt(0)] / 2`
	//    `x = -4 / 2`
	//
	//4.  **Solve for x.**
	//    `x = -2`
	//Alright, the user wants to solve the quadratic equation `x² + 4x + 4 = 0`. My first instinct is to see if I can factor it; that's often the fastest approach if it works.  Looking at the coefficients, I see `a = 1`, `b = 4`, and `c = 4`.  Factoring is clearly the most direct path here. I need to find two numbers that multiply to 4 (c) and add up to 4 (b). Hmm, let's see… 1 and 4? Nope, that adds to 5.  2 and 2? Perfect!  2 times 2 is 4, and 2 plus 2 is also 4.
	//
	//So, `x² + 4x + 4` factors nicely into `(x + 2)(x + 2)`.  Ah, a perfect square trinomial! That's useful to note. Now, I can write the equation as `(x + 2)² = 0`.  Taking the square root of both sides gives me `x + 2 = 0`.  And finally, subtracting 2 from both sides, I get `x = -2`.  That's the solution.
	//
	//Just to be thorough, and maybe to offer an alternative explanation, let's verify this using the quadratic formula. It's `x = [-b ± √(b² - 4ac)] / 2a`. Plugging in my values:  `x = [-4 ± √(4² - 4 * 1 * 4)] / (2 * 1)`.  That simplifies to `x = [-4 ± √(16 - 16)] / 2`, or `x = [-4 ± 0] / 2`.  Therefore, `x = -2`. The discriminant being zero tells me I have exactly one real, repeated root.  Great. So, whether I factor or use the quadratic formula, the answer is the same.
	return nil
}

Java

כך מתקינים או מעדכנים את Java.

מידע נוסף מופיע ב מאמרי העזרה בנושא SDK.

מגדירים משתני סביבה כדי להשתמש ב-Google Gen AI SDK עם Vertex AI:

# Replace the `GOOGLE_CLOUD_PROJECT` and `GOOGLE_CLOUD_LOCATION` values
# with appropriate values for your project.
export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT
export GOOGLE_CLOUD_LOCATION=global
export GOOGLE_GENAI_USE_ENTERPRISE=True

import com.google.genai.Client;
import com.google.genai.types.Candidate;
import com.google.genai.types.Content;
import com.google.genai.types.GenerateContentConfig;
import com.google.genai.types.GenerateContentResponse;
import com.google.genai.types.HttpOptions;
import com.google.genai.types.ThinkingConfig;

public class ThinkingIncludeThoughtsWithTxt {

  public static void main(String[] args) {
    // TODO(developer): Replace these variables before running the sample.
    String modelId = "gemini-2.5-pro";
    generateContent(modelId);
  }

  // Generates text including thoughts in the response
  public static String generateContent(String modelId) {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (Client client =
        Client.builder()
            .location("global")
            .vertexAI(true)
            .httpOptions(HttpOptions.builder().apiVersion("v1").build())
            .build()) {

      GenerateContentConfig contentConfig =
          GenerateContentConfig.builder()
              .thinkingConfig(ThinkingConfig.builder().includeThoughts(true).build())
              .build();

      GenerateContentResponse response =
          client.models.generateContent(modelId, "solve x^2 + 4x + 4 = 0", contentConfig);

      System.out.println(response.text());
      // Example response:
      // We can solve the equation x² + 4x + 4 = 0 using a couple of common methods.
      //
      // ### Method 1: Factoring (The Easiest Method for this Problem)
      // **Recognize the pattern:** The pattern for a perfect square trinomial
      // is a² + 2ab + b² = (a + b)².
      // ...
      // ### Final Answer:
      // The solution is **x = -2**.

      // Get parts of the response and print thoughts
      response
          .candidates()
          .flatMap(candidates -> candidates.stream().findFirst())
          .flatMap(Candidate::content)
          .flatMap(Content::parts)
          .ifPresent(
              parts -> {
                parts.forEach(
                    part -> {
                      if (part.thought().orElse(false)) {
                        part.text().ifPresent(System.out::println);
                      }
                    });
              });
      // Example response:
      // Alright, let's break down this quadratic equation, x² + 4x + 4 = 0. My initial thought is,
      // "classic quadratic."  I'll need to find the values of 'x' that make this equation true. The
      // equation is in standard form, and since the coefficients are relatively small, I
      // immediately suspect that factoring might be the easiest route.  It's worth checking.
      //
      // First, I assessed what I had. *a* is 1, *b* is 4, and *c* is 4. I consider my toolkit.
      // Factoring is the likely first choice, then I can use the quadratic formula as a backup,
      // because that ALWAYS works, and I could use graphing. However, for this, factoring seems the
      // cleanest approach.
      //
      // Okay, factoring. I need two numbers that multiply to *c* (which is 4) and add up to *b*
      // (also 4).  I quickly run through the factor pairs of 4: (1, 4), (-1, -4), (2, 2), (-2, -2).
      //  Aha! 2 and 2 fit the bill. They multiply to 4 *and* add up to 4.  Therefore, I can rewrite
      // the equation as (x + 2)(x + 2) = 0.  That simplifies to (x + 2)² = 0. Perfect square
      // trinomial – nice and tidy. Seeing that pattern from the outset can save a step or two. Now,
      // to solve for *x*:  if (x + 2)² = 0, then x + 2 must equal 0.  Therefore, x = -2. Done.
      //
      // But, for the sake of a full explanation, let's use the quadratic formula as a second
      // method. It's a reliable way to double-check the answer, plus it's good practice.  I plug my
      // *a*, *b*, and *c* values into the formula: x = [-b ± √(b² - 4ac)] / (2a). That gives me  x
      // = [-4 ± √(4² - 4 * 1 * 4)] / (2 * 1). Simplifying under the radical, I get x = [-4 ± √(16 -
      // 16)] / 2. So, x = [-4 ± √0] / 2. The square root of 0 is zero, which is very telling!  When
      // the discriminant (b² - 4ac) is zero, you get one real solution, a repeated root. This means
      // x = -4 / 2, which simplifies to x = -2.  Exactly the same as before.
      //
      // Therefore, the answer is x = -2.  Factoring was the most straightforward route.  For
      // completeness, I showed the solution via the quadratic formula, too. Both approaches lead to
      // the same single solution.  This is a repeated root – a double root, if you will.
      //
      // And to be absolutely sure...let's check our answer! Substitute -2 back into the original
      // equation. (-2)² + 4(-2) + 4 = 4 - 8 + 4 = 0.  Yep, 0 = 0. The solution is correct.
      return response.text();
    }
  }
}

תגובה יכולה להכיל חתימת מחשבה בלי טקסט של סיכום המחשבה בתרחישים הבאים:

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

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

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

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

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

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

טכניקות לכתיבת פרומפטים

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

לקבלת אסטרטגיות מקיפות, דפוסי multishot, הנחיות לאימות וטיפים לניפוי באגים, אפשר לעיין במדריך להנחיות מסוג Thinking.

תמחור

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

מידע נוסף על התמחור של Agent Platform במאמר שליטה בשימוש במודלים מוסבר איך לנהל את העלויות.

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

מדריך

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

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

מדריך

מדריך לכתיבת פרומפטים של חשיבה

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

מסוף

מסוף Google Cloud

אתם יכולים לנסות לתת הנחיות ל-Gemini בעצמכם במסוף Google Cloud.