Myślenie

Wszystkie modele Gemini wykorzystują wewnętrzny „proces myślowy”, który znacznie poprawia ich zdolność do wnioskowania 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ślące oferują te konfiguracje i opcje:

  • Kontrolowanie ilości rozumowania
    Możesz skonfigurować poziomy rozumowania, aby kontrolować, ile „rozumowania” 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 zdecydować, w jakim stopniu model może potrzebować zdolności myślenia.

  • Otrzymywanie podsumowań toku rozumowania
    Możesz włączyć podsumowania toku rozumowania, aby dołączyć je do wygenerowanej odpowiedzi. Te podsumowania to syntetyczne wersje nieprzetworzonych procesów myślowych modelu, które dają wgląd w jego wewnętrzny proces rozumowania.

  • Obsługa sygnatur myśli
    Pakiety SDK Firebase AI Logic 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, aby dowiedzieć się, jak korzystać z modeli myślących.


Sprawdzone metody i wskazówki dotyczące promptów podczas korzystania z modeli myślących

Zalecamy przetestowanie prompta w Google AI Studio lub Agent  Studio, gdzie możesz zobaczyć cały proces rozumowania. Możesz zidentyfikować obszary, w których model mógł popełnić błąd, i doprecyzować prompty, aby uzyskać bardziej spójne i dokładne odpowiedzi.

Zacznij od ogólnego prompta, który opisuje pożądany wynik, i obserwuj, jak model określa swoją odpowiedź. Jeśli odpowiedź nie jest zgodna z oczekiwaniami, pomóż modelowi wygenerować lepszą odpowiedź, korzystając z dowolnej z tych technik tworzenia promptów:

  • podamy szczegółowe instrukcje dotyczące korzystania z tej funkcji;
  • Podaj kilka przykładów par danych wejściowych i wyjściowych.
  • podawać wskazówki dotyczące sposobu sformułowania i sformatowania danych wyjściowych i odpowiedzi;
  • Podaj konkretne kroki weryfikacji

Oprócz promptów warto rozważyć te rekomendacje:

  • Ustaw instrukcje systemowe, które są jak „wprowadzenie” dodawane, zanim model otrzyma dalsze instrukcje z prompta lub od użytkownika. Pozwalają one sterować zachowaniem modelu na podstawie konkretnych potrzeb i przypadków użycia.

  • Ustaw poziom rozumowania, aby kontrolować, jak bardzo model może się zastanawiać. Jeśli ustawisz wysoki poziom, model będzie mógł w razie potrzeby więcej myśleć. Jeśli ustawisz niższą wartość, model nie będzie „zbytnio analizować” odpowiedzi, a także zarezerwuje większą część łącznego limitu tokenów wyjściowych na rzeczywistą odpowiedź, co może pomóc zmniejszyć opóźnienia i koszty.

  • Włącz monitorowanie wykorzystania AI w konsoli Firebase, aby monitorować liczbę tokenów myślenia i opóźnienie żądań z włączonym myśleniem. Jeśli masz włączone podsumowania procesów myślowych, będą one wyświetlane w konsoli, gdzie możesz sprawdzić szczegółowe rozumowanie modelu, co pomoże Ci w debugowaniu i ulepszaniu promptów.


Kontrolowanie ilości rozumowania

Możesz skonfigurować poziomy rozumowania, aby kontrolować, ile „myślenia” i rozumowania 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 poziomów trudności zadań, aby zdecydować, w jakim stopniu model może potrzebować zdolności 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 zmniejszenie opóźnienia lub kosztów.
  • W przypadku bardziej złożonych zadań ustaw wyższą wartość myślenia.

Poziomy myślenia

Aby kontrolować, ile myślenia może wykonać model, aby wygenerować odpowiedź, możesz określić poziom myślenia, czyli liczbę tokenów myślenia, których może użyć.

Ustawianie poziomu myślenia

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

Ustaw poziom myślenia w GenerationConfig w ramach tworzenia instancji GenerativeModel. Konfiguracja jest utrzymywana przez cały okres istnienia instancji. Jeśli chcesz używać różnych poziomów rozumowania w przypadku różnych żądań, utwórz instancje GenerativeModel 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.x_MODEL_NAME",
  generationConfig: generationConfig
)

