Razonamiento

Los modelos de razonamiento se entrenan para generar un "proceso de pensamiento" interno antes de producir una respuesta. Como resultado, los modelos de razonamiento son capaces de realizar un razonamiento más sólido, una planificación de varios pasos, la resolución de problemas matemáticos y la generación de código que los modelos sin capacidades de razonamiento.

El proceso de pensamiento está habilitado de forma predeterminada en todos los modelos de Gemini. Cuando usas Agent Studio en Gemini Enterprise Agent Platform, puedes ver el proceso de pensamiento completo junto con la respuesta generada del modelo.

Modelos compatibles

El pensamiento es compatible con los siguientes modelos:

Haz clic para expandir los modelos compatibles

• Gemini Omni Flash vista previa
• Gemini Omni 1.1 Flash vista previa
• Gemini 3.8 Flash
• Gemini 3.7 Flash
• Gemini 3.6 Flash
• Gemini 3.5 Flash-Lite
• Gemini 3.5 Flash
• Gemini 3.1 Pro versión preliminar
• Gemini 3.1 Flash-Lite Image (Nano Banana 2 Lite)
• Gemini 3.1 Flash-Lite
• Imagen de Gemini 3.1 Flash
• Gemini 3 Pro Image
• Gemini 3 Flash vista previa
• Gemini 2.5 Pro
• Gemini 2.5 Flash-Lite
• Gemini 2.5 Flash

Controla el razonamiento del modelo

Puedes controlar la cantidad de razonamiento que realiza el modelo antes de devolver una respuesta. El método para controlar el pensamiento difiere según la versión del modelo.

Modelos de Gemini 3 y versiones posteriores

Los modelos de Gemini 3 introducen el parámetro thinking_level, que simplifica la configuración del presupuesto de razonamiento en niveles discretos. Para obtener respuestas más rápidas y con menor latencia cuando no se requiere un razonamiento complejo, puedes restringir el thinking_level del modelo.

En la siguiente tabla, se resumen los valores de thinking_level que admite cada modelo y el valor predeterminado de thinking_level para cada modelo:

Modelo	Valores admitidos de thinking_level:	Predeterminado
Gemini 3.8 Flash	LOW, MEDIUM, HIGH	MEDIUM
Gemini 3.7 Flash	LOW, MEDIUM, HIGH	MEDIUM
Gemini 3.6 Flash	MINIMAL, LOW, MEDIUM, HIGH	MEDIUM
Gemini 3.5 Flash-Lite	MINIMAL, LOW, MEDIUM, HIGH	MINIMAL
Gemini 3.5 Flash	MINIMAL, LOW, MEDIUM, HIGH	MEDIUM
Gemini 3.1 Pro versión preliminar	LOW, MEDIUM, HIGH	HIGH
Imagen de Gemini 3.1 Flash-Lite (Nano Banana 2 Lite)	MINIMAL, HIGH	MINIMAL
Gemini 3.1 Flash-Lite	MINIMAL, LOW, MEDIUM, HIGH	MINIMAL
Gemini 3.1 Flash Image	MINIMAL, HIGH	MINIMAL
Gemini 3 Pro Image	HIGH	HIGH
Gemini 3 Flash versión preliminar	MINIMAL, LOW, MEDIUM, HIGH	HIGH

• MINIMAL: Restringe el modelo para que use la menor cantidad posible de tokens para pensar y se usa mejor para tareas de baja complejidad que no se beneficiarían de un razonamiento extenso. Este es el nivel predeterminado para Gemini 3.1 Flash-Lite. MINIMAL se acerca lo más posible a un presupuesto cero para el pensamiento, pero aún requiere firmas de pensamiento. Si no se proporcionan firmas de pensamiento en la solicitud, el modelo devuelve un error 400. Para obtener más información, consulta Firmas de pensamiento.

  from google import genai
  from google.genai import types
  
  client = genai.Client()
  
  response = client.models.generate_content(
      model="gemini-3-flash-preview",
      contents="How does AI work?",
      config=types.GenerateContentConfig(
          thinking_config=types.ThinkingConfig(
              thinking_level=types.ThinkingLevel.MINIMAL
          )
      ),
  )
  print(response.text)
  

