Pemikiran Gemini

Model seri Gemini 2.5 menggunakan "proses berpikir" internal yang secara signifikan meningkatkan kemampuan penalaran dan perencanaan multi-langkahnya, sehingga sangat efektif untuk tugas-tugas kompleks seperti coding, matematika tingkat lanjut, dan analisis data.

Panduan ini menunjukkan cara menggunakan kemampuan berpikir Gemini menggunakan Gemini API.

Sebelum memulai

Pastikan Anda menggunakan model seri 2.5 yang didukung untuk penalaran. Anda mungkin merasa bermanfaat untuk menjelajahi model ini di AI Studio sebelum mempelajari API:

Membuat konten dengan pemikiran

Memulai permintaan dengan model pemikiran serupa dengan permintaan pembuatan konten lainnya. Perbedaan utamanya terletak pada penentuan salah satu model dengan dukungan pemikiran di kolom model, seperti yang ditunjukkan dalam contoh pembuatan teks berikut:

Python

from google import genai

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

print(response.text)

JavaScript

import { GoogleGenAI } from "@google/genai";

const ai = new GoogleGenAI({});

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-pro",
    contents: prompt,
  });

  console.log(response.text);
}

main();

Go

package main

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

func main() {
  ctx := context.Background()
  client, err := genai.NewClient(ctx, nil)
  if err != nil {
      log.Fatal(err)
  }

  prompt := "Explain the concept of Occam's Razor and provide a simple, everyday example."
  model := "gemini-2.5-pro"

  resp, _ := client.Models.GenerateContent(ctx, model, genai.Text(prompt), nil)

  fmt.Println(resp.Text())
}

