The latest Gemini models (like gemini-3.1-pro-preview) are available to use with Firebase AI Logic on all platforms!

Gemini 2.0 Flash and Flash-Lite models will be retired on March 31, 2026. To avoid service disruption, update to a newer model like gemini-2.5-flash-lite. Learn more.

Myślenie

Gemini 3 i Gemini 2.5 mogą korzystać z wewnętrznego „procesu myślowego”, który znacznie poprawia ich zdolności 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.

Modele myślowe oferują te konfiguracje i opcje:

Kontrolowanie ilości „myślenia”
Możesz skonfigurować, ile „myślenia” może wykonać model. Ta konfiguracja jest szczególnie ważna, jeśli priorytetem jest zmniejszenie opóźnienia lub kosztów. Zapoznaj się też z porównaniem trudności zadań, aby określić, w jakim stopniu model może potrzebować funkcji myślenia.

Możesz kontrolować tę konfigurację za pomocą poziomów myślenia (modele Gemini 3 i nowsze) lub budżetów myślenia (modele Gemini 2.5).
Uzyskiwanie podsumowań myśli
Możesz włączyć podsumowania myśli, aby dołączać je do wygenerowanej odpowiedzi. Te podsumowania to zsyntetyzowane wersje surowych przemyśleń modelu, które pozwalają zrozumieć jego wewnętrzny proces rozumowania.
Obsługa sygnatur myśli
Pakiety Firebase AI Logic SDK automatycznie obsługują sygnatury myśli, co zapewnia modelowi dostęp do kontekstu myśli z poprzednich tur, zwłaszcza podczas korzystania z wywoływania funkcji.

Zapoznaj się ze sprawdzonymi metodami i wskazówkami dotyczącymi promptów w przypadku korzystania z modeli myślowych.

Używanie modelu myślowego

Używaj modelu myślącego tak samo jak każdego innego modelu Gemini.

Aby w pełni wykorzystać potencjał modeli myślowych, zapoznaj się z sekcją Sprawdzone metody i wskazówki dotyczące promptów w przypadku modeli myślowych na tej stronie.

Modele obsługujące tę funkcję

Ta funkcja jest obsługiwana tylko przez modele Gemini 3 i Gemini 2.5.

gemini-3-pro-preview
gemini-3-pro-image-preview (znany też jako „nano banana pro”)
gemini-3-flash-preview
gemini-2.5-pro
gemini-2.5-flash
gemini-2.5-flash-lite

Sprawdzone metody i wskazówki dotyczące promptów w przypadku korzystania z modeli myślowych

Zalecamy przetestowanie promptu w Google AI Studio lub Vertex AI Studio, gdzie możesz zobaczyć cały proces myślowy. Możesz zidentyfikować obszary, w których model mógł się pomylić, aby dopracować prompty i uzyskiwać bardziej spójne i dokładne odpowiedzi.

Zacznij od ogólnego prompta opisującego oczekiwany wynik i obserwuj wstępne przemyślenia modelu na temat tego, jak określa on odpowiedź. Jeśli odpowiedź nie jest zgodna z oczekiwaniami, pomóż modelowi wygenerować lepszą odpowiedź, korzystając z jednej z tych technik promptowania:

podamy szczegółowe instrukcje;
Podaj kilka przykładów par danych wejściowych i wyjściowych.
Podaj wskazówki dotyczące sformułowania i formatowania danych wyjściowych oraz odpowiedzi.
Podaj konkretne kroki weryfikacji

Oprócz promptów możesz też skorzystać z tych rekomendacji:

Ustaw instrukcje systemowe, które są jak „wstęp” dodawany przed tym, jak model zostanie poddany dalszym instrukcjom z promptu lub użytkownika końcowego. Pozwalają one sterować działaniem modelu w zależności od konkretnych potrzeb i przypadków użycia.
Ustaw poziom myślenia (lub budżet na myślenie w przypadku modeli Gemini 2.5), aby kontrolować, ile czasu model może poświęcić na myślenie. Jeśli ustawisz wysoki poziom, model będzie mógł w razie potrzeby dłużej myśleć. Jeśli ustawisz niższą wartość, model nie będzie „zbyt długo” zastanawiać się nad odpowiedzią, a także zarezerwuje więcej tokenów z całkowitego limitu na rzeczywistą odpowiedź, co może pomóc zmniejszyć opóźnienia i koszty.
Włącz monitorowanie AI w Firebasekonsoli, aby śledzić liczbę tokenów przetwarzania i opóźnienie żądań, w których włączono przetwarzanie. Jeśli masz włączone podsumowania myśli, będą one wyświetlane w konsoli, w której możesz sprawdzić szczegółowe uzasadnienie modelu, aby debugować i dopracowywać prompty.

Kontrolowanie ilości myślenia

Możesz skonfigurować, ile „myślenia” i wyciągania wniosków może wykonać model, zanim zwróci odpowiedź. Ta konfiguracja jest szczególnie ważna, jeśli priorytetem jest zmniejszenie opóźnienia lub kosztów.

Zapoznaj się z porównaniem trudności zadań, aby określić, w jakim stopniu model może potrzebować funkcji myślenia. Oto kilka ogólnych wskazówek:

Ustaw niższą wartość myślenia w przypadku mniej złożonych zadań lub jeśli priorytetem jest dla Ciebie skrócenie czasu oczekiwania lub obniżenie kosztów.
Ustaw wyższą wartość myślenia w przypadku bardziej złożonych zadań.

