העמקה

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

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

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

    אפשר לשלוט בהגדרה הזו באמצעות רמות העמקה (מודלים מגרסה Gemini 3.x ואילך) או באמצעות תקציבי חשיבה (מודלים מגרסה Gemini 2.5).

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

  • טיפול בחתימות של מחשבות
    ערכות ה-SDK של Firebase AI Logic מטפלות אוטומטית בחתימות של מחשבות, וכך מוודאות שלמודל תהיה גישה להקשר של המחשבות מהתורות הקודמות, במיוחד כשמשתמשים בקריאה לפונקציה.

חשוב לעיין בשיטות המומלצות ובהנחיות לכתיבת הנחיות לשימוש במודלים של חשיבה.


שימוש במודל חשיבה

משתמשים במודל חושב בדיוק כמו בכל מודל אחר של Gemini.

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

מודלים שתומכים ביכולת הזו

רק בדגמים Gemini 3.x ו-Gemini 2.5 יש תמיכה באפשרות הזו.

  • gemini-3.1-pro-preview
  • gemini-3.5-flash
  • gemini-3.1-flash-lite
  • ‫gemini-3-pro-image-preview (או Nano Banana Pro)
  • ‫gemini-3.1-flash-image-preview (נקרא גם Nano Banana 2)
  • gemini-2.5-pro
  • gemini-2.5-flash
  • gemini-2.5-flash-lite

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

מומלץ לבדוק את ההנחיה ב-Google AI Studio או ב-Vertex AI Studio, שבהם אפשר לראות את תהליך החשיבה המלא. תוכלו לזהות אזורים שבהם המודל סטה מההנחיה, כדי לשפר את ההנחיות ולקבל תשובות עקביות ומדויקות יותר.

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

  • לתת הוראות מפורטות
  • תנו כמה דוגמאות של זוגות קלט-פלט
  • מתן הנחיות לגבי הניסוח והפורמט של הפלט והתשובות
  • ציון שלבי אימות ספציפיים

בנוסף להנחיות, כדאי להשתמש בהמלצות הבאות:

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

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

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


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

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

כדאי לעיין בהשוואה בין רמות הקושי של המשימות כדי להחליט כמה יכולת חשיבה נדרשת למודל. הנה כמה הנחיות כלליות:

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

אפשר לשלוט בהגדרה הזו באמצעות רמות העמקה (מודלים מגרסה Gemini 3 ואילך) או באמצעות תקציבי חשיבה (מודלים מגרסה Gemini 2.5).

רמות ההעמקה (מודלים מגרסה Gemini 3.x ואילך)

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

הגדרת רמת ההעמקה

לוחצים על הספק Gemini API כדי לראות בדף הזה תוכן וקוד שספציפיים לספק.

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

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

Swift

מגדירים את רמת ההעמקה בGenerationConfig במסגרת יצירת מכונת GenerativeModel.


// ...

// Set the thinking configuration
// Use a thinking level value appropriate for your model (example value shown here)
let generationConfig = GenerationConfig(
  thinkingConfig: ThinkingConfig(thinkingLevel: .low)
)

// Specify the config as part of creating the `GenerativeModel` instance
let model = FirebaseAI.firebaseAI(backend: .googleAI()).generativeModel(
  modelName: "GEMINI_3_MODEL_NAME",
  generationConfig: generationConfig
)

// ...

Kotlin

מגדירים את ערכי הפרמטרים ב-GenerationConfig כחלק מיצירת מופע של GenerativeModel.


// ...

// Set the thinking configuration
// Use a thinking level value appropriate for your model (example value shown here)
val generationConfig = generationConfig {
  thinkingConfig = thinkingConfig {
      thinkingLevel = ThinkingLevel.LOW
  }
}

// Specify the config as part of creating the `GenerativeModel` instance
val model = Firebase.ai(backend = GenerativeBackend.googleAI()).generativeModel(
  modelName = "GEMINI_3_MODEL_NAME",
  generationConfig,
)

// ...

Java

מגדירים את ערכי הפרמטרים ב-GenerationConfig כחלק מיצירת מופע של GenerativeModel.


// ...

