Costruire con il pensiero esteso

Il pensiero esteso offre a Claude capacità di ragionamento avanzate per compiti complessi, fornendo al contempo diversi livelli di trasparenza nel suo processo di pensiero passo dopo passo prima di fornire la risposta finale.

Modelli supportati

Il pensiero esteso è supportato nei seguenti modelli:

Claude Opus 4 (claude-opus-4-20250514)
Claude Sonnet 4 (claude-sonnet-4-20250514)
Claude Sonnet 3.7 (claude-3-7-sonnet-20250219)

Il comportamento dell’API differisce tra i modelli Claude 3.7 e Claude 4, ma le strutture dell’API rimangono esattamente le stesse.

Per maggiori informazioni, consulta Differenze nel pensiero tra le versioni dei modelli.

Come funziona il pensiero esteso

Quando il pensiero esteso è attivato, Claude crea blocchi di contenuto thinking dove produce il suo ragionamento interno. Claude incorpora le intuizioni di questo ragionamento prima di elaborare una risposta finale.

La risposta dell’API includerà blocchi di contenuto thinking, seguiti da blocchi di contenuto text.

Ecco un esempio del formato di risposta predefinito:

{
  "content": [
    {
      "type": "thinking",
      "thinking": "Analizziamo questo passo dopo passo...",
      "signature": "WaUjzkypQ2mUEVM36O2TxuC06KN8xyfbJwyem2dw3URve/op91XWHOEBLLqIOMfFG/UvLEczmEsUjavL...."
    },
    {
      "type": "text",
      "text": "In base alla mia analisi..."
    }
  ]
}

Per maggiori informazioni sul formato di risposta del pensiero esteso, consulta il Riferimento API Messages.

Come utilizzare il pensiero esteso

Ecco un esempio di utilizzo del pensiero esteso nell’API Messages:

curl https://api.anthropic.com/v1/messages \
     --header "x-api-key: $ANTHROPIC_API_KEY" \
     --header "anthropic-version: 2023-06-01" \
     --header "content-type: application/json" \
     --data \
'{
    "model": "claude-sonnet-4-20250514",
    "max_tokens": 16000,
    "thinking": {
        "type": "enabled",
        "budget_tokens": 10000
    },
    "messages": [
        {
            "role": "user",
            "content": "Ci sono un numero infinito di numeri primi tali che n mod 4 == 3?"
        }
    ]
}'

Per attivare il pensiero esteso, aggiungi un oggetto thinking, con il parametro thinking impostato su enabled e il budget_tokens su un budget di token specifico per il pensiero esteso.

Il parametro budget_tokens determina il numero massimo di token che Claude può utilizzare per il suo processo di ragionamento interno. Nei modelli Claude 4, questo limite si applica ai token di pensiero completi, e non al risultato riassunto. Budget più grandi possono migliorare la qualità della risposta consentendo un’analisi più approfondita per problemi complessi, anche se Claude potrebbe non utilizzare l’intero budget allocato, specialmente in intervalli superiori a 32k.

budget_tokens deve essere impostato su un valore inferiore a max_tokens. Tuttavia, quando si utilizza il pensiero interlacciato con gli strumenti, è possibile superare questo limite poiché il limite di token diventa l’intera finestra di contesto (200k token).

Pensiero riassunto

Con il pensiero esteso abilitato, l’API Messages per i modelli Claude 4 restituisce un riassunto del processo di pensiero completo di Claude. Il pensiero riassunto fornisce tutti i vantaggi di intelligenza del pensiero esteso, prevenendo al contempo l’uso improprio.

Ecco alcune considerazioni importanti per il pensiero riassunto:

Ti viene addebitato il costo dei token di pensiero completi generati dalla richiesta originale, non dei token del riassunto.
Il conteggio dei token di output addebitati non corrisponderà al conteggio dei token che vedi nella risposta.
Le prime righe dell’output di pensiero sono più dettagliate, fornendo un ragionamento dettagliato particolarmente utile per scopi di ingegneria dei prompt.
Poiché Anthropic cerca di migliorare la funzionalità di pensiero esteso, il comportamento di riassunto è soggetto a modifiche.
Il riassunto preserva le idee chiave del processo di pensiero di Claude con una latenza aggiunta minima, consentendo un’esperienza utente fluida e una facile migrazione dai modelli Claude 3.7 ai modelli Claude 4.
Il riassunto viene elaborato da un modello diverso da quello che hai scelto nelle tue richieste. Il modello di pensiero non vede l’output riassunto.

Claude Sonnet 3.7 continua a restituire l’output di pensiero completo.

Nei rari casi in cui hai bisogno di accedere all’output di pensiero completo per i modelli Claude 4, contatta il nostro team di vendita.

Streaming del pensiero

Puoi trasmettere in streaming le risposte di pensiero esteso utilizzando eventi inviati dal server (SSE).

Quando lo streaming è abilitato per il pensiero esteso, ricevi contenuti di pensiero tramite eventi thinking_delta.

Per ulteriore documentazione sullo streaming tramite l’API Messages, consulta Streaming Messages.

Ecco come gestire lo streaming con il pensiero:

curl https://api.anthropic.com/v1/messages \
     --header "x-api-key: $ANTHROPIC_API_KEY" \
     --header "anthropic-version: 2023-06-01" \
     --header "content-type: application/json" \
     --data \
'{
    "model": "claude-sonnet-4-20250514",
    "max_tokens": 16000,
    "stream": true,
    "thinking": {
        "type": "enabled",
        "budget_tokens": 10000
    },
    "messages": [
        {
            "role": "user",
            "content": "Quanto fa 27 * 453?"
        }
    ]
}'

Esempio di output di streaming:

event: message_start
data: {"type": "message_start", "message": {"id": "msg_01...", "type": "message", "role": "assistant", "content": [], "model": "claude-sonnet-4-20250514", "stop_reason": null, "stop_sequence": null}}

event: content_block_start
data: {"type": "content_block_start", "index": 0, "content_block": {"type": "thinking", "thinking": ""}}

event: content_block_delta
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "thinking_delta", "thinking": "Risolviamo questo passo dopo passo:\n\n1. Prima scomponiamo 27 * 453"}}

event: content_block_delta
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "thinking_delta", "thinking": "\n2. 453 = 400 + 50 + 3"}}

// Ulteriori delta di pensiero...