Możesz kontrolować tę konfigurację za pomocą poziomów myślenia (modele Gemini 3 i nowsze) lub budżetów myślenia (modele Gemini 2.5).

Poziomy myślenia (Gemini 3 modeli)

Aby kontrolować, ile czasu model Gemini 3 może poświęcić na myślenie w celu wygenerowania odpowiedzi, możesz określić poziom myślenia, czyli liczbę tokenów myślenia, których może użyć.

Ustawianie poziomu myślenia

Kliknij Gemini API dostawcę, aby wyświetlić na tej stronie treści i kod specyficzne dla tego dostawcy.

Ustaw poziom myślenia w GenerationConfig podczas tworzenia instancji GenerativeModel dla modelu Gemini 3. Konfiguracja jest utrzymywana przez cały okres istnienia instancji. Jeśli chcesz używać różnych poziomów myślenia w przypadku różnych żądań, utwórz GenerativeModel instancje skonfigurowane z każdym poziomem.

Więcej informacji o obsługiwanych wartościach poziomu myślenia znajdziesz w dalszej części tej sekcji.

Swift

Ustaw poziom myślenia w GenerationConfig podczas tworzenia instancji GenerativeModel.

)

// ...

// ...

// Set the thinking configuration
// Use a thinking level value appropriate for your model (example value shown here)
let generationConfig = GenerationConfig(
  thinkingConfig: ThinkingConfig(thinkingLevel: .low)
)

// Specify the config as part of creating the `GenerativeModel` instance
let model = FirebaseAI.firebaseAI(backend: .googleAI()).generativeModel(
  modelName: "GEMINI_3_MODEL_NAME",
  generationConfig: generationConfig
)

// ...

Kotlin

Ustaw wartości parametrów w sekcji GenerationConfig podczas tworzenia instancji GenerativeModel.

)

// ...

// ...

// Set the thinking configuration
// Use a thinking level value appropriate for your model (example value shown here)
val generationConfig = generationConfig {
  thinkingConfig = thinkingConfig {
      thinkingLevel = ThinkingLevel.LOW
  }
}

// Specify the config as part of creating the `GenerativeModel` instance
val model = Firebase.ai(backend = GenerativeBackend.googleAI()).generativeModel(
  modelName = "GEMINI_3_MODEL_NAME",
  generationConfig,
)

// ...

Java

Ustaw wartości parametrów w sekcji GenerationConfig podczas tworzenia instancji GenerativeModel.

;

// ...

// ...

// Set the thinking configuration
// Use a thinking level value appropriate for your model (example value shown here)
ThinkingConfig thinkingConfig = new ThinkingConfig.Builder()
    .setThinkingLevel(ThinkingLevel.LOW)
    .build();

GenerationConfig generationConfig = GenerationConfig.builder()
    .setThinkingConfig(thinkingConfig)
    .build();

// Specify the config as part of creating the `GenerativeModel` instance
GenerativeModelFutures model = GenerativeModelFutures.from(
        FirebaseAI.getInstance(GenerativeBackend.googleAI())
                .generativeModel(
                  /* modelName */ "GEMINI_3_MODEL_NAME",
                  /* generationConfig */ generationConfig
                );
);

// ...

Web

Ustaw wartości parametrów w sekcji GenerationConfig podczas tworzenia instancji GenerativeModel.

;

// ...

// ...

const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// Set the thinking configuration
// Use a thinking level value appropriate for your model (example value shown here)
const generationConfig = {
  thinkingConfig: {
    thinkingLevel: ThinkingLevel.LOW
  }
};

// Specify the config as part of creating the `GenerativeModel` instance
const model = getGenerativeModel(ai, { model: "GEMINI_3_MODEL_NAME", generationConfig });

// ...

Dart

Ustaw wartości parametrów w sekcji GenerationConfig podczas tworzenia instancji GenerativeModel.


// ...

// ...

// Set the thinking configuration
// Use a thinking level value appropriate for your model (example value shown here)
final thinkingConfig = ThinkingConfig.withThinkingLevel(ThinkingLevel.low);

final generationConfig = GenerationConfig(
  thinkingConfig: thinkingConfig
);

// Specify the config as part of creating the `GenerativeModel` instance
final model = FirebaseAI.googleAI().generativeModel(
  model: 'GEMINI_3_MODEL_NAME',
  config: generationConfig,
);

// ...

Unity

Ustaw wartości parametrów w sekcji GenerationConfig podczas tworzenia instancji GenerativeModel.

;

// ...

// ...

// Set the thinking configuration
// Use a thinking level value appropriate for your model (example value shown here)
var thinkingConfig = new ThinkingConfig(thinkingLevel: ThinkingLevel.Low);

var generationConfig = new GenerationConfig(
  thinkingConfig: thinkingConfig
);

// Specify the config as part of creating the `GenerativeModel` instance
var model = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI()).GetGenerativeModel(
  modelName: "GEMINI_3_MODEL_NAME",
  generationConfig: generationConfig
);

// ...

Obsługiwane wartości poziomu myślenia

