---
title: Ragionamento esteso
url: https://platform.claude.com/docs/it/build-with-claude/extended-thinking
description: Configura il ragionamento esteso manuale con un budget fisso budget_tokens sui modelli Claude che lo supportano, e migra al ragionamento adattivo.
---

<Note>
  Per scoprire come la "zero data retention" (conservazione zero dei dati), o ZDR, si applica a questa funzionalità, consulta [API e conservazione dei dati](https://platform.claude.com/docs/it/manage-claude/api-and-data-retention).
</Note>

<Warning>
  L'"extended thinking" (ragionamento esteso) (`thinking.type: "enabled"` con `budget_tokens`) è deprecato sui modelli Claude 4.6 (le richieste che lo utilizzano hanno comunque esito positivo). Claude 4.7 e i modelli successivi non lo supportano e rifiutano le richieste che lo utilizzano, restituendo un errore 400. Su Claude 4.5 e sui modelli precedenti che supportano il thinking, il ragionamento esteso è l'unica modalità di thinking disponibile. Claude Mythos Preview supporta entrambe le modalità. Dove sono disponibili entrambe le modalità, usa invece l'[adaptive thinking](https://platform.claude.com/docs/it/build-with-claude/thinking) (ragionamento adattivo).

  Consulta [Migrazione al ragionamento adattivo](https://platform.claude.com/docs/it/build-with-claude/extended-thinking#migrating-to-adaptive-thinking) per passare al ragionamento adattivo. Se il tuo modello supporta solo il ragionamento esteso, questa pagina descrive la configurazione supportata; non è necessaria alcuna modifica finché non passi a un modello più recente.
</Warning>

<Note>
  Se una richiesta fallisce con un errore 400 il cui messaggio inizia con `"thinking.type.enabled" is not supported`, il tuo modello usa invece il ragionamento adattivo. Consulta [Risoluzione dei problemi del ragionamento](https://platform.claude.com/docs/it/build-with-claude/thinking-troubleshooting#error-thinking-type-enabled), oppure vai direttamente a [Migrazione al ragionamento adattivo](https://platform.claude.com/docs/it/build-with-claude/extended-thinking#migrating-to-adaptive-thinking).
</Note>

L'"extended thinking" (ragionamento esteso) in modalità manuale ti offre un controllo diretto su quanto Claude pensa. Imposti un budget di token di ragionamento su ogni richiesta con `thinking: {type: "enabled", budget_tokens: N}`, e Claude pensa entro quel budget prima di iniziare la sua risposta finale. La modalità manuale rimane utile quando il tuo carico di lavoro richiede una latenza prevedibile o un controllo preciso sui costi del ragionamento. Questa pagina spiega come impostare e regolare il budget, come la modalità manuale interagisce con il ragionamento interlacciato e la "prompt caching" (cache dei prompt), e come migrare al ragionamento adattivo.

Per capire come funziona il ragionamento in sé, inclusi i blocchi di ragionamento e la forma della risposta, il parametro `display`, lo streaming, il ragionamento con l'uso degli strumenti e la crittografia, consulta la [panoramica sul ragionamento](https://platform.claude.com/docs/it/build-with-claude/thinking).

## Modelli supportati

La disponibilità del ragionamento esteso per modello, inclusi i modelli in cui il ragionamento esteso è l'unica modalità, è elencata nella [tabella di configurazione per modello](https://platform.claude.com/docs/it/build-with-claude/thinking-troubleshooting#supported-models).

## Come usare il ragionamento esteso

Ecco un esempio di utilizzo del ragionamento esteso nella Messages API:

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "content-type: application/json" \
    -d '{
      "model": "claude-sonnet-4-6",
      "max_tokens": 16000,
      "thinking": {
        "type": "enabled",
        "budget_tokens": 10000
      },
      "messages": [
        {
          "role": "user",
          "content": "Are there an infinite number of prime numbers such that n mod 4 == 3?"
        }
      ]
    }'
  ```

  ```bash CLI
  ant messages create \
    --format yaml <<'YAML'
  model: claude-sonnet-4-6
  max_tokens: 16000
  thinking:
    type: enabled
    budget_tokens: 10000
  messages:
    - role: user
      content: Are there an infinite number of prime numbers such that n mod 4 == 3?
  YAML
  ```

  ```python Python
  client = anthropic.Anthropic()

  response = client.messages.create(
      model="claude-sonnet-4-6",
      max_tokens=16000,
      thinking={"type": "enabled", "budget_tokens": 10000},
      messages=[
          {
              "role": "user",
              "content": "Are there an infinite number of prime numbers such that n mod 4 == 3?",
          }
      ],
  )

  # La risposta contiene blocchi di ragionamento riassunti e blocchi di testo
  for block in response.content:
      match block.type:
          case "thinking":
              print(f"\nThinking summary: {block.thinking}")
          case "text":
              print(f"\nResponse: {block.text}")
  ```

  ```typescript TypeScript
  const client = new Anthropic();

  const response = await client.messages.create({
    model: "claude-sonnet-4-6",
    max_tokens: 16000,
    thinking: {
      type: "enabled",
      budget_tokens: 10000
    },
    messages: [
      {
        role: "user",
        content: "Are there an infinite number of prime numbers such that n mod 4 == 3?"
      }
    ]
  });

  // La risposta contiene blocchi di ragionamento riassunti e blocchi di testo
  for (const block of response.content) {
    switch (block.type) {
      case "thinking":
        console.log(`\nThinking summary: ${block.thinking}`);
        break;
      case "text":
        console.log(`\nResponse: ${block.text}`);
        break;
    }
  }
  ```

  ```csharp C#
  AnthropicClient client = new();

  var response = await client.Messages.Create(new()
  {
      Model = Model.ClaudeSonnet4_6,
      MaxTokens = 16000,
      Thinking = new ThinkingConfigEnabled(budgetTokens: 10000),
      Messages =
      [
          new()
          {
              Role = Role.User,
              Content = "Are there an infinite number of prime numbers such that n mod 4 == 3?",
          },
      ],
  });

  // La risposta contiene blocchi di ragionamento riassunti e blocchi di testo
  foreach (var block in response.Content)
  {
      if (block.TryPickThinking(out var thinking))
      {
          Console.WriteLine($"\nThinking summary: {thinking.Thinking}");
      }
      else if (block.TryPickText(out var text))
      {
          Console.WriteLine($"\nResponse: {text.Text}");
      }
  }
  ```

  ```go Go
  client := anthropic.NewClient()

  response, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeSonnet4_6,
  	MaxTokens: 16000,
  	Thinking:  anthropic.ThinkingConfigParamOfEnabled(10000),
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock("Are there an infinite number of prime numbers such that n mod 4 == 3?")),
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }

  // La risposta contiene blocchi di ragionamento riassunti e blocchi di testo
  for _, block := range response.Content {
  	switch block := block.AsAny().(type) {
  	case anthropic.ThinkingBlock:
  		fmt.Printf("\nThinking summary: %s", block.Thinking)
  	case anthropic.TextBlock:
  		fmt.Printf("\nResponse: %s", block.Text)
  	}
  }
  ```

  ```java Java
  import com.anthropic.client.okhttp.AnthropicOkHttpClient;
  import com.anthropic.models.messages.MessageCreateParams;
  import com.anthropic.models.messages.Model;

  void main() {
      var client = AnthropicOkHttpClient.fromEnv();

      var params = MessageCreateParams.builder()
          .model(Model.CLAUDE_SONNET_4_6)
          .maxTokens(16_000)
          .enabledThinking(10_000)
          .addUserMessage("Are there an infinite number of prime numbers such that n mod 4 == 3?")
          .build();

      var response = client.messages().create(params);

      // La risposta contiene blocchi di ragionamento riassunti e blocchi di testo
      for (var block : response.content()) {
          block.thinking().ifPresent(thinkingBlock ->
              IO.println("\nThinking summary: " + thinkingBlock.thinking())
          );
          block.text().ifPresent(textBlock ->
              IO.println("\nResponse: " + textBlock.text())
          );
      }
  }
  ```

  ```php PHP
  $client = new Client();

  $response = $client->messages->create(
      model: 'claude-sonnet-4-6',
      maxTokens: 16000,
      thinking: ['type' => 'enabled', 'budget_tokens' => 10000],
      messages: [
          [
              'role' => 'user',
              'content' => 'Are there an infinite number of prime numbers such that n mod 4 == 3?',
          ],
      ],
  );

  // La risposta contiene blocchi di ragionamento riassunti e blocchi di testo
  foreach ($response->content as $block) {
      echo match (true) {
          $block instanceof \Anthropic\Messages\ThinkingBlock => "\nThinking summary: {$block->thinking}",
          $block instanceof \Anthropic\Messages\TextBlock => "\nResponse: {$block->text}",
          default => '',
      };
  }
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  response = client.messages.create(
    model: "claude-sonnet-4-6",
    max_tokens: 16_000,
    thinking: {
      type: :enabled,
      budget_tokens: 10_000
    },
    messages: [
      {
        role: :user,
        content: "Are there an infinite number of prime numbers such that n mod 4 == 3?"
      }
    ]
  )

  # La risposta contiene blocchi di ragionamento riassunti e blocchi di testo
  response.content.each do |block|
    case block
    when Anthropic::Models::ThinkingBlock
      puts "\nThinking summary: #{block.thinking}"
    when Anthropic::Models::TextBlock
      puts "\nResponse: #{block.text}"
    end
  end
  ```
</CodeGroup>

Per attivare il ragionamento esteso manuale, aggiungi un oggetto `thinking` con `type` impostato su `enabled` e un valore `budget_tokens`.

Il parametro `budget_tokens` imposta un obiettivo per quanti token Claude può usare per il suo processo di ragionamento interno. Budget più ampi possono migliorare la qualità della risposta consentendo un'analisi più approfondita per problemi complessi.

## Regole del budget e regolazione

`budget_tokens` deve soddisfare questi vincoli:

* **Minimo di 1.024 token.** L'API rifiuta valori inferiori.
* **Inferiore a `max_tokens`.** I token di ragionamento contano ai fini del limite `max_tokens` per il turno, quindi il budget deve lasciare spazio per la risposta finale. L'unica eccezione è il [ragionamento interlacciato](https://platform.claude.com/docs/it/build-with-claude/extended-thinking#interleaved-thinking), dove `budget_tokens` può superare `max_tokens` perché il budget copre tutti i blocchi di ragionamento all'interno di un singolo turno dell'assistente.
* **Nessun pre-riscaldamento della cache.** Poiché `budget_tokens` deve essere inferiore a `max_tokens`, il ragionamento esteso non può essere combinato con `max_tokens: 0` ([pre-riscaldamento della cache](https://platform.claude.com/docs/it/build-with-claude/prompt-caching#pre-warming-the-cache)).

Il budget è un obiettivo piuttosto che un limite rigido. L'utilizzo effettivo dei token varia in base al compito, e Claude può smettere di ragionare ben prima che il budget sia esaurito; `max_tokens` rimane il tetto massimo rigido sull'output totale.

Su Claude Opus 4.5, l'unico modello con solo ragionamento esteso che supporta l'[effort](https://platform.claude.com/docs/it/build-with-claude/effort), l'effort modella la risposta complessiva mentre `budget_tokens` imposta la profondità del ragionamento; imposta entrambi.

Per regolare il budget:

* Adatta il punto di partenza al compito. Per compiti semplici, inizia vicino al minimo di 1.024 token e aumenta in modo incrementale per trovare l'intervallo ottimale per il tuo caso d'uso. Per compiti complessi, inizia con un budget più ampio di 16.000 token o più e regola in base alle tue esigenze di latenza e qualità. Budget più elevati consentono un ragionamento più completo, con rendimenti decrescenti che dipendono dal compito, e al costo di una maggiore latenza. Per compiti critici, testa impostazioni diverse per trovare il giusto equilibrio.
* Per budget di ragionamento superiori a 32k, usa l'[elaborazione batch](https://platform.claude.com/docs/it/build-with-claude/batch-processing) per evitare problemi di rete. Spingere il modello a pensare oltre i 32k token produce richieste di lunga durata che possono incorrere in timeout di sistema e limiti di connessioni aperte.

Per tenere traccia di quanto ti costa effettivamente un budget, monitora il campo `usage.output_tokens_details.thinking_tokens` nella risposta, che riporta quanti dei token di output fatturati erano ragionamento interno. In streaming, questa suddivisione appare solo nell'evento finale `message_delta`.

Quando sei pronto ad abbandonare i budget manuali, consulta [Migrazione al ragionamento adattivo](https://platform.claude.com/docs/it/build-with-claude/extended-thinking#migrating-to-adaptive-thinking).

## Ragionamento interlacciato in modalità manuale

L'"interleaved thinking" (ragionamento interlacciato) consente a Claude di ragionare tra le chiamate agli strumenti all'interno di un singolo turno dell'assistente, valutando ogni risultato dello strumento prima di decidere cosa fare dopo. Per il concetto, la struttura del turno e il suo comportamento sui modelli con ragionamento adattivo, consulta [ragionamento interlacciato](https://platform.claude.com/docs/it/build-with-claude/thinking#interleaved-thinking) nella panoramica del ragionamento. Questa sezione spiega come abilitarlo quando usi il ragionamento manuale `type: "enabled"`.

Su Claude Opus 4.5, Claude Sonnet 4.5 (deprecato) e sui modelli Claude 4 precedenti, aggiungi l'[header beta](https://platform.claude.com/docs/it/api/beta-headers) `interleaved-thinking-2025-05-14` alla tua richiesta API.

La generazione 4.6 si divide in modalità manuale:

* **Claude Sonnet 4.6**: l'header beta con `type: "enabled"` manuale è ancora funzionante ma deprecato. Preferisci il [ragionamento adattivo](https://platform.claude.com/docs/it/build-with-claude/thinking), che interlaccia automaticamente senza alcun header.
* **Claude Opus 4.6**: la modalità manuale non ha alcun ragionamento interlacciato. Solo la sua modalità adattiva interlaccia, quindi passa a `thinking: {type: "adaptive"}` se hai bisogno di ragionamento tra le chiamate agli strumenti su questo modello.

Claude Haiku 4.5 non supporta il ragionamento interlacciato. Sulla Claude API, l'header beta viene accettato ma ignorato.

Altre due considerazioni per il ragionamento interlacciato in modalità manuale:

* `budget_tokens` può superare `max_tokens` in questo caso; le [regole del budget](https://platform.claude.com/docs/it/build-with-claude/extended-thinking#budget-rules-and-tuning) spiegano questa eccezione.
* Il ragionamento interlacciato è supportato solo per gli [strumenti usati tramite la Messages API](https://platform.claude.com/docs/it/agents-and-tools/tool-use/overview).

Il modo in cui le piattaforme trattano l'header beta differisce. La Claude API e [Claude Platform on AWS](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws) accettano `interleaved-thinking-2025-05-14` su qualsiasi modello e lo ignorano dove non è supportato. L'accettazione non equivale all'effetto: sui modelli che rifiutano `type: "enabled"` (4.7 e successivi) o che non dispongono dell'interlacciamento in modalità manuale (Claude Opus 4.6), l'header non ha alcun effetto in modalità manuale; lì il ragionamento adattivo interlaccia automaticamente.

Le piattaforme gestite dai partner ([Amazon Bedrock](https://platform.claude.com/docs/it/build-with-claude/claude-in-amazon-bedrock) e [Google Cloud](https://platform.claude.com/docs/it/build-with-claude/claude-on-vertex-ai)) accettano allo stesso modo l'header su qualsiasi modello senza restituire un errore, e lo ignorano sui modelli che non supportano il ragionamento interlacciato.

## Struttura del turno in modalità manuale

Le regole generali sulla struttura del turno, inclusi il ciclo di uso degli strumenti a turno singolo, la gestione dei conflitti a metà turno e l'attivazione/disattivazione del ragionamento tra i turni, si trovano in [Ragionamento con l'uso degli strumenti](https://platform.claude.com/docs/it/build-with-claude/thinking#thinking-with-tool-use).

La modalità manuale aggiunge un requisito: il turno finale dell'assistente di una richiesta con ragionamento abilitato deve iniziare con un blocco di ragionamento (il [ragionamento adattivo](https://platform.claude.com/docs/it/build-with-claude/thinking) elimina tale requisito). Modificare la configurazione del ragionamento tra i turni invalida anche la cache dei prompt; consulta la sezione seguente.

## Cache dei prompt in modalità manuale

La modalità manuale aggiunge una regola al comportamento di caching indipendente dalla modalità descritto in [ragionamento e cache dei prompt](https://platform.claude.com/docs/it/build-with-claude/thinking#thinking-and-prompt-caching): modificare `budget_tokens` tra le richieste invalida i breakpoint della cache, proprio come il cambio di modalità di ragionamento, perché il valore del budget viene reso nel prompt. I breakpoint a livello di messaggio falliscono sempre dopo una modifica del budget; se falliscono anche i breakpoint degli strumenti e del prompt di sistema dipende da dove il modello rende la configurazione.

In pratica, scegli un budget e mantienilo stabile per tutta la durata di una conversazione in cache. Eseguire una conversazione multi-turno con caching a livello di messaggio su Claude Sonnet 4.6 e modificare il budget alla terza richiesta da 4.000 a 8.000 token mostra direttamente l'invalidazione:

```text Output wrap
First request - establishing cache
First response usage: { cache_creation_input_tokens: 1370, cache_read_input_tokens: 0, input_tokens: 17, output_tokens: 700 }