event: content_block_delta
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "signature_delta", "signature": "EqQBCgIYAhIM1gbcDa9GJwZA2b3hGgxBdjrkzLoky3dl1pkiMOYds..."}}

event: content_block_stop
data: {"type": "content_block_stop", "index": 0}

event: content_block_start
data: {"type": "content_block_start", "index": 1, "content_block": {"type": "text", "text": ""}}

event: content_block_delta
data: {"type": "content_block_delta", "index": 1, "delta": {"type": "text_delta", "text": "27 * 453 = 12.231"}}

// Ulteriori delta di testo...

event: content_block_stop
data: {"type": "content_block_stop", "index": 1}

event: message_delta
data: {"type": "message_delta", "delta": {"stop_reason": "end_turn", "stop_sequence": null}}

event: message_stop
data: {"type": "message_stop"}

Quando utilizzi lo streaming con il pensiero abilitato, potresti notare che il testo a volte arriva in blocchi più grandi alternati con consegne più piccole, token per token. Questo è un comportamento previsto, specialmente per i contenuti di pensiero.

Il sistema di streaming deve elaborare i contenuti in batch per prestazioni ottimali, il che può risultare in questo modello di consegna “a blocchi”, con possibili ritardi tra gli eventi di streaming. Stiamo lavorando continuamente per migliorare questa esperienza, con aggiornamenti futuri focalizzati sul rendere più fluido lo streaming dei contenuti di pensiero.

Pensiero esteso con l’uso di strumenti

Il pensiero esteso può essere utilizzato insieme all’uso di strumenti, permettendo a Claude di ragionare sulla selezione degli strumenti e sull’elaborazione dei risultati.

Quando si utilizza il pensiero esteso con l’uso di strumenti, è necessario essere consapevoli delle seguenti limitazioni:

Limitazione nella scelta degli strumenti: L’uso di strumenti con il pensiero supporta solo tool_choice: any (non specific, auto o altri valori).
Preservare i blocchi di pensiero: Durante l’uso degli strumenti, è necessario passare i blocchi thinking all’API per l’ultimo messaggio dell’assistente. Includi il blocco completo non modificato all’API per mantenere la continuità del ragionamento.

Esempio: Passare blocchi di pensiero con risultati degli strumenti

Ecco un esempio pratico che mostra come preservare i blocchi di pensiero quando si forniscono risultati degli strumenti:

weather_tool = {
    "name": "get_weather",
    "description": "Ottieni il meteo attuale per una località",
    "input_schema": {
        "type": "object",
        "properties": {
            "location": {"type": "string"}
        },
        "required": ["location"]
    }
}

# Prima richiesta - Claude risponde con pensiero e richiesta di strumento
response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000
    },
    tools=[weather_tool],
    messages=[
        {"role": "user", "content": "Che tempo fa a Parigi?"}
    ]
)

La risposta dell’API includerà blocchi di pensiero, testo e tool_use:

{
    "content": [
        {
            "type": "thinking",
            "thinking": "L'utente vuole sapere il meteo attuale a Parigi. Ho accesso a una funzione `get_weather`...",
            "signature": "BDaL4VrbR2Oj0hO4XpJxT28J5TILnCrrUXoKiiNBZW9P+nr8XSj1zuZzAl4egiCCpQNvfyUuFFJP5CncdYZEQPPmLxYsNrcs...."
        },
        {
            "type": "text",
            "text": "Posso aiutarti a ottenere le informazioni meteo attuali per Parigi. Lascia che controlli per te"
        },
        {
            "type": "tool_use",
            "id": "toolu_01CswdEQBMshySk6Y9DFKrfq",
            "name": "get_weather",
            "input": {
                "location": "Paris"
            }
        }
    ]
}

Ora continuiamo la conversazione e utilizziamo lo strumento

# Estrai il blocco di pensiero e il blocco di utilizzo dello strumento
thinking_block = next((block for block in response.content
                      if block.type == 'thinking'), None)
tool_use_block = next((block for block in response.content
                      if block.type == 'tool_use'), None)

# Chiama la tua API meteo reale, qui è dove andrebbe la tua chiamata API effettiva
# fingiamo che questo sia ciò che otteniamo
weather_data = {"temperature": 88}

# Seconda richiesta - Includi il blocco di pensiero e il risultato dello strumento
# Nessun nuovo blocco di pensiero verrà generato nella risposta
continuation = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000
    },
    tools=[weather_tool],
    messages=[
        {"role": "user", "content": "Che tempo fa a Parigi?"},
        # nota che il thinking_block viene passato insieme al tool_use_block
        # se questo non viene passato, viene generato un errore
        {"role": "assistant", "content": [thinking_block, tool_use_block]},
        {"role": "user", "content": [{
            "type": "tool_result",
            "tool_use_id": tool_use_block.id,
            "content": f"Temperatura attuale: {weather_data['temperature']}°F"
        }]}
    ]
)

La risposta dell’API ora includerà solo testo

{
    "content": [
        {
            "type": "text",
            "text": "Attualmente a Parigi, la temperatura è di 88°F (31°C)"
        }
    ]
}

Preservare i blocchi di pensiero

Durante l’uso degli strumenti, è necessario passare i blocchi thinking all’API, e devi includere il blocco completo non modificato all’API. Questo è fondamentale per mantenere il flusso di ragionamento del modello e l’integrità della conversazione.

Sebbene sia possibile omettere i blocchi thinking dai turni precedenti con ruolo assistant, suggeriamo di passare sempre tutti i blocchi di pensiero all’API per qualsiasi conversazione multi-turno. L’API:

Filtrerà automaticamente i blocchi di pensiero forniti
Utilizzerà i blocchi di pensiero rilevanti necessari per preservare il ragionamento del modello
Addebiterà solo i token di input per i blocchi mostrati a Claude

Quando Claude invoca gli strumenti, sta mettendo in pausa la costruzione di una risposta per attendere informazioni esterne. Quando vengono restituiti i risultati degli strumenti, Claude continuerà a costruire quella risposta esistente. Questo rende necessario preservare i blocchi di pensiero durante l’uso degli strumenti, per un paio di motivi:

Continuità del ragionamento: I blocchi di pensiero catturano il ragionamento passo dopo passo di Claude che ha portato alle richieste di strumenti. Quando pubblichi i risultati degli strumenti, includere il pensiero originale garantisce che Claude possa continuare il suo ragionamento da dove si era interrotto.
Mantenimento del contesto: Mentre i risultati degli strumenti appaiono come messaggi utente nella struttura dell’API, fanno parte di un flusso di ragionamento continuo. Preservare i blocchi di pensiero mantiene questo flusso concettuale attraverso più chiamate API. Per maggiori informazioni sulla gestione del contesto, consulta la nostra guida sulle finestre di contesto.

Importante: Quando fornisci blocchi thinking, l’intera sequenza di blocchi thinking consecutivi deve corrispondere agli output generati dal modello durante la richiesta originale; non puoi riorganizzare o modificare la sequenza di questi blocchi.

Pensiero interlacciato

Il pensiero esteso con l’uso di strumenti nei modelli Claude 4 supporta il pensiero interlacciato, che consente a Claude di pensare tra le chiamate agli strumenti e di fare ragionamenti più sofisticati dopo aver ricevuto i risultati degli strumenti.

Con il pensiero interlacciato, Claude può:

Ragionare sui risultati di una chiamata a uno strumento prima di decidere cosa fare dopo
Concatenare più chiamate a strumenti con passaggi di ragionamento intermedi
Prendere decisioni più sfumate basate su risultati intermedi

Per abilitare il pensiero interlacciato, aggiungi l’header beta interleaved-thinking-2025-05-14 alla tua richiesta API.

Il pensiero interlacciato è supportato solo per gli strumenti utilizzati tramite l’API Messages.

Con il pensiero interlacciato, il budget_tokens può superare il parametro max_tokens poiché rappresenta il budget totale per tutti i blocchi di pensiero all’interno di un singolo turno dell’assistente.

Uso degli strumenti senza pensiero interlacciato

import anthropic

client = anthropic.Anthropic()

# Definisci gli strumenti
calculator_tool = {
    "name": "calculator",
    "description": "Esegui calcoli matematici",
    "input_schema": {
        "type": "object",
        "properties": {
            "expression": {
                "type": "string",
                "description": "Espressione matematica da valutare"
            }
        },
        "required": ["expression"]
    }
}

database_tool = {
    "name": "database_query",
    "description": "Interroga il database dei prodotti",
    "input_schema": {
        "type": "object",
        "properties": {
            "query": {
                "type": "string",
                "description": "Query SQL da eseguire"
            }
        },
        "required": ["query"]
    }
}

# Prima richiesta - Claude pensa una volta prima di tutte le chiamate agli strumenti
response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000
    },
    tools=[calculator_tool, database_tool],
    messages=[{
        "role": "user",
        "content": "Qual è il ricavo totale se abbiamo venduto 150 unità del prodotto A a $50 ciascuna, e come si confronta con il nostro ricavo mensile medio dal database?"
    }]
)

# La risposta include il pensiero seguito dagli usi degli strumenti
# Nota: Claude pensa una volta all'inizio, poi prende tutte le decisioni sugli strumenti
print("Prima risposta:")
for block in response.content:
    if block.type == "thinking":
        print(f"Pensiero (riassunto): {block.thinking}")
    elif block.type == "tool_use":
        print(f"Uso dello strumento: {block.name} con input {block.input}")
    elif block.type == "text":
        print(f"Testo: {block.text}")

# Dovresti eseguire gli strumenti e restituire i risultati...
# Dopo aver ricevuto entrambi i risultati degli strumenti, Claude risponde direttamente senza pensiero aggiuntivo

In questo esempio senza pensiero interlacciato:

Claude pensa una volta all’inizio per comprendere il compito
Prende tutte le decisioni sull’uso degli strumenti in anticipo
Quando vengono restituiti i risultati degli strumenti, Claude fornisce immediatamente una risposta senza pensiero aggiuntivo

Uso degli strumenti con pensiero interlacciato

import anthropic

client = anthropic.Anthropic()

# Stesse definizioni degli strumenti di prima
calculator_tool = {
    "name": "calculator",
    "description": "Esegui calcoli matematici",
    "input_schema": {
        "type": "object",
        "properties": {
            "expression": {
                "type": "string",
                "description": "Espressione matematica da valutare"
            }
        },
        "required": ["expression"]
    }
}

database_tool = {
    "name": "database_query",
    "description": "Interroga il database dei prodotti",
    "input_schema": {
        "type": "object",
        "properties": {
            "query": {
                "type": "string",
                "description": "Query SQL da eseguire"
            }
        },
        "required": ["query"]
    }
}

# Prima richiesta con pensiero interlacciato abilitato
response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000
    },
    tools=[calculator_tool, database_tool],
    # Abilita il pensiero interlacciato con l'header beta
    extra_headers={
        "anthrop-beta": "interleaved-thinking-2025-05-14"
    },
    messages=[{
        "role": "user",
        "content": "Qual è il ricavo totale se abbiamo venduto 150 unità del prodotto A a $50 ciascuna, e come si confronta con il nostro ricavo mensile medio dal database?"
    }]
)

print("Risposta iniziale:")
thinking_blocks = []
tool_use_blocks = []

for block in response.content:
    if block.type == "thinking":
        thinking_blocks.append(block)
        print(f"Pensiero: {block.thinking}")
    elif block.type == "tool_use":
        tool_use_blocks.append(block)
        print(f"Uso dello strumento: {block.name} con input {block.input}")
    elif block.type == "text":
        print(f"Testo: {block.text}")

# Primo risultato dello strumento (calcolatrice)
calculator_result = "7500"  # 150 * 50

# Continua con il primo risultato dello strumento
response2 = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000
    },
    tools=[calculator_tool, database_tool],
    extra_headers={
        "anthrop-beta": "interleaved-thinking-2025-05-14"
    },
    messages=[
        {
            "role": "user",
            "content": "Qual è il ricavo totale se abbiamo venduto 150 unità del prodotto A a $50 ciascuna, e come si confronta con il nostro ricavo mensile medio dal database?"
        },
        {
            "role": "assistant",
            "content": [thinking_blocks[0], tool_use_blocks[0]]
        },
        {
            "role": "user",
            "content": [{
                "type": "tool_result",
                "tool_use_id": tool_use_blocks[0].id,
                "content": calculator_result
            }]
        }
    ]
)