W tabeli poniżej znajdziesz wartości poziomu myślenia, które możesz ustawić dla każdego modelu, konfigurując jego thinkingLevel.

	`MINIMAL`	`LOW`	`MEDIUM`	`HIGH`
	Model używa jak najmniejszej liczby tokenów, prawie nie myśli. Zadania o niskiej złożoności	Model używa mniejszej liczby tokenów, co minimalizuje czas oczekiwania i koszty. Proste zadania i zadania wymagające dużej przepustowości	Model stosuje zrównoważone podejście Zadania o średniej złożoności	Model wykorzystuje tokeny do maksymalnego poziomu złożone prompty wymagające dogłębnego rozumowania,
Gemini 3 Pro				(domyślnie)
Gemini 3 Pro Image („nano banana pro”)				(domyślnie)
Gemini 3 Flash				(domyślnie)

Budżety na myślenie (modele Gemini 2.5)

Aby kontrolować, ile czasu Gemini 2.5 może poświęcić na myślenie w celu wygenerowania odpowiedzi, możesz określić budżet na myślenie, czyli liczbę tokenów, których może użyć.

Ustawianie budżetu na myślenie

Kliknij Gemini API dostawcę, aby wyświetlić na tej stronie treści i kod specyficzne dla tego dostawcy.

Ustaw budżet na myślenie w GenerationConfig podczas tworzenia instancji GenerativeModel dla modelu Gemini 2.5. Konfiguracja jest utrzymywana przez cały okres istnienia instancji. Jeśli chcesz używać różnych budżetów na potrzeby różnych żądań, utwórz GenerativeModel instancje skonfigurowane z poszczególnymi budżetami.

Więcej informacji o obsługiwanych wartościach budżetu na myślenie znajdziesz w dalszej części tej sekcji.

Swift

Ustaw budżet na myślenie w GenerationConfig podczas tworzenia instancji GenerativeModel.

)

// ...

// ...

// Set the thinking configuration
// Use a thinking budget value appropriate for your model (example value shown here)
let generationConfig = GenerationConfig(
  thinkingConfig: ThinkingConfig(thinkingBudget: 1024)
)

// Specify the config as part of creating the `GenerativeModel` instance
let model = FirebaseAI.firebaseAI(backend: .googleAI()).generativeModel(
  modelName: "GEMINI_2.5_MODEL_NAME",
  generationConfig: generationConfig
)

// ...

Kotlin

Ustaw wartości parametrów w sekcji GenerationConfig podczas tworzenia instancji GenerativeModel.

)

// ...

// ...

// Set the thinking configuration
// Use a thinking budget value appropriate for your model (example value shown here)
val generationConfig = generationConfig {
  thinkingConfig = thinkingConfig {
      thinkingBudget = 1024
  }
}

// Specify the config as part of creating the `GenerativeModel` instance
val model = Firebase.ai(backend = GenerativeBackend.googleAI()).generativeModel(
  modelName = "GEMINI_2.5_MODEL_NAME",
  generationConfig,
)

// ...

Java

Ustaw wartości parametrów w sekcji GenerationConfig podczas tworzenia instancji GenerativeModel.

;

// ...

// ...

// Set the thinking configuration
// Use a thinking budget value appropriate for your model (example value shown here)
ThinkingConfig thinkingConfig = new ThinkingConfig.Builder()
    .setThinkingBudget(1024)
    .build();

GenerationConfig generationConfig = GenerationConfig.builder()
    .setThinkingConfig(thinkingConfig)
    .build();

// Specify the config as part of creating the `GenerativeModel` instance
GenerativeModelFutures model = GenerativeModelFutures.from(
        FirebaseAI.getInstance(GenerativeBackend.googleAI())
                .generativeModel(
                  /* modelName */ "GEMINI_2.5_MODEL_NAME",
                  /* generationConfig */ generationConfig
                );
);

// ...

Web

Ustaw wartości parametrów w sekcji GenerationConfig podczas tworzenia instancji GenerativeModel.

;

// ...

// ...

const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// Set the thinking configuration
// Use a thinking budget value appropriate for your model (example value shown here)
const generationConfig = {
  thinkingConfig: {
    thinkingBudget: 1024
  }
};

// Specify the config as part of creating the `GenerativeModel` instance
const model = getGenerativeModel(ai, { model: "GEMINI_2.5_MODEL_NAME", generationConfig });

// ...

Dart

Ustaw wartości parametrów w sekcji GenerationConfig podczas tworzenia instancji GenerativeModel.


// ...

// ...

// Set the thinking configuration
// Use a thinking budget value appropriate for your model (example value shown here)
final thinkingConfig = ThinkingConfig.withThinkingBudget(1024);

final generationConfig = GenerationConfig(
  thinkingConfig: thinkingConfig
);

// Specify the config as part of creating the `GenerativeModel` instance
final model = FirebaseAI.googleAI().generativeModel(
  model: 'GEMINI_2.5_MODEL_NAME',
  config: generationConfig,
);

// ...

Unity

Ustaw wartości parametrów w sekcji GenerationConfig podczas tworzenia instancji GenerativeModel.

;

// ...

// ...

// Set the thinking configuration
// Use a thinking budget value appropriate for your model (example value shown here)
var thinkingConfig = new ThinkingConfig(thinkingBudget: 1024);

var generationConfig = new GenerationConfig(
  thinkingConfig: thinkingConfig
);

// Specify the config as part of creating the `GenerativeModel` instance
var model = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI()).GetGenerativeModel(
  modelName: "GEMINI_2.5_MODEL_NAME",
  generationConfig: generationConfig
);

// ...

Obsługiwane wartości budżetu na myślenie