// Set the thinking configuration
// Use a thinking level value appropriate for your model (example value shown here)
ThinkingConfig thinkingConfig = new ThinkingConfig.Builder()
    .setThinkingLevel(ThinkingLevel.LOW)
    .build();

GenerationConfig generationConfig = GenerationConfig.builder()
    .setThinkingConfig(thinkingConfig)
    .build();

// Specify the config as part of creating the `GenerativeModel` instance
GenerativeModelFutures model = GenerativeModelFutures.from(
        FirebaseAI.getInstance(GenerativeBackend.googleAI())
                .generativeModel(
                  /* modelName */ "GEMINI_3_MODEL_NAME",
                  /* generationConfig */ generationConfig
                );
);

// ...

Web

מגדירים את ערכי הפרמטרים ב-GenerationConfig כחלק מיצירת מופע של GenerativeModel.


// ...

const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// Set the thinking configuration
// Use a thinking level value appropriate for your model (example value shown here)
const generationConfig = {
  thinkingConfig: {
    thinkingLevel: ThinkingLevel.LOW
  }
};

// Specify the config as part of creating the `GenerativeModel` instance
const model = getGenerativeModel(ai, { model: "GEMINI_3_MODEL_NAME", generationConfig });

// ...

Dart

מגדירים את ערכי הפרמטרים ב-GenerationConfig כחלק מיצירת מופע של GenerativeModel.


// ...

// Set the thinking configuration
// Use a thinking level value appropriate for your model (example value shown here)
final thinkingConfig = ThinkingConfig.withThinkingLevel(ThinkingLevel.low);

final generationConfig = GenerationConfig(
  thinkingConfig: thinkingConfig
);

// Specify the config as part of creating the `GenerativeModel` instance
final model = FirebaseAI.googleAI().generativeModel(
  model: 'GEMINI_3_MODEL_NAME',
  config: generationConfig,
);

// ...

Unity

מגדירים את ערכי הפרמטרים ב-GenerationConfig כחלק מיצירת מופע של GenerativeModel.


// ...

// Set the thinking configuration
// Use a thinking level value appropriate for your model (example value shown here)
var thinkingConfig = new ThinkingConfig(thinkingLevel: ThinkingLevel.Low);

var generationConfig = new GenerationConfig(
  thinkingConfig: thinkingConfig
);

// Specify the config as part of creating the `GenerativeModel` instance
var model = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI()).GetGenerativeModel(
  modelName: "GEMINI_3_MODEL_NAME",
  generationConfig: generationConfig
);

// ...

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

בטבלה הבאה מפורטים ערכי רמת החשיבה שאפשר להגדיר לכל מודל על ידי הגדרת thinkingLevel של המודל.

MINIMAL LOW MEDIUM HIGH

המודל משתמש בכמה שפחות טוקנים; כמעט ללא חשיבה

משימות עם מורכבות נמוכה

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

משימות פשוטות ומשימות עם נפח נתונים גבוה

המודל משתמש בגישה מאוזנת

משימות ברמת מורכבות בינונית

המודל משתמש בטוקנים עד לרמה המקסימלית שלו

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

gemini-3.1-pro-preview ‫ (ברירת מחדל)
gemini-3.5-flash ‫ (ברירת מחדל)
gemini-3.1-flash-lite ‫ (ברירת מחדל)
‫gemini-3-pro-image-preview (Nano Banana Pro) ‫ (ברירת מחדל)
‫gemini-3.1-flash-image-preview (Nano Banana 2) ‫ (ברירת מחדל)


תקציבי חשיבה (מודלים של Gemini 2.5)

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

הגדרת תקציב החשיבה

לוחצים על הספק Gemini API כדי לראות בדף הזה תוכן וקוד שספציפיים לספק.

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

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

Swift

מגדירים את תקציב החשיבה ב-GenerationConfig כחלק מיצירת מופע GenerativeModel.


// ...

// Set the thinking configuration
// Use a thinking budget value appropriate for your model (example value shown here)
let generationConfig = GenerationConfig(
  thinkingConfig: ThinkingConfig(thinkingBudget: 1024)
)