print("\nDopo il risultato della calcolatrice:")
# Con il pensiero interlacciato, Claude può pensare al risultato della calcolatrice
# prima di decidere di interrogare il database
for block in response2.content:
    if block.type == "thinking":
        thinking_blocks.append(block)
        print(f"Pensiero interlacciato: {block.thinking}")
    elif block.type == "tool_use":
        tool_use_blocks.append(block)
        print(f"Uso dello strumento: {block.name} con input {block.input}")

# Secondo risultato dello strumento (database)
database_result = "5200"  # Esempio di ricavo mensile medio

# Continua con il secondo risultato dello strumento
response3 = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000
    },
    tools=[calculator_tool, database_tool],
    extra_headers={
        "anthrop-beta": "interleaved-thinking-2025-05-14"
    },
    messages=[
        {
            "role": "user",
            "content": "Qual è il ricavo totale se abbiamo venduto 150 unità del prodotto A a $50 ciascuna, e come si confronta con il nostro ricavo mensile medio dal database?"
        },
        {
            "role": "assistant",
            "content": [thinking_blocks[0], tool_use_blocks[0]]
        },
        {
            "role": "user",
            "content": [{
                "type": "tool_result",
                "tool_use_id": tool_use_blocks[0].id,
                "content": calculator_result
            }]
        },
        {
            "role": "assistant",
            "content": thinking_blocks[1:] + tool_use_blocks[1:]
        },
        {
            "role": "user",
            "content": [{
                "type": "tool_result",
                "tool_use_id": tool_use_blocks[1].id,
                "content": database_result
            }]
        }
    ]
)

print("\nDopo il risultato del database:")
# Con il pensiero interlacciato, Claude può pensare a entrambi i risultati
# prima di formulare la risposta finale
for block in response3.content:
    if block.type == "thinking":
        print(f"Pensiero finale: {block.thinking}")
    elif block.type == "text":
        print(f"Risposta finale: {block.text}")

In questo esempio con pensiero interlacciato:

Claude pensa inizialmente al compito
Dopo aver ricevuto il risultato della calcolatrice, Claude può pensare di nuovo a cosa significa quel risultato
Claude decide quindi come interrogare il database in base al primo risultato
Dopo aver ricevuto il risultato del database, Claude pensa ancora una volta a entrambi i risultati prima di formulare una risposta finale
Il budget di pensiero è distribuito tra tutti i blocchi di pensiero all’interno del turno

Questo modello consente catene di ragionamento più sofisticate in cui l’output di ogni strumento informa la decisione successiva.

Pensiero esteso con caching dei prompt

Il caching dei prompt con il pensiero ha diverse considerazioni importanti:

Rimozione del contesto dei blocchi di pensiero

I blocchi di pensiero dai turni precedenti vengono rimossi dal contesto, il che può influenzare i punti di interruzione della cache
Quando si continuano conversazioni con l’uso di strumenti, i blocchi di pensiero vengono memorizzati nella cache e contano come token di input quando vengono letti dalla cache
Questo crea un compromesso: mentre i blocchi di pensiero non consumano spazio nella finestra di contesto visivamente, contano comunque per l’utilizzo dei token di input quando sono memorizzati nella cache
Se il pensiero viene disabilitato, le richieste falliranno se passi contenuti di pensiero nel turno di utilizzo dello strumento corrente. In altri contesti, i contenuti di pensiero passati all’API vengono semplicemente ignorati

Modelli di invalidazione della cache

Le modifiche ai parametri di pensiero (abilitato/disabilitato o allocazione del budget) invalidano i punti di interruzione della cache dei messaggi
Il pensiero interlacciato amplifica l’invalidazione della cache, poiché i blocchi di pensiero possono verificarsi tra più chiamate a strumenti
I prompt di sistema e gli strumenti rimangono memorizzati nella cache nonostante le modifiche ai parametri di pensiero o la rimozione dei blocchi

Mentre i blocchi di pensiero vengono rimossi per il caching e i calcoli del contesto, devono essere preservati quando si continuano conversazioni con l’uso di strumenti, specialmente con il pensiero interlacciato.

Comprendere il comportamento di caching dei blocchi di pensiero

Quando si utilizza il pensiero esteso con l’uso di strumenti, i blocchi di pensiero mostrano un comportamento di caching specifico che influisce sul conteggio dei token:

Come funziona:

Il caching si verifica solo quando fai una richiesta successiva che include risultati degli strumenti
Quando viene effettuata la richiesta successiva, la cronologia della conversazione precedente (inclusi i blocchi di pensiero) può essere memorizzata nella cache
Questi blocchi di pensiero memorizzati nella cache contano come token di input nelle tue metriche di utilizzo quando vengono letti dalla cache
Quando viene incluso un blocco utente non relativo ai risultati degli strumenti, tutti i blocchi di pensiero precedenti vengono ignorati e rimossi dal contesto

Esempio dettagliato di flusso:

Richiesta 1:

Utente: "Che tempo fa a Parigi?"

Risposta 1:

[thinking_block_1] + [tool_use block 1]

Richiesta 2:

Utente: ["Che tempo fa a Parigi?"], 
Assistente: [thinking_block_1] + [tool_use block 1], 
Utente: [tool_result_1, cache=True]

Risposta 2:

[thinking_block_2] + [text block 2]

La richiesta 2 scrive una cache del contenuto della richiesta (non della risposta). La cache include il messaggio utente originale, il primo blocco di pensiero, il blocco di utilizzo dello strumento e il risultato dello strumento.

Richiesta 3:

Utente: ["Che tempo fa a Parigi?"], 
Assistente: [thinking_block_1] + [tool_use block 1], 
Utente: [tool_result_1, cache=True], 
Assistente: [thinking_block_2] + [text block 2], 
Utente: [Risposta testuale, cache=True]

Poiché è stato incluso un blocco utente non relativo ai risultati degli strumenti, tutti i blocchi di pensiero precedenti vengono ignorati. Questa richiesta verrà elaborata allo stesso modo di:

Utente: ["Che tempo fa a Parigi?"], 
Assistente: [tool_use block 1], 
Utente: [tool_result_1, cache=True], 
Assistente: [text block 2], 
Utente: [Risposta testuale, cache=True]

Punti chiave:

Questo comportamento di caching avviene automaticamente, anche senza marcatori espliciti cache_control
Questo comportamento è coerente sia che si utilizzi il pensiero regolare o il pensiero interlacciato

Caching del prompt di sistema (preservato quando il pensiero cambia)

from anthropic import Anthropic
import requests
from bs4 import BeautifulSoup

client = Anthropic()

