Pensiero di Gemini

I modelli della serie Gemini 2.5 utilizzano un "processo di pensiero" interno che migliora notevolmente le loro capacità di ragionamento e pianificazione a più passaggi, rendendoli altamente efficaci per attività complesse come programmazione, matematica avanzata e analisi dei dati.

Questa guida mostra come utilizzare le funzionalità di pensiero di Gemini tramite l'API Gemini.

Prima di iniziare

Assicurati di utilizzare un modello di serie 2.5 supportato per il pensiero. Ti consigliamo di esplorare questi modelli in AI Studio prima di approfondire l'API:

Generare contenuti con il pensiero

L'avvio di una richiesta con un modello di pensiero è simile a qualsiasi altra richiesta di generazione di contenuti. La differenza principale sta nello specificare uno dei modelli con supporto per il pensiero nel campo model, come dimostrato nel seguente esempio di generazione di testo:

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

Riepiloghi dei pensieri (sperimentale)

I riepiloghi dei pensieri offrono informazioni sul processo di ragionamento interno del modello. Questa funzionalità può essere utile per verificare l'approccio del modello e mantenere informati gli utenti durante le attività più lunghe, soprattutto se combinata con lo streaming.

Puoi attivare i riepiloghi dei pensieri impostando includeThoughts su true nella configurazione della richiesta. Puoi quindi accedere al riepilogo eseguendo l'iterazione del parametro response e controllando il valore booleano thought.parts

Ecco un esempio che mostra come attivare e recuperare i riepiloghi dei pensieri senza streaming, che restituisce un singolo riepilogo finale dei pensieri con la risposta:

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

Ecco un esempio di utilizzo del pensiero con lo streaming, che restituisce riepiloghi incrementali graduali durante la generazione:

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

Budget di pensiero

Il parametro thinkingBudget ti consente di indicare al modello il numero di token di pensiero che può utilizzare per generare una risposta. Un numero di token più elevato in genere consente un ragionamento più dettagliato, che può essere utile per affrontare attività più complesse. Se non imposti thinkingBudget, il modello aggiusterà dinamicamente il budget in base alla complessità della richiesta.

  • thinkingBudget deve essere un numero intero compreso tra 0 e 24576.
  • Se imposti il budget di pensiero su 0, il pensiero viene disattivato.
  • A seconda del prompt, il modello potrebbe superare o sottovalutare il budget di token.
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
    }
  }
}'

Prezzi

Quando il pensiero è attivo, il prezzo della risposta è la somma dei token di output e dei token di pensiero. Puoi ottenere il numero totale di token di pensiero generati dal campo thoughtsTokenCount.

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

I modelli di pensiero generano pensieri completi per migliorare la qualità della risposta finale e poi generano riepiloghi per fornire informazioni sul processo di pensiero. Pertanto, i prezzi si basano sui token di pensiero completi che il modello deve generare per creare un riepilogo, anche se solo il riepilogo viene visualizzato dall'API.

Scopri di più sui token nella guida Conteggio token.

Modelli supportati

Puoi trovare tutte le funzionalità del modello nella pagina Panoramica del modello.

Modello Riepiloghi di pensiero Budget di pensiero
Gemini 2.5 Flash ✔️ ✔️
Gemini 2.5 Pro ✔️ X

Best practice

Questa sezione include alcune indicazioni per utilizzare in modo efficiente i modelli di pensiero. Come sempre, seguendo le nostre linee guida e best practice per i prompt otterrai i risultati migliori.

Debug e gestione

  • Esamina il ragionamento: quando non ricevi la risposta prevista dai modelli di pensiero, può essere utile analizzare attentamente il processo di ragionamento di Gemini. Puoi vedere in che modo ha suddiviso l'attività ed è arrivato alla conclusione e utilizzare queste informazioni per correggere il modello in modo da ottenere i risultati corretti.

  • Fornisci indicazioni per il ragionamento: se prevedi un output particolarmente lungo, ti consigliamo di fornire indicazioni nel prompt per limitare la quantità di pensiero utilizzata dal modello. In questo modo puoi riservare più output del token per la tua risposta.

Complessità delle attività

  • Attività semplici (il pensiero potrebbe essere disattivato): per richieste semplici in cui non è richiesto un ragionamento complesso, come il recupero o la classificazione di fatti, il pensiero non è necessario. Ecco alcuni esempi:
    • "Dove è stata fondata DeepMind?"
    • "Questa email richiede una riunione o fornisce solo informazioni?"
  • Attività di media complessità (valore predefinito/un po' di pensiero): molte richieste comuni beneficiano di un certo grado di elaborazione passo passo o di una comprensione più approfondita. Gemini può utilizzare in modo flessibile la funzionalità di pensiero per attività quali:
    • Fai un'analogia tra la fotosintesi e la crescita.
    • Confronta e contrapponi le auto elettriche e le auto ibride.
  • Attività difficili (massima capacità di pensiero): per le sfide davvero complesse, il modello deve utilizzare tutte le sue capacità di ragionamento e pianificazione, spesso coinvolgendo molti passaggi interni prima di fornire una risposta. Ecco alcuni esempi:
    • Risolvi il problema 1 dell'AIME 2025: trova la somma di tutte le basi intere b > 9 per le quali 17b è un divisore di 97b.
    • Scrivi codice Python per un'applicazione web che visualizzi i dati in tempo reale del mercato azionario, inclusa l'autenticazione utente. Rendilo il più efficiente possibile.

Pensare con strumenti e funzionalità

I modelli di pensiero funzionano con tutti gli strumenti e le funzionalità di Gemini. In questo modo, i modelli possono interagire con sistemi esterni, eseguire codice o accedere a informazioni in tempo reale, incorporando i risultati nel loro ragionamento e nella risposta finale.

  • Lo strumento di ricerca consente al modello di eseguire query sulla Ricerca Google per trovare informazioni aggiornate o informazioni diverse da quelle dei dati di addestramento. Questa opzione è utile per domande su eventi recenti o argomenti molto specifici.

  • Lo strumento di esecuzione del codice consente al modello di generare ed eseguire codice Python per eseguire calcoli, manipolare i dati o risolvere problemi che sono gestiti meglio in modo algoritmico. Il modello riceve l'output del codice e può utilizzarlo nella risposta.

  • Con l'output strutturato, puoi costringere Gemini a rispondere con JSON. Questo è particolarmente utile per integrare l'output del modello nelle applicazioni.

  • La chiamata di funzione collega il modello di pensiero a strumenti e API esterni, in modo da poter ragionare su quando chiamare la funzione corretta e su quali parametri fornire.

Puoi provare esempi di utilizzo di strumenti con modelli di pensiero nel cookbook sul pensiero.

Passaggi successivi

  • Per esaminare esempi più approfonditi, ad esempio:

    • Utilizzare gli strumenti con il pensiero
    • Streaming con pensiero
    • Modificare il budget di pensiero per ottenere risultati diversi

    e altro ancora, prova il nostro Ricettario per il pensiero.

  • La copertura del pensiero è ora disponibile nella nostra guida alla compatibilità con OpenAI.

  • Per saperne di più su Gemini 2.5 Pro Preview e Gemini Flash 2.5 Thinking, visita la pagina del modello.