// ...

Kotlin

Ustaw wartości parametrów w GenerationConfig w ramach 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.x_MODEL_NAME",
  generationConfig,
)

// ...

Java

Ustaw wartości parametrów w GenerationConfig w ramach 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.x_MODEL_NAME",
                  /* generationConfig */ generationConfig
                );
);

// ...

Web

Ustaw wartości parametrów w GenerationConfig w ramach 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.x_MODEL_NAME", generationConfig });

// ...

Dart

Ustaw wartości parametrów w GenerationConfig w ramach 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.x_MODEL_NAME',
  generationConfig: generationConfig,
);

// ...

Unity

Ustaw wartości parametrów w GenerationConfig w ramach 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.x_MODEL_NAME",
  generationConfig: generationConfig
);

// ...

Obsługiwane wartości poziomu myślenia

W tabeli poniżej znajdziesz wartości poziomu rozumowania, które możesz ustawić dla każdego modelu, konfigurując jego parametr 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 o wysokiej przepustowości

Model stosuje zrównoważone podejście

Zadania o umiarkowanej złożoności

Model wykorzystuje tokeny do maksymalnego poziomu.

skomplikowane prompty, które wymagają zaawansowanego rozumowania;

Gemini 4 Argon
gemini-4-argon 		1 (domyślnie)
Gemini 3.x Pro
gemini-3.1-pro-preview 		(domyślnie)
Gemini 3.x Flash
gemini-3.8-flash
gemini-3.7-flash
gemini-3.6-flash
gemini-3.5-flash
nie jest obsługiwany przez gemini-3.8-flash ani gemini-3.7-flash 1 		(domyślnie)
Gemini 3.x Flash‑Lite
gemini-3.5-flash-lite
gemini-3.1-flash-lite 		(domyślnie)
Gemini Nano Banana 2.1
gemini-nano-banana-2.1 		(domyślnie)
Gemini Nano Banana 2
gemini-3.1-flash-image		 (domyślnie)
Gemini Nano Banana 2 Lite
gemini-3.1-flash-lite-image		 (domyślnie)
Gemini Nano Banana Pro
gemini-3-pro-image 		(domyślnie)

1 gemini-4-argon, gemini-3.8-flash i gemini-3.7-flash nie obsługują poziomu myślenia MINIMAL. Jeśli ustawisz poziom rozumowania na MINIMAL, żądanie zakończy się niepowodzeniem i zwróci błąd 400.


Limity czasu na myślenie (Gemini 2.5 modele)

Aby kontrolować, ile czasu model Gemini 2.5 może poświęcić na myślenie, aby wygenerować odpowiedź, możesz określić budżet na myślenie, czyli liczbę tokenów na myślenie, które może wykorzystać.


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

  • Łatwe zadania – nie wymagają skomplikowanego rozumowania
    Proste prośby, które nie wymagają skomplikowanego rozumowania, takie jak wyszukiwanie faktów lub klasyfikacja. Przykłady:

    • „Gdzie powstała firma DeepMind?”
    • „Czy ten e-mail zawiera prośbę o spotkanie czy tylko informacje?”

  • Zadania o umiarkowanym stopniu trudności – prawdopodobnie wymagają pewnego przemyślenia
    Typowe prośby, 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 wykorzystanie możliwości modelu
    Bardzo złożone wyzwania, takie jak rozwiązywanie skomplikowanych problemów matematycznych lub zadań związanych z kodowaniem. Tego typu zadania wymagają od modelu wykorzystania wszystkich 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 całkowitych podstaw b > 9, dla których 17b jest dzielnikiem 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ą wydajność”.


Podsumowania procesu myślowego

Podsumowania rozumowania to synteza nieprzetworzonych procesów myślowych modelu, która pozwala zrozumieć jego wewnętrzny proces rozumowania.

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

  • Możesz wyświetlić podsumowanie procesu myślowego w interfejsie aplikacji lub udostępnić je użytkownikom. Podsumowanie procesu rozumowania jest zwracane jako osobna część odpowiedzi, dzięki czemu masz większą kontrolę nad tym, jak jest używane w aplikacji.

  • Jeśli włączysz też monitorowanie wykorzystania AI w konsoli Firebase, podsumowania procesów myślowych będą wyświetlane w konsoli, gdzie możesz sprawdzić szczegółowe rozumowanie modelu, co pomoże Ci w debugowaniu i ulepszaniu promptów.