def fetch_article_content(url):
    response = requests.get(url)
    soup = BeautifulSoup(response.content, 'html.parser')

    # Rimuovi elementi script e style
    for script in soup(["script", "style"]):
        script.decompose()

    # Ottieni il testo
    text = soup.get_text()

    # Dividi in righe e rimuovi spazi iniziali e finali su ciascuna
    lines = (line.strip() for line in text.splitlines())
    # Dividi i titoli multipli in una riga ciascuno
    chunks = (phrase.strip() for line in lines for phrase in line.split("  "))
    # Elimina le righe vuote
    text = '\n'.join(chunk for chunk in chunks if chunk)

    return text

# Recupera il contenuto dell'articolo
book_url = "https://www.gutenberg.org/cache/epub/1342/pg1342.txt"
book_content = fetch_article_content(book_url)
# Usa solo il testo sufficiente per il caching (primi capitoli)
LARGE_TEXT = book_content[:5000]

SYSTEM_PROMPT=[
    {
        "type": "text",
        "text": "Sei un assistente AI incaricato di analisi letteraria. Analizza attentamente il seguente testo.",
    },
    {
        "type": "text",
        "text": LARGE_TEXT,
        "cache_control": {"type": "ephemeral"}
    }
]

MESSAGES = [
    {
        "role": "user",
        "content": "Analizza il tono di questo passaggio."
    }
]

# Prima richiesta - stabilisci la cache
print("Prima richiesta - stabilisco la cache")
response1 = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=20000,
    thinking={
        "type": "enabled",
        "budget_tokens": 4000
    },
    system=SYSTEM_PROMPT,
    messages=MESSAGES
)

print(f"Utilizzo della prima risposta: {response1.usage}")

MESSAGES.append({
    "role": "assistant",
    "content": response1.content
})
MESSAGES.append({
    "role": "user",
    "content": "Analizza i personaggi in questo passaggio."
})
# Seconda richiesta - stessi parametri di pensiero (previsto hit della cache)
print("\nSeconda richiesta - stessi parametri di pensiero (previsto hit della cache)")
response2 = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=20000,
    thinking={
        "type": "enabled",
        "budget_tokens": 4000
    },
    system=SYSTEM_PROMPT,
    messages=MESSAGES
)

print(f"Utilizzo della seconda risposta: {response2.usage}")

# Terza richiesta - parametri di pensiero diversi (miss della cache per i messaggi)
print("\nTerza richiesta - parametri di pensiero diversi (miss della cache per i messaggi)")
response3 = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=20000,
    thinking={
        "type": "enabled",
        "budget_tokens": 8000  # Budget di pensiero modificato
    },
    system=SYSTEM_PROMPT,  # Il prompt di sistema rimane nella cache
    messages=MESSAGES  # La cache dei messaggi viene invalidata
)

print(f"Utilizzo della terza risposta: {response3.usage}")

Caching dei messaggi (invalidato quando il pensiero cambia)

from anthropic import Anthropic
import requests
from bs4 import BeautifulSoup

client = Anthropic()

def fetch_article_content(url):
    response = requests.get(url)
    soup = BeautifulSoup(response.content, 'html.parser')

    # Rimuovi elementi script e style
    for script in soup(["script", "style"]):
        script.decompose()

    # Ottieni il testo
    text = soup.get_text()

    # Dividi in righe e rimuovi spazi iniziali e finali su ciascuna
    lines = (line.strip() for line in text.splitlines())
    # Dividi i titoli multipli in una riga ciascuno
    chunks = (phrase.strip() for line in lines for phrase in line.split("  "))
    # Elimina le righe vuote
    text = '\n'.join(chunk for chunk in chunks if chunk)

    return text

# Recupera il contenuto dell'articolo
book_url = "https://www.gutenberg.org/cache/epub/1342/pg1342.txt"
book_content = fetch_article_content(book_url)
# Usa solo il testo sufficiente per il caching (primi capitoli)
LARGE_TEXT = book_content[:5000]

# Nessun prompt di sistema - caching nei messaggi invece
MESSAGES = [
    {
        "role": "user",
        "content": [
            {
                "type": "text",
                "text": LARGE_TEXT,
                "cache_control": {"type": "ephemeral"},
            },
            {
                "type": "text",
                "text": "Analizza il tono di questo passaggio."
            }
        ]
    }
]

# Prima richiesta - stabilisci la cache
print("Prima richiesta - stabilisco la cache")
response1 = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=20000,
    thinking={
        "type": "enabled",
        "budget_tokens": 4000
    },
    messages=MESSAGES
)

print(f"Utilizzo della prima risposta: {response1.usage}")

MESSAGES.append({
    "role": "assistant",
    "content": response1.content
})
MESSAGES.append({
    "role": "user",
    "content": "Analizza i personaggi in questo passaggio."
})
# Seconda richiesta - stessi parametri di pensiero (previsto hit della cache)
print("\nSeconda richiesta - stessi parametri di pensiero (previsto hit della cache)")
response2 = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=20000,
    thinking={
        "type": "enabled",
        "budget_tokens": 4000  # Stesso budget di pensiero
    },
    messages=MESSAGES
)

print(f"Utilizzo della seconda risposta: {response2.usage}")

MESSAGES.append({
    "role": "assistant",
    "content": response2.content
})
MESSAGES.append({
    "role": "user",
    "content": "Analizza l'ambientazione in questo passaggio."
})

# Terza richiesta - budget di pensiero diverso (previsto miss della cache)
print("\nTerza richiesta - budget di pensiero diverso (previsto miss della cache)")
response3 = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=20000,
    thinking={
        "type": "enabled",
        "budget_tokens": 8000  # Budget di pensiero diverso interrompe la cache
    },
    messages=MESSAGES
)

print(f"Utilizzo della terza risposta: {response3.usage}")

Ecco l’output dello script (potresti vedere numeri leggermente diversi)

Prima richiesta - stabilisco la cache
Utilizzo della prima risposta: { cache_creation_input_tokens: 1370, cache_read_input_tokens: 0, input_tokens: 17, output_tokens: 700 }

Seconda richiesta - stessi parametri di pensiero (previsto hit della cache)

Utilizzo della seconda risposta: { cache_creation_input_tokens: 0, cache_read_input_tokens: 1370, input_tokens: 303, output_tokens: 874 }