• LOW: Restringe el modelo para que use menos tokens para pensar y es adecuado para tareas más simples en las que no se requiere un razonamiento extenso. LOW es ideal para tareas de alta capacidad de procesamiento en las que la velocidad es esencial:

  from google import genai
  from google.genai import types
  
  client = genai.Client()
  
  response = client.models.generate_content(
      model="gemini-3.5-flash",
      contents="How does AI work?",
      config=types.GenerateContentConfig(
          thinking_config=types.ThinkingConfig(
              thinking_level=types.ThinkingLevel.LOW
          )
      ),
  )
  print(response.text)
  

• MEDIUM: Ofrece un enfoque equilibrado adecuado para tareas de complejidad moderada que se benefician del razonamiento, pero no requieren una planificación profunda de varios pasos. Proporciona más capacidad de razonamiento que LOW y, al mismo tiempo, mantiene una latencia más baja que HIGH:

  from google import genai
  from google.genai import types
  
  client = genai.Client()
  
  response = client.models.generate_content(
      model="gemini-3-flash-preview",
      contents="How does AI work?",
      config=types.GenerateContentConfig(
          thinking_config=types.ThinkingConfig(
              thinking_level=types.ThinkingLevel.MEDIUM
          )
      ),
  )
  print(response.text)
  

• HIGH: Permite que el modelo use más tokens para pensar y es adecuado para instrucciones complejas que requieren un razonamiento profundo, como la planificación de varios pasos, la generación de código verificado o situaciones avanzadas de llamadas a funciones. Este es el nivel predeterminado para los modelos Gemini 3 Pro y Gemini 3 Flash. Usa esta configuración cuando reemplaces tareas para las que tal vez hayas usado modelos de razonamiento especializados:

  from google import genai
  from google.genai import types
  
  client = genai.Client()
  
  response = client.models.generate_content(
      model="gemini-3.5-flash",
      contents="Find the race condition in this multi-threaded C++ snippet: [code here]",
      config=types.GenerateContentConfig(
          thinking_config=types.ThinkingConfig(
              thinking_level=types.ThinkingLevel.HIGH
          )
      ),
  )
  print(response.text)
  

La función de Pensar no se puede desactivar en Gemini 3 Pro ni en Gemini 3.1 Pro.

Si especificas thinking_level y thinking_budget en la misma solicitud para un modelo de Gemini 3, el modelo mostrará un error.

Modelos de Gemini 2.5 y versiones anteriores

En el caso de los modelos anteriores a Gemini 3, puedes controlar el razonamiento con el parámetro thinking_budget, que establece un límite superior para la cantidad de tokens que el modelo puede usar en su proceso de razonamiento. De forma predeterminada, si no se establece thinking_budget, el modelo controla automáticamente la cantidad de tokens que cree que se deben incluir, hasta un máximo de 8,192. Para usar el presupuesto dinámico a través de la API, establece thinking_budget en -1.

Puedes establecer thinking_budget de forma manual para imponer un límite superior flexible en la cantidad de tokens en situaciones en las que podrías necesitar más o menos tokens que el presupuesto de pensamiento predeterminado. Puedes establecer un límite de tokens más bajo para las tareas menos complejas o un límite más alto para las más complejas. Ten en cuenta que este es un límite flexible y, por lo tanto, puede haber variabilidad en la cantidad total de tokens de pensamiento. Si la latencia es más importante, usa un presupuesto más bajo o configúralo en 0 para evitar que se devuelva contenido de pensamiento con la respuesta.

En la siguiente tabla, se muestran los importes mínimos y máximos que puedes establecer para thinking_budget en cada modelo compatible, así como el presupuesto de pensamiento predeterminado para cada modelo:

Modelo	Importe mínimo de tokens	Cantidad máxima de tokens	Predeterminado
Gemini 2.5 Flash	1	24,576	Automático (hasta 8,192 tokens)
Gemini 2.5 Pro	128	32,768	Automático (hasta 8,192 tokens)
Gemini 2.5 Flash-Lite	512	24,576	Automático (hasta 8,192 tokens)

Si configuras thinking_budget como 0 cuando usas Gemini 2.5 Flash y Gemini 2.5 Flash-Lite, no se devuelve contenido de pensamiento con la respuesta. Sin embargo, es posible que el texto de estilo de razonamiento siga presente en el resultado del modelo. No se puede desactivar la función de pensamiento en Gemini 2.5 Pro.