REST

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-pro:generateContent" \
 -H "x-goog-api-key: $GEMINI_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."
         }
       ]
     }
   ]
 }'
 ```

Anggaran penalaran

Parameter thinkingBudget memandu model tentang jumlah token penalaran yang akan digunakan saat membuat respons. Jumlah token yang lebih tinggi umumnya memungkinkan penalaran yang lebih mendetail, yang dapat bermanfaat untuk menangani tugas yang lebih kompleks. Jika latensi lebih penting, gunakan anggaran yang lebih rendah atau nonaktifkan pemikiran dengan menyetel thinkingBudget ke 0. Menetapkan thinkingBudget ke -1 akan mengaktifkan pemikiran dinamis, yang berarti model akan menyesuaikan anggaran berdasarkan kompleksitas permintaan.

thinkingBudget hanya didukung di Gemini 2.5 Flash, 2.5 Pro, dan 2.5 Flash-Lite. Bergantung pada perintahnya, model dapat melampaui atau tidak memenuhi anggaran token.

Berikut adalah detail konfigurasi thinkingBudget untuk setiap jenis model.

Model Setelan default
(Anggaran penalaran tidak ditetapkan)		 Rentang Menonaktifkan alur berpikir Mengaktifkan pemikiran dinamis
2.5 Pro Pemikiran dinamis: Model memutuskan kapan dan seberapa banyak yang harus dipikirkan 128 hingga 32768 T/A: Tidak dapat menonaktifkan pemikiran thinkingBudget = -1
2.5 Flash Pemikiran dinamis: Model memutuskan kapan dan seberapa banyak yang harus dipikirkan 0 hingga 24576 thinkingBudget = 0 thinkingBudget = -1
2.5 Flash Lite Model tidak berpikir 512 hingga 24576 thinkingBudget = 0 thinkingBudget = -1

Python

from google import genai
from google.genai import types

client = genai.Client()

response = client.models.generate_content(
    model="gemini-2.5-pro",
    contents="Provide a list of 3 famous physicists and their key contributions",
    config=types.GenerateContentConfig(
        thinking_config=types.ThinkingConfig(thinking_budget=1024)
        # Turn off thinking:
        # thinking_config=types.ThinkingConfig(thinking_budget=0)
        # Turn on dynamic thinking:
        # thinking_config=types.ThinkingConfig(thinking_budget=-1)
    ),
)

print(response.text)

JavaScript

import { GoogleGenAI } from "@google/genai";

const ai = new GoogleGenAI({});

async function main() {
  const response = await ai.models.generateContent({
    model: "gemini-2.5-pro",
    contents: "Provide a list of 3 famous physicists and their key contributions",
    config: {
      thinkingConfig: {
        thinkingBudget: 1024,
        // Turn off thinking:
        // thinkingBudget: 0
        // Turn on dynamic thinking:
        // thinkingBudget: -1
      },
    },
  });

  console.log(response.text);
}

main();

Go

package main

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

func main() {
  ctx := context.Background()
  client, err := genai.NewClient(ctx, nil)
  if err != nil {
      log.Fatal(err)
  }

  thinkingBudgetVal := int32(1024)

  contents := genai.Text("Provide a list of 3 famous physicists and their key contributions")
  model := "gemini-2.5-pro"
  resp, _ := client.Models.GenerateContent(ctx, model, contents, &genai.GenerateContentConfig{
    ThinkingConfig: &genai.ThinkingConfig{
      ThinkingBudget: &thinkingBudgetVal,
      // Turn off thinking:
      // ThinkingBudget: int32(0),
      // Turn on dynamic thinking:
      // ThinkingBudget: int32(-1),
    },
  })

fmt.Println(resp.Text())
}

REST

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-pro:generateContent" \
-H "x-goog-api-key: $GEMINI_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
          # Thinking off:
          # "thinkingBudget": 0
          # Turn on dynamic thinking:
          # "thinkingBudget": -1
    }
  }
}'

Ringkasan pemikiran

Ringkasan pemikiran adalah versi sintetis dari pemikiran mentah model dan memberikan insight tentang proses penalaran internal model. Perhatikan bahwa anggaran penalaran berlaku untuk pemikiran mentah model, bukan ringkasan pemikiran.

Anda dapat mengaktifkan ringkasan pemikiran dengan menyetel includeThoughts ke true dalam konfigurasi permintaan. Anda kemudian dapat mengakses ringkasan dengan melakukan iterasi pada response parameter parts, dan memeriksa boolean thought.

Berikut adalah contoh yang menunjukkan cara mengaktifkan dan mengambil ringkasan pemikiran tanpa streaming, yang menampilkan satu ringkasan pemikiran akhir dengan respons:

Python

from google import genai
from google.genai import types

client = genai.Client()
prompt = "What is the sum of the first 50 prime numbers?"
response = client.models.generate_content(
  model="gemini-2.5-pro",
  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()

JavaScript

import { GoogleGenAI } from "@google/genai";

const ai = new GoogleGenAI({});

async function main() {
  const response = await ai.models.generateContent({
    model: "gemini-2.5-pro",
    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();

Go

package main

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

func main() {
  ctx := context.Background()
  client, err := genai.NewClient(ctx, nil)
  if err != nil {
      log.Fatal(err)
  }

  contents := genai.Text("What is the sum of the first 50 prime numbers?")
  model := "gemini-2.5-pro"
  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)
      }
    }
  }
}

Berikut adalah contoh penggunaan berpikir dengan streaming, yang menampilkan ringkasan inkremental yang bergulir selama pembuatan:

Python

from google import genai
from google.genai import types

client = genai.Client()

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-pro",
    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("Answer:")
      print(part.text)
      answer += part.text

JavaScript

import { GoogleGenAI } from "@google/genai";

const ai = new GoogleGenAI({});

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-pro",
    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();

Go

package main

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

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?
`

func main() {
  ctx := context.Background()
  client, err := genai.NewClient(ctx, nil)
  if err != nil {
      log.Fatal(err)
  }

  contents := genai.Text(prompt)
  model := "gemini-2.5-pro"

  resp := client.Models.GenerateContentStream(ctx, model, contents, &genai.GenerateContentConfig{
    ThinkingConfig: &genai.ThinkingConfig{
      IncludeThoughts: true,
    },
  })

  for chunk := range resp {
    for _, part := range chunk.Candidates[0].Content.Parts {
      if len(part.Text) == 0 {
        continue
      }

      if part.Thought {
        fmt.Printf("Thought: %s\n", part.Text)
      } else {
        fmt.Printf("Answer: %s\n", part.Text)
      }
    }
  }
}