Terza richiesta - budget di pensiero diverso (previsto miss della cache)
Utilizzo della terza risposta: { cache_creation_input_tokens: 1370, cache_read_input_tokens: 0, input_tokens: 747, output_tokens: 619 }

Questo esempio dimostra che quando il caching è impostato nell’array dei messaggi, la modifica dei parametri di pensiero (budget_tokens aumentato da 4000 a 8000) invalida la cache. La terza richiesta non mostra alcun hit della cache con cache_creation_input_tokens=1370 e cache_read_input_tokens=0, dimostrando che il caching basato sui messaggi viene invalidato quando i parametri di pensiero cambiano.

Max tokens e dimensione della finestra di contesto con pensiero esteso

Nei modelli Claude più vecchi (prima di Claude Sonnet 3.7), se la somma dei token del prompt e max_tokens superava la finestra di contesto del modello, il sistema avrebbe automaticamente regolato max_tokens per adattarsi al limite del contesto. Ciò significava che potevi impostare un valore max_tokens grande e il sistema lo avrebbe silenziosamente ridotto secondo necessità.

Con i modelli Claude 3.7 e 4, max_tokens (che include il tuo budget di pensiero quando il pensiero è abilitato) viene applicato come un limite rigoroso. Il sistema ora restituirà un errore di convalida se i token del prompt + max_tokens superano la dimensione della finestra di contesto.

Puoi leggere la nostra guida sulle finestre di contesto per un’analisi più approfondita.

La finestra di contesto con pensiero esteso

Quando si calcola l’utilizzo della finestra di contesto con il pensiero abilitato, ci sono alcune considerazioni da tenere presenti:

I blocchi di pensiero dai turni precedenti vengono rimossi e non conteggiati nella finestra di contesto
Il pensiero del turno corrente conta per il limite max_tokens per quel turno

Il diagramma seguente mostra la gestione specializzata dei token quando il pensiero esteso è abilitato:

La finestra di contesto effettiva viene calcolata come:

finestra di contesto =
  (token di input correnti - token di pensiero precedenti) +
  (token di pensiero + token di pensiero criptati + token di output di testo)

Consigliamo di utilizzare l’API di conteggio dei token per ottenere conteggi accurati dei token per il tuo caso d’uso specifico, specialmente quando si lavora con conversazioni multi-turno che includono il pensiero.

La finestra di contesto con pensiero esteso e uso di strumenti

Quando si utilizza il pensiero esteso con l’uso di strumenti, i blocchi di pensiero devono essere esplicitamente preservati e restituiti con i risultati degli strumenti.

Il calcolo della finestra di contesto effettiva per il pensiero esteso con l’uso di strumenti diventa:

finestra di contesto =
  (token di input correnti + token di pensiero precedenti + token di utilizzo degli strumenti) +
  (token di pensiero + token di pensiero criptati + token di output di testo)

Il diagramma seguente illustra la gestione dei token per il pensiero esteso con l’uso di strumenti:

Gestione dei token con pensiero esteso

Dato il comportamento della finestra di contesto e di max_tokens con i modelli Claude 3.7 e 4 con pensiero esteso, potresti dover:

Monitorare e gestire più attivamente il tuo utilizzo di token
Regolare i valori max_tokens man mano che la lunghezza del prompt cambia
Potenzialmente utilizzare gli endpoint di conteggio dei token più frequentemente
Essere consapevole che i blocchi di pensiero precedenti non si accumulano nella finestra di contesto

Questa modifica è stata apportata per fornire un comportamento più prevedibile e trasparente, specialmente poiché i limiti massimi di token sono aumentati significativamente.

Crittografia del pensiero

Il contenuto completo del pensiero è crittografato e restituito nel campo signature. Questo campo viene utilizzato per verificare che i blocchi di pensiero siano stati generati da Claude quando vengono passati nuovamente all’API. Quando si trasmettono in streaming le risposte, la firma viene aggiunta tramite un signature_delta all’interno di un evento content_block_delta appena prima dell’evento content_block_stop.

Nota che il campo firma sarà significativamente più lungo rispetto ai modelli precedenti. Questo è un campo opaco e non dovrebbe essere interpretato o analizzato - esiste esclusivamente per scopi di verifica.

È strettamente necessario inviare i blocchi di pensiero solo quando si utilizzano strumenti con pensiero esteso. Altrimenti puoi omettere i blocchi di pensiero dai turni precedenti, o lasciare che l’API li rimuova per te se li passi indietro.

Se invii i blocchi di pensiero, ti consigliamo di passare tutto indietro come l’hai ricevuto per coerenza e per evitare potenziali problemi.

Redazione del pensiero

Occasionalmente, il ragionamento interno di Claude verrà segnalato dai nostri sistemi di sicurezza. Quando ciò accade, crittografiamo parte o tutto il blocco thinking e lo restituiamo a te come blocco redacted_thinking. I blocchi redacted_thinking vengono decrittografati quando passati nuovamente all’API, permettendo a Claude di continuare la sua risposta senza perdere contesto.

Quando si costruiscono applicazioni rivolte ai clienti che utilizzano il pensiero esteso:

Sii consapevole che i blocchi di pensiero redatti contengono contenuti crittografati che non sono leggibili dall’uomo
Considera di fornire una semplice spiegazione come: “Parte del ragionamento interno di Claude è stata automaticamente crittografata per motivi di sicurezza. Questo non influisce sulla qualità delle risposte.”
Se mostri blocchi di pensiero agli utenti, puoi filtrare i blocchi redatti preservando i normali blocchi di pensiero
Sii trasparente sul fatto che l’utilizzo delle funzionalità di pensiero esteso potrebbe occasionalmente comportare la crittografia di alcuni ragionamenti
Implementa una gestione degli errori appropriata per gestire elegantemente il pensiero redatto senza interrompere la tua UI

Ecco un esempio che mostra sia blocchi di pensiero normali che redatti:

{
  "content": [
    {
      "type": "thinking",
      "thinking": "Analizziamo questo passo dopo passo...",
      "signature": "WaUjzkypQ2mUEVM36O2TxuC06KN8xyfbJwyem2dw3URve/op91XWHOEBLLqIOMfFG/UvLEczmEsUjavL...."
    },
    {
      "type": "redacted_thinking",
      "data": "EmwKAhgBEgy3va3pzix/LafPsn4aDFIT2Xlxh0L5L8rLVyIwxtE3rAFBa8cr3qpPkNRj2YfWXGmKDxH4mPnZ5sQ7vB9URj2pLmN3kF8/dW5hR7xJ0aP1oLs9yTcMnKVf2wRpEGjH9XZaBt4UvDcPrQ..."
    },
    {
      "type": "text",
      "text": "In base alla mia analisi..."
    }
  ]
}