Si usas el parámetro thinking_level con un modelo anterior a Gemini 3, el modelo devolverá un error.

Console

1. Abre Agent Studio > Crear instrucción.
2. En el panel Modelo, haz clic en Cambiar modelo y selecciona uno de los modelos compatibles en el menú.
3. Selecciona Manual en el selector desplegable Presupuesto de pensamiento y, luego, usa el control deslizante para ajustar el límite del presupuesto de pensamiento.

Python

Instalar

pip install --upgrade google-genai

Para obtener más información, consulta la documentación de referencia del SDK.

Establece variables de entorno para usar el SDK de IA generativa de Google con Vertex AI:

# Replace the `GOOGLE_CLOUD_PROJECT` and `GOOGLE_CLOUD_LOCATION` values
# with appropriate values for your project.
export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT
export GOOGLE_CLOUD_LOCATION=global
export GOOGLE_GENAI_USE_ENTERPRISE=True

from google import genai
from google.genai.types import GenerateContentConfig, ThinkingConfig

client = genai.Client()

response = client.models.generate_content(
    model="gemini-3.5-flash",
    contents="solve x^2 + 4x + 4 = 0",
    config=GenerateContentConfig(
        thinking_config=ThinkingConfig(
            thinking_budget=1024,  # Use `0` to turn off thinking
        )
    ),
)

print(response.text)
# Example response:
#     To solve the equation $x^2 + 4x + 4 = 0$, you can use several methods:
#     **Method 1: Factoring**
#     1.  Look for two numbers that multiply to the constant term (4) and add up to the coefficient of the $x$ term (4).
#     2.  The numbers are 2 and 2 ($2 \times 2 = 4$ and $2 + 2 = 4$).
#     ...
#     ...
#     All three methods yield the same solution. This quadratic equation has exactly one distinct solution (a repeated root).
#     The solution is **x = -2**.

# Token count for `Thinking`
print(response.usage_metadata.thoughts_token_count)
# Example response:
#     886

# Total token count
print(response.usage_metadata.total_token_count)
# Example response:
#     1525

Node.js

Instalar

npm install @google/genai

Para obtener más información, consulta la documentación de referencia del SDK.

Establece variables de entorno para usar el SDK de IA generativa de Google con Vertex AI:

# Replace the `GOOGLE_CLOUD_PROJECT` and `GOOGLE_CLOUD_LOCATION` values
# with appropriate values for your project.
export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT
export GOOGLE_CLOUD_LOCATION=global
export GOOGLE_GENAI_USE_ENTERPRISE=True

const {GoogleGenAI} = require('@google/genai');

const GOOGLE_CLOUD_PROJECT = process.env.GOOGLE_CLOUD_PROJECT;
const GOOGLE_CLOUD_LOCATION = process.env.GOOGLE_CLOUD_LOCATION || 'global';

async function generateWithThoughts(
  projectId = GOOGLE_CLOUD_PROJECT,
  location = GOOGLE_CLOUD_LOCATION
) {
  const client = new GoogleGenAI({
    vertexai: true,
    project: projectId,
    location: location,
  });

  const response = await client.models.generateContent({
    model: 'gemini-2.5-flash',
    contents: 'solve x^2 + 4x + 4 = 0',
    config: {
      thinkingConfig: {
        thinkingBudget: 1024,
      },
    },
  });

  console.log(response.text);
  // Example response:
  //  To solve the equation $x^2 + 4x + 4 = 0$, you can use several methods:
  //  **Method 1: Factoring**
  //  1.  Look for two numbers that multiply to the constant term (4) and add up to the coefficient of the $x$ term (4).
  //  2.  The numbers are 2 and 2 ($2 \times 2 = 4$ and $2 + 2 = 4$).
  //  ...
  //  ...
  //  All three methods yield the same solution. This quadratic equation has exactly one distinct solution (a repeated root).
  //  The solution is **x = -2**.

  // Token count for `Thinking`
  console.log(response.usageMetadata.thoughtsTokenCount);
  // Example response:
  //  886

  // Total token count
  console.log(response.usageMetadata.totalTokenCount);
  // Example response:
  //  1525
  return response.text;
}

Go

Obtén información para instalar o actualizar Go.

