Gemini

Modele z serii Gemini 3 i 2.5 wykorzystują wewnętrzny „proces myślowy”, który znacznie poprawia ich zdolność do rozumowania i planowania wieloetapowego, dzięki czemu są bardzo skuteczne w przypadku złożonych zadań, takich jak kodowanie, zaawansowana matematyka i analiza danych.

Z tego przewodnika dowiesz się, jak korzystać z możliwości myślenia Gemini za pomocą interfejsu Gemini API.

Generowanie treści z myśleniem

Inicjowanie prośby za pomocą modelu myślowego jest podobne do każdej innej prośby o wygenerowanie treści. Kluczowa różnica polega na określeniu jednego z modeli z obsługą myślenia w polu model, jak pokazano w tym przykładzie generowania tekstu:

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();

Przeczytaj

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."
         }
       ]
     }
   ]
 }'
 ```

Podsumowania przemyśleń

Podsumowania procesu myślowego to zsyntetyzowane wersje pierwotnych myśli modelu, które pozwalają poznać jego wewnętrzny proces rozumowania. Pamiętaj, że poziomy myślenia i budżety dotyczą surowych myśli modelu, a nie podsumowań myśli.

Aby włączyć podsumowania myśli, ustaw w konfiguracji żądania wartość includeThoughts na true. Następnie możesz uzyskać dostęp do podsumowania, iterując parametr responseparts i sprawdzając wartość logiczną thought.

Oto przykład pokazujący, jak włączyć i pobrać podsumowania myśli bez przesyłania strumieniowego, co zwraca jedno końcowe podsumowanie myśli w odpowiedzi:

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();

Przeczytaj

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

A oto przykład użycia funkcji myślenia strumieniowego, która podczas generowania zwraca podsumowania kroczące i przyrostowe:

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();

Przeczytaj

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

Kontrolowanie myślenia

Modele Gemini domyślnie korzystają z dynamicznego myślenia, automatycznie dostosowując poziom rozumowania do złożoności zapytania użytkownika. Jeśli jednak masz określone ograniczenia dotyczące opóźnienia lub wymagasz, aby model przeprowadzał bardziej szczegółowe rozumowanie niż zwykle, możesz opcjonalnie użyć parametrów do kontrolowania sposobu myślenia.

Poziomy myślenia (Gemini 3 Pro)

Parametr thinkingLevel, zalecany w przypadku modeli Gemini 3 i nowszych, pozwala kontrolować sposób rozumowania. Poziom myślenia możesz ustawić na "low" lub "high". Jeśli nie określisz poziomu myślenia, Gemini użyje domyślnego dynamicznego poziomu myślenia modelu, "high", w przypadku Gemini 3 Pro w wersji testowej.

Python

from google import genai
from google.genai import types

client = genai.Client()

response = client.models.generate_content(
    model="gemini-3-pro-preview",
    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 } from "@google/genai";

const ai = new GoogleGenAI({});

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

  console.log(response.text);
}

main();

Przeczytaj

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-pro-preview"
  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-pro-preview: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"
    }
  }
}'

Nie możesz wyłączyć myślenia w przypadku Gemini 3 Pro. Modele z serii Gemini 2.5 nie obsługują thinkingLevel. Zamiast tego używaj thinkingBudget.

Budżety na myślenie

Parametr thinkingBudget, wprowadzony w serii Gemini 2.5, określa liczbę tokenów myślenia, których model ma użyć do rozumowania.

Poniżej znajdziesz thinkingBudget szczegóły konfiguracji każdego typu modelu. Możesz wyłączyć myślenie, ustawiając wartość thinkingBudget na 0. Ustawienie wartości thinkingBudget na -1 włącza dynamiczne myślenie, co oznacza, że model dostosuje budżet do złożoności żądania.

Model Ustawienie domyślne
(budżet na myślenie nie jest ustawiony)		 Zakres Wyłącz przebieg rozumowania Włącz myślenie dynamiczne
2.5 Pro Dynamiczne myślenie: model decyduje, kiedy i ile myśleć Od 128 do 32768 Nie dotyczy: nie można wyłączyć myślenia thinkingBudget = -1
2.5 Flash Dynamiczne myślenie: model decyduje, kiedy i ile myśleć Od 0 do 24576 thinkingBudget = 0 thinkingBudget = -1
2.5 Flash Preview Dynamiczne myślenie: model decyduje, kiedy i ile myśleć Od 0 do 24576 thinkingBudget = 0 thinkingBudget = -1
2.5 Flash Lite Model nie myśli Od 512 do 24576 thinkingBudget = 0 thinkingBudget = -1
2.5 Flash Lite (wersja testowa) Model nie myśli Od 512 do 24576 thinkingBudget = 0 thinkingBudget = -1
Robotics-ER 1.5 Preview Dynamiczne myślenie: model decyduje, kiedy i ile myśleć Od 0 do 24576 thinkingBudget = 0 thinkingBudget = -1
2.5 Flash Live Native Audio Preview (09-2025) Dynamiczne myślenie: model decyduje, kiedy i ile myśleć Od 0 do 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();

Przeczytaj

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

W zależności od promptu model może przekroczyć lub nie wykorzystać w pełni budżetu tokenów.

Podpisy myślowe

Interfejs Gemini API jest bezstanowy, więc model traktuje każde żądanie API niezależnie i nie ma dostępu do kontekstu myślowego z poprzednich tur interakcji wieloturkowych.

Aby zachować kontekst myślowy w interakcjach wieloetapowych, Gemini zwraca sygnatury myśli, które są zaszyfrowanymi reprezentacjami wewnętrznego procesu myślowego modelu.

  • Modele Gemini 2.5 zwracają sygnatury myśli, gdy myślenie jest włączone, a żądanie obejmuje wywoływanie funkcji, a w szczególności deklaracje funkcji.
  • Modele Gemini 3 mogą zwracać sygnatury myśli dla wszystkich typów części. Zalecamy zawsze przekazywać wszystkie podpisy w takiej postaci, w jakiej zostały otrzymane, ale w przypadku podpisów wywołań funkcji jest to wymagane. Więcej informacji znajdziesz na stronie Podpisy myśli.

Pakiet SDK generatywnej AI od Google automatycznie obsługuje zwracanie sygnatur myśli. Ręczne zarządzanie sygnaturami myśli jest konieczne tylko wtedy, gdy modyfikujesz historię rozmów lub używasz interfejsu REST API.

Inne ograniczenia dotyczące wywoływania funkcji, o których warto pamiętać:

  • Sygnatury są zwracane przez model w innych częściach odpowiedzi, np. w wywołaniach funkcji lub częściach tekstowych. Zwróć całą odpowiedź ze wszystkimi częściami do modelu w kolejnych turach.
  • Nie łącz części z sygnaturami.
  • Nie łącz części z podpisem z częścią bez podpisu.

Ceny

Gdy myślenie jest włączone, cena odpowiedzi jest sumą tokenów wyjściowych i tokenów myślenia. Łączną liczbę wygenerowanych tokenów myślenia możesz uzyskać z pola 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}`);

