Ta strona została przetłumaczona przez Cloud Translation API.

Gemini

Modele z serii Gemini 2.5 korzystają z wewnętrznego „procesu myślenia”, który znacznie poprawia ich zdolności do wnioskowania i planowania wieloetapowego, dzięki czemu są one bardzo skuteczne w spełnianiu złożonych zadań, takich jak kodowanie, zaawansowana matematyka czy analiza danych.

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

Zanim zaczniesz

Upewnij się, że używasz obsługiwanego modelu z serii 2.5. Zanim zaczniesz korzystać z interfejsu API, warto zapoznać się z tymi modelami w AI Studio:

Generowanie treści z myśleniem

Inicjowanie żądania z modelem myślenia jest podobne do inicjowania żądania generowania treści. Główna różnica polega na określeniu w polu model jednego z modeli z obsługą myślenia, jak pokazano w tym przykładzie generowania tekstu:

PythonJavaScriptPrzeczytajREST

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

Podsumowania myśli (funkcja eksperymentalna)

Podsumowania procesów myślowych dostarczają informacji o procesie rozumowania modelu. Ta funkcja może być przydatna do weryfikacji podejścia modelu i informowania użytkowników o dłuższych zadaniach, zwłaszcza w połączeniu z transmisją na żywo.

Możesz włączyć podsumowania myśli, ustawiając wartość includeThoughts na true w konfiguracji żądania. Następnie możesz uzyskać dostęp do podsumowania, przechodząc przez response parametr parts i sprawdzając wartość logiczną thought.

Oto przykład pokazujący, jak włączyć i pobrać podsumowania myśli bez strumieniowego przesyłania, co zwraca pojedyncze, ostateczne podsumowanie myśli wraz z odpowiedzią:

PythonJavaScriptPrzeczytaj

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

Oto przykład użycia metody „myślenie z wykorzystaniem strumieniowania”, która zwraca cząstkowe podsumowania podczas generowania:

PythonJavaScript

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

Budżety na myślenie

Parametr thinkingBudget pozwala modelowi określić liczbę tokenów myślenia, których może użyć podczas generowania odpowiedzi. Większa liczba tokenów umożliwia zwykle bardziej szczegółowe rozumowanie, co może być przydatne przy rozwiązywaniu bardziej złożonych zadań. Jeśli nie ustawisz parametru thinkingBudget, model będzie dynamicznie dostosowywał budżet na podstawie złożoności żądania.

Wartość thinkingBudget musi być liczbą całkowitą z zakresu od 0 do 24576.
Ustawienie budżetu na myślenie na wartość 0 powoduje wyłączenie myślenia.
W zależności od prompta model może przekroczyć lub nie wykorzystać budżetu tokenów.

PythonJavaScriptPrzeczytajREST

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

Ceny

Gdy myślenie jest włączone, cena odpowiedzi to suma tokenów wyjściowych i tokenów myślenia. Łączną liczbę wygenerowanych tokenów myślenia znajdziesz w polu thoughtsTokenCount.

PythonJavaScriptPrzeczytaj

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

Modele myślenia generują pełne myśli, aby poprawić jakość ostatecznej odpowiedzi, a następnie generują podsumowania, aby zapewnić wgląd w proces myślowy. Cena jest więc ustalana na podstawie pełnych tokenów myśli, które model musi wygenerować, aby utworzyć podsumowanie, mimo że tylko podsumowanie jest wyjściem z interfejsu API.

Więcej informacji o tokenach znajdziesz w poradnikach Liczenie tokenów.

Obsługiwane modele

Wszystkie możliwości modelu znajdziesz na stronie informacje o modelu.

Model	Podsumowania myślenia	Budżet na myślenie
Gemini 2.5 Flash	✔️	✔️
Gemini 2.5 Pro	✔️	X

Sprawdzone metody

Ta sekcja zawiera wskazówki dotyczące efektywnego korzystania z modeli myślenia. Jak zawsze, najlepsze wyniki osiągniesz, jeśli będziesz przestrzegać naszych wskazówek i sprawdzonych metod.

Debugowanie i sterowanie