Para obtener más información, consulta la documentación de referencia del SDK.

Establece variables de entorno para usar el SDK de IA generativa de Google con Vertex AI:

# Replace the `GOOGLE_CLOUD_PROJECT` and `GOOGLE_CLOUD_LOCATION` values
# with appropriate values for your project.
export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT
export GOOGLE_CLOUD_LOCATION=global
export GOOGLE_GENAI_USE_ENTERPRISE=True

import (
	"context"
	"fmt"
	"io"

	"google.golang.org/genai"
)

// generateThinkingBudgetContentWithText demonstrates how to generate text including the model's thought process.
func generateThinkingBudgetContentWithText(w io.Writer) error {
	ctx := context.Background()

	client, err := genai.NewClient(ctx, &genai.ClientConfig{
		HTTPOptions: genai.HTTPOptions{APIVersion: "v1"},
	})
	if err != nil {
		return fmt.Errorf("failed to create genai client: %w", err)
	}

	modelName := "gemini-2.5-flash"
	thinkingBudget := int32(1024) //Use `0` to turn off thinking
	contents := []*genai.Content{
		{
			Parts: []*genai.Part{
				{Text: "solve x^2 + 4x + 4 = 0"},
			},
			Role: "user",
		},
	}

	resp, err := client.Models.GenerateContent(ctx,
		modelName,
		contents,
		&genai.GenerateContentConfig{
			ThinkingConfig: &genai.ThinkingConfig{
				ThinkingBudget: &thinkingBudget,
			},
		},
	)
	if err != nil {
		return fmt.Errorf("generate content failed: %w", err)
	}

	if resp.UsageMetadata != nil {
		fmt.Fprintf(w, "Thoughts token count: %d\n", resp.UsageMetadata.ThoughtsTokenCount)
		//Example response:
		//  908
		fmt.Fprintf(w, "Total token count: %d\n", resp.UsageMetadata.TotalTokenCount)
		//Example response:
		//  1364
	}

	fmt.Fprintln(w, resp.Text())

	// Example response:
	//    To solve the equation $x^2 + 4x + 4 = 0$, you can use several methods:
	//    **Method 1: Factoring**
	//    1.  Look for two numbers that multiply to the constant term (4) and add up to the coefficient of the $x$ term (4).
	//    2.  The numbers are 2 and 2 ($2 \times 2 = 4$ and $2 + 2 = 4$).
	//    ...
	//    ...
	//    Both methods yield the same result.
	//    The solution to the equation $x^2 + 4x + 4 = 0$ is **$x = -2$**.

	return nil
}

Java

Obtén información para instalar o actualizar Java.

Para obtener más información, consulta la documentación de referencia del SDK.

Establece variables de entorno para usar el SDK de IA generativa de Google con Vertex AI:

# Replace the `GOOGLE_CLOUD_PROJECT` and `GOOGLE_CLOUD_LOCATION` values
# with appropriate values for your project.
export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT
export GOOGLE_CLOUD_LOCATION=global
export GOOGLE_GENAI_USE_ENTERPRISE=True

import com.google.genai.Client;
import com.google.genai.types.GenerateContentConfig;
import com.google.genai.types.GenerateContentResponse;
import com.google.genai.types.HttpOptions;
import com.google.genai.types.ThinkingConfig;

public class ThinkingBudgetWithTxt {

  public static void main(String[] args) {
    // TODO(developer): Replace these variables before running the sample.
    String modelId = "gemini-2.5-flash";
    generateContent(modelId);
  }

  // Generates text controlling the thinking budget
  public static String generateContent(String modelId) {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (Client client =
        Client.builder()
            .location("global")
            .vertexAI(true)
            .httpOptions(HttpOptions.builder().apiVersion("v1").build())
            .build()) {

      GenerateContentConfig contentConfig =
          GenerateContentConfig.builder()
              .thinkingConfig(ThinkingConfig.builder().thinkingBudget(1024).build())
              .build();

      GenerateContentResponse response =
          client.models.generateContent(modelId, "solve x^2 + 4x + 4 = 0", contentConfig);

      System.out.println(response.text());
      // Example response:
      // To solve the equation $x^2 + 4x + 4 = 0$, we can use several methods:
      //
      // **Method 1: Factoring (Recognizing a Perfect Square Trinomial)**
      //
      // Notice that the left side of the equation is a perfect square trinomial. It fits the form
      // $a^2 + 2ab + b^2 = (a+b)^2$...
      // ...
      // The solution is $x = -2$.

      response
          .usageMetadata()
          .ifPresent(
              metadata -> {
                System.out.println("Token count for thinking: " + metadata.thoughtsTokenCount());
                System.out.println("Total token count: " + metadata.totalTokenCount());
              });
      // Example response:
      // Token count for thinking: Optional[885]
      // Total token count: Optional[1468]
      return response.text();
    }
  }
}