W tabeli poniżej znajdziesz wartości budżetu na myślenie, które możesz ustawić dla każdego modelu, konfigurując thinkingBudget modelu.

Model	Wartość domyślna	Dostępny zakres budżetu na myślenie		Wartość, która wyłącza myślenie	Wartość, która włącza dynamiczne myślenie
Model	Wartość domyślna			Wartość, która wyłącza myślenie	Wartość, która włącza dynamiczne myślenie	Wartość minimalna	Wartość maksymalna
Gemini 2.5 Pro	`8,192`	`128`	`32,768`	Nie można wyłączyć	`-1`
Gemini 2.5 Flash	`8,192`	`1`	`24,576`	`0`	`-1`
Gemini 2.5 Flash‑Lite	`0` (myślenie jest domyślnie wyłączone)	`512`	`24,576`	`0` (lub w ogóle nie konfiguruj budżetu na myślenie)	`-1`

Wyłączanie myślenia w przypadku modeli Gemini 2.5

W przypadku łatwiejszych zadań zdolność myślenia nie jest tak ważna i wystarczy tradycyjne wnioskowanie. Jeśli priorytetem jest zmniejszenie opóźnienia lub kosztów, możesz nie chcieć, aby model poświęcał więcej czasu lub generował wyższe koszty niż jest to konieczne do wygenerowania odpowiedzi.

W takich sytuacjach możesz wyłączyć (lub zatrzymać) myślenie w przypadku niektórych modeli:

Gemini 2.5 Pro: myślenie nie może być wyłączone
Gemini 2.5 Flash: wyłącz myślenie, ustawiając thinkingBudget na 0 tokenów.
Gemini 2.5 Flash‑Lite: myślenie jest domyślnie wyłączone (nie ustawiaj więc jawnie wartości thinkingBudget lub ustaw ją na 0)

Pamiętaj, że w przypadku wszystkich modeli Gemini 3 nie można wyłączyć myślenia.

Włączanie dynamicznego myślenia w przypadku modeli Gemini 2.5

W przypadku dynamicznego myślenia model decyduje, kiedy i ile myśli (do maksymalnego budżetu na myślenie, jak opisano poniżej).

Włącz myślenie dynamiczne, ustawiając thinkingBudget na -1.
Gdy dynamiczne myślenie jest włączone, maksymalna liczba tokenów myślenia wynosi zawsze 8192 tokeny.

Pamiętaj, że wszystkie modele Gemini 3 zawsze korzystają z dynamicznego myślenia.

Złożoność zadań dla wszystkich modeli myślących

Proste zadania – myślenie nie jest tak konieczne
Proste prośby, które nie wymagają złożonego rozumowania, np. wyszukiwanie faktów lub klasyfikacja. Przykłady:
- „Gdzie powstała firma DeepMind?”
- „Czy ten e-mail zawiera prośbę o spotkanie, czy tylko informacje?”
Umiarkowane zadania – wymagają pewnego zastanowienia
Typowe żądania, które wymagają pewnego stopnia przetwarzania krok po kroku lub głębszego zrozumienia. Przykłady:
- „Utwórz analogię między fotosyntezą a dorastaniem”.
- „Porównaj samochody elektryczne i hybrydowe”.
Trudne zadania – może być konieczne maksymalne zaangażowanie myślowe
Naprawdę złożone wyzwania, takie jak rozwiązywanie skomplikowanych zadań matematycznych lub pisanie kodu. Tego typu zadania wymagają od modelu pełnego zaangażowania możliwości rozumowania i planowania, często obejmują wiele wewnętrznych kroków, zanim zostanie udzielona odpowiedź. Przykłady:
- „Rozwiąż zadanie 1 z AIME 2025: znajdź sumę wszystkich podstaw całkowitych b > 9, dla których 17b jest dzielnikiem 97b”.
- „Napisz kod w Pythonie dla aplikacji internetowej, która wizualizuje dane z rynku akcji w czasie rzeczywistym, w tym uwierzytelnianie użytkowników. Zadbaj o jak największą wydajność”.

Podsumowania przemyśleń

Podsumowania myśli to zsyntetyzowane wersje surowych myśli modelu, które dostarczają informacji o wewnętrznym procesie rozumowania modelu.

Oto kilka powodów, dla których warto uwzględniać podsumowania myśli w odpowiedziach:

Podsumowanie przemyśleń możesz wyświetlać w interfejsie aplikacji lub udostępniać użytkownikom. Podsumowanie myśli jest zwracane jako osobna część odpowiedzi, dzięki czemu masz większą kontrolę nad sposobem jego wykorzystania w aplikacji.
Jeśli włączysz też monitorowanie AI w Firebasekonsoli, w konsoli będą wyświetlane podsumowania myśli, w których możesz sprawdzić szczegółowe uzasadnienie modelu, aby debugować i dopracowywać prompty.

Oto kilka najważniejszych informacji o podsumowaniach myśli:

Podsumowania myśli nie są kontrolowane przez budżety na myślenie (budżety mają zastosowanie tylko do surowych myśli modelu). Jeśli jednak myślenie jest wyłączone, model nie zwróci podsumowania myśli.
Podsumowania przemyśleń są traktowane jako część zwykłej odpowiedzi modelu w postaci wygenerowanego tekstu i są liczone jako tokeny wyjściowe.

Włącz podsumowania myśli

Kliknij Gemini API dostawcę, aby wyświetlić na tej stronie treści i kod specyficzne dla tego dostawcy.