// Specify the config as part of creating the `GenerativeModel` instance
let model = FirebaseAI.firebaseAI(backend: .googleAI()).generativeModel(
  modelName: "GEMINI_2.5_MODEL_NAME",
  generationConfig: generationConfig
)

// ...

Kotlin

מגדירים את ערכי הפרמטרים ב-GenerationConfig כחלק מיצירת מופע של GenerativeModel.


// ...

// Set the thinking configuration
// Use a thinking budget value appropriate for your model (example value shown here)
val generationConfig = generationConfig {
  thinkingConfig = thinkingConfig {
      thinkingBudget = 1024
  }
}

// Specify the config as part of creating the `GenerativeModel` instance
val model = Firebase.ai(backend = GenerativeBackend.googleAI()).generativeModel(
  modelName = "GEMINI_2.5_MODEL_NAME",
  generationConfig,
)

// ...

Java

מגדירים את ערכי הפרמטרים ב-GenerationConfig כחלק מיצירת מופע של GenerativeModel.


// ...

// Set the thinking configuration
// Use a thinking budget value appropriate for your model (example value shown here)
ThinkingConfig thinkingConfig = new ThinkingConfig.Builder()
    .setThinkingBudget(1024)
    .build();

GenerationConfig generationConfig = GenerationConfig.builder()
    .setThinkingConfig(thinkingConfig)
    .build();

// Specify the config as part of creating the `GenerativeModel` instance
GenerativeModelFutures model = GenerativeModelFutures.from(
        FirebaseAI.getInstance(GenerativeBackend.googleAI())
                .generativeModel(
                  /* modelName */ "GEMINI_2.5_MODEL_NAME",
                  /* generationConfig */ generationConfig
                );
);

// ...

Web

מגדירים את ערכי הפרמטרים ב-GenerationConfig כחלק מיצירת מופע של GenerativeModel.


// ...

const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// Set the thinking configuration
// Use a thinking budget value appropriate for your model (example value shown here)
const generationConfig = {
  thinkingConfig: {
    thinkingBudget: 1024
  }
};

// Specify the config as part of creating the `GenerativeModel` instance
const model = getGenerativeModel(ai, { model: "GEMINI_2.5_MODEL_NAME", generationConfig });

// ...

Dart

מגדירים את ערכי הפרמטרים ב-GenerationConfig כחלק מיצירת מופע של GenerativeModel.


// ...

// Set the thinking configuration
// Use a thinking budget value appropriate for your model (example value shown here)
final thinkingConfig = ThinkingConfig.withThinkingBudget(1024);

final generationConfig = GenerationConfig(
  thinkingConfig: thinkingConfig
);

// Specify the config as part of creating the `GenerativeModel` instance
final model = FirebaseAI.googleAI().generativeModel(
  model: 'GEMINI_2.5_MODEL_NAME',
  config: generationConfig,
);

// ...

Unity

מגדירים את ערכי הפרמטרים ב-GenerationConfig כחלק מיצירת מופע של GenerativeModel.


// ...

// Set the thinking configuration
// Use a thinking budget value appropriate for your model (example value shown here)
var thinkingConfig = new ThinkingConfig(thinkingBudget: 1024);

var generationConfig = new GenerationConfig(
  thinkingConfig: thinkingConfig
);

// Specify the config as part of creating the `GenerativeModel` instance
var model = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI()).GetGenerativeModel(
  modelName: "GEMINI_2.5_MODEL_NAME",
  generationConfig: generationConfig
);

// ...

ערכים נתמכים של תקציב החשיבה

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

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


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

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

    • ‫"Where was DeepMind founded?"
    • "האם האימייל הזה הוא הזמנה לפגישה או שהוא רק מספק מידע?"

  • משימות בינוניות – סביר להניח שנדרשת חשיבה מסוימת
    בקשות נפוצות שמועילות ממידה מסוימת של עיבוד שלב אחר שלב או הבנה מעמיקה יותר. דוגמאות:

    • ‫"Create an analogy between photosynthesis and growing up"‏ (צור אנלוגיה בין פוטוסינתזה לבין התבגרות).
    • ‫"Compare and contrast electric cars and hybrid cars."

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

    • ‫"Solve problem 1 in AIME 2025: Find the sum of all integer bases b > 9 for which 17b is a divisor of 97b."
    • "תכתוב קוד Python לאפליקציית אינטרנט שמציגה נתונים של שוק המניות בזמן אמת, כולל אימות משתמשים. הקוד צריך להיות יעיל ככל האפשר".