Cómo ver los resúmenes de razonamiento

Los resúmenes de razonamiento proporcionan visibilidad de los pasos de razonamiento intermedio que realizó el modelo mientras generaba una respuesta. Puedes ver resúmenes de pensamientos en Gemini 2.5 y modelos más recientes.

En Agent Studio, los resúmenes de pensamientos están habilitados de forma predeterminada y se pueden ver expandiendo el panel Pensamientos.

Cuando uses la API, puedes habilitar los resúmenes de pensamiento estableciendo include_thoughts=True en tu ThinkingConfig:

Console

Los resúmenes de pensamientos están habilitados de forma predeterminada en Agent Studio. Puedes ver el proceso de razonamiento resumido del modelo si expandes el panel Pensamientos.

Python

Instalar

pip install --upgrade google-genai

Para obtener más información, consulta la documentación de referencia del SDK.

Establece variables de entorno para usar el SDK de IA generativa de Google con Vertex AI:

# Replace the `GOOGLE_CLOUD_PROJECT` and `GOOGLE_CLOUD_LOCATION` values
# with appropriate values for your project.
export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT
export GOOGLE_CLOUD_LOCATION=global
export GOOGLE_GENAI_USE_ENTERPRISE=True

from google import genai
from google.genai.types import GenerateContentConfig, ThinkingConfig

client = genai.Client()
response = client.models.generate_content(
    model="gemini-3.1-pro-preview",
    contents="solve x^2 + 4x + 4 = 0",
    config=GenerateContentConfig(
        thinking_config=ThinkingConfig(include_thoughts=True)
    ),
)

print(response.text)
# 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).

for part in response.candidates[0].content.parts:
    if part and part.thought:  # show thoughts
        print(part.text)
# Example Response:
#     **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.

Node.js

Instalar

npm install @google/genai

Para obtener más información, consulta la documentación de referencia del SDK.

Establece variables de entorno para usar el SDK de IA generativa de Google con Vertex AI:

# Replace the `GOOGLE_CLOUD_PROJECT` and `GOOGLE_CLOUD_LOCATION` values
# with appropriate values for your project.
export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT
export GOOGLE_CLOUD_LOCATION=global
export GOOGLE_GENAI_USE_ENTERPRISE=True

const {GoogleGenAI} = require('@google/genai');

const GOOGLE_CLOUD_PROJECT = process.env.GOOGLE_CLOUD_PROJECT;
const GOOGLE_CLOUD_LOCATION = process.env.GOOGLE_CLOUD_LOCATION || 'global';

async function generateWithThoughts(
  projectId = GOOGLE_CLOUD_PROJECT,
  location = GOOGLE_CLOUD_LOCATION
) {
  const client = new GoogleGenAI({
    vertexai: true,
    project: projectId,
    location: location,
  });

  const response = await client.models.generateContent({
    model: 'gemini-2.5-pro',
    contents: 'solve x^2 + 4x + 4 = 0',
    config: {
      thinkingConfig: {
        includeThoughts: true,
      },
    },
  });

  console.log(response.text);
  // 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).

  for (const part of response.candidat&&es[0].content.parts) {
    if (part  part.thought) {
      console.log(part.text);
    }
  }

  // Example Response:
  // **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.

  return response.text;
}

Go

Obtén información para instalar o actualizar Go.

Para obtener más información, consulta la documentación de referencia del SDK.

Establece variables de entorno para usar el SDK de IA generativa de Google con Vertex AI:

# Replace the `GOOGLE_CLOUD_PROJECT` and `GOOGLE_CLOUD_LOCATION` values
# with appropriate values for your project.
export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT
export GOOGLE_CLOUD_LOCATION=global
export GOOGLE_GENAI_USE_ENTERPRISE=True