Second request - same thinking parameters (cache hit expected)
Second response usage: { cache_creation_input_tokens: 0, cache_read_input_tokens: 1370, input_tokens: 303, output_tokens: 874 }

Third request - different thinking budget (cache miss expected)
Third response usage: { cache_creation_input_tokens: 1370, cache_read_input_tokens: 0, input_tokens: 747, output_tokens: 619 }
```

La terza richiesta ricrea la cache (`cache_creation_input_tokens=1370`, `cache_read_input_tokens=0`) perché il budget è cambiato tra le richieste. Per una versione eseguibile dello stesso esperimento in modalità adattiva, dove il livello di effort svolge il ruolo nella cache che `budget_tokens` svolge qui, consulta [Cache dei prompt](https://platform.claude.com/docs/it/build-with-claude/thinking-steering-and-cost#prompt-caching) nella pagina sull'orientamento del ragionamento.

## Meccaniche condivise

La maggior parte del comportamento del ragionamento è indipendente dalla modalità ed è documentata una sola volta nella pagina [Ragionamento](https://platform.claude.com/docs/it/build-with-claude/thinking). Tutto ciò che è descritto lì si applica anche in modalità manuale:

* [Controllo della visualizzazione del ragionamento](https://platform.claude.com/docs/it/build-with-claude/thinking#controlling-thinking-display)
* [Streaming del ragionamento](https://platform.claude.com/docs/it/build-with-claude/thinking#streaming-thinking)
* [Ragionamento con l'uso degli strumenti](https://platform.claude.com/docs/it/build-with-claude/thinking#thinking-with-tool-use), inclusa la [conservazione dei blocchi di ragionamento](https://platform.claude.com/docs/it/build-with-claude/thinking#preserving-thinking-blocks)
* [Ragionamento e cache dei prompt](https://platform.claude.com/docs/it/build-with-claude/thinking#thinking-and-prompt-caching)
* [Ragionamento e finestra di contesto](https://platform.claude.com/docs/it/build-with-claude/thinking#thinking-and-the-context-window)
* [Crittografia del ragionamento](https://platform.claude.com/docs/it/build-with-claude/thinking#thinking-encryption)
* [Prezzi](https://platform.claude.com/docs/it/build-with-claude/thinking-steering-and-cost#pricing) (nella pagina [Orientare il ragionamento](https://platform.claude.com/docs/it/build-with-claude/thinking-steering-and-cost))

## Migrazione al ragionamento adattivo

Se il tuo modello supporta solo il ragionamento esteso (Claude Sonnet 4.5 (deprecato), Claude Opus 4.5, Claude Haiku 4.5 e i modelli Claude 4 precedenti), al momento non è necessaria alcuna azione: il ragionamento adattivo non è disponibile su questi modelli, e `type: "adaptive"` [restituisce un errore 400](https://platform.claude.com/docs/it/build-with-claude/thinking-troubleshooting#error-thinking-type-adaptive). Mantieni `budget_tokens` finché non passi a un modello che supporta il ragionamento adattivo, quindi applica la corrispondenza descritta di seguito.

Devi migrare da `type: "enabled"` se:

* Usi Claude Opus 4.6 o Claude Sonnet 4.6, dove `budget_tokens` è deprecato.
* Usi Claude 4.7 o un modello successivo, come Claude Opus 5.5, Claude Sonnet 5, Claude Sonnet 5.5, Claude Fable 5.1 o Claude Haiku 5.5, dove `type: "enabled"` restituisce un errore 400.

La mappatura è minima: rimuovi `budget_tokens`, imposta `thinking: {type: "adaptive"}` e controlla la profondità del ragionamento con `output_config: {effort: ...}` invece di un budget di token.

```json
{
  "model": "claude-sonnet-4-6",
  "max_tokens": 16000,
  "thinking": {
    "type": "enabled",
    "budget_tokens": 10000
  }
}
```

diventa:

```json
{
  "model": "claude-sonnet-4-6",
  "max_tokens": 16000,
  "thinking": {
    "type": "adaptive"
  },
  "output_config": {
    "effort": "high"
  }
}
```

`effort: "high"` è il valore predefinito su Claude Sonnet 4.6, quindi ometterlo qui produce un comportamento identico; compare solo per mostrare dove si trova il controllo della profondità in modalità adattiva. Claude Opus 5.5 e Claude Haiku 5.5 hanno come valore predefinito `"medium"`, mentre gli altri modelli che supportano l'effort hanno come valore predefinito `"high"` (consulta [Livelli di effort](https://platform.claude.com/docs/it/build-with-claude/effort#effort-levels)).

Aspettati una differenza di comportamento, non solo un cambiamento di sintassi. Con un budget fisso, Claude ragiona a ogni richiesta. Con il ragionamento adattivo, Claude determina se e quanto ragionare a ogni richiesta, e con impostazioni di [effort](https://platform.claude.com/docs/it/build-with-claude/effort) più basse può saltare completamente il ragionamento sugli input semplici. Dopo la migrazione puoi anche rimuovere l'header beta `interleaved-thinking-2025-05-14`: il ragionamento adattivo interlaccia automaticamente e la Claude API ignora l'header su questi modelli. Cambia anche la conservazione dei blocchi di ragionamento: Claude Opus 4.5 e i modelli con numero di versione 4.6 o superiore mantengono nel contesto i blocchi di ragionamento dei turni precedenti e li fatturano come input, mentre Claude Sonnet 4.5 (deprecato), Claude Haiku 4.5 e i modelli precedenti li rimuovevano; consulta [preservazione dei blocchi di ragionamento per modello](https://platform.claude.com/docs/it/build-with-claude/thinking#thinking-block-preservation-by-model).

Il cambio di modalità è una modifica della configurazione del ragionamento, quindi la prima richiesta dopo il cambio invalida i breakpoint della cache, come descritto in [Cache dei prompt in modalità manuale](https://platform.claude.com/docs/it/build-with-claude/extended-thinking#extended-thinking-with-prompt-caching).

Per una guida completa, consulta [ragionamento adattivo](https://platform.claude.com/docs/it/build-with-claude/thinking), [effort](https://platform.claude.com/docs/it/build-with-claude/effort) e la [guida alla migrazione dei modelli](https://platform.claude.com/docs/it/about-claude/models/migration-guide).

## Prossimi passi

<CardGroup cols={3}>
  <Card title="Ragionamento" icon="brain" href="https://platform.claude.com/docs/it/build-with-claude/thinking">
    Scopri come funziona il ragionamento: blocchi, visualizzazione, streaming e uso degli strumenti.
  </Card>

  <Card title="Orientare il ragionamento" icon="compass" href="https://platform.claude.com/docs/it/build-with-claude/thinking-steering-and-cost">
    Lascia che Claude determini quando e quanto ragionare a ogni richiesta.
  </Card>

  <Card title="Ragionamento nei flussi di lavoro con strumenti e multi-turno" icon="wrench" href="https://platform.claude.com/docs/it/build-with-claude/thinking-tool-workflows">
    Conserva i blocchi di ragionamento e gestisci il ragionamento tra chiamate agli strumenti e turni.
  </Card>
</CardGroup>