Tanda tangan pikiran

Karena panggilan pembuatan teks dan konten Gemini API standar bersifat stateless, saat menggunakan pemikiran dalam interaksi multi-giliran (seperti chat), model tidak memiliki akses ke konteks pemikiran dari giliran sebelumnya.

Anda dapat mempertahankan konteks pemikiran menggunakan tanda tangan pemikiran, yang merupakan representasi terenkripsi dari proses pemikiran internal model. Model menampilkan tanda tangan pemikiran dalam objek respons saat pemikiran dan panggilan fungsi diaktifkan. Untuk memastikan model mempertahankan konteks di beberapa giliran percakapan, Anda harus memberikan tanda tangan pemikiran kembali ke model dalam permintaan berikutnya.

Anda akan menerima tanda tangan pemikiran saat:

  • Pemikiran diaktifkan dan pikiran dihasilkan.
  • Permintaan mencakup deklarasi fungsi.

Anda dapat menemukan contoh berpikir dengan panggilan fungsi di halaman Panggilan fungsi.

Batasan penggunaan lain yang perlu dipertimbangkan dengan panggilan fungsi meliputi:

  • Tanda tangan ditampilkan dari model dalam bagian lain dalam respons, misalnya panggilan fungsi atau bagian teks. Kembalikan seluruh respons dengan semua bagiannya ke model pada giliran berikutnya.
  • Jangan menggabungkan bagian dengan tanda tangan.
  • Jangan menggabungkan satu bagian dengan tanda tangan dengan bagian lain tanpa tanda tangan.

Harga

Jika penalaran diaktifkan, harga respons adalah jumlah token output dan token penalaran. Anda bisa mendapatkan total jumlah token pemikiran yang dihasilkan dari kolom thoughtsTokenCount.

Python

# ...
print("Thoughts tokens:",response.usage_metadata.thoughts_token_count)
print("Output tokens:",response.usage_metadata.candidates_token_count)

JavaScript

// ...
console.log(`Thoughts tokens: ${response.usageMetadata.thoughtsTokenCount}`);
console.log(`Output tokens: ${response.usageMetadata.candidatesTokenCount}`);

Go

// ...
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))

Model pemikiran menghasilkan pemikiran lengkap untuk meningkatkan kualitas respons akhir, lalu menghasilkan ringkasan untuk memberikan insight tentang proses pemikiran. Jadi, harga didasarkan pada token pemikiran penuh yang perlu dihasilkan model untuk membuat ringkasan, meskipun hanya ringkasan yang dihasilkan dari API.

Anda dapat mempelajari lebih lanjut token dalam panduan Penghitungan token.

Model yang didukung

Fitur Thinking didukung di semua model seri 2.5. Anda dapat menemukan semua kemampuan model di halaman ringkasan model.

Praktik terbaik

Bagian ini mencakup beberapa panduan untuk menggunakan model berpikir secara efisien. Seperti biasa, mengikuti panduan dan praktik terbaik pembuatan perintah kami akan memberikan hasil terbaik.

Proses debug dan pengarahan

  • Tinjau penalaran: Jika Anda tidak mendapatkan respons yang diharapkan dari model pemikiran, Anda dapat menganalisis ringkasan pemikiran Gemini dengan cermat. Anda dapat melihat cara model memecah tugas dan mencapai kesimpulannya, serta menggunakan informasi tersebut untuk mengoreksi hasil yang salah.

  • Memberikan Panduan dalam Penalaran: Jika Anda menginginkan output yang sangat panjang, Anda dapat memberikan panduan dalam perintah untuk membatasi jumlah pemikiran yang digunakan model. Dengan begitu, Anda dapat mencadangkan lebih banyak output token untuk respons Anda.