Podsumowania przemyśleń możesz włączyć, ustawiając w konfiguracji modelu wartość includeThoughts na true. Podsumowanie możesz wyświetlić, sprawdzając pole thoughtSummary w odpowiedzi.

Oto przykład, który pokazuje, jak włączyć i pobrać podsumowania myśli w odpowiedzi:

Swift

Włącz podsumowania myśli w GenerationConfig podczas tworzenia instancji GenerativeModel.

onse.")
}
print("Answer: \(text)")

// ...

// Set the thinking configuration
// Optionally enable thought summaries in the generated response (default is false)
let generationConfig = GenerationConfig(
  thinkingConfig: ThinkingConfig(includeThoughts: true)
)

// Specify the config as part of creating the `GenerativeModel` instance
let model = FirebaseAI.firebaseAI(backend: .googleAI()).generativeModel(
  modelName: "GEMINI_MODEL_NAME",
  generationConfig: generationConfig
)

let response = try await model.generateContent("solve x^2 + 4x + 4 = 0")

// Handle the response that includes thought summaries
if let thoughtSummary = response.thoughtSummary {
  print("Thought Summary: \(thoughtSummary)")
}
guard let text = response.text else {
  fatalError("No text in response.")
}
print("Answer: \(text)")

Kotlin

Włącz podsumowania myśli w GenerationConfig podczas tworzenia instancji GenerativeModel.


    println("Answer: $it")
}

// ...

// Set the thinking configuration
// Optionally enable thought summaries in the generated response (default is false)
val generationConfig = generationConfig {
  thinkingConfig = thinkingConfig {
      includeThoughts = true
  }
}

// Specify the config as part of creating the `GenerativeModel` instance
val model = Firebase.ai(backend = GenerativeBackend.googleAI()).generativeModel(
  modelName = "GEMINI_MODEL_NAME",
  generationConfig,
)

val response = model.generateContent("solve x^2 + 4x + 4 = 0")

// Handle the response that includes thought summaries
response.thoughtSummary?.let {
    println("Thought Summary: $it")
}
response.text?.let {
    println("Answer: $it")
}

Java

Włącz podsumowania myśli w GenerationConfig podczas tworzenia instancji GenerativeModel.

  }
}, MoreExecutors.directExecutor());

// ...

// Set the thinking configuration
// Optionally enable thought summaries in the generated response (default is false)
ThinkingConfig thinkingConfig = new ThinkingConfig.Builder()
    .setIncludeThoughts(true)
    .build();

GenerationConfig generationConfig = GenerationConfig.builder()
    .setThinkingConfig(thinkingConfig)
    .build();

// Specify the config as part of creating the `GenerativeModel` instance
GenerativeModelFutures model = GenerativeModelFutures.from(
        FirebaseAI.getInstance(GenerativeBackend.googleAI())
                .generativeModel(
                  /* modelName */ "GEMINI_MODEL_NAME",
                  /* generationConfig */ generationConfig
                );
);

// Handle the response that includes thought summaries
ListenableFuture responseFuture = model.generateContent("solve x^2 + 4x + 4 = 0&quot;);
Futures.addCallback(responseFuture, new FutureCallback() {
    @Override
    public void onSuccess(GenerateContentResponse response) {
        if (response.getThoughtSummary() != null) {
            System.out.println("Thought Summary: " + response.getThoughtSummary());
        }
        if (response.getText() != null) {
            System.out.println("Answer: " + response.getText());
        }
    }

    @Override
    public void onFailure(Throwable t) {
        // Handle error
    }
}, MoreExecutors.directExecutor());

Web

Włącz podsumowania myśli w GenerationConfig podczas tworzenia instancji GenerativeModel.

`Answer: ${text}`);

// ...

const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// Set the thinking configuration
// Optionally enable thought summaries in the generated response (default is false)
const generationConfig = {
  thinkingConfig: {
    includeThoughts: true
  }
};

// Specify the config as part of creating the `GenerativeModel` instance
const model = getGenerativeModel(ai, { model: "GEMINI_MODEL_NAME", generationConfig });

const result = await model.generateContent("solve x^2 + 4x + 4 = 0");
const response = result.response;

// Handle the response that includes thought summaries
if (response.thoughtSummary()) {
    console.log(`Thought Summary: ${response.thoughtSummary()}`);
}
const text = response.text();
console.log(`Answer: ${text}`);

Dart

Włącz podsumowania myśli w GenerationConfig podczas tworzenia instancji GenerativeModel.

swer: ${response.text}');
}

// ...

// Set the thinking configuration
// Optionally enable thought summaries in the generated response (default is false)
final thinkingConfig = ThinkingConfig(includeThoughts: true);

final generationConfig = GenerationConfig(
  thinkingConfig: thinkingConfig
);

// Specify the config as part of creating the `GenerativeModel` instance
final model = FirebaseAI.googleAI().generativeModel(
  model: 'GEMINI_MODEL_NAME',
  generationConfig: generationConfig,
);

final response = await model.generateContent('solve x^2 + 4x + 4 = 0');

// Handle the response that includes thought summaries
if (response.thoughtSummary != null) {
  print('Thought Summary: ${response.thoughtSummary}');
}
if (response.text != null) {
  print('Answer: ${response.text}');
}

Unity

Włącz podsumowania myśli w GenerationConfig podczas tworzenia instancji GenerativeModel.