Vedere blocchi di pensiero redatti nell’output è un comportamento previsto. Il modello può ancora utilizzare questo ragionamento redatto per informare le sue risposte mantenendo le protezioni di sicurezza.

Se hai bisogno di testare la gestione del pensiero redatto nella tua applicazione, puoi utilizzare questa stringa di test speciale come prompt: ANTHROPIC_MAGIC_STRING_TRIGGER_REDACTED_THINKING_46C9A13E193C177646C7398A98432ECCCE4C1253D5E2D82641AC0E52CC2876CB

Quando passi blocchi thinking e redacted_thinking all’API in una conversazione multi-turno, devi includere il blocco completo non modificato all’API per l’ultimo turno dell’assistente. Questo è fondamentale per mantenere il flusso di ragionamento del modello. Ti suggeriamo di passare sempre tutti i blocchi di pensiero all’API. Per maggiori dettagli, consulta la sezione Preservare i blocchi di pensiero sopra.

Esempio: Lavorare con blocchi di pensiero redatti

Questo esempio dimostra come gestire i blocchi redacted_thinking che possono apparire nelle risposte quando il ragionamento interno di Claude contiene contenuti segnalati dai sistemi di sicurezza:

import anthropic

client = anthropic.Anthropic()

# Utilizzo di un prompt speciale che attiva il pensiero redatto (solo a scopo dimostrativo)
response = client.messages.create(
    model="claude-3-7-sonnet-20250219",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000
    },
    messages=[{
        "role": "user",
        "content": "ANTHROPIC_MAGIC_STRING_TRIGGER_REDACTED_THINKING_46C9A13E193C177646C7398A98432ECCCE4C1253D5E2D82641AC0E52CC2876CB"
    }]
)

# Identifica i blocchi di pensiero redatti
has_redacted_thinking = any(
    block.type == "redacted_thinking" for block in response.content
)

if has_redacted_thinking:
    print("La risposta contiene blocchi di pensiero redatti")
    # Questi blocchi sono ancora utilizzabili nelle richieste successive

    # Estrai tutti i blocchi (sia redatti che non redatti)
    all_thinking_blocks = [
        block for block in response.content
        if block.type in ["thinking", "redacted_thinking"]
    ]

    # Quando passi alle richieste successive, includi tutti i blocchi senza modifiche
    # Questo preserva l'integrità del ragionamento di Claude

    print(f"Trovati {len(all_thinking_blocks)} blocchi di pensiero in totale")
    print(f"Questi blocchi sono ancora addebitabili come token di output")

Differenze nel pensiero tra le versioni dei modelli

L’API Messages gestisce il pensiero in modo diverso tra i modelli Claude Sonnet 3.7 e Claude 4, principalmente nel comportamento di redazione e riassunto.

Vedi la tabella seguente per un confronto condensato:

Funzionalità	Claude Sonnet 3.7	Modelli Claude 4
Output di pensiero	Restituisce l’output di pensiero completo	Restituisce il pensiero riassunto
Pensiero interlacciato	Non supportato	Supportato con l’header beta `interleaved-thinking-2025-05-14`

Prezzi

Il pensiero esteso utilizza lo schema di prezzi standard dei token:

Modello	Token di input base	Scritture cache	Hit cache	Token di output
Claude Opus 4	$15 / MTok	$18,75 / MTok	$1,50 / MTok	$75 / MTok
Claude Sonnet 4	$3 / MTok	$3,75 / MTok	$0,30 / MTok	$15 / MTok
Claude Sonnet 3.7	$3 / MTok	$3,75 / MTok	$0,30 / MTok	$15 / MTok

Il processo di pensiero comporta addebiti per:

Token utilizzati durante il pensiero (token di output)
Blocchi di pensiero dall’ultimo turno dell’assistente inclusi nelle richieste successive (token di input)
Token di output di testo standard

Quando il pensiero esteso è abilitato, un prompt di sistema specializzato viene automaticamente incluso per supportare questa funzionalità.

Quando si utilizza il pensiero riassunto:

Token di input: Token nella tua richiesta originale (esclude i token di pensiero dai turni precedenti)
Token di output (addebitati): I token di pensiero originali che Claude ha generato internamente
Token di output (visibili): I token di pensiero riassunti che vedi nella risposta
Nessun addebito: Token utilizzati per generare il riassunto

Il conteggio dei token di output addebitati non corrisponderà al conteggio dei token visibili nella risposta. Ti viene addebitato l’intero processo di pensiero, non il riassunto che vedi.

Migliori pratiche e considerazioni per il pensiero esteso

Lavorare con i budget di pensiero

Ottimizzazione del budget: Il budget minimo è di 1.024 token. Suggeriamo di iniziare dal minimo e aumentare il budget di pensiero in modo incrementale per trovare l’intervallo ottimale per il tuo caso d’uso. Conteggi di token più elevati consentono un ragionamento più completo ma con rendimenti decrescenti a seconda del compito. Aumentare il budget può migliorare la qualità della risposta a scapito di una maggiore latenza. Per compiti critici, testa diverse impostazioni per trovare l’equilibrio ottimale. Nota che il budget di pensiero è un obiettivo piuttosto che un limite rigoroso—l’utilizzo effettivo dei token può variare in base al compito.
Punti di partenza: Inizia con budget di pensiero più grandi (16k+ token) per compiti complessi e regola in base alle tue esigenze.
Budget grandi: Per budget di pensiero superiori a 32k, consigliamo di utilizzare l’elaborazione in batch per evitare problemi di rete. Le richieste che spingono il modello a pensare sopra i 32k token causano richieste di lunga durata che potrebbero scontrarsi con i timeout di sistema e i limiti di connessione aperta.
Monitoraggio dell’utilizzo dei token: Monitora l’utilizzo dei token di pensiero per ottimizzare costi e prestazioni.

Considerazioni sulle prestazioni