סיכומי חשיבה

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

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

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

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

הנה כמה נקודות חשובות לגבי סיכומי מחשבות:

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

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

הפעלת סיכומים של תהליכי חשיבה

לוחצים על הספק Gemini API כדי לראות בדף הזה תוכן וקוד שספציפיים לספק.

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

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

Swift

מפעילים את סיכומי המחשבות ב-GenerationConfig במהלך יצירת מופע של GenerativeModel.


// ...

// Set the thinking configuration
// Optionally enable thought summaries in the generated response (default is false)
let generationConfig = GenerationConfig(
  thinkingConfig: ThinkingConfig(includeThoughts: true)
)

// Specify the config as part of creating the `GenerativeModel` instance
let model = FirebaseAI.firebaseAI(backend: .googleAI()).generativeModel(
  modelName: "GEMINI_MODEL_NAME",
  generationConfig: generationConfig
)

let response = try await model.generateContent("solve x^2 + 4x + 4 = 0")

// Handle the response that includes thought summaries
if let thoughtSummary = response.thoughtSummary {
  print("Thought Summary: \(thoughtSummary)")
}
guard let text = response.text else {
  fatalError("No text in response.")
}
print("Answer: \(text)")

Kotlin

מפעילים את סיכומי המחשבות ב-GenerationConfig במהלך יצירת מופע של GenerativeModel.


// ...

// Set the thinking configuration
// Optionally enable thought summaries in the generated response (default is false)
val generationConfig = generationConfig {
  thinkingConfig = thinkingConfig {
      includeThoughts = true
  }
}

// Specify the config as part of creating the `GenerativeModel` instance
val model = Firebase.ai(backend = GenerativeBackend.googleAI()).generativeModel(
  modelName = "GEMINI_MODEL_NAME",
  generationConfig,
)

val response = model.generateContent("solve x^2 + 4x + 4 = 0")

// Handle the response that includes thought summaries
response.thoughtSummary?.let {
    println("Thought Summary: $it")
}
response.text?.let {
    println("Answer: $it")
}

Java

מפעילים את סיכומי המחשבות ב-GenerationConfig במהלך יצירת מופע של GenerativeModel.


// ...

// Set the thinking configuration
// Optionally enable thought summaries in the generated response (default is false)
ThinkingConfig thinkingConfig = new ThinkingConfig.Builder()
    .setIncludeThoughts(true)
    .build();

GenerationConfig generationConfig = GenerationConfig.builder()
    .setThinkingConfig(thinkingConfig)
    .build();

// Specify the config as part of creating the `GenerativeModel` instance
GenerativeModelFutures model = GenerativeModelFutures.from(
        FirebaseAI.getInstance(GenerativeBackend.googleAI())
                .generativeModel(
                  /* modelName */ "GEMINI_MODEL_NAME",
                  /* generationConfig */ generationConfig
                );
);

// Handle the response that includes thought summaries
ListenableFuture responseFuture = model.generateContent("solve x^2 + 4x + 4 = 0");
Futures.addCallback(responseFuture, new FutureCallback() {
    @Override
    public void onSuccess(GenerateContentResponse response) {
        if (response.getThoughtSummary() != null) {
            System.out.println("Thought Summary: " + response.getThoughtSummary());
        }
        if (response.getText() != null) {
            System.out.println("Answer: " + response.getText());
        }
    }

    @Override
    public void onFailure(Throwable t) {
        // Handle error
    }
}, MoreExecutors.directExecutor());

Web

מפעילים את סיכומי המחשבות ב-GenerationConfig במהלך יצירת מופע של GenerativeModel.


// ...

const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// Set the thinking configuration
// Optionally enable thought summaries in the generated response (default is false)
const generationConfig = {
  thinkingConfig: {
    includeThoughts: true
  }
};