"Answer: {response.Text}");
}

// ...

// Set the thinking configuration
// Optionally enable thought summaries in the generated response (default is false)
var thinkingConfig = new ThinkingConfig(includeThoughts: true);

var generationConfig = new GenerationConfig(
  thinkingConfig: thinkingConfig
);

// Specify the config as part of creating the `GenerativeModel` instance
var model = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI()).GetGenerativeModel(
  modelName: "GEMINI_MODEL_NAME",
  generationConfig: generationConfig
);

var response = await model.GenerateContentAsync("solve x^2 + 4x + 4 = 0");

// Handle the response that includes thought summaries
if (response.ThoughtSummary != null) {
    Debug.Log($"Thought Summary: {response.ThoughtSummary}");
}
if (response.Text != null) {
    Debug.Log($"Answer: {response.Text}");
}

Wyświetlanie odpowiedzi i podsumowania procesu myślowego

# Example Response:
#     Okay, let's solve the quadratic equation x² + 4x + 4 = 0.
#     ...
#     **Answer:**
#     The solution to the equation x² + 4x + 4 = 0 is x = -2. This is a repeated root (or a root with multiplicity 2).

# Example Thought Summary:
#     **My Thought Process for Solving the Quadratic Equation**
#
#     Alright, let's break down this quadratic, x² + 4x + 4 = 0. First things first:
#     it's a quadratic; the x² term gives it away, and we know the general form is
#     ax² + bx + c = 0.
#
#     So, let's identify the coefficients: a = 1, b = 4, and c = 4. Now, what's the
#     most efficient path to the solution? My gut tells me to try factoring; it's
#     often the fastest route if it works. If that fails, I'll default to the quadratic
#     formula, which is foolproof. Completing the square? It's good for deriving the
#     formula or when factoring is difficult, but not usually my first choice for
#     direct solving, but it can't hurt to keep it as an option.
#
#     Factoring, then. I need to find two numbers that multiply to 'c' (4) and add
#     up to 'b' (4). Let's see... 1 and 4 don't work (add up to 5). 2 and 2? Bingo!
#     They multiply to 4 and add up to 4. This means I can rewrite the equation as
#     (x + 2)(x + 2) = 0, or more concisely, (x + 2)² = 0. Solving for x is now
#     trivial: x + 2 = 0, thus x = -2.
#
#     Okay, just to be absolutely certain, I'll run the quadratic formula just to
#     double-check. x = [-b ± √(b² - 4ac)] / 2a. Plugging in the values, x = [-4 ±
#     √(4² - 4 * 1 * 4)] / (2 * 1). That simplifies to x = [-4 ± √0] / 2. So, x =
#     -2 again - a repeated root. Nice.
#
#     Now, let's check via completing the square. Starting from the same equation,
#     (x² + 4x) = -4. Take half of the b-value (4/2 = 2), square it (2² = 4), and
#     add it to both sides, so x² + 4x + 4 = -4 + 4. Which simplifies into (x + 2)²
#     = 0. The square root on both sides gives us x + 2 = 0, therefore x = -2, as
#      expected.
#
#     Always, *always* confirm! Let's substitute x = -2 back into the original
#     equation: (-2)² + 4(-2) + 4 = 0. That's 4 - 8 + 4 = 0. It checks out.
#
#     Conclusion: the solution is x = -2. Confirmed.

Wyświetlanie podsumowań strumienia myśli

Możesz też wyświetlać podsumowania myśli, jeśli zdecydujesz się przesyłać strumieniowo odpowiedź za pomocą generateContentStream. Podczas generowania odpowiedzi będą zwracane bieżące, przyrostowe podsumowania.

Swift

Włącz podsumowania myśli w GenerationConfig podczas tworzenia instancji GenerativeModel.

r ---")
    }
    print(text)
    answer += text
  }
}

// ...

// Set the thinking configuration
// Optionally enable thought summaries in the generated response (default is false)
let generationConfig = GenerationConfig(
  thinkingConfig: ThinkingConfig(includeThoughts: true)
)

// Specify the config as part of creating the `GenerativeModel` instance
let model = FirebaseAI.firebaseAI(backend: .googleAI()).generativeModel(
  modelName: "GEMINI_MODEL_NAME",
  generationConfig: generationConfig
)

let stream = try model.generateContentStream("solve x^2 + 4x + 4 = 0")

// Handle the streamed response that includes thought summaries
var thoughts = ""
var answer = ""
for try await response in stream {
  if let thought = response.thoughtSummary {
    if thoughts.isEmpty {
      print("--- Thoughts Summary ---")
    }
    print(thought)
    thoughts += thought
  }

  if let text = response.text {
    if answer.isEmpty {
      print("--- Answer ---")
    }
    print(text)
    answer += text
  }
}

Kotlin

Włącz podsumowania myśli w GenerationConfig podczas tworzenia instancji GenerativeModel.

uot;)
        }
        print(it)
        answer += it
    }
}

// ...

// Set the thinking configuration
// Optionally enable thought summaries in the generated response (default is false)
val generationConfig = generationConfig {
  thinkingConfig = thinkingConfig {
      includeThoughts = true
  }
}

// Specify the config as part of creating the `GenerativeModel` instance
val model = Firebase.ai(backend = GenerativeBackend.googleAI()).generativeModel(
  modelName = "GEMINI_MODEL_NAME",
  generationConfig,
)