Tempi di risposta: Sii preparato per tempi di risposta potenzialmente più lunghi a causa dell’elaborazione aggiuntiva richiesta per il processo di ragionamento. Tieni conto che la generazione di blocchi di pensiero potrebbe aumentare il tempo di risposta complessivo.
Requisiti di streaming: Lo streaming è richiesto quando max_tokens è maggiore di 21.333. Durante lo streaming, sii preparato a gestire sia i blocchi di contenuto di pensiero che di testo man mano che arrivano.

Compatibilità delle funzionalità

Il pensiero non è compatibile con le modifiche di temperature o top_k così come con l’uso forzato di strumenti.
Quando il pensiero è abilitato, puoi impostare top_p a valori tra 1 e 0,95.
Non puoi pre-compilare le risposte quando il pensiero è abilitato.
Le modifiche al budget di pensiero invalidano i prefissi di prompt memorizzati nella cache che includono messaggi. Tuttavia, i prompt di sistema memorizzati nella cache e le definizioni degli strumenti continueranno a funzionare quando i parametri di pensiero cambiano.

Linee guida per l’utilizzo

Selezione dei compiti: Utilizza il pensiero esteso per compiti particolarmente complessi che beneficiano di un ragionamento passo dopo passo come matematica, codifica e analisi.
Gestione del contesto: Non è necessario rimuovere i blocchi di pensiero precedenti da solo. L’API Anthropic ignora automaticamente i blocchi di pensiero dai turni precedenti e non vengono inclusi nel calcolo dell’utilizzo del contesto.
Ingegneria dei prompt: Consulta i nostri suggerimenti per l’ingegneria dei prompt con pensiero esteso se vuoi massimizzare le capacità di pensiero di Claude.

Prossimi passi

Prova il ricettario del pensiero esteso

Esplora esempi pratici di pensiero nel nostro ricettario.

Suggerimenti per l'ingegneria dei prompt con pensiero esteso

Impara le migliori pratiche di ingegneria dei prompt per il pensiero esteso.

Caching dei prompt Messaggi in Streaming

On this page

Modelli supportati
Come funziona il pensiero esteso
Come utilizzare il pensiero esteso
Pensiero riassunto
Streaming del pensiero
Pensiero esteso con l’uso di strumenti
Preservare i blocchi di pensiero
Pensiero interlacciato
Pensiero esteso con caching dei prompt
Comprendere il comportamento di caching dei blocchi di pensiero
Max tokens e dimensione della finestra di contesto con pensiero esteso
La finestra di contesto con pensiero esteso
La finestra di contesto con pensiero esteso e uso di strumenti
Gestione dei token con pensiero esteso
Crittografia del pensiero
Redazione del pensiero
Differenze nel pensiero tra le versioni dei modelli
Prezzi
Migliori pratiche e considerazioni per il pensiero esteso
Lavorare con i budget di pensiero
Considerazioni sulle prestazioni
Compatibilità delle funzionalità
Linee guida per l’utilizzo
Prossimi passi

Primi passi

Modelli e prezzi

Scopri Claude

Capacità

Strumenti

Protocollo di contesto del modello (MCP)

Casi d'uso

Ingegneria dei prompt

Test e valutazione

Rafforzare le protezioni

Centro legale

Costruire con il pensiero esteso

Modelli supportati

Come funziona il pensiero esteso

Come utilizzare il pensiero esteso

Pensiero riassunto

Streaming del pensiero

Pensiero esteso con l’uso di strumenti

Preservare i blocchi di pensiero

Pensiero interlacciato

Pensiero esteso con caching dei prompt

Comprendere il comportamento di caching dei blocchi di pensiero

Max tokens e dimensione della finestra di contesto con pensiero esteso

La finestra di contesto con pensiero esteso

La finestra di contesto con pensiero esteso e uso di strumenti

Gestione dei token con pensiero esteso

Crittografia del pensiero

Redazione del pensiero

Differenze nel pensiero tra le versioni dei modelli

Prezzi

Migliori pratiche e considerazioni per il pensiero esteso

Lavorare con i budget di pensiero

Considerazioni sulle prestazioni

Compatibilità delle funzionalità

Linee guida per l’utilizzo

Prossimi passi

Prova il ricettario del pensiero esteso

Suggerimenti per l'ingegneria dei prompt con pensiero esteso

Primi passi

Modelli e prezzi

Scopri Claude

Capacità

Strumenti

Protocollo di contesto del modello (MCP)

Casi d'uso

Ingegneria dei prompt

Test e valutazione

Rafforzare le protezioni

Centro legale

​Modelli supportati

​Come funziona il pensiero esteso

​Come utilizzare il pensiero esteso

​Pensiero riassunto

​Streaming del pensiero

​Pensiero esteso con l’uso di strumenti

​Preservare i blocchi di pensiero

​Pensiero interlacciato

​Pensiero esteso con caching dei prompt

​Comprendere il comportamento di caching dei blocchi di pensiero

​Max tokens e dimensione della finestra di contesto con pensiero esteso

​La finestra di contesto con pensiero esteso

​La finestra di contesto con pensiero esteso e uso di strumenti

​Gestione dei token con pensiero esteso

​Crittografia del pensiero

​Redazione del pensiero

​Differenze nel pensiero tra le versioni dei modelli

​Prezzi

​Migliori pratiche e considerazioni per il pensiero esteso

​Lavorare con i budget di pensiero

​Considerazioni sulle prestazioni

​Compatibilità delle funzionalità

​Linee guida per l’utilizzo

​Prossimi passi

Prova il ricettario del pensiero esteso

Suggerimenti per l'ingegneria dei prompt con pensiero esteso

Modelli supportati

Come funziona il pensiero esteso

Come utilizzare il pensiero esteso

Pensiero riassunto

Streaming del pensiero

Pensiero esteso con l’uso di strumenti

Preservare i blocchi di pensiero

Pensiero interlacciato

Pensiero esteso con caching dei prompt

Comprendere il comportamento di caching dei blocchi di pensiero

Max tokens e dimensione della finestra di contesto con pensiero esteso

La finestra di contesto con pensiero esteso

La finestra di contesto con pensiero esteso e uso di strumenti

Gestione dei token con pensiero esteso

Crittografia del pensiero

Redazione del pensiero

Differenze nel pensiero tra le versioni dei modelli

Prezzi

Migliori pratiche e considerazioni per il pensiero esteso

Lavorare con i budget di pensiero

Considerazioni sulle prestazioni

Compatibilità delle funzionalità

Linee guida per l’utilizzo

Prossimi passi