Se usó la API de Cloud Translation para traducir esta página.

Pensamiento de Gemini

Los modelos de la serie Gemini 2.5 usan un "proceso de pensamiento" interno que mejora significativamente sus capacidades de razonamiento y planificación de varios pasos, lo que los hace muy eficaces para tareas complejas, como programación, matemáticas avanzadas y análisis de datos.

En esta guía, se muestra cómo trabajar con las capacidades de pensamiento de Gemini con la API de Gemini.

Antes de comenzar

Asegúrate de usar un modelo de la serie 2.5 compatible para el pensamiento. Te recomendamos que explores estos modelos en AI Studio antes de comenzar a usar la API:

Genera contenido con pensamiento

Iniciar una solicitud con un modelo de pensamiento es similar a cualquier otra solicitud de generación de contenido. La diferencia clave reside en especificar uno de los modelos con compatibilidad de pensamiento en el campo model, como se muestra en el siguiente ejemplo de generación de texto:

PythonJavaScriptGoREST

from google import genai

client = genai.Client(api_key="GOOGLE_API_KEY")
prompt = "Explain the concept of Occam's Razor and provide a simple, everyday example."
response = client.models.generate_content(
    model="gemini-2.5-flash-preview-05-20",
    contents=prompt
)

print(response.text)

import { GoogleGenAI } from "@google/genai";

const ai = new GoogleGenAI({ apiKey: "GOOGLE_API_KEY" });

async function main() {
  const prompt = "Explain the concept of Occam's Razor and provide a simple, everyday example.";

  const response = await ai.models.generateContent({
    model: "gemini-2.5-flash-preview-05-20",  
    contents: prompt,
  });

  console.log(response.text);
}

main();

// import packages here