Przeczytaj

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

Modele myślowe generują pełne myśli, aby poprawić jakość ostatecznej odpowiedzi, a następnie wyświetlają podsumowania, które pozwalają zrozumieć proces myślowy. Ceny są więc oparte na pełnych tokenach myśli, których model potrzebuje do wygenerowania podsumowania, mimo że interfejs API zwraca tylko podsumowanie.

Więcej informacji o tokenach znajdziesz w przewodniku Liczba tokenów.

Sprawdzone metody

W tej sekcji znajdziesz wskazówki dotyczące efektywnego korzystania z modeli myślowych. Jak zawsze, najlepsze wyniki uzyskasz, jeśli będziesz postępować zgodnie z naszymi wskazówkami i sprawdzonymi metodami dotyczącymi promptów.

Debugowanie i sterowanie

  • Sprawdzanie uzasadnienia: jeśli modele myślowe nie dają oczekiwanej odpowiedzi, warto dokładnie przeanalizować podsumowania myśli Gemini. Możesz zobaczyć, jak podzielił zadanie i doszedł do wniosku, a także wykorzystać te informacje, aby poprawić wyniki.

  • Podaj wskazówki dotyczące uzasadnienia: jeśli oczekujesz szczególnie długiego wyniku, możesz podać w prompcie wskazówki, aby ograniczyć ilość myślenia, jakiej używa model. Dzięki temu możesz zarezerwować więcej tokenów wyjściowych na swoją odpowiedź.

Złożoność zadania

  • Proste zadania (myślenie może być wyłączone): w przypadku prostych zapytań, które nie wymagają złożonego rozumowania, np. wyszukiwania faktów lub klasyfikacji, myślenie nie jest wymagane. Przykłady:
    • „Gdzie powstała firma DeepMind?”
    • „Czy ten e-mail zawiera prośbę o spotkanie, czy tylko informacje?”
  • Średnio złożone zadania (domyślne/wymagające pewnego zastanowienia): wiele typowych próśb wymaga przetwarzania krok po kroku lub głębszego zrozumienia. Gemini może elastycznie wykorzystywać swoje możliwości do wykonywania takich zadań jak:
    • Porównaj fotosyntezę i dorastanie.
    • Porównaj samochody elektryczne i hybrydowe.
  • Trudne zadania (maksymalne możliwości myślenia): w przypadku naprawdę złożonych wyzwań, takich jak rozwiązywanie skomplikowanych problemów matematycznych lub zadań związanych z kodowaniem, zalecamy ustawienie wysokiego budżetu na myślenie. Tego typu zadania wymagają od modelu pełnego wykorzystania możliwości rozumowania i planowania, co często wiąże się z wieloma wewnętrznymi krokami przed udzieleniem odpowiedzi. Przykłady:
    • Rozwiąż zadanie 1 z AIME 2025: znajdź sumę wszystkich podstaw całkowitych b > 9, dla których 17b jest dzielnikiem liczby 97b.
    • Napisz kod w Pythonie dla aplikacji internetowej, która wizualizuje dane giełdowe w czasie rzeczywistym, w tym uwierzytelnianie użytkowników. Zadbaj o jak największą skuteczność.

Obsługiwane modele, narzędzia i funkcje

Funkcje myślenia są obsługiwane we wszystkich modelach z serii 3 i 2.5. Wszystkie możliwości modelu znajdziesz na stronie informacji o modelu.

Modele myślące działają ze wszystkimi narzędziami i funkcjami Gemini. Umożliwia to modelom interakcję z systemami zewnętrznymi, wykonywanie kodu lub dostęp do informacji w czasie rzeczywistym oraz uwzględnianie wyników w swoim rozumowaniu i odpowiedziach.

Przykłady użycia narzędzi z modelami myślącymi znajdziesz w książce kucharskiej dotyczącej myślenia.

Co dalej?