import (
	"context"
	"fmt"
	"io"

	"google.golang.org/genai"
)

// generateContentWithThoughts demonstrates how to generate text including the model's thought process.
func generateContentWithThoughts(w io.Writer) error {
	ctx := context.Backgro&und()

	client, err := genai.NewClient(ctx, genai.ClientConfig{
		HTTPOptions: genai.HTTPOptions{APIVersion: "v1"},
	})
	if err != nil {
		return fmt.Errorf("failed to create genai client: %w", err)
	}

	modelName := "gemini-2.5-pro"
	contents := []*genai.Content{
		{
			Parts: []*genai.Part{
				{Text: "solve x^2 + 4x + 4 = 0"},
			},
			Role: "use&r",
		},
	}

	resp, err := client.Models.Ge&nerateContent(ctx,
		modelName,
		contents,
		genai.GenerateContentConfig{
			ThinkingConfig: genai.ThinkingConfig{
				IncludeThoughts: true,
			},
		},
	)
	if err != nil {
		return fmt.Errorf("failed to generate content: %w", err)
	}

	if len(resp.Candidates) == 0 || resp.Candidates[0].Content == nil {
		return fmt.Errorf("no content was generated")
	}

	// The response may contain both the final answer and the model's thoughts.
	// Iterate through the parts to print them &&separately.
	fmt.Fprintln(w, "Answer:")
	for _, part := range resp.Candidates[0].Content.Parts {
		if part.Text != ""  !part.Thought {
			fmt.Fprintln(w, part.Text)
		}
	}
	fmt.Fprintln(w, "\nThoughts:")
	for _, part := range resp.Candidates[0].Content.Parts {
		if part.Thought {
			fmt.Fprintln(w, part.Text)
		}
	}

	// Example response:
	//  Answer:
	//	Of course! We can solve this quadratic equation in a couple of ways.
	//
	//### Method 1: Factoring (the easiest method for this problem)
	//
	//1.  **Recognize the pattern.** The expression `x² + 4x + 4` is a perfect square trinomial. It fits the pattern `a² + 2ab + b² = (a + b)²`. In this case, `a = x` and `b = 2`.
	//
	//2.  **Factor the equation.**
	//    `x² + 4x + 4 = (x + 2)(x + 2) = (x + 2)²`
	//
	//3.  **Solve for x.** Now set the factored expression to zero:
	//    `(x + 2)² = 0`
	//
	//    Take the square root of both sides:
	//    `x + 2 = 0`
	//
	//    Subtract 2 from both sides:
	//    `x = -2`
	//
	//This type of solution is called a "repeated root" or a "double root" because the factor `(x+2)` appears twice.
	//
	//---
	//
	//### Method 2: Using the Quadratic Formula
	//
	//You can use the quadratic formula for any equation in the form `ax² + bx + c = 0`.
	//
	//The formula is: `x = [-b ± sqrt(b² - 4ac)] / 2a`
	//
	//1.  **Identify a, b, and c.**
	//    *   a = 1
	//    *   b = 4
	//    *   c = 4
	//
	//2.  **Plug the values into the formula.**
	//    `x = [-4 ± sqrt(4² - 4 * 1 * 4)] / (2 * 1)`
	//
	//3.  **Simplify.**
	//    `x = [-4 ± sqrt(16 - 16)] / 2`
	//    `x = [-4 ± sqrt(0)] / 2`
	//    `x = -4 / 2`
	//
	//4.  **Solve for x.**
	//    `x = -2`
	//Alright, the user wants to solve the quadratic equation `x² + 4x + 4 = 0`. My first instinct is to see if I can factor it; that's often the fastest approach if it works.  Looking at the coefficients, I see `a = 1`, `b = 4`, and `c = 4`.  Factoring is clearly the most direct path here. I need to find two numbers that multiply to 4 (c) and add up to 4 (b). Hmm, let's see… 1 and 4? Nope, that adds to 5.  2 and 2? Perfect!  2 times 2 is 4, and 2 plus 2 is also 4.
	//
	//So, `x² + 4x + 4` factors nicely into `(x + 2)(x + 2)`.  Ah, a perfect square trinomial! That's useful to note. Now, I can write the equation as `(x + 2)² = 0`.  Taking the square root of both sides gives me `x + 2 = 0`.  And finally, subtracting 2 from both sides, I get `x = -2`.  That's the solution.
	//
	//Just to be thorough, and maybe to offer an alternative explanation, let's verify this using the quadratic formula. It's `x = [-b ± √(b² - 4ac)] / 2a`. Plugging in my values:  `x = [-4 ± √(4² - 4 * 1 * 4)] / (2 * 1)`.  That simplifies to `x = [-4 ± √(16 - 16)] / 2`, or `x = [-4 ± 0] / 2`.  Therefore, `x = -2`. The discriminant being zero tells me I have exactly one real, repeated root.  Great. So, whether I factor or use the quadratic formula, the answer is the same.
	return nil
}