Kompleksitas tugas

  • Tugas Mudah (Pemikiran bisa DINONAKTIFKAN): Untuk permintaan langsung yang tidak memerlukan penalaran yang rumit, seperti pengambilan atau klasifikasi fakta, pemikiran tidak diperlukan. Contohnya antara lain:
    • "Di mana DeepMind didirikan?"
    • "Apakah email ini meminta rapat atau hanya memberikan informasi?"
  • Tugas Sedang (Default/Beberapa Pemikiran): Banyak permintaan umum yang diuntungkan dari pemrosesan langkah demi langkah atau pemahaman yang lebih mendalam. Gemini dapat menggunakan kemampuan penalaran secara fleksibel untuk tugas seperti:
    • Analogi fotosintesis dan tumbuh dewasa.
    • Bandingkan dan bedakan mobil listrik dan mobil hibrida.
  • Tugas Sulit (Kemampuan Berpikir Maksimum): Untuk tantangan yang benar-benar kompleks, seperti menyelesaikan soal matematika yang rumit atau tugas coding, sebaiknya tetapkan anggaran berpikir yang tinggi. Jenis tugas ini mengharuskan model menggunakan kemampuan penalaran dan perencanaannya secara penuh, yang sering kali melibatkan banyak langkah internal sebelum memberikan jawaban. Contohnya antara lain:
    • Pecahkan masalah 1 di AIME 2025: Temukan jumlah semua basis bilangan bulat b > 9 yang membuat 17b menjadi pembagi 97b.
    • Tulis kode Python untuk aplikasi web yang memvisualisasikan data pasar saham real-time, termasuk autentikasi pengguna. Buat seefisien mungkin.

Berpikir dengan alat dan kemampuan

Model pemikiran berfungsi dengan semua alat dan kemampuan Gemini. Hal ini memungkinkan model berinteraksi dengan sistem eksternal, mengeksekusi kode, atau mengakses informasi real-time, dengan menggabungkan hasilnya ke dalam penalaran dan respons akhirnya.

  • Alat penelusuran memungkinkan model membuat kueri Google Penelusuran untuk menemukan informasi terbaru atau informasi di luar data pelatihannya. Hal ini berguna untuk pertanyaan tentang peristiwa terbaru atau topik yang sangat spesifik.

  • Alat eksekusi kode memungkinkan model membuat dan menjalankan kode Python untuk melakukan perhitungan, memanipulasi data, atau memecahkan masalah yang paling baik ditangani secara algoritma. Model menerima output kode dan dapat menggunakannya dalam responsnya.

  • Dengan output terstruktur, Anda dapat membatasi Gemini untuk merespons dengan JSON. Hal ini sangat berguna untuk mengintegrasikan output model ke dalam aplikasi.

  • Panggilan fungsi menghubungkan model pemikiran ke alat dan API eksternal, sehingga model dapat menentukan kapan harus memanggil fungsi yang tepat dan parameter apa yang harus diberikan.

  • Konteks URL memberikan URL sebagai konteks tambahan untuk perintah Anda. Model kemudian dapat mengambil konten dari URL dan menggunakan konten tersebut untuk menginformasikan dan membentuk responsnya.

Anda dapat mencoba contoh penggunaan alat dengan model pemikiran di Buku resep pemikiran.

Apa langkah selanjutnya?

  • Untuk mempelajari contoh yang lebih mendalam, seperti:

    • Menggunakan alat dengan pemikiran
    • Streaming dengan pemikiran
    • Menyesuaikan anggaran penalaran untuk hasil yang berbeda

    dan lainnya, coba Buku resep berpikir kami.

  • Cakupan pemikiran kini tersedia di panduan Kompatibilitas OpenAI kami.

  • Untuk mengetahui info selengkapnya tentang Gemini 2.5 Pro, Gemini Flash 2.5, dan Gemini 2.5 Flash-Lite, buka halaman model.