// Specify the config as part of creating the `GenerativeModel` instance
const model = getGenerativeModel(ai, { model: "GEMINI_MODEL_NAME", generationConfig });

const result = await model.generateContent("solve x^2 + 4x + 4 = 0");
const response = result.response;

// Handle the response that includes thought summaries
if (response.thoughtSummary()) {
    console.log(`Thought Summary: ${response.thoughtSummary()}`);
}
const text = response.text();
console.log(`Answer: ${text}`);

Dart

מפעילים את סיכומי המחשבות ב-GenerationConfig במהלך יצירת מופע של GenerativeModel.


// ...

// Set the thinking configuration
// Optionally enable thought summaries in the generated response (default is false)
final thinkingConfig = ThinkingConfig(includeThoughts: true);

final generationConfig = GenerationConfig(
  thinkingConfig: thinkingConfig
);

// Specify the config as part of creating the `GenerativeModel` instance
final model = FirebaseAI.googleAI().generativeModel(
  model: 'GEMINI_MODEL_NAME',
  generationConfig: generationConfig,
);

final response = await model.generateContent('solve x^2 + 4x + 4 = 0');

// Handle the response that includes thought summaries
if (response.thoughtSummary != null) {
  print('Thought Summary: ${response.thoughtSummary}');
}
if (response.text != null) {
  print('Answer: ${response.text}');
}

Unity

מפעילים את סיכומי המחשבות ב-GenerationConfig במהלך יצירת מופע של GenerativeModel.


// ...

// Set the thinking configuration
// Optionally enable thought summaries in the generated response (default is false)
var thinkingConfig = new ThinkingConfig(includeThoughts: true);

var generationConfig = new GenerationConfig(
  thinkingConfig: thinkingConfig
);

// Specify the config as part of creating the `GenerativeModel` instance
var model = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI()).GetGenerativeModel(
  modelName: "GEMINI_MODEL_NAME",
  generationConfig: generationConfig
);

var response = await model.GenerateContentAsync("solve x^2 + 4x + 4 = 0");

// Handle the response that includes thought summaries
if (response.ThoughtSummary != null) {
    Debug.Log($"Thought Summary: {response.ThoughtSummary}");
}
if (response.Text != null) {
    Debug.Log($"Answer: {response.Text}");
}

הצגת סיכומי המחשבות באופן שוטף

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

Swift

מפעילים את סיכומי המחשבות ב-GenerationConfig במהלך יצירת מופע של GenerativeModel.


// ...

// Set the thinking configuration
// Optionally enable thought summaries in the generated response (default is false)
let generationConfig = GenerationConfig(
  thinkingConfig: ThinkingConfig(includeThoughts: true)
)

// Specify the config as part of creating the `GenerativeModel` instance
let model = FirebaseAI.firebaseAI(backend: .googleAI()).generativeModel(
  modelName: "GEMINI_MODEL_NAME",
  generationConfig: generationConfig
)

let stream = try model.generateContentStream("solve x^2 + 4x + 4 = 0")

// Handle the streamed response that includes thought summaries
var thoughts = ""
var answer = ""
for try await response in stream {
  if let thought = response.thoughtSummary {
    if thoughts.isEmpty {
      print("--- Thoughts Summary ---")
    }
    print(thought)
    thoughts += thought
  }

  if let text = response.text {
    if answer.isEmpty {
      print("--- Answer ---")
    }
    print(text)
    answer += text
  }
}

Kotlin

מפעילים את סיכומי המחשבות ב-GenerationConfig במהלך יצירת מופע של GenerativeModel.


// ...

// Set the thinking configuration
// Optionally enable thought summaries in the generated response (default is false)
val generationConfig = generationConfig {
  thinkingConfig = thinkingConfig {
      includeThoughts = true
  }
}

// Specify the config as part of creating the `GenerativeModel` instance
val model = Firebase.ai(backend = GenerativeBackend.googleAI()).generativeModel(
  modelName = "GEMINI_MODEL_NAME",
  generationConfig,
)