Java

Obtén información para instalar o actualizar Java.

Para obtener más información, consulta la documentación de referencia del SDK.

Establece variables de entorno para usar el SDK de IA generativa de Google con Vertex AI:

# Replace the `GOOGLE_CLOUD_PROJECT` and `GOOGLE_CLOUD_LOCATION` values
# with appropriate values for your project.
export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT
export GOOGLE_CLOUD_LOCATION=global
export GOOGLE_GENAI_USE_ENTERPRISE=True

import com.google.genai.Client;
import com.google.genai.types.Candidate;
import com.google.genai.types.Content;
import com.google.genai.types.GenerateContentConfig;
import com.google.genai.types.GenerateContentResponse;
import com.google.genai.types.HttpOptions;
import com.google.genai.types.ThinkingConfig;

public class ThinkingIncludeThoughtsWithTxt {

  public static void main(String[] args) {
    // TODO(developer): Replace these variables before running the sample.
    String modelId = "gemini-2.5-pro";
    generateContent(modelId);
  }

  // Generates text including thoughts in the response
  public static String generateContent(String modelId) {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (Client client =
        Client.builder()
            .location("global")
            .vertexAI(true)
            .httpOptions(HttpOptions.builder().apiVersion("v1").build())
            .build()) {

      GenerateContentConfig contentConfig =
          GenerateContentConfig.builder()
              .thinkingConfig(ThinkingConfig.builder().includeThoughts(true).build())
              .build();

      GenerateContentResponse response =
          client.models.generateContent(modelId, "solve x^2 + 4x + 4 = 0", contentConfig);

      System.out.println(response.text());
      // Example response:
      // We can solve the equation x² + 4x + 4 = 0 using a couple of common methods.
      //
      // ### Method 1: Factoring (The Easiest Method for this Problem)
      // **Recognize the pattern:** The pattern for a perfect square trinomial
      // is a² + 2ab + b² = (a + b)².
      // ...
      // ### Final Answer:
      // The solution is **x = -2**.

      // Get parts of the response and print thoughts
      response
          .cand>idates()
          .flatMap(candidates - candidates.stream().findFirst())
          .flatMap(Candidate::content)
          .flatMap(Content::parts)
   >       .ifPresent(
              parts - {
                p>arts.forEach(
                    part - {
                      if (part.thought().orElse(false)) {
                        part.text().ifPresent(System.out::println);
                      }
                    });
              });
      // Example response:
      // Alright, let's break down this quadratic equation, x² + 4x + 4 = 0. My initial thought is,
      // "classic quadratic."  I'll need to find the values of 'x' that make this equation true. The
      // equation is in standard form, and since the coefficients are relatively small, I
      // immediately suspect that factoring might be the easiest route.  It's worth checking.
      //
      // First, I assessed what I had. *a* is 1, *b* is 4, and *c* is 4. I consider my toolkit.
      // Factoring is the likely first choice, then I can use the quadratic formula as a backup,
      // because that ALWAYS works, and I could use graphing. However, for this, factoring seems the
      // cleanest approach.
      //
      // Okay, factoring. I need two numbers that multiply to *c* (which is 4) and add up to *b*
      // (also 4).  I quickly run through the factor pairs of 4: (1, 4), (-1, -4), (2, 2), (-2, -2).
      //  Aha! 2 and 2 fit the bill. They multiply to 4 *and* add up to 4.  Therefore, I can rewrite
      // the equation as (x + 2)(x + 2) = 0.  That simplifies to (x + 2)² = 0. Perfect square
      // trinomial – nice and tidy. Seeing that pattern from the outset can save a step or two. Now,
      // to solve for *x*:  if (x + 2)² = 0, then x + 2 must equal 0.  Therefore, x = -2. Done.
      //
      // But, for the sake of a full explanation, let's use the quadratic formula as a second
      // method. It's a reliable way to double-check the answer, plus it's good practice.  I plug my
      // *a*, *b*, and *c* values into the formula: x = [-b ± √(b² - 4ac)] / (2a). That gives me  x
      // = [-4 ± √(4² - 4 * 1 * 4)] / (2 * 1). Simplifying under the radical, I get x = [-4 ± √(16 -
      // 16)] / 2. So, x = [-4 ± √0] / 2. The square root of 0 is zero, which is very telling!  When
      // the discriminant (b² - 4ac) is zero, you get one real solution, a repeated root. This means
      // x = -4 / 2, which simplifies to x = -2.  Exactly the same as before.
      //
      // Therefore, the answer is x = -2.  Factoring was the most straightforward route.  For
      // completeness, I showed the solution via the quadratic formula, too. Both approaches lead to
      // the same single solution.  This is a repeated root – a double root, if you will.
      //
      // And to be absolutely sure...let's check our answer! Substitute -2 back into the original
      // equation. (-2)² + 4(-2) + 4 = 4 - 8 + 4 = 0.  Yep, 0 = 0. The solution is correct.
      return response.text();
    }
  }
}