func main() {
  ctx := context.Background()
  client, err := genai.NewClient(ctx, option.WithAPIKey(os.Getenv("GOOGLE_API_KEY")))
  if err != nil {
    log.Fatal(err)
  }
  defer client.Close()

  model := client.GenerativeModel("gemini-2.5-flash-preview-05-20")  
  resp, err := model.GenerateContent(ctx, genai.Text("Explain the concept of Occam's Razor and provide a simple, everyday example."))
  if err != nil {
    log.Fatal(err)
  }
  fmt.Println(resp.Text())
}

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash-preview-05-20:generateContent?key=$GOOGLE_API_KEY" \
 -H 'Content-Type: application/json' \
 -X POST \
 -d '{
   "contents": [
     {
       "parts": [
         {
           "text": "Explain the concept of Occam\''s Razor and provide a simple, everyday example."
         }
       ]
     }
   ]
 }'
 ```

Resúmenes de pensamientos (experimental)

Los resúmenes de pensamientos ofrecen estadísticas sobre el proceso de razonamiento interno del modelo. Esta función puede ser valiosa para verificar el enfoque del modelo y mantener informados a los usuarios durante tareas más largas, especialmente cuando se combina con la transmisión.

Para habilitar los resúmenes de pensamientos, establece includeThoughts en true en la configuración de la solicitud. Luego, puedes iterar por el parts del parámetro response y verificar el valor booleano thought para acceder al resumen.

Este es un ejemplo que muestra cómo habilitar y recuperar resúmenes de pensamientos sin transmitir, lo que muestra un solo resumen de pensamientos final con la respuesta:

PythonJavaScriptGo

from google import genai
from google.genai import types

client = genai.Client(api_key="GOOGLE_API_KEY")
prompt = "What is the sum of the first 50 prime numbers?"
response = client.models.generate_content(
  model="gemini-2.5-flash-preview-05-20",
  contents=prompt,
  config=types.GenerateContentConfig(
    thinking_config=types.ThinkingConfig(
      include_thoughts=True
    )
  )
)

for part in response.candidates[0].content.parts:
  if not part.text:
    continue
  if part.thought:
    print("Thought summary:")
    print(part.text)
    print()
  else:
    print("Answer:")
    print(part.text)
    print()

import { GoogleGenAI } from "@google/genai";

const ai = new GoogleGenAI({ apiKey: "GOOGLE_API_KEY" });

async function main() {
  const response = await ai.models.generateContent({
    model: "gemini-2.5-flash-preview-05-20",
    contents: "What is the sum of the first 50 prime numbers?",
    config: {
      thinkingConfig: {
        includeThoughts: true,
      },
    },
  });

  for (const part of response.candidates[0].content.parts) {
    if (!part.text) {
      continue;
    }
    else if (part.thought) {
      console.log("Thoughts summary:");
      console.log(part.text);
    }
    else {
      console.log("Answer:");
      console.log(part.text);
    }
  }
}

main();

package main

import (
  "context"
  "fmt"
  "google.golang.org/genai"
  "os"
)

func main() {
  ctx := context.Background()
  client, _ := genai.NewClient(ctx, &genai.ClientConfig{
    APIKey:  os.Getenv("GOOGLE_API_KEY"),
    Backend: genai.BackendGeminiAPI,
  })

  contents := genai.Text("What is the sum of the first 50 prime numbers?")
  model := "gemini-2.5-flash-preview-05-20"
  resp, _ := client.Models.GenerateContent(ctx, model, contents, &genai.GenerateContentConfig{
    ThinkingConfig: &genai.ThinkingConfig{
      IncludeThoughts: true,
    },
  })

  for _, part := range resp.Candidates[0].Content.Parts {
    if part.Text != "" {
      if part.Thought {
        fmt.Println("Thoughts Summary:")
        fmt.Println(part.Text)
      } else {
        fmt.Println("Answer:")
        fmt.Println(part.Text)
      }
    }
  }
}

Este es un ejemplo de cómo pensar con transmisión, que muestra resúmenes incrementales y continuos durante la generación:

PythonJavaScript

from google import genai
from google.genai import types

client = genai.Client(api_key="GOOGLE_API_KEY")

prompt = """
Alice, Bob, and Carol each live in a different house on the same street: red, green, and blue.
The person who lives in the red house owns a cat.
Bob does not live in the green house.
Carol owns a dog.
The green house is to the left of the red house.
Alice does not own a cat.
Who lives in each house, and what pet do they own?
"""

thoughts = ""
answer = ""

for chunk in client.models.generate_content_stream(
    model="gemini-2.5-flash-preview-05-20",
    contents=prompt,
    config=types.GenerateContentConfig(
      thinking_config=types.ThinkingConfig(
        include_thoughts=True
      )
    )
):
  for part in chunk.candidates[0].content.parts:
    if not part.text:
      continue
    elif part.thought:
      if not thoughts:
        print("Thoughts summary:")
      print(part.text)
      thoughts += part.text
    else:
      if not answer:
        print("Thoughts summary:")
      print(part.text)
      answer += part.text

import { GoogleGenAI } from "@google/genai";

const ai = new GoogleGenAI({ apiKey: "GOOGLE_API_KEY" });

const prompt = `Alice, Bob, and Carol each live in a different house on the same
street: red, green, and blue. The person who lives in the red house owns a cat.
Bob does not live in the green house. Carol owns a dog. The green house is to
the left of the red house. Alice does not own a cat. Who lives in each house,
and what pet do they own?`;

let thoughts = "";
let answer = "";

async function main() {
  const response = await ai.models.generateContentStream({
    model: "gemini-2.5-flash-preview-05-20",
    contents: prompt,
    config: {
      thinkingConfig: {
        includeThoughts: true,
      },
    },
  });

  for await (const chunk of response) {
    for (const part of chunk.candidates[0].content.parts) {
      if (!part.text) {
        continue;
      } else if (part.thought) {
        if (!thoughts) {
          console.log("Thoughts summary:");
        }
        console.log(part.text);
        thoughts = thoughts + part.text;
      } else {
        if (!answer) {
          console.log("Answer:");
        }
        console.log(part.text);
        answer = answer + part.text;
      }
    }
  }
}

await main();

Presupuestos de pensamiento

El parámetro thinkingBudget te permite guiar al modelo sobre la cantidad de tokens de razonamiento que puede usar cuando genera una respuesta. Por lo general, una cantidad de tokens más alta permite un razonamiento más detallado, lo que puede ser beneficioso para abordar tareas más complejas. Si no configuras thinkingBudget, el modelo ajustará el presupuesto de forma dinámica según la complejidad de la solicitud.

thinkingBudget debe ser un número entero entre 0 y 24576.
Si estableces el presupuesto de pensamiento en 0, se inhabilita el pensamiento.
Según la instrucción, el modelo puede desbordar o quedarse por debajo del presupuesto de tokens.

PythonJavaScriptGoREST

from google import genai
from google.genai import types

client = genai.Client()

response = client.models.generate_content(
    model="gemini-2.5-flash-preview-05-20",
    contents="Provide a list of 3 famous physicists and their key contributions",
    config=types.GenerateContentConfig(
        thinking_config=types.ThinkingConfig(thinking_budget=1024)
    ),
)

print(response.text)

import { GoogleGenAI } from "@google/genai";

const ai = new GoogleGenAI({ apiKey: "GOOGLE_API_KEY" });

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

  console.log(response.text);
}

main();

package main

import (
  "context"
  "fmt"
  "google.golang.org/genai"
  "os"
)

func main() {
  ctx := context.Background()
  client, _ := genai.NewClient(ctx, &genai.ClientConfig{
    APIKey:  os.Getenv("GOOGLE_API_KEY"),
    Backend: genai.BackendGeminiAPI,
  })

  thinkingBudgetVal := int32(1024)

  contents := genai.Text("Provide a list of 3 famous physicists and their key contributions")
  model := "gemini-2.5-flash-preview-05-20"
  resp, _ := client.Models.GenerateContent(ctx, model, contents, &genai.GenerateContentConfig{
    ThinkingConfig: &genai.ThinkingConfig{
      ThinkingBudget: &thinkingBudgetVal,
    },
  })

fmt.Println(resp.Text())
}

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash-preview-05-20:generateContent?key=$GOOGLE_API_KEY" \
-H 'Content-Type: application/json' \
-X POST \
-d '{
  "contents": [
    {
      "parts": [
        {
          "text": "Provide a list of 3 famous physicists and their key contributions"
        }
      ]
    }
  ],
  "generationConfig": {
    "thinkingConfig": {
          "thinkingBudget": 1024
    }
  }
}'

Precios

Cuando se activa el pensamiento, el precio de la respuesta es la suma de los tokens de salida y los tokens de pensamiento. Puedes obtener la cantidad total de tokens de pensamiento generados desde el campo thoughtsTokenCount.

PythonJavaScriptGo

# ...
print("Thoughts tokens:",response.usage_metadata.thoughts_token_count)
print("Output tokens:",response.usage_metadata.candidates_token_count)

// ...
console.log(`Thoughts tokens: ${response.usageMetadata.thoughtsTokenCount}`);
console.log(`Output tokens: ${response.usageMetadata.candidatesTokenCount}`);

// ...
usageMetadata, err := json.MarshalIndent(response.UsageMetadata, "", "  ")
if err != nil {
  log.Fatal(err)
}
fmt.Println("Thoughts tokens:", string(usageMetadata.thoughts_token_count))
fmt.Println("Output tokens:", string(usageMetadata.candidates_token_count))

Los modelos de pensamiento generan pensamientos completos para mejorar la calidad de la respuesta final y, luego, generar resúmenes que proporcionan estadísticas sobre el proceso de pensamiento. Por lo tanto, los precios se basan en los tokens de pensamiento completos que el modelo debe generar para crear un resumen, a pesar de que solo el resumen es el resultado de la API.

Puedes obtener más información sobre los tokens en la guía Cálculo de tokens.

Modelos compatibles

Puedes encontrar todas las funciones del modelo en la página de descripción general del modelo.

Modelo	Resúmenes de pensamiento	Presupuesto de pensamiento
Gemini 2.5 Flash	✔️	✔️
Gemini 2.5 Pro	✔️	X

Prácticas recomendadas

En esta sección, se incluye orientación para usar los modelos de pensamiento de manera eficiente. Como siempre, si sigues nuestras prácticas recomendadas y la orientación sobre las indicaciones, obtendrás los mejores resultados.

Depuración y dirección

Revisa el razonamiento: Cuando no obtienes la respuesta esperada de los modelos de pensamiento, puede ser útil analizar cuidadosamente el proceso de razonamiento de Gemini. Puedes ver cómo desglosó la tarea y llegó a su conclusión, y usar esta información para corregir y obtener los resultados correctos.
Proporciona orientación en el razonamiento: Si esperas un resultado particularmente extenso, te recomendamos que proporciones orientación en la instrucción para restringir la cantidad de pensamiento que usa el modelo. Esto te permite reservar más del resultado del token para tu respuesta.

Complejidad de la tarea

Tareas fáciles (el pensamiento puede estar desactivado): Para las solicitudes directas en las que no se requiere un razonamiento complejo, como la recuperación de hechos o la clasificación, no es necesario pensar. Estos son algunos ejemplos:
- "¿Dónde se fundó DeepMind?"
- "¿Este correo electrónico solicita una reunión o solo proporciona información?"
Tareas intermedias (predeterminadas/con algo de pensamiento): Muchas solicitudes comunes se benefician de un grado de procesamiento paso a paso o de una comprensión más profunda. Gemini puede usar de forma flexible la capacidad de pensar para tareas como las siguientes:
- Haz una analogía entre la fotosíntesis y el crecimiento.
- Compara y contrasta los autos eléctricos y los híbridos.
Tareas difíciles (máxima capacidad de pensamiento): Para desafíos realmente complejos, el modelo debe activar todas sus capacidades de razonamiento y planificación, lo que a menudo implica muchos pasos internos antes de proporcionar una respuesta. Estos son algunos ejemplos:
- Resuelve el problema 1 de AIME 2025: Encuentra la suma de todas las bases de números enteros b > 9 para las que 17_b es un divisor de 97_b.
- Escribir código de Python para una aplicación web que visualice datos del mercado de valores en tiempo real, incluida la autenticación de usuarios Haz que sea lo más eficiente posible.

Pensar con herramientas y capacidades

Los modelos de pensamiento funcionan con todas las herramientas y capacidades de Gemini. Esto permite que los modelos interactúen con sistemas externos, ejecuten código o accedan a información en tiempo real, e incorporen los resultados en su razonamiento y respuesta final.

La herramienta de búsqueda permite que el modelo consulte la Búsqueda de Google para encontrar información actualizada o información más allá de sus datos de entrenamiento. Esto es útil para preguntas sobre eventos recientes o temas muy específicos.
La herramienta de ejecución de código permite que el modelo genere y ejecute código Python para realizar cálculos, manipular datos o resolver problemas que se manejan mejor de forma algorítmica. El modelo recibe el resultado del código y puede usarlo en su respuesta.
Con el resultado estructurado, puedes restringir Gemini para que responda con JSON. Esto es particularmente útil para integrar el resultado del modelo en las aplicaciones.
Las llamadas a función conectan el modelo de pensamiento a herramientas y APIs externas, de modo que pueda razonar sobre cuándo llamar a la función correcta y qué parámetros proporcionar.

Puedes probar ejemplos del uso de herramientas con modelos de pensamiento en el libro de recetas de pensamiento.

Próximos pasos

Para trabajar en ejemplos más detallados, como los siguientes:
- Cómo usar herramientas con el pensamiento
- Transmisión con pensamiento
- Cómo ajustar el presupuesto de pensamiento para obtener diferentes resultados
y mucho más, consulta nuestro libro de recetas de pensamiento.
La cobertura de pensamiento ahora está disponible en nuestra guía de Compatibilidad con OpenAI.
Para obtener más información sobre la versión preliminar de Gemini 2.5 Pro y Gemini Flash 2.5 Thinking, visita la página del modelo.