// Handle the streamed response that includes thought summaries
var thoughts = ""
var answer = ""
model.generateContentStream("solve x^2 + 4x + 4 = 0").collect { response ->
    response.thoughtSummary?.let {
        if (thoughts.isEmpty()) {
            println("--- Thoughts Summary ---")
        }
        print(it)
        thoughts += it
    }
    response.text?.let {
        if (answer.isEmpty()) {
            println("--- Answer ---")
        }
        print(it)
        answer += it
    }
}

Java

Włącz podsumowania myśli w GenerationConfig podczas tworzenia instancji GenerativeModel.


}, throwable -> {
    // Handle error
});

// ...

// Set the thinking configuration
// Optionally enable thought summaries in the generated response (default is false)
ThinkingConfig thinkingConfig = new ThinkingConfig.Builder()
    .setIncludeThoughts(true)
    .build();

GenerationConfig generationConfig = GenerationConfig.builder()
    .setThinkingConfig(thinkingConfig)
    .build();

// Specify the config as part of creating the `GenerativeModel` instance
GenerativeModelFutures model = GenerativeModelFutures.from(
        FirebaseAI.getInstance(GenerativeBackend.googleAI())
                .generativeModel(
                  /* modelName */ "GEMINI_MODEL_NAME",
                  /* generationConfig */ generationConfig
                );
);

// Streaming with Java is complex and depends on the async library used.
// This is a conceptual example using a reactive stream.
Flowable responseStream = model.generateContentStream("solve x^2 + 4x + 4 = 0");

// Handle the streamed response that includes thought summaries
StringBuilder thoughts = new StringBuilder();
StringBuilder answer = new StringBuilder();

responseStream.subscribe(response -> {
    if (response.getThoughtSummary() != null) {
        if (thoughts.length() == 0) {
            System.out.println("--- Thoughts Summary ---");
        }
        System.out.print(response.getThoughtSummary());
        thoughts.append(response.getThoughtSummary());
    }
    if (response.getText() != null) {
        if (answer.length() == 0) {
            System.out.println("--- Answer ---");
        }
        System.out.print(response.getText());
        answer.append(response.getText());
    }
}, throwable -> {
    // Handle error
});

Web

Włącz podsumowania myśli w GenerationConfig podczas tworzenia instancji GenerativeModel.

out.write(text) could be used.
    console.log(text);
    answer += text;
  }
}

// ...

const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// Set the thinking configuration
// Optionally enable thought summaries in the generated response (default is false)
const generationConfig = {
  thinkingConfig: {
    includeThoughts: true
  }
};

// Specify the config as part of creating the `GenerativeModel` instance
const model = getGenerativeModel(ai, { model: "GEMINI_MODEL_NAME", generationConfig });

const result = await model.generateContentStream("solve x^2 + 4x + 4 = 0");

// Handle the streamed response that includes thought summaries
let thoughts = "";
let answer = "";
for await (const chunk of result.stream) {
  if (chunk.thoughtSummary()) {
    if (thoughts === "") {
      console.log("--- Thoughts Summary ---");
    }
    // In Node.js, process.stdout.write(chunk.thoughtSummary()) could be used
    // to avoid extra newlines.
    console.log(chunk.thoughtSummary());
    thoughts += chunk.thoughtSummary();
  }

  const text = chunk.text();
  if (text) {
    if (answer === "") {
      console.log("--- Answer ---");
    }
    // In Node.js, process.stdout.write(text) could be used.
    console.log(text);
    answer += text;
  }
}

Dart

Włącz podsumowania myśli w GenerationConfig podczas tworzenia instancji GenerativeModel.

39;);
    }
    answer += response.text!;
  }
}

// ...

// Set the thinking configuration
// Optionally enable thought summaries in the generated response (default is false)
final thinkingConfig = ThinkingConfig(includeThoughts: true);

final generationConfig = GenerationConfig(
  thinkingConfig: thinkingConfig
);

// Specify the config as part of creating the `GenerativeModel` instance
final model = FirebaseAI.googleAI().generativeModel(
  model: 'GEMINI_MODEL_NAME',
  generationConfig: generationConfig,
);

final responses = model.generateContentStream('solve x^2 + 4x + 4 = 0');

// Handle the streamed response that includes thought summaries
var thoughts = '';
var answer = '';
await for (final response in responses) {
  if (response.thoughtSummary != null) {
    if (thoughts.isEmpty) {
      print('--- Thoughts Summary ---');
    }
    thoughts += response.thoughtSummary!;
  }
  if (response.text != null) {
    if (answer.isEmpty) {
      print('--- Answer ---');
    }
    answer += response.text!;
  }
}

Unity

Włącz podsumowania myśli w GenerationConfig podczas tworzenia instancji GenerativeModel.

og(response.Text);
        answer += response.Text;
    }
}

// ...

// Set the thinking configuration
// Optionally enable thought summaries in the generated response (default is false)
var thinkingConfig = new ThinkingConfig(includeThoughts: true);

var generationConfig = new GenerationConfig(
  thinkingConfig: thinkingConfig
);

// Specify the config as part of creating the `GenerativeModel` instance
var model = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI()).GetGenerativeModel(
  modelName: "GEMINI_MODEL_NAME",
  generationConfig: generationConfig
);

var stream = model.GenerateContentStreamAsync("solve x^2 + 4x + 4 = 0");