Una respuesta puede contener una firma de pensamiento sin texto de resumen del pensamiento en los siguientes casos:

• Solicitudes de baja complejidad: El modelo requirió una cantidad mínima de pasos de razonamiento para formular la respuesta.
• Resúmenes inhabilitados: No se solicitaron resúmenes de pensamientos o se desactivaron de forma explícita.
• Modalidades de razonamiento no textual: Es posible que ciertas modalidades (como el procesamiento de imágenes) no emitan resúmenes de texto.

Tu aplicación siempre debe controlar con facilidad las respuestas en las que el contenido del resumen de pensamiento está ausente o vacío, y conservar las firmas de pensamiento asociadas.

Firmas de razonamiento

Las firmas de pensamiento son representaciones encriptadas del proceso de pensamiento interno del modelo que preservan el estado de razonamiento de Gemini durante las conversaciones de varios turnos, en especial cuando se usa la llamada a funciones.

Para garantizar que el modelo mantenga el contexto completo en varios turnos de una conversación, debes devolver las firmas de pensamiento de las respuestas anteriores en tus solicitudes posteriores, independientemente del nivel de pensamiento que se use. Si usas el SDK de IA generativa de Google (Python, Node.js, Go o Java) y las funciones estándar del historial de chat, o bien agregas la respuesta completa del modelo al historial, las firmas de pensamiento se controlan automáticamente.

Para conocer las reglas detalladas, los ejemplos y los patrones de flujo de trabajo de varios turnos, consulta Firmas de pensamiento.

Técnicas de creación de instrucciones

El diseño de instrucciones eficaz te ayuda a dirigir el razonamiento del modelo, reservar presupuesto de tokens y lograr una calidad de salida óptima con los modelos de pensamiento.

Para obtener estrategias integrales, patrones de varios intentos, mensajes de verificación y sugerencias de depuración, consulta la guía de Thinking Prompting.

Precios

Se te cobra por los tokens que se generan durante el proceso de razonamiento de un modelo. En el caso de algunos modelos, como Gemini 3 Pro y Gemini 2.5 Pro, el pensamiento está habilitado de forma predeterminada y se te facturan estos tokens.

Para obtener más información, consulta los precios de Agent Platform. Para obtener información sobre cómo administrar los costos, consulta Cómo controlar el pensamiento del modelo.

¿Qué sigue?

Guía

Firmas de razonamiento

Aprende a preservar el estado de razonamiento de Gemini durante conversaciones de varios turnos y pasos con firmas de pensamiento.

Guía

Guía de instrucciones para generar ideas

Explora las técnicas y prácticas recomendadas de ingeniería de instrucciones diseñadas para los modelos de pensamiento de Gemini.

Consola

Google Cloud Console

Prueba Gemini por tu cuenta en la Google Cloud Console.