// Handle the streamed response that includes thought summaries
var thoughts = ""
var answer = ""
model.generateContentStream("solve x^2 + 4x + 4 = 0").collect { response ->
    response.thoughtSummary?.let {
        if (thoughts.isEmpty()) {
            println("--- Thoughts Summary ---")
        }
        print(it)
        thoughts += it
    }
    response.text?.let {
        if (answer.isEmpty()) {
            println("--- Answer ---")
        }
        print(it)
        answer += it
    }
}

Java

מפעילים את סיכומי המחשבות ב-GenerationConfig במהלך יצירת מופע של GenerativeModel.


// ...

// Set the thinking configuration
// Optionally enable thought summaries in the generated response (default is false)
ThinkingConfig thinkingConfig = new ThinkingConfig.Builder()
    .setIncludeThoughts(true)
    .build();

GenerationConfig generationConfig = GenerationConfig.builder()
    .setThinkingConfig(thinkingConfig)
    .build();

// Specify the config as part of creating the `GenerativeModel` instance
GenerativeModelFutures model = GenerativeModelFutures.from(
        FirebaseAI.getInstance(GenerativeBackend.googleAI())
                .generativeModel(
                  /* modelName */ "GEMINI_MODEL_NAME",
                  /* generationConfig */ generationConfig
                );
);

// Streaming with Java is complex and depends on the async library used.
// This is a conceptual example using a reactive stream.
Flowable responseStream = model.generateContentStream("solve x^2 + 4x + 4 = 0");

// Handle the streamed response that includes thought summaries
StringBuilder thoughts = new StringBuilder();
StringBuilder answer = new StringBuilder();

responseStream.subscribe(response -> {
    if (response.getThoughtSummary() != null) {
        if (thoughts.length() == 0) {
            System.out.println("--- Thoughts Summary ---");
        }
        System.out.print(response.getThoughtSummary());
        thoughts.append(response.getThoughtSummary());
    }
    if (response.getText() != null) {
        if (answer.length() == 0) {
            System.out.println("--- Answer ---");
        }
        System.out.print(response.getText());
        answer.append(response.getText());
    }
}, throwable -> {
    // Handle error
});

Web

מפעילים את סיכומי המחשבות ב-GenerationConfig במהלך יצירת מופע של GenerativeModel.


// ...

const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// Set the thinking configuration
// Optionally enable thought summaries in the generated response (default is false)
const generationConfig = {
  thinkingConfig: {
    includeThoughts: true
  }
};

// Specify the config as part of creating the `GenerativeModel` instance
const model = getGenerativeModel(ai, { model: "GEMINI_MODEL_NAME", generationConfig });

const result = await model.generateContentStream("solve x^2 + 4x + 4 = 0");

// Handle the streamed response that includes thought summaries
let thoughts = "";
let answer = "";
for await (const chunk of result.stream) {
  if (chunk.thoughtSummary()) {
    if (thoughts === "") {
      console.log("--- Thoughts Summary ---");
    }
    // In Node.js, process.stdout.write(chunk.thoughtSummary()) could be used
    // to avoid extra newlines.
    console.log(chunk.thoughtSummary());
    thoughts += chunk.thoughtSummary();
  }

  const text = chunk.text();
  if (text) {
    if (answer === "") {
      console.log("--- Answer ---");
    }
    // In Node.js, process.stdout.write(text) could be used.
    console.log(text);
    answer += text;
  }
}

Dart

מפעילים את סיכומי המחשבות ב-GenerationConfig במהלך יצירת מופע של GenerativeModel.


// ...

// Set the thinking configuration
// Optionally enable thought summaries in the generated response (default is false)
final thinkingConfig = ThinkingConfig(includeThoughts: true);

final generationConfig = GenerationConfig(
  thinkingConfig: thinkingConfig
);

// Specify the config as part of creating the `GenerativeModel` instance
final model = FirebaseAI.googleAI().generativeModel(
  model: 'GEMINI_MODEL_NAME',
  generationConfig: generationConfig,
);

final responses = model.generateContentStream('solve x^2 + 4x + 4 = 0');

// Handle the streamed response that includes thought summaries
var thoughts = '';
var answer = '';
await for (final response in responses) {
  if (response.thoughtSummary != null) {
    if (thoughts.isEmpty) {
      print('--- Thoughts Summary ---');
    }
    thoughts += response.thoughtSummary!;
  }
  if (response.text != null) {
    if (answer.isEmpty) {
      print('--- Answer ---');
    }
    answer += response.text!;
  }
}

