חשיבה של Gemini

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

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

לפני שמתחילים

חשוב לוודא שאתם משתמשים במודל נתמך מסדרה 2.5 לצורך חשיבה. מומלץ לבדוק את המודלים האלה ב-AI Studio לפני שמתחילים לעבוד עם ה-API:

יצירת תוכן באמצעות חשיבה

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

from google import genai

client = genai.Client(api_key="GOOGLE_API_KEY")
prompt = "Explain the concept of Occam's Razor and provide a simple, everyday example."
response = client.models.generate_content(
    model="gemini-2.5-flash-preview-05-20",
    contents=prompt
)

print(response.text)
import { GoogleGenAI } from "@google/genai";

const ai = new GoogleGenAI({ apiKey: "GOOGLE_API_KEY" });

async function main() {
  const prompt = "Explain the concept of Occam's Razor and provide a simple, everyday example.";

  const response = await ai.models.generateContent({
    model: "gemini-2.5-flash-preview-05-20",  
    contents: prompt,
  });

  console.log(response.text);
}

main();
// import packages here

func main() {
  ctx := context.Background()
  client, err := genai.NewClient(ctx, option.WithAPIKey(os.Getenv("GOOGLE_API_KEY")))
  if err != nil {
    log.Fatal(err)
  }
  defer client.Close()

  model := client.GenerativeModel("gemini-2.5-flash-preview-05-20")  
  resp, err := model.GenerateContent(ctx, genai.Text("Explain the concept of Occam's Razor and provide a simple, everyday example."))
  if err != nil {
    log.Fatal(err)
  }
  fmt.Println(resp.Text())
}
curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash-preview-05-20:generateContent?key=$GOOGLE_API_KEY" \
 -H 'Content-Type: application/json' \
 -X POST \
 -d '{
   "contents": [
     {
       "parts": [
         {
           "text": "Explain the concept of Occam\''s Razor and provide a simple, everyday example."
         }
       ]
     }
   ]
 }'
 ```

סיכומי מחשבות (ניסיוני)

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

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

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

from google import genai
from google.genai import types

client = genai.Client(api_key="GOOGLE_API_KEY")
prompt = "What is the sum of the first 50 prime numbers?"
response = client.models.generate_content(
  model="gemini-2.5-flash-preview-05-20",
  contents=prompt
  config=types.GenerateContentConfig(
    thinking_config=types.ThinkingConfig(
      include_thoughts=True
    )
  )
)

for part in response.candidates[0].content.parts:
  if not part.text:
    continue
  if part.thought:
    print("Thought summary:")
    print(part.text)
    print()
  else:
    print("Answer:")
    print(part.text)
    print()
import { GoogleGenAI } from "@google/genai";

const ai = new GoogleGenAI({ apiKey: "GOOGLE_API_KEY" });

async function main() {
  const response = await ai.models.generateContent({
    model: "gemini-2.5-flash-preview-05-20",
    contents: "What is the sum of the first 50 prime numbers?",
    config: {
      thinkingConfig: {
        includeThoughts: true,
      },
    },
  });

  for (const part of response.candidates[0].content.parts) {
    if (!part.text) {
      continue;
    }
    else if (part.thought) {
      console.log("Thoughts summary:");
      console.log(part.text);
    }
    else {
      console.log("Answer:");
      console.log(part.text);
    }
  }
}

main();
package main

import (
  "context"
  "fmt"
  "google.golang.org/genai"
  "os"
)

func main() {
  ctx := context.Background()
  client, _ := genai.NewClient(ctx, &genai.ClientConfig{
    APIKey:  os.Getenv("GOOGLE_API_KEY"),
    Backend: genai.BackendGeminiAPI,
  })

  contents := genai.Text("What is the sum of the first 50 prime numbers?")
  model := "gemini-2.5-flash-preview-05-20"
  resp, _ := client.Models.GenerateContent(ctx, model, contents, &genai.GenerateContentConfig{
    ThinkingConfig: &genai.ThinkingConfig{
      IncludeThoughts: true,
    },
  })

  for _, part := range resp.Candidates[0].Content.Parts {
    if part.Text != "" {
      if part.Thought {
        fmt.Println("Thoughts Summary:")
        fmt.Println(part.Text)
      } else {
        fmt.Println("Answer:")
        fmt.Println(part.Text)
      }
    }
  }
}

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

from google import genai
from google.genai import types

client = genai.Client(api_key="GOOGLE_API_KEY")

prompt = """
Alice, Bob, and Carol each live in a different house on the same street: red, green, and blue.
The person who lives in the red house owns a cat.
Bob does not live in the green house.
Carol owns a dog.
The green house is to the left of the red house.
Alice does not own a cat.
Who lives in each house, and what pet do they own?
"""

thoughts = ""
answer = ""

for chunk in client.models.generate_content_stream(
    model="gemini-2.5-flash-preview-05-20",
    contents=prompt,
    config=types.GenerateContentConfig(
      thinking_config=types.ThinkingConfig(
        include_thoughts=True
      )
    )
):
  for part in chunk.candidates[0].content.parts:
    if not part.text:
      continue
    elif part.thought:
      if not thoughts:
        print("Thoughts summary:")
      print(part.text)
      thoughts += part.text
    else:
      if not answer:
        print("Thoughts summary:")
      print(part.text)
      answer += part.text
import { GoogleGenAI } from "@google/genai";

const ai = new GoogleGenAI({ apiKey: "GOOGLE_API_KEY" });

const prompt = `Alice, Bob, and Carol each live in a different house on the same
street: red, green, and blue. The person who lives in the red house owns a cat.
Bob does not live in the green house. Carol owns a dog. The green house is to
the left of the red house. Alice does not own a cat. Who lives in each house,
and what pet do they own?`;

let thoughts = "";
let answer = "";

async function main() {
  const response = await ai.models.generateContentStream({
    model: "gemini-2.5-flash-preview-05-20",
    contents: prompt,
    config: {
      thinkingConfig: {
        includeThoughts: true,
      },
    },
  });

  for await (const chunk of response) {
    for (const part of chunk.candidates[0].content.parts) {
      if (!part.text) {
        continue;
      } else if (part.thought) {
        if (!thoughts) {
          console.log("Thoughts summary:");
        }
        console.log(part.text);
        thoughts = thoughts + part.text;
      } else {
        if (!answer) {
          console.log("Answer:");
        }
        console.log(part.text);
        answer = answer + part.text;
      }
    }
  }
}

await main();

תקציבים לחשיבה

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

  • הערך thinkingBudget חייב להיות מספר שלם בטווח 0 עד 24576.
  • הגדרת תקציב החשיבה ל-0 משביתה את החשיבה.
  • בהתאם להנחיה, יכול להיות שהמודל יגרום לחריגה ממכסת האסימונים או לחריגה שלפיה לא נעשה שימוש בכל האסימונים.
from google import genai
from google.genai import types

client = genai.Client()

response = client.models.generate_content(
    model="gemini-2.5-flash-preview-05-20",
    contents="Provide a list of 3 famous physicists and their key contributions",
    config=types.GenerateContentConfig(
        thinking_config=types.ThinkingConfig(thinking_budget=1024)
    ),
)

print(response.text)
import { GoogleGenAI } from "@google/genai";

const ai = new GoogleGenAI({ apiKey: "GOOGLE_API_KEY" });

async function main() {
  const response = await ai.models.generateContent({
    model: "gemini-2.5-flash-preview-05-20",
    contents: "Provide a list of 3 famous physicists and their key contributions",
    config: {
      thinkingConfig: {
        thinkingBudget: 1024,
      },
    },
  });

  console.log(response.text);
}

main();
package main

import (
  "context"
  "fmt"
  "google.golang.org/genai"
  "os"
)

func main() {
  ctx := context.Background()
  client, _ := genai.NewClient(ctx, &genai.ClientConfig{
    APIKey:  os.Getenv("GOOGLE_API_KEY"),
    Backend: genai.BackendGeminiAPI,
  })

  thinkingBudgetVal := int32(1024)

  contents := genai.Text("Provide a list of 3 famous physicists and their key contributions")
  model := "gemini-2.5-flash-preview-05-20"
  resp, _ := client.Models.GenerateContent(ctx, model, contents, &genai.GenerateContentConfig{
    ThinkingConfig: &genai.ThinkingConfig{
      ThinkingBudget: &thinkingBudgetVal,
    },
  })

fmt.Println(resp.Text())
}
curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash-preview-05-20:generateContent?key=$GOOGLE_API_KEY" \
-H 'Content-Type: application/json' \
-X POST \
-d '{
  "contents": [
    {
      "parts": [
        {
          "text": "Provide a list of 3 famous physicists and their key contributions"
        }
      ]
    }
  ],
  "generationConfig": {
    "thinkingConfig": {
          "thinkingBudget": 1024
    }
  }
}'

תמחור

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

# ...
print("Thoughts tokens:",response.usage_metadata.thoughts_token_count)
print("Output tokens:",response.usage_metadata.candidates_token_count)
// ...
console.log(`Thoughts tokens: ${response.usageMetadata.thoughtsTokenCount}`);
console.log(`Output tokens: ${response.usageMetadata.candidatesTokenCount}`);
// ...
usageMetadata, err := json.MarshalIndent(response.UsageMetadata, "", "  ")
if err != nil {
  log.Fatal(err)
}
fmt.Println("Thoughts tokens:", string(usageMetadata.thoughts_token_count))
fmt.Println("Output tokens:", string(usageMetadata.candidates_token_count))

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

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

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

כל יכולות המודל מפורטות בדף סקירה כללית של הדגם.

דגם סיכומי חשיבה תקציב לחשיבה
Gemini 2.5 Flash ✔️ ✔️
Gemini 2.5 Pro ✔️ X

שיטות מומלצות

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

ניפוי באגים והכוונה

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

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

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

  • משימות פשוטות (אפשר להשבית את החשיבה): לבקשות פשוטות שלא דורשות חשיבה מורכבת, כמו אחזור עובדות או סיווג, אין צורך בחשיבה. דוגמאות:
    • "Where was DeepMind founded?‎"
    • "האם האימייל הזה הוא בקשה לפגישה או שהוא רק מספק מידע?"
  • משימות בינוניות (ברירת המחדל/חשיבה חלקית): בקשות נפוצות רבות נהנות משיעור מסוים של עיבוד שלב אחר שלב או הבנה מעמיקה יותר. ‫Gemini יכול להשתמש באופן גמיש ביכולת החשיבה במשימות כמו:
    • השוואה בין פוטוסינתזה לבין התבגרות.
    • השוואה וניגוד בין רכבים חשמליים לבין רכבים היברידיים.
  • משימות קשות (יכולת חשיבה מקסימלית): כדי להתמודד עם אתגרים מורכבים באמת, המודל צריך להפעיל את מלוא יכולות ההסקה והתכנון שלו, ולעיתים קרובות הוא צריך לבצע הרבה שלבים פנימיים לפני שהוא מספק תשובה. דוגמאות:
    • פתרון בעיה 1 ב-AIME 2025: חיפוש הסכום של כל הבסיסים המספריים b > 9 שבהם 17b הוא חלוק של 97b.
    • כתיבה של קוד Python לאפליקציית אינטרנט שמציגה נתונים של שוק המניות בזמן אמת, כולל אימות משתמשים. רצוי שהיא תהיה יעילה ככל האפשר.

חשיבה באמצעות כלים ויכולות

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

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

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

  • בעזרת פלט מובנה, תוכלו לאלץ את Gemini להשיב ב-JSON. האפשרות הזו שימושית במיוחד לשילוב הפלט של המודל באפליקציות.

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

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

מה השלב הבא?

  • דוגמאות מפורטות יותר, כמו:

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

    ועוד, כדאי לנסות את ספר הבישול של Thinking.

  • התיעוד של החשיבה זמין עכשיו במדריך שלנו בנושא תאימות ל-OpenAI.

  • מידע נוסף על Gemini 2.5 Pro Preview ועל Gemini Flash 2.5 Thinking זמין בדף המודל.