Sprawdzanie procesu wnioskowania: jeśli nie otrzymujesz oczekiwanej odpowiedzi od modeli myślących, możesz dokładnie przeanalizować proces wnioskowania Gemini. Możesz zobaczyć, jak model podzielił zadanie i doszedł do wniosku, a na tej podstawie wprowadzić poprawki, aby uzyskać właściwe wyniki.
Podanie wskazówek dotyczących rozumowania: jeśli zależy Ci na szczególnie długim wyjściu, możesz podać w promptach wskazówki, aby ograniczyć ilość myślenia, której model ma użyć. Dzięki temu możesz zarezerwować więcej tokenów na potrzeby odpowiedzi.

Złożoność zadania

Łatwe zadania (myślenie może być wyłączone): w przypadku prostych zapytań, w których nie jest wymagane złożone rozumowanie, np. wyszukiwanie faktów lub klasyfikacja, myślenie nie jest wymagane. Przykłady:
- „Where was DeepMind founded?"
- „Czy ten e-mail jest zaproszeniem na spotkanie, czy tylko zawiera informacje?”
Średnie złożone zadania (domyślne/wymagające pewnego zastanowienia): wiele typowych zapytań wymaga przetwarzania krok po kroku lub głębszego zrozumienia. Gemini może elastycznie wykorzystywać zdolność do myślenia do zadań takich jak:
- Analogize fotosyntezy i dojrzewania.
- Porównaj samochody elektryczne i hybrydowe.
Trudne zadania (maksymalna zdolność do myślenia): w przypadku naprawdę złożonych wyzwań model musi w pełni wykorzystać swoje możliwości rozumowania i planowania, co często wymaga wielu wewnętrznych kroków przed udzieleniem odpowiedzi. Przykłady:
- Rozwiąż zadanie 1 w AIME 2025: znajdź sumę wszystkich liczb całkowitych b > 9, dla których 17_b jest dzielnikiem 97_b.
- Napisz kod Pythona dla aplikacji internetowej, która wizualizuje dane giełdowe w czasie rzeczywistym, w tym uwierzytelnianie użytkowników. Spraw, aby był jak najbardziej efektywny.

Rozważanie możliwości i funkcji narzędzi

Modele myślenia działają z wszystkimi narzędziami i możliwościami Gemini. Dzięki temu modele mogą wchodzić w interakcje z systemami zewnętrznymi, wykonywać kod lub uzyskiwać informacje w czasie rzeczywistym, uwzględniając wyniki w swoim rozumowaniu i ostatecznej odpowiedzi.

Narzędzie wyszukiwania umożliwia modelowi wysyłanie zapytań do wyszukiwarki Google w celu znajdowania aktualnych informacji lub informacji wykraczających poza dane szkoleniowe. Jest to przydatne w przypadku pytań dotyczących ostatnich wydarzeń lub bardzo konkretnych tematów.
Narzędzie do wykonywania kodu umożliwia modelowi generowanie i uruchamianie kodu Pythona w celu wykonywania obliczeń, manipulowania danymi lub rozwiązywania problemów, które najlepiej rozwiązać za pomocą algorytmu. Model otrzymuje dane wyjściowe kodu i może ich użyć w swojej odpowiedzi.
Dzięki uporządkowanemu wyjściu możesz ograniczyć Gemini do odpowiadania w formacie JSON. Jest to szczególnie przydatne w przypadku integrowania danych wyjściowych modelu w aplikacji.
Wywoływanie funkcji łączy model myślenia z zewnętrznymi narzędziami i interfejsami API, dzięki czemu może podejmować decyzje dotyczące tego, kiedy wywołać odpowiednią funkcję i jakie parametry podać.

Przykłady korzystania z narzędzi z modelami myślenia znajdziesz w książce kucharskiej Thinking (Myślenie).

Co dalej?

Aby zapoznać się z bardziej szczegółowymi przykładami, takimi jak:
- Korzystanie z narzędzi z myśleniem
- Transmisja z przebiegiem rozumowania
- Dostosowywanie budżetu na myślenie do różnych wyników
i inne, wypróbuj naszą Książkę kucharska myślenia.
Zasięg myślenia jest teraz dostępny w naszym przewodniku Zgodność z OpenAI.
Więcej informacji o wersji przedpremierowej modelu Gemini 2.5 Pro i modelu Gemini 2.5 Flash Thinking znajdziesz na stronie modelu.