// Handle the streamed response that includes thought summaries
var thoughts = "";
var answer = "";
await foreach (var response in stream)
{
    if (response.ThoughtSummary != null)
    {
        if (string.IsNullOrEmpty(thoughts))
        {
            Debug.Log("--- Thoughts Summary ---");
        }
        Debug.Log(response.ThoughtSummary);
        thoughts += response.ThoughtSummary;
    }
    if (response.Text != null)
    {
        if (string.IsNullOrEmpty(answer))
        {
            Debug.Log("--- Answer ---");
        }
        Debug.Log(response.Text);
        answer += response.Text;
    }
}

Podpisy myśli

Podczas korzystania z funkcji myślenia w interakcjach wieloetapowych model nie ma dostępu do kontekstu myślenia z poprzednich etapów. Jeśli jednak korzystasz z wywoływania funkcji, możesz używać sygnatur myśli, aby zachować kontekst myślowy w kolejnych turach. Podpisy myśli to zaszyfrowane reprezentacje wewnętrznego procesu myślowego modelu. Są one dostępne podczas korzystania z myślenia i wywoływania funkcji. Sygnatury myśli są generowane, gdy:

Myślenie jest włączone i generowane są pomysły.
Żądanie zawiera deklaracje funkcji.

Aby korzystać z sygnatur myśli, używaj wywoływania funkcji w normalny sposób. Pakiety Firebase AI Logic SDK upraszczają ten proces, zarządzając stanem i automatycznie obsługując podpisy myśli. Zestawy SDK automatycznie przekazują wygenerowane sygnatury myśli między kolejnymi wywołaniami funkcji sendMessage lub sendMessageStream w ramach Chat sesji.

Ceny i zliczanie tokenów myślowych

Tokeny myślenia mają takie same ceny jak tokeny wyjściowe tekstu. Jeśli włączysz podsumowania myśli, będą one traktowane jako tokeny myśli i odpowiednio wyceniane.

Możesz włączyć monitorowanie AI w Firebasekonsoli, aby śledzić liczbę tokenów przetwarzania w przypadku żądań, w których włączono przetwarzanie.

Łączną liczbę tokenów myślenia możesz uzyskać z pola thoughtsTokenCount w atrybucie usageMetadata odpowiedzi:

Swift

// ...

let response = try await model.generateContent("Why is the sky blue?")

if let usageMetadata = response.usageMetadata {
  print("Thoughts Token Count: \(usageMetadata.thoughtsTokenCount)")
}

Kotlin

// ...

val response = model.generateContent("Why is the sky blue?")

response.usageMetadata?.let { usageMetadata ->
    println("Thoughts Token Count: ${usageMetadata.thoughtsTokenCount}")
}

Java

// ...

ListenableFuture<GenerateContentResponse> response =
    model.generateContent("Why is the sky blue?");

Futures.addCallback(response, new Futu<reCallbackGenerateConte>ntResponse() {
    @Override
    public void onSuccess(GenerateContentResponse result) {
        String usageMetadata = result.getUsageMetadata();
        if (usageMetadata != null) {
            System.out.println("Thoughts Token Count: " +
                usageMetadata.getThoughtsTokenCount());
        }
    }

    @Override
    public void onFailure(Throwable t) {
        t.printStackTrace();
    }
}, executor);

Web

// ...

const response = await model.generateContent("Why is the sky blue?");

if (response?.usageMetadata?.thoughtsTokenCount != null) {
    console.log(`Thoughts Token Count: ${response.usageMetadata.thoughtsTokenCount}`);
}

Dart

// ...

final response = await model.generateContent(
  Content.text("Why is the sky blue?"),
]);

if (response?.usageMetadata case final usageMetadata?) {
  print("Thoughts Token Count: ${usageMetadata.thoughtsTokenCount}");
}

Unity

// ...

var response = await model.GenerateContentAsync("Why is the sky blue?");

if (response.UsageMetadata != null)
{
    UnityEngine.Debug.Log($"Thoughts Token Count: {response.UsageMetadata?.ThoughtsTokenCount}");
}

Więcej informacji o tokenach znajdziesz w przewodniku po tokenach.

Myślenie Zadbaj o dobrą organizację dzięki kolekcji Zapisuj i kategoryzuj treści zgodnie ze swoimi preferencjami.

Używanie modelu myślowego

Modele obsługujące tę funkcję

Sprawdzone metody i wskazówki dotyczące promptów w przypadku korzystania z modeli myślowych

Kontrolowanie ilości myślenia

Poziomy myślenia (Gemini 3 modeli)

Ustawianie poziomu myślenia

Swift

Kotlin

Java

Web

Dart

Unity

Obsługiwane wartości poziomu myślenia

Budżety na myślenie (modele Gemini 2.5)

Ustawianie budżetu na myślenie

Swift

Kotlin

Java

Web

Dart

Unity

Obsługiwane wartości budżetu na myślenie

Wyłączanie myślenia w przypadku modeli Gemini 2.5

Włączanie dynamicznego myślenia w przypadku modeli Gemini 2.5

Złożoność zadań dla wszystkich modeli myślących

Podsumowania przemyśleń

Włącz podsumowania myśli

Swift

Kotlin

Java

Web

Dart

Unity

Wyświetlanie podsumowań strumienia myśli

Swift

Kotlin

Java

Web

Dart

Unity

Podpisy myśli

Ceny i zliczanie tokenów myślowych

Swift

Kotlin

Java

Web

Dart

Unity

Myślenie