Unity

מפעילים את סיכומי המחשבות ב-GenerationConfig במהלך יצירת מופע של GenerativeModel.


// ...

// Set the thinking configuration
// Optionally enable thought summaries in the generated response (default is false)
var thinkingConfig = new ThinkingConfig(includeThoughts: true);

var generationConfig = new GenerationConfig(
  thinkingConfig: thinkingConfig
);

// Specify the config as part of creating the `GenerativeModel` instance
var model = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI()).GetGenerativeModel(
  modelName: "GEMINI_MODEL_NAME",
  generationConfig: generationConfig
);

var stream = model.GenerateContentStreamAsync("solve x^2 + 4x + 4 = 0");

// Handle the streamed response that includes thought summaries
var thoughts = "";
var answer = "";
await foreach (var response in stream)
{
    if (response.ThoughtSummary != null)
    {
        if (string.IsNullOrEmpty(thoughts))
        {
            Debug.Log("--- Thoughts Summary ---");
        }
        Debug.Log(response.ThoughtSummary);
        thoughts += response.ThoughtSummary;
    }
    if (response.Text != null)
    {
        if (string.IsNullOrEmpty(answer))
        {
            Debug.Log("--- Answer ---");
        }
        Debug.Log(response.Text);
        answer += response.Text;
    }
}


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

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

  • החשיבה מופעלת והמחשבות נוצרות.
  • הבקשה כוללת הצהרות על פונקציות.

כדי ליהנות מהיתרונות של חתימות מחשבה, משתמשים בקריאה לפונקציה כרגיל. ערכות ה-SDK‏ Firebase AI Logic מפשטות את התהליך על ידי ניהול המצב וטיפול אוטומטי בחתימות המחשבה בשבילכם. ערכות ה-SDK מעבירות באופן אוטומטי את חתימות המחשבה שנוצרו בין קריאות עוקבות ל-sendMessage או ל-sendMessageStream בסשן Chat.


תמחור וספירה של טוקנים

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

אפשר להפעיל מעקב אחרי שימוש בתכונות AI במסוף Firebase כדי לעקוב אחרי מספר הטוקנים של החשיבה בבקשות שבהן החשיבה מופעלת.

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

Swift 

// ...

let response = try await model.generateContent("Why is the sky blue?")

if let usageMetadata = response.usageMetadata {
  print("Thoughts Token Count: \(usageMetadata.thoughtsTokenCount)")
}

Kotlin 

// ...

val response = model.generateContent("Why is the sky blue?")

response.usageMetadata?.let { usageMetadata ->
    println("Thoughts Token Count: ${usageMetadata.thoughtsTokenCount}")
}

Java 

// ...

ListenableFuture<GenerateContentResponse> response =
    model.generateContent("Why is the sky blue?");

Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
    @Override
    public void onSuccess(GenerateContentResponse result) {
        String usageMetadata = result.getUsageMetadata();
        if (usageMetadata != null) {
            System.out.println("Thoughts Token Count: " +
                usageMetadata.getThoughtsTokenCount());
        }
    }

    @Override
    public void onFailure(Throwable t) {
        t.printStackTrace();
    }
}, executor);

Web 

// ...

const response = await model.generateContent("Why is the sky blue?");

if (response?.usageMetadata?.thoughtsTokenCount != null) {
    console.log(`Thoughts Token Count: ${response.usageMetadata.thoughtsTokenCount}`);
}

Dart 

// ...

final response = await model.generateContent(
  Content.text("Why is the sky blue?"),
]);

if (response?.usageMetadata case final usageMetadata?) {
  print("Thoughts Token Count: ${usageMetadata.thoughtsTokenCount}");
}

Unity 

// ...

var response = await model.GenerateContentAsync("Why is the sky blue?");

if (response.UsageMetadata != null)
{
    UnityEngine.Debug.Log($"Thoughts Token Count: {response.UsageMetadata?.ThoughtsTokenCount}");
}

מידע נוסף על טוקנים זמין במדריך לספירת טוקנים.