Oto kilka najważniejszych informacji o podsumowaniach procesów myślowych:

  • Podsumowania rozumowania nie są kontrolowane przez budżety na rozumowanie (budżety dotyczą tylko nieprzetworzonych procesów rozumowania modelu). Jeśli jednak myślenie jest wyłączone, model nie zwróci podsumowania procesu myślowego.

  • Podsumowania rozumowania są traktowane jako część zwykłej odpowiedzi modelu w postaci wygenerowanego tekstu i są liczone jako tokeny wyjściowe.

Włącz podsumowania procesu myślowego

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

Możesz włączyć podsumowania rozumowania, ustawiając parametr includeThoughts na wartość „true” w konfiguracji modelu. Podsumowanie możesz następnie wyświetlić, sprawdzając pole thoughtSummary w odpowiedzi.

Oto przykład pokazujący, jak włączyć i pobrać podsumowania rozumowania w odpowiedzi:

Swift

Włącz podsumowania procesów myślowych w GenerationConfig podczas tworzenia instancji GenerativeModel.


// ...

// 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 procesów myślowych w GenerationConfig podczas tworzenia instancji GenerativeModel.


// ...

// 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 procesów myślowych w GenerationConfig podczas tworzenia instancji GenerativeModel.


// ...

// 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");
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 procesów myślowych w GenerationConfig podczas tworzenia instancji GenerativeModel.


// ...

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 procesów myślowych w GenerationConfig w ramach tworzenia instancji GenerativeModel.


// ...

// 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([Content.text('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 procesów myślowych w GenerationConfig podczas tworzenia instancji GenerativeModel.


// ...

// 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}");
}

Podsumowania procesu myślowego w trybie strumieniowym

Możesz też wyświetlać podsumowania procesów myślowych, jeśli zdecydujesz się na przesyłanie odpowiedzi strumieniowo za pomocą generateContentStream. Spowoduje to zwrócenie stopniowych, przyrostowych podsumowań podczas generowania odpowiedzi.

Swift

Włącz podsumowania procesów myślowych w GenerationConfig podczas tworzenia instancji GenerativeModel.


// ...

// 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 procesów myślowych w GenerationConfig podczas tworzenia instancji GenerativeModel.


// ...

// 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 procesów myślowych w GenerationConfig podczas tworzenia instancji GenerativeModel.


// ...

// 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 procesów myślowych w GenerationConfig podczas tworzenia instancji GenerativeModel.


// ...

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 procesów myślowych w GenerationConfig w ramach tworzenia instancji GenerativeModel.


// ...

// 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([Content.text('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 procesów myślowych w GenerationConfig podczas tworzenia instancji GenerativeModel.


// ...

// 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 procesu rozumowania w interakcjach wieloetapowych model nie ma dostępu do kontekstu rozumowania z poprzednich etapów. Jeśli jednak używasz wywoływania funkcji, możesz wykorzystać podpisy myśli, aby zachować kontekst myśli między turami. Podpisy rozumowania to zaszyfrowane reprezentacje wewnętrznego procesu rozumowania modelu. Są one dostępne, gdy używasz rozumowania i wywoływania funkcji. Podpisy myśli są generowane, gdy:

  • Myślenie jest włączone i generowane są procesy myślowe.
  • Żądanie zawiera deklaracje funkcji.

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


Ceny i zliczanie tokenów myślenia

Tokeny myślenia są rozliczane według tych samych cen co tokeny wyjściowe tekstu. Jeśli włączysz podsumowania rozumowania, będą one traktowane jako tokeny myślenia i odpowiednio wyceniane.

Możesz włączyć monitorowanie wykorzystania AI w konsoli Firebase, aby śledzić liczbę tokenów myślenia w przypadku żądań z włączonym myśleniem.

Łą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 FutureCallback<GenerateContentResponse>() {
    @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.