Pemikiran Gemini

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

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

Membuat konten dengan penalaran

Memulai permintaan dengan model penalaran mirip dengan permintaan pembuatan konten lainnya. Perbedaan utamanya terletak pada penentuan salah satu model dengan dukungan penalaran 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-3.8-flash",
    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-3.8-flash",
    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-3.8-flash"

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

  fmt.Println(resp.Text())
}

REST

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.8-flash: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."
         }
       ]
     }
   ]
 }'
 ```

Ringkasan penalaran

Ringkasan penalaran adalah versi ringkas dari penalaran mentah model dan menawarkan insight tentang proses penalaran internal model. Perhatikan bahwa tingkat dan anggaran penalaran berlaku untuk penalaran mentah model, bukan untuk ringkasan penalaran.

Anda dapat mengaktifkan ringkasan penalaran dengan menetapkan includeThoughts ke true dalam konfigurasi permintaan. Kemudian, Anda dapat mengakses ringkasan dengan melakukan iterasi melalui parts parameter response, dan memeriksa boolean thought.

Berikut adalah contoh yang menunjukkan cara mengaktifkan dan mengambil ringkasan penalaran tanpa streaming, yang menampilkan satu ringkasan penalaran 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-3.8-flash",
  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-3.8-flash",
    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-3.8-flash"
  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 penalaran dengan streaming, yang menampilkan ringkasan inkremental 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-3.8-flash",
    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-3.8-flash",
    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-3.8-flash"

  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)
      }
    }
  }
}

Mengontrol penalaran

Model Gemini melakukan penalaran dinamis secara default, dan otomatis menyesuaikan jumlah upaya penalaran berdasarkan kompleksitas permintaan pengguna. Namun, jika Anda memiliki batasan latensi tertentu atau mengharuskan model melakukan penalaran yang lebih mendalam dari biasanya, Anda dapat menggunakan parameter secara opsional untuk mengontrol perilaku penalaran.

Tingkat penalaran (Gemini 4 dan Gemini 3)

Parameter thinkingLevel, yang diperlukan untuk model Gemini 4 dan direkomendasikan untuk model Gemini 3, memungkinkan Anda mengontrol perilaku penalaran. Gemini 4 (gemini-4-argon) mendukung low, medium (default), dan high.

Tabel berikut menjelaskan setelan thinkingLevel untuk setiap jenis model:

Tingkat Penalaran Gemini 3.8 Flash Gemini 3.6 Flash Gemini 4 Argon Gemini 3.5 &3.1 Flash-Lite Gemini 3.1 Flash-Lite Image Gemini 3 Flash Gemini Robotics ER 2 Deskripsi
minimal Tidak didukung (error) Didukung Tidak didukung (error) Didukung (Default) Didukung (Default) Didukung Didukung Cocok dengan setelan "tidak ada penalaran" untuk sebagian besar kueri. Perhatikan bahwa minimal tidak menjamin bahwa penalaran dinonaktifkan, model mungkin melakukan penalaran yang sangat minimal untuk tugas yang kompleks.
low Didukung Didukung Didukung Didukung Tidak Didukung Didukung Didukung Meminimalkan latensi dan biaya.
medium Didukung (Default) Didukung (Default) Didukung (Default) Didukung Tidak didukung Didukung Didukung Penalaran yang seimbang untuk sebagian besar tugas.
high Didukung (Dinamis) Didukung (Dinamis) Didukung (Dinamis) Didukung (Dinamis) Didukung (Dinamis) Didukung (Default, Dinamis) Didukung (Default, Dinamis) Memaksimalkan kedalaman penalaran. Model mungkin memerlukan waktu yang jauh lebih lama untuk mencapai token output pertama (non-penalaran), tetapi output akan lebih dipertimbangkan dengan cermat.

Contoh berikut menunjukkan cara menetapkan tingkat penalaran.

Python

from google import genai
from google.genai import types

client = genai.Client()

response = client.models.generate_content(
    model="gemini-3.8-flash",
    contents="Provide a list of 3 famous physicists and their key contributions",
    config=types.GenerateContentConfig(
        thinking_config=types.ThinkingConfig(thinking_level="low")
    ),
)

print(response.text)

JavaScript

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

const ai = new GoogleGenAI({});

async function main() {
  const response = await ai.models.generateContent({
    model: "gemini-3.8-flash",
    contents: "Provide a list of 3 famous physicists and their key contributions",
    config: {
      thinkingConfig: {
        thinkingLevel: ThinkingLevel.LOW,
      },
    },
  });

  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)
  }

  thinkingLevelVal := "low"

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

fmt.Println(resp.Text())
}

REST

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.8-flash: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": {
          "thinkingLevel": "low"
    }
  }
}'

Anda tidak dapat menonaktifkan penalaran untuk Gemini 4 Argon. Gemini 3 Flash dan Flash-Lite juga tidak mendukung penonaktifan penalaran penuh. Jika Anda tidak menentukan tingkat penalaran, Gemini akan menggunakan tingkat penalaran default model (misalnya, "medium" untuk Gemini 4 Argon, Gemini 3.8 Flash, dan Gemini 3.6 Flash).

Model seri Gemini 2.5 tidak mendukung thinkingLevel; gunakan thinkingBudget sebagai gantinya.

Batas token dan max_output_tokens

Parameter pembuatan max_output_tokens menetapkan jumlah maksimum token yang dapat dihasilkan respons, termasuk token penalaran.

Jika ditetapkan, parameter ini bertindak sebagai batas maksimum yang diterapkan oleh infrastruktur tanpa mengubah cara model mengalokasikan anggaran penalarannya (thinking_level).

Jika model mencapai batas ini saat melakukan penalaran, model akan berhenti membuat dengan finish_reason: MAX_TOKENS dan menampilkan output yang dipotong atau kosong (sambil tetap menagih token penalaran yang dihasilkan). Untuk mengurangi biaya atau latensi tanpa memotong respons, turunkan thinking_level (low atau medium) dan jangan menetapkan max_output_tokens yang kecil.

Untuk model Gemini 4 (gemini-4-argon), perhatikan batas konteks dan output berikut:

  • Jendela konteks 1 juta bersama: Token input, penalaran, dan output berbagi satu jendela konteks 1 juta token (1,048,576 token). Jika token input Anda ditambah max_output_tokens melebihi 1.048.576 token, API akan otomatis membatasi output ke ruang yang tersisa di jendela konteks (1,048,576 dikurangi token input Anda).
  • Batas output per permintaan (streaming 64 ribu / non-streaming 32 ribu) dan dekode panjang (hingga 1 juta token): Satu permintaan streaming (streamGenerateContent) menampilkan hingga 65,536 token, dan satu permintaan non-streaming (generateContent) menampilkan hingga 32,768 token. Untuk membuat di luar batas per permintaan (hingga 1,048,576 token dikurangi input Anda), tetapkan max_output_tokens di atas batas. Google GenAI SDK terbaru akan terus melakukan hop secara otomatis secara default (automatic_continuation=True), atau Anda dapat menjalankan loop klien menggunakan continuation_token yang ditampilkan saat hop berhenti dengan finish_reason: "CONTINUATION". Lihat Dekode panjang untuk contoh kode.

Anggaran penalaran

Parameter thinkingBudget, yang diperkenalkan dengan seri Gemini 2.5, memandu model tentang jumlah token penalaran tertentu yang akan digunakan untuk penalaran.

Berikut adalah detail konfigurasi thinkingBudget untuk setiap jenis model. Anda dapat menonaktifkan penalaran dengan menetapkan thinkingBudget ke 0. Menetapkan thinkingBudget ke -1 akan mengaktifkan penalaran dinamis, yang berarti model akan menyesuaikan anggaran berdasarkan kompleksitas permintaan.

Model Setelan default
(Anggaran penalaran tidak ditetapkan)		 Rentang Nonaktifkan penalaran Aktifkan penalaran dinamis
2.5 Pro Penalaran dinamis 128 hingga 32768 T/A: Tidak dapat menonaktifkan penalaran thinkingBudget = -1 (Default)
2.5 Flash Penalaran dinamis 0 hingga 24576 thinkingBudget = 0 thinkingBudget = -1 (Default)
2.5 Flash Preview Penalaran dinamis 0 hingga 24576 thinkingBudget = 0 thinkingBudget = -1 (Default)
2.5 Flash Lite Model tidak melakukan penalaran 512 hingga 24576 thinkingBudget = 0 thinkingBudget = -1
2.5 Flash Lite Preview Model tidak melakukan penalaran 512 hingga 24576 thinkingBudget = 0 thinkingBudget = -1
Robotics-ER 1.6 Preview Penalaran dinamis 0 hingga 24576 thinkingBudget = 0 thinkingBudget = -1 (Default)
2.5 Flash Live Native Audio Preview (09-2025) Penalaran dinamis 0 hingga 24576 thinkingBudget = 0 thinkingBudget = -1 (Default)

Python

from google import genai
from google.genai import types

client = genai.Client()

response = client.models.generate_content(
    model="gemini-2.5-flash",
    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-flash",
    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-flash"
  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-flash: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
    }
  }
}'

Bergantung pada perintah, model mungkin meluap atau kekurangan anggaran token.

Tanda tangan penalaran

Gemini API bersifat stateless, sehingga model memperlakukan setiap permintaan API secara independen dan tidak memiliki akses ke konteks penalaran dari giliran sebelumnya dalam interaksi multi-giliran.

Untuk memungkinkan mempertahankan konteks penalaran di seluruh interaksi multi-giliran, Gemini menampilkan tanda tangan penalaran, yang merupakan representasi terenkripsi dari proses penalaran internal model.

  • Model Gemini 2.5 menampilkan tanda tangan penalaran saat penalaran diaktifkan dan permintaan menyertakan panggilan fungsi, khususnya deklarasi fungsi.
  • Model Gemini 4 dan Gemini 3 dapat menampilkan tanda tangan penalaran untuk semua jenis bagian. Sebaiknya selalu teruskan semua tanda tangan seperti yang diterima, tetapi hal ini diperlukan untuk tanda tangan panggilan fungsi. Baca halaman Tanda Tangan Penalaran untuk mempelajari lebih lanjut.

Batasan penggunaan lainnya yang perlu dipertimbangkan dengan panggilan fungsi mencakup:

  • Tanda tangan ditampilkan dari model dalam bagian lain dalam respons, misalnya panggilan fungsi atau bagian teks. Teruskan seluruh respons dengan semua bagian kembali 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 dapat memperoleh jumlah total token penalaran 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

// ...
fmt.Println("Thoughts tokens:", response.UsageMetadata.ThoughtsTokenCount)
fmt.Println("Output tokens:", response.UsageMetadata.CandidatesTokenCount)

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

Anda dapat mempelajari token lebih lanjut di panduan Penghitungan token.

Praktik terbaik

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

Proses debug dan pengarahan

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

  • Berikan Panduan dalam Penalaran: Jika Anda mengharapkan output yang sangat panjang, sebaiknya berikan panduan dalam perintah Anda untuk membatasi jumlah penalaran yang digunakan model. Hal ini memungkinkan Anda mencadangkan lebih banyak output token untuk respons Anda.

Kompleksitas tugas

  • Tugas Mudah (Penalaran dapat DINONAKTIFKAN): Untuk permintaan sederhana yang tidak memerlukan penalaran kompleks, seperti pengambilan atau klasifikasi fakta, penalaran tidak diperlukan. Contohnya antara lain:
    • "Di mana DeepMind didirikan?"
    • "Apakah email ini meminta rapat atau hanya memberikan informasi?"
  • Tugas Sedang (Default/Beberapa Penalaran): 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:
    • Menganalogikan fotosintesis dan tumbuh dewasa.
    • Membandingkan dan membedakan mobil listrik dan mobil hibrida.
  • Tugas Sulit (Kemampuan Penalaran Maksimum): Untuk tantangan yang benar-benar kompleks, seperti menyelesaikan soal matematika yang rumit atau tugas coding, sebaiknya tetapkan anggaran penalaran yang tinggi. Jenis tugas ini mengharuskan model untuk menggunakan kemampuan penalaran dan perencanaan penuh, yang sering kali melibatkan banyak langkah internal sebelum memberikan jawaban. Contohnya antara lain:
    • Selesaikan soal 1 di AIME 2025: Temukan jumlah semua basis bilangan bulat b > 9 untuk yang 17b adalah pembagi 97b.
    • Tulis kode Python untuk aplikasi web yang memvisualisasikan data pasar saham real-time, termasuk autentikasi pengguna. Buat seefisien mungkin.

Model, alat, dan kemampuan yang didukung

Fitur penalaran didukung di semua model seri 4, 3, dan 2.5. Anda dapat menemukan semua kemampuan model di halaman ringkasan model.

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

Anda dapat mencoba contoh penggunaan alat dengan model penalaran di [Buku resep penalaran][Colab].

Apa langkah selanjutnya?

[Colab]: https://colab.sandbox.google.com/github/google-gemini/cookbook/blob/main/quickstarts/Get_started_thinking.ipynb