העמקה

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

בדף הזה מוסבר איך:

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

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

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

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

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

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

אופן ההגדרה של תהליך החשיבה תלוי בגרסת המודל:

‫Gemini 3 ומודלים חדשים יותר

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

המסוף

  1. עוברים אל Agent Studio, לוחצים על חדש > צ'אט ומרחיבים את חלונית המודל.

    פתיחת Agent Studio

  2. בחלונית Model settings, בוחרים מודל נתמך בתפריט Model.
  3. בוחרים ערך מהתפריט הנפתח רמת חשיבה.

Python

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(
            # Options: MINIMAL, LOW, MEDIUM, HIGH, XHIGH
            thinking_level=types.ThinkingLevel.THINKING_LEVEL_VALUE
        )
    ),
)

print(response.text)

ערכים של רמות ההעמקה

אפשר להגדיר את thinking_level לאחד מהערכים הבאים:

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

רמות ההעמקה שנתמכות בכל מודל

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

דגם ערכי thinking_level נתמכים ברירת מחדל
‫Gemini Robotics ER 2 גרסת טרום-השקה (Preview) MINIMAL,‏ LOW,‏ MEDIUM,‏ HIGH HIGH
Gemini Nano Banana 2.1 MINIMAL, MEDIUM, HIGH MEDIUM
‫Gemini 4 Hydrogen LOW,‏ MEDIUM,‏ HIGH,‏ XHIGH HIGH
‫Gemini 4 Carbon לסייבר LOW, MEDIUM, HIGH HIGH
Gemini 4 Carbon LOW, MEDIUM, HIGH MEDIUM
‫Gemini 4 Argon Cyber Permissive LOW, MEDIUM, HIGH HIGH
‫Gemini 4 Argon LOW, MEDIUM, HIGH MEDIUM
Gemini 3.8 Flash Cyber LOW, MEDIUM, HIGH MEDIUM
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 Image‏ (Nano Banana 2 Lite) MINIMAL, HIGH MINIMAL
‫Gemini 3.1 Flash-Lite MINIMAL,‏ LOW,‏ MEDIUM,‏ HIGH MINIMAL
‫Gemini 3.1 Flash Image MINIMAL, HIGH MINIMAL
תמונה של Gemini 3 Pro HIGH HIGH
‫Gemini 3 Flash גרסת טרום-השקה (Preview) MINIMAL,‏ LOW,‏ MEDIUM,‏ HIGH HIGH

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

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

המסוף

  1. עוברים אל Agent Studio ולוחצים על חדש > צ'אט.

    פתיחת Agent Studio

  2. בחלונית Model settings, בוחרים מודל נתמך בתפריט Model.
  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();
    }
  }
}

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

תקציבי חשיבה נתמכים לפי מודל

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

דגם מספר מינימלי של טוקנים מספר הטוקנים המקסימלי ברירת מחדל
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 טוקנים)

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

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

אי אפשר להשבית את מצב החשיבה ב-Gemini 2.5 Pro.

הצגת סיכומים של תהליך החשיבה

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

המסוף

סיכומי תהליך החשיבה מופעלים כברירת מחדל ב-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();
    }
  }
}

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

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

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

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

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

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

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

במאמר חתימות מחשבה מפורטות דרישות, דוגמאות ודפוסי הטמעה.

תמחור

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

לפרטים מלאים על התעריפים, ראו תמחור.

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

מדריך

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

מדריך

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

מסוף

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