Documentation — Spybara

agent-sdk/claude-code-features.md +9 −7

Details

14 14

15## Controlla le impostazioni del filesystem con settingSources15## Controlla le impostazioni del filesystem con settingSources

16 16

17L'opzione delle fonti di impostazione ([`setting_sources`](/it/agent-sdk/python#claude-agent-options) in Python, [`settingSources`](/it/agent-sdk/typescript#setting-source) in TypeScript) controlla quali impostazioni basate sul filesystem carica l'SDK. Passa un elenco esplicito per acconsentire a fonti specifiche, oppure passa un array vuoto per disabilitare le impostazioni utente, progetto e locali.17L'opzione delle fonti di impostazione ([`setting_sources`](/it/agent-sdk/python#claudeagentoptions) in Python, [`settingSources`](/it/agent-sdk/typescript#settingsource) in TypeScript) controlla quali impostazioni basate sul filesystem carica l'SDK. Passa un elenco esplicito per acconsentire a fonti specifiche, oppure passa un array vuoto per disabilitare le impostazioni utente, progetto e locali.

18 18

19Questo esempio carica sia le impostazioni a livello di utente che a livello di progetto impostando `settingSources` su `["user", "project"]`:19Questo esempio carica sia le impostazioni a livello di utente che a livello di progetto impostando `settingSources` su `["user", "project"]`:

20 20

65 ```65 ```

66</CodeGroup>66</CodeGroup>

67 67

68Ogni fonte carica le impostazioni da una posizione specifica, dove `<cwd>` è la directory di lavoro che passi tramite l'opzione `cwd` (o la directory corrente del processo se non impostata). Per la definizione del tipo completo, vedi [`SettingSource`](/it/agent-sdk/typescript#setting-source) (TypeScript) o [`SettingSource`](/it/agent-sdk/python#setting-source) (Python).68Ogni fonte carica le impostazioni da una posizione specifica, dove `<cwd>` è la directory di lavoro che passi tramite l'opzione `cwd`, o la directory corrente del processo se non impostata. Per la definizione del tipo completo, vedi [`SettingSource`](/it/agent-sdk/typescript#settingsource) (TypeScript) o [`SettingSource`](/it/agent-sdk/python#settingsource) (Python).

69 69

71| :---------- | :------------------------------------------------------------------------------------------------------------------ | :------------------------------------------------------------------------------------------------------------------------------------------------- |71| :---------- | :------------------------------------------------------------------------------------------------------------------ | :------------------------------------------------------------------------------------------------------------------------------------------------- |

119 119

120Le skills sono file markdown che danno al tuo agente conoscenze specializzate e flussi di lavoro invocabili. A differenza di `CLAUDE.md` (che si carica ogni sessione), le skills si caricano su richiesta. L'agente riceve le descrizioni delle skills all'avvio e carica il contenuto completo quando rilevante.120Le skills sono file markdown che danno al tuo agente conoscenze specializzate e flussi di lavoro invocabili. A differenza di `CLAUDE.md` (che si carica ogni sessione), le skills si caricano su richiesta. L'agente riceve le descrizioni delle skills all'avvio e carica il contenuto completo quando rilevante.

121 121

122Le skills vengono scoperte dal filesystem tramite `settingSources`. Con le opzioni predefinite, le skills di utente e progetto si caricano automaticamente. Lo strumento `Skill` è abilitato per impostazione predefinita quando non specifichi `allowedTools`. Se stai usando un allowlist `allowedTools`, includi `"Skill"` esplicitamente.122Le skills vengono scoperte dal filesystem tramite `settingSources`. Quando l'opzione `skills` su `query()` viene omessa, le skills di utente e progetto scoperte vengono abilitate e lo strumento Skill è disponibile, corrispondendo al comportamento della CLI. Per controllare quali skills sono abilitate, passa `skills` come `"all"`, un elenco di nomi di skills, o `[]` per disabilitare tutte. L'SDK abilita automaticamente lo strumento Skill quando `skills` è impostato, quindi non è necessario aggiungerlo a `allowedTools`.

123 123

124<CodeGroup>124<CodeGroup>

125 ```python Python theme={null}125 ```python Python theme={null}

131 prompt="Review this PR using our code review checklist",131 prompt="Review this PR using our code review checklist",

132 options=ClaudeAgentOptions(132 options=ClaudeAgentOptions(

133 setting_sources=["user", "project"],133 setting_sources=["user", "project"],

134 allowed_tools=["Skill", "Read", "Grep", "Glob"],134 skills="all",

135 allowed_tools=["Read", "Grep", "Glob"],

135 ),136 ),

136 ):137 ):

137 if isinstance(message, ResultMessage) and message.subtype == "success":138 if isinstance(message, ResultMessage) and message.subtype == "success":

147 prompt: "Review this PR using our code review checklist",148 prompt: "Review this PR using our code review checklist",

148 options: {149 options: {

149 settingSources: ["user", "project"],150 settingSources: ["user", "project"],

150 allowedTools: ["Skill", "Read", "Grep", "Glob"]151 skills: "all",

152 allowedTools: ["Read", "Grep", "Glob"]

151 }153 }

152 })) {154 })) {

153 if (message.type === "result" && message.subtype === "success") {155 if (message.type === "result" && message.subtype === "success") {

260| Vuoi... | Usa | Superficie SDK |262| Vuoi... | Usa | Superficie SDK |

261| :--------------------------------------------------------------------------------------------------------- | :---------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |263| :--------------------------------------------------------------------------------------------------------- | :---------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

264| Eseguire un flusso di lavoro riutilizzabile (deploy, review, release) | [Skills invocabili dall'utente](/it/agent-sdk/skills) | `settingSources` + `allowedTools: ["Skill"]` |266| Eseguire un flusso di lavoro riutilizzabile (deploy, review, release) | [Skills invocabili dall'utente](/it/agent-sdk/skills) | opzione `settingSources` + `skills` |

266| Coordinare più istanze di Claude Code con elenchi di attività condivisi e messaggistica diretta tra agenti | [Team di agenti](/it/agent-teams) | Non configurato direttamente tramite le opzioni SDK. I team di agenti sono una funzionalità CLI in cui una sessione agisce come il capo del team, coordinando il lavoro tra i compagni di squadra indipendenti |268| Coordinare più istanze di Claude Code con elenchi di attività condivisi e messaggistica diretta tra agenti | [Team di agenti](/it/agent-teams) | Non configurato direttamente tramite le opzioni SDK. I team di agenti sono una funzionalità CLI in cui una sessione agisce come il capo del team, coordinando il lavoro tra i compagni di squadra indipendenti |

267| Eseguire logica deterministica sulle chiamate di strumenti (audit, block, transform) | [Hooks](/it/agent-sdk/hooks) | parametro `hooks` con callback, o script shell caricati tramite `settingSources` |269| Eseguire logica deterministica sulle chiamate di strumenti (audit, block, transform) | [Hooks](/it/agent-sdk/hooks) | parametro `hooks` con callback, o script shell caricati tramite `settingSources` |

agent-sdk/mcp.md +772 −0 created

Details

1> ## Documentation Index

2> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt

3> Use this file to discover all available pages before exploring further.

5# Connettiti a strumenti esterni con MCP

7> Configura i server MCP per estendere il tuo agente con strumenti esterni. Copre i tipi di trasporto, la ricerca di strumenti per set di strumenti di grandi dimensioni, l'autenticazione e la gestione degli errori.

9Il [Model Context Protocol (MCP)](https://modelcontextprotocol.io/docs/getting-started/intro) è uno standard aperto per connettere agenti AI a strumenti e fonti di dati esterni. Con MCP, il tuo agente può interrogare database, integrarsi con API come Slack e GitHub e connettersi ad altri servizi senza scrivere implementazioni di strumenti personalizzate.

11I server MCP possono essere eseguiti come processi locali, connettersi tramite HTTP o essere eseguiti direttamente all'interno della tua applicazione SDK.

13<Note>

14 Questa pagina copre la configurazione di MCP per l'Agent SDK. Per aggiungere server MCP al Claude Code CLI in modo che si carichino in ogni progetto, consulta [Ambiti di installazione di MCP](/it/mcp#mcp-installation-scopes).

15</Note>

17## Quickstart

19Questo esempio si connette al server MCP della [documentazione di Claude Code](https://code.claude.com/docs) utilizzando il [trasporto HTTP](#httpsse-servers) e utilizza [`allowedTools`](#allow-mcp-tools) con un carattere jolly per consentire tutti gli strumenti dal server.

21<CodeGroup>

22 ```typescript TypeScript theme={null}

23 import { query } from "@anthropic-ai/claude-agent-sdk";

25 for await (const message of query({

26 prompt: "Use the docs MCP server to explain what hooks are in Claude Code",

27 options: {

28 mcpServers: {

29 "claude-code-docs": {

30 type: "http",

31 url: "https://code.claude.com/docs/mcp"

32 }

33 },

34 allowedTools: ["mcp__claude-code-docs__*"]

35 }

36 })) {

37 if (message.type === "result" && message.subtype === "success") {

38 console.log(message.result);

39 }

40 }

41 ```

43 ```python Python theme={null}

44 import asyncio

45 from claude_agent_sdk import query, ClaudeAgentOptions, ResultMessage

48 async def main():

49 options = ClaudeAgentOptions(

50 mcp_servers={

51 "claude-code-docs": {

52 "type": "http",

53 "url": "https://code.claude.com/docs/mcp",

54 }

55 },

56 allowed_tools=["mcp__claude-code-docs__*"],

57 )

59 async for message in query(

60 prompt="Use the docs MCP server to explain what hooks are in Claude Code",

61 options=options,

62 ):

63 if isinstance(message, ResultMessage) and message.subtype == "success":

64 print(message.result)

67 asyncio.run(main())

68 ```

69</CodeGroup>

71L'agente si connette al server di documentazione, cerca informazioni su hooks e restituisce i risultati.

73## Aggiungi un server MCP

75Puoi configurare i server MCP nel codice quando chiami `query()`, oppure in un file `.mcp.json` caricato tramite [`settingSources`](#from-a-config-file).

77### Nel codice

79Passa i server MCP direttamente nell'opzione `mcpServers`:

81<CodeGroup>

82 ```typescript TypeScript theme={null}

83 import { query } from "@anthropic-ai/claude-agent-sdk";

85 for await (const message of query({

86 prompt: "List files in my project",

87 options: {

88 mcpServers: {

89 filesystem: {

90 command: "npx",

91 args: ["-y", "@modelcontextprotocol/server-filesystem", "/Users/me/projects"]

92 }

93 },

94 allowedTools: ["mcp__filesystem__*"]

95 }

96 })) {

97 if (message.type === "result" && message.subtype === "success") {

98 console.log(message.result);

99 }

100 }

101 ```

102

103 ```python Python theme={null}

104 import asyncio

105 from claude_agent_sdk import query, ClaudeAgentOptions, ResultMessage

106

107

108 async def main():

109 options = ClaudeAgentOptions(

110 mcp_servers={

111 "filesystem": {

112 "command": "npx",

113 "args": [

114 "-y",

115 "@modelcontextprotocol/server-filesystem",

116 "/Users/me/projects",

117 ],

118 }

119 },

120 allowed_tools=["mcp__filesystem__*"],

121 )

122

123 async for message in query(prompt="List files in my project", options=options):

124 if isinstance(message, ResultMessage) and message.subtype == "success":

125 print(message.result)

126

127

128 asyncio.run(main())

129 ```

130</CodeGroup>

131

132### Da un file di configurazione

133

134Crea un file `.mcp.json` nella radice del tuo progetto. Il file viene rilevato quando la fonte di impostazione `project` è abilitata, il che è il caso per le opzioni predefinite di `query()`. Se imposti `settingSources` esplicitamente, includi `"project"` affinché questo file venga caricato:

135

136```json theme={null}

137{

138 "mcpServers": {

139 "filesystem": {

140 "command": "npx",

141 "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/me/projects"]

142 }

143 }

144}

145```

146

147## Consenti strumenti MCP

148

149Gli strumenti MCP richiedono un'autorizzazione esplicita prima che Claude possa utilizzarli. Senza autorizzazione, Claude vedrà che gli strumenti sono disponibili ma non sarà in grado di chiamarli.

150

151### Convenzione di denominazione degli strumenti

152

153Gli strumenti MCP seguono il modello di denominazione `mcp__<server-name>__<tool-name>`. Ad esempio, un server GitHub denominato `"github"` con uno strumento `list_issues` diventa `mcp__github__list_issues`.

154

155### Concedi accesso con allowedTools

156

157Utilizza `allowedTools` per specificare quali strumenti MCP Claude può utilizzare:

158

159```typescript hidelines={1,-1} theme={null}

160const _ = {

161 options: {

162 mcpServers: {

163 // your servers

164 },

165 allowedTools: [

166 "mcp__github__*", // All tools from the github server

167 "mcp__db__query", // Only the query tool from db server

168 "mcp__slack__send_message" // Only send_message from slack server

169 ]

170 }

171};

172```

173

174I caratteri jolly (`*`) ti permettono di consentire tutti gli strumenti da un server senza elencare ciascuno individualmente.

175

176<Note>

177 **Preferisci `allowedTools` rispetto alle modalità di autorizzazione per l'accesso a MCP.** `permissionMode: "acceptEdits"` non approva automaticamente gli strumenti MCP (solo le modifiche ai file e i comandi Bash del filesystem). `permissionMode: "bypassPermissions"` approva automaticamente gli strumenti MCP ma disabilita anche tutti gli altri prompt di sicurezza, il che è più ampio del necessario. Un carattere jolly in `allowedTools` concede esattamente il server MCP che desideri e niente di più. Consulta [Modalità di autorizzazione](/it/agent-sdk/permissions#permission-modes) per un confronto completo.

178</Note>

179

180### Scopri gli strumenti disponibili

181

182Per vedere quali strumenti fornisce un server MCP, controlla la documentazione del server o connettiti al server e ispeziona il messaggio di inizializzazione `system`:

183

184```typescript theme={null}

185for await (const message of query({ prompt: "...", options })) {

186 if (message.type === "system" && message.subtype === "init") {

187 console.log("Available MCP tools:", message.mcp_servers);

188 }

189}

190```

191

192## Tipi di trasporto

193

194I server MCP comunicano con il tuo agente utilizzando diversi protocolli di trasporto. Controlla la documentazione del server per vedere quale trasporto supporta:

195

196* Se la documentazione ti fornisce un **comando da eseguire** (come `npx @modelcontextprotocol/server-github`), utilizza stdio

197* Se la documentazione ti fornisce un **URL**, utilizza HTTP o SSE

198* Se stai costruendo i tuoi strumenti personalizzati nel codice, utilizza un server MCP SDK

199

200### Server stdio

201

202Processi locali che comunicano tramite stdin/stdout. Utilizza questo per i server MCP che esegui sulla stessa macchina:

203

204<Tabs>

205 <Tab title="Nel codice">

206 <CodeGroup>

207 ```typescript TypeScript hidelines={1,-1} theme={null}

208 const _ = {

209 options: {

210 mcpServers: {

211 github: {

212 command: "npx",

213 args: ["-y", "@modelcontextprotocol/server-github"],

214 env: {

215 GITHUB_TOKEN: process.env.GITHUB_TOKEN

216 }

217 }

218 },

219 allowedTools: ["mcp__github__list_issues", "mcp__github__search_issues"]

220 }

221 };

222 ```

223

224 ```python Python theme={null}

225 options = ClaudeAgentOptions(

226 mcp_servers={

227 "github": {

228 "command": "npx",

229 "args": ["-y", "@modelcontextprotocol/server-github"],

230 "env": {"GITHUB_TOKEN": os.environ["GITHUB_TOKEN"]},

231 }

232 },

233 allowed_tools=["mcp__github__list_issues", "mcp__github__search_issues"],

234 )

235 ```

236 </CodeGroup>

237 </Tab>

238

239 <Tab title=".mcp.json">

240 ```json theme={null}

241 {

242 "mcpServers": {

243 "github": {

244 "command": "npx",

245 "args": ["-y", "@modelcontextprotocol/server-github"],

246 "env": {

247 "GITHUB_TOKEN": "${GITHUB_TOKEN}"

248 }

249 }

250 }

251 }

252 ```

253 </Tab>

254</Tabs>

255

256### Server HTTP/SSE

257

258Utilizza HTTP o SSE per i server MCP ospitati nel cloud e le API remote:

259

260<Tabs>

261 <Tab title="Nel codice">

262 <CodeGroup>

263 ```typescript TypeScript hidelines={1,-1} theme={null}

264 const _ = {

265 options: {

266 mcpServers: {

267 "remote-api": {

268 type: "sse",

269 url: "https://api.example.com/mcp/sse",

270 headers: {

271 Authorization: `Bearer ${process.env.API_TOKEN}`

272 }

273 }

274 },

275 allowedTools: ["mcp__remote-api__*"]

276 }

277 };

278 ```

279

280 ```python Python theme={null}

281 options = ClaudeAgentOptions(

282 mcp_servers={

283 "remote-api": {

284 "type": "sse",

285 "url": "https://api.example.com/mcp/sse",

286 "headers": {"Authorization": f"Bearer {os.environ['API_TOKEN']}"},

287 }

288 },

289 allowed_tools=["mcp__remote-api__*"],

290 )

291 ```

292 </CodeGroup>

293 </Tab>

294

295 <Tab title=".mcp.json">

296 ```json theme={null}

297 {

298 "mcpServers": {

299 "remote-api": {

300 "type": "sse",

301 "url": "https://api.example.com/mcp/sse",

302 "headers": {

303 "Authorization": "Bearer ${API_TOKEN}"

304 }

305 }

306 }

307 }

308 ```

309 </Tab>

310</Tabs>

311

312Per HTTP (non-streaming), utilizza `"type": "http"` invece.

313

314### Server MCP SDK

315

316Definisci strumenti personalizzati direttamente nel codice della tua applicazione invece di eseguire un processo server separato. Consulta la [guida agli strumenti personalizzati](/it/agent-sdk/custom-tools) per i dettagli di implementazione.

317

318## Ricerca di strumenti MCP

319

320Quando hai molti strumenti MCP configurati, le definizioni degli strumenti possono consumare una parte significativa della tua finestra di contesto. La ricerca di strumenti risolve questo problema trattenendo le definizioni degli strumenti dal contesto e caricando solo quelli di cui Claude ha bisogno per ogni turno.

321

322La ricerca di strumenti è abilitata per impostazione predefinita. Consulta [Ricerca di strumenti](/it/agent-sdk/tool-search) per le opzioni di configurazione e i dettagli.

323

324Per ulteriori dettagli, incluse le best practice e l'utilizzo della ricerca di strumenti con strumenti SDK personalizzati, consulta la [guida alla ricerca di strumenti](/it/agent-sdk/tool-search).

325

326## Autenticazione

327

328La maggior parte dei server MCP richiede l'autenticazione per accedere ai servizi esterni. Passa le credenziali tramite variabili di ambiente nella configurazione del server.

329

330### Passa le credenziali tramite variabili di ambiente

331

332Utilizza il campo `env` per passare chiavi API, token e altre credenziali al server MCP:

333

334<Tabs>

335 <Tab title="Nel codice">

336 <CodeGroup>

337 ```typescript TypeScript hidelines={1,-1} theme={null}

338 const _ = {

339 options: {

340 mcpServers: {

341 github: {

342 command: "npx",

343 args: ["-y", "@modelcontextprotocol/server-github"],

344 env: {

345 GITHUB_TOKEN: process.env.GITHUB_TOKEN

346 }

347 }

348 },

349 allowedTools: ["mcp__github__list_issues"]

350 }

351 };

352 ```

353

354 ```python Python theme={null}

355 options = ClaudeAgentOptions(

356 mcp_servers={

357 "github": {

358 "command": "npx",

359 "args": ["-y", "@modelcontextprotocol/server-github"],

360 "env": {"GITHUB_TOKEN": os.environ["GITHUB_TOKEN"]},

361 }

362 },

363 allowed_tools=["mcp__github__list_issues"],

364 )

365 ```

366 </CodeGroup>

367 </Tab>

368

369 <Tab title=".mcp.json">

370 ```json theme={null}

371 {

372 "mcpServers": {

373 "github": {

374 "command": "npx",

375 "args": ["-y", "@modelcontextprotocol/server-github"],

376 "env": {

377 "GITHUB_TOKEN": "${GITHUB_TOKEN}"

378 }

379 }

380 }

381 }

382 ```

383

384 La sintassi `${GITHUB_TOKEN}` espande le variabili di ambiente in fase di esecuzione.

385 </Tab>

386</Tabs>

387

388Consulta [Elenca i problemi da un repository](#list-issues-from-a-repository) per un esempio completo e funzionante con registrazione di debug.

389

390### Intestazioni HTTP per server remoti

391

392Per i server HTTP e SSE, passa le intestazioni di autenticazione direttamente nella configurazione del server:

393

394<Tabs>

395 <Tab title="Nel codice">

396 <CodeGroup>

397 ```typescript TypeScript hidelines={1,-1} theme={null}

398 const _ = {

399 options: {

400 mcpServers: {

401 "secure-api": {

402 type: "http",

403 url: "https://api.example.com/mcp",

404 headers: {

405 Authorization: `Bearer ${process.env.API_TOKEN}`

406 }

407 }

408 },

409 allowedTools: ["mcp__secure-api__*"]

410 }

411 };

412 ```

413

414 ```python Python theme={null}

415 options = ClaudeAgentOptions(

416 mcp_servers={

417 "secure-api": {

418 "type": "http",

419 "url": "https://api.example.com/mcp",

420 "headers": {"Authorization": f"Bearer {os.environ['API_TOKEN']}"},

421 }

422 },

423 allowed_tools=["mcp__secure-api__*"],

424 )

425 ```

426 </CodeGroup>

427 </Tab>

428

429 <Tab title=".mcp.json">

430 ```json theme={null}

431 {

432 "mcpServers": {

433 "secure-api": {

434 "type": "http",

435 "url": "https://api.example.com/mcp",

436 "headers": {

437 "Authorization": "Bearer ${API_TOKEN}"

438 }

439 }

440 }

441 }

442 ```

443

444 La sintassi `${API_TOKEN}` espande le variabili di ambiente in fase di esecuzione.

445 </Tab>

446</Tabs>

447

448### Autenticazione OAuth2

449

450La [specifica MCP supporta OAuth 2.1](https://modelcontextprotocol.io/specification/2025-03-26/basic/authorization) per l'autorizzazione. L'SDK non gestisce i flussi OAuth automaticamente, ma puoi passare i token di accesso tramite intestazioni dopo aver completato il flusso OAuth nella tua applicazione:

451

452<CodeGroup>

453 ```typescript TypeScript theme={null}

454 // After completing OAuth flow in your app

455 const accessToken = await getAccessTokenFromOAuthFlow();

456

457 const options = {

458 mcpServers: {

459 "oauth-api": {

460 type: "http",

461 url: "https://api.example.com/mcp",

462 headers: {

463 Authorization: `Bearer ${accessToken}`

464 }

465 }

466 },

467 allowedTools: ["mcp__oauth-api__*"]

468 };

469 ```

470

471 ```python Python theme={null}

472 # After completing OAuth flow in your app

473 access_token = await get_access_token_from_oauth_flow()

474

475 options = ClaudeAgentOptions(

476 mcp_servers={

477 "oauth-api": {

478 "type": "http",

479 "url": "https://api.example.com/mcp",

480 "headers": {"Authorization": f"Bearer {access_token}"},

481 }

482 },

483 allowed_tools=["mcp__oauth-api__*"],

484 )

485 ```

486</CodeGroup>

487

488## Esempi

489

490### Elenca i problemi da un repository

491

492Questo esempio si connette al [server GitHub MCP](https://github.com/modelcontextprotocol/servers/tree/main/src/github) per elencare i problemi recenti. L'esempio include la registrazione di debug per verificare la connessione MCP e le chiamate agli strumenti.

493

494Prima di eseguire, crea un [token di accesso personale GitHub](https://github.com/settings/tokens) con ambito `repo` e impostalo come variabile di ambiente:

495

496```bash theme={null}

497export GITHUB_TOKEN=ghp_xxxxxxxxxxxxxxxxxxxx

498```

499

500<CodeGroup>

501 ```typescript TypeScript theme={null}

502 import { query } from "@anthropic-ai/claude-agent-sdk";

503

504 for await (const message of query({

505 prompt: "List the 3 most recent issues in anthropics/claude-code",

506 options: {

507 mcpServers: {

508 github: {

509 command: "npx",

510 args: ["-y", "@modelcontextprotocol/server-github"],

511 env: {

512 GITHUB_TOKEN: process.env.GITHUB_TOKEN

513 }

514 }

515 },

516 allowedTools: ["mcp__github__list_issues"]

517 }

518 })) {

519 // Verify MCP server connected successfully

520 if (message.type === "system" && message.subtype === "init") {

521 console.log("MCP servers:", message.mcp_servers);

522 }

523

524 // Log when Claude calls an MCP tool

525 if (message.type === "assistant") {

526 for (const block of message.message.content) {

527 if (block.type === "tool_use" && block.name.startsWith("mcp__")) {

528 console.log("MCP tool called:", block.name);

529 }

530 }

531 }

532

533 // Print the final result

534 if (message.type === "result" && message.subtype === "success") {

535 console.log(message.result);

536 }

537 }

538 ```

539

540 ```python Python theme={null}

541 import asyncio

542 import os

543 from claude_agent_sdk import (

544 query,

545 ClaudeAgentOptions,

546 ResultMessage,

547 SystemMessage,

548 AssistantMessage,

549 )

550

551

552 async def main():

553 options = ClaudeAgentOptions(

554 mcp_servers={

555 "github": {

556 "command": "npx",

557 "args": ["-y", "@modelcontextprotocol/server-github"],

558 "env": {"GITHUB_TOKEN": os.environ["GITHUB_TOKEN"]},

559 }

560 },

561 allowed_tools=["mcp__github__list_issues"],

562 )

563

564 async for message in query(

565 prompt="List the 3 most recent issues in anthropics/claude-code",

566 options=options,

567 ):

568 # Verify MCP server connected successfully

569 if isinstance(message, SystemMessage) and message.subtype == "init":

570 print("MCP servers:", message.data.get("mcp_servers"))

571

572 # Log when Claude calls an MCP tool

573 if isinstance(message, AssistantMessage):

574 for block in message.content:

575 if hasattr(block, "name") and block.name.startswith("mcp__"):

576 print("MCP tool called:", block.name)

577

578 # Print the final result

579 if isinstance(message, ResultMessage) and message.subtype == "success":

580 print(message.result)

581

582

583 asyncio.run(main())

584 ```

585</CodeGroup>

586

587### Interroga un database

588

589Questo esempio utilizza il [server Postgres MCP](https://github.com/modelcontextprotocol/servers/tree/main/src/postgres) per interrogare un database. La stringa di connessione viene passata come argomento al server. L'agente scopre automaticamente lo schema del database, scrive la query SQL e restituisce i risultati:

590

591<CodeGroup>

592 ```typescript TypeScript theme={null}

593 import { query } from "@anthropic-ai/claude-agent-sdk";

594

595 // Connection string from environment variable

596 const connectionString = process.env.DATABASE_URL;

597

598 for await (const message of query({

599 // Natural language query - Claude writes the SQL

600 prompt: "How many users signed up last week? Break it down by day.",

601 options: {

602 mcpServers: {

603 postgres: {

604 command: "npx",

605 // Pass connection string as argument to the server

606 args: ["-y", "@modelcontextprotocol/server-postgres", connectionString]

607 }

608 },

609 // Allow only read queries, not writes

610 allowedTools: ["mcp__postgres__query"]

611 }

612 })) {

613 if (message.type === "result" && message.subtype === "success") {

614 console.log(message.result);

615 }

616 }

617 ```

618

619 ```python Python theme={null}

620 import asyncio

621 import os

622 from claude_agent_sdk import query, ClaudeAgentOptions, ResultMessage

623

624

625 async def main():

626 # Connection string from environment variable

627 connection_string = os.environ["DATABASE_URL"]

628

629 options = ClaudeAgentOptions(

630 mcp_servers={

631 "postgres": {

632 "command": "npx",

633 # Pass connection string as argument to the server

634 "args": [

635 "-y",

636 "@modelcontextprotocol/server-postgres",

637 connection_string,

638 ],

639 }

640 },

641 # Allow only read queries, not writes

642 allowed_tools=["mcp__postgres__query"],

643 )

644

645 # Natural language query - Claude writes the SQL

646 async for message in query(

647 prompt="How many users signed up last week? Break it down by day.",

648 options=options,

649 ):

650 if isinstance(message, ResultMessage) and message.subtype == "success":

651 print(message.result)

652

653

654 asyncio.run(main())

655 ```

656</CodeGroup>

657

658## Gestione degli errori

659

660I server MCP possono non riuscire a connettersi per vari motivi: il processo del server potrebbe non essere installato, le credenziali potrebbero non essere valide o un server remoto potrebbe essere irraggiungibile.

661

662L'SDK emette un messaggio `system` con sottotipo `init` all'inizio di ogni query. Questo messaggio include lo stato della connessione per ogni server MCP. Controlla il campo `status` per rilevare gli errori di connessione prima che l'agente inizi a lavorare:

663

664<CodeGroup>

665 ```typescript TypeScript theme={null}

666 import { query } from "@anthropic-ai/claude-agent-sdk";

667

668 for await (const message of query({

669 prompt: "Process data",

670 options: {

671 mcpServers: {

672 "data-processor": dataServer

673 }

674 }

675 })) {

676 if (message.type === "system" && message.subtype === "init") {

677 const failedServers = message.mcp_servers.filter((s) => s.status !== "connected");

678

679 if (failedServers.length > 0) {

680 console.warn("Failed to connect:", failedServers);

681 }

682 }

683

684 if (message.type === "result" && message.subtype === "error_during_execution") {

685 console.error("Execution failed");

686 }

687 }

688 ```

689

690 ```python Python theme={null}

691 import asyncio

692 from claude_agent_sdk import query, ClaudeAgentOptions, SystemMessage, ResultMessage

693

694

695 async def main():

696 options = ClaudeAgentOptions(mcp_servers={"data-processor": data_server})

697

698 async for message in query(prompt="Process data", options=options):

699 if isinstance(message, SystemMessage) and message.subtype == "init":

700 failed_servers = [

701 s

702 for s in message.data.get("mcp_servers", [])

703 if s.get("status") != "connected"

704 ]

705

706 if failed_servers:

707 print(f"Failed to connect: {failed_servers}")

708

709 if (

710 isinstance(message, ResultMessage)

711 and message.subtype == "error_during_execution"

712 ):

713 print("Execution failed")

714

715

716 asyncio.run(main())

717 ```

718</CodeGroup>

719

720## Troubleshooting

721

722### Il server mostra lo stato "failed"

723

724Controlla il messaggio `init` per vedere quali server non hanno potuto connettersi:

725

726```typescript theme={null}

727if (message.type === "system" && message.subtype === "init") {

728 for (const server of message.mcp_servers) {

729 if (server.status === "failed") {

730 console.error(`Server ${server.name} failed to connect`);

731 }

732 }

733}

734```

735

736Cause comuni:

737

738* **Variabili di ambiente mancanti**: Assicurati che i token e le credenziali richiesti siano impostati. Per i server stdio, controlla che il campo `env` corrisponda a quello che il server si aspetta.

739* **Server non installato**: Per i comandi `npx`, verifica che il pacchetto esista e che Node.js sia nel tuo PATH.

740* **Stringa di connessione non valida**: Per i server di database, verifica il formato della stringa di connessione e che il database sia accessibile.

741* **Problemi di rete**: Per i server HTTP/SSE remoti, controlla che l'URL sia raggiungibile e che eventuali firewall consentano la connessione.

742

743### Gli strumenti non vengono chiamati

744

745Se Claude vede gli strumenti ma non li utilizza, controlla di aver concesso l'autorizzazione con `allowedTools`:

746

747```typescript hidelines={1,-1} theme={null}

748const _ = {

749 options: {

750 mcpServers: {

751 // your servers

752 },

753 allowedTools: ["mcp__servername__*"] // Required for Claude to use the tools

754 }

755};

756```

757

758### Timeout della connessione

759

760L'SDK MCP ha un timeout predefinito di 60 secondi per le connessioni del server. Se il tuo server impiega più tempo per avviarsi, la connessione avrà esito negativo. Per i server che hanno bisogno di più tempo di avvio, considera:

761

762* Utilizzare un server più leggero se disponibile

763* Pre-riscaldare il server prima di avviare il tuo agente

764* Controllare i log del server per le cause di inizializzazione lenta

765

766## Risorse correlate

767

768* **[Guida agli strumenti personalizzati](/it/agent-sdk/custom-tools)**: Costruisci il tuo server MCP che viene eseguito in-process con la tua applicazione SDK

769* **[Autorizzazioni](/it/agent-sdk/permissions)**: Controlla quali strumenti MCP il tuo agente può utilizzare con `allowedTools` e `disallowedTools`

770* **[Riferimento SDK TypeScript](/it/agent-sdk/typescript)**: Riferimento API completo incluse le opzioni di configurazione di MCP

771* **[Riferimento SDK Python](/it/agent-sdk/python)**: Riferimento API completo incluse le opzioni di configurazione di MCP

772* **[Directory dei server MCP](https://github.com/modelcontextprotocol/servers)**: Sfoglia i server MCP disponibili per database, API e altro

agent-sdk/python.md +2 −1

Details

836| `setting_sources` | `list[SettingSource] \| None` | `None` (Impostazioni predefinite CLI: tutte le fonti) | Controlla quali impostazioni del filesystem caricare. Passa `[]` per disabilitare le impostazioni utente, progetto e locali. Le impostazioni della politica gestita vengono caricate indipendentemente. Vedi [Usa le funzionalità di Claude Code](/it/agent-sdk/claude-code-features#what-settingsources-does-not-control) |836| `setting_sources` | `list[SettingSource] \| None` | `None` (Impostazioni predefinite CLI: tutte le fonti) | Controlla quali impostazioni del filesystem caricare. Passa `[]` per disabilitare le impostazioni utente, progetto e locali. Le impostazioni della politica gestita vengono caricate indipendentemente. Vedi [Usa le funzionalità di Claude Code](/it/agent-sdk/claude-code-features#what-settingsources-does-not-control) |

837| `skills` | `list[str] \| Literal["all"] \| None` | `None` | Skills disponibili per la sessione. Passa `"all"` per abilitare ogni skill scoperta, o un elenco di nomi di skill. Quando impostato, l'SDK abilita lo strumento Skill automaticamente senza elencarlo in `allowed_tools`. Vedi [Skills](/it/agent-sdk/skills) |

1049| `tools` | No | Array di nomi di strumenti consentiti. Se omesso, eredita tutti gli strumenti |1050| `tools` | No | Array di nomi di strumenti consentiti. Se omesso, eredita tutti gli strumenti |

1050| `disallowedTools` | No | Array di nomi di strumenti da rimuovere dal set di strumenti dell'agente |1051| `disallowedTools` | No | Array di nomi di strumenti da rimuovere dal set di strumenti dell'agente |

1051| `model` | No | Override del modello per questo agente. Accetta un alias come `"sonnet"`, `"opus"`, `"haiku"`, o `"inherit"`, o un ID modello completo. Se omesso, utilizza il modello principale |1052| `model` | No | Override del modello per questo agente. Accetta un alias come `"sonnet"`, `"opus"`, `"haiku"`, o `"inherit"`, o un ID modello completo. Se omesso, utilizza il modello principale |

1052| `skills` | No | Elenco dei nomi di skills disponibili per questo agente |1053| `skills` | No | Elenco dei nomi di skills da precaricare nel contesto dell'agente all'avvio. Le skills non elencate rimangono invocabili attraverso lo strumento Skill |

1053| `memory` | No | Fonte di memoria per questo agente: `"user"`, `"project"`, o `"local"` |1054| `memory` | No | Fonte di memoria per questo agente: `"user"`, `"project"`, o `"local"` |

1054| `mcpServers` | No | Server MCP disponibili per questo agente. Ogni voce è un nome di server o un dict `{name: config}` inline |1055| `mcpServers` | No | Server MCP disponibili per questo agente. Ogni voce è un nome di server o un dict `{name: config}` inline |

1055| `initialPrompt` | No | Auto-inviato come il primo turno utente quando questo agente viene eseguito come agente del thread principale |1056| `initialPrompt` | No | Auto-inviato come il primo turno utente quando questo agente viene eseguito come agente del thread principale |

agent-sdk/sessions.md +324 −0 created

Details

1> ## Documentation Index

2> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt

3> Use this file to discover all available pages before exploring further.

5# Lavorare con le sessioni

7> Come le sessioni mantengono la cronologia della conversazione dell'agente, e quando utilizzare continue, resume e fork per tornare a un'esecuzione precedente.

9Una sessione è la cronologia della conversazione che l'SDK accumula mentre il tuo agente lavora. Contiene il tuo prompt, ogni chiamata di strumento che l'agente ha effettuato, ogni risultato dello strumento e ogni risposta. L'SDK la scrive su disco automaticamente in modo che tu possa tornare ad essa in seguito.

11Tornare a una sessione significa che l'agente ha il contesto completo da prima: file che ha già letto, analisi che ha già eseguito, decisioni che ha già preso. Puoi fare una domanda di follow-up, recuperare da un'interruzione o diramati per provare un approccio diverso.

13<Note>

14 Le sessioni mantengono la **conversazione**, non il filesystem. Per fare uno snapshot e ripristinare i cambiamenti ai file che l'agente ha apportato, utilizza [file checkpointing](/it/agent-sdk/file-checkpointing).

15</Note>

17Questa guida copre come scegliere l'approccio giusto per la tua app, le interfacce SDK che tracciano automaticamente le sessioni, come acquisire gli ID di sessione e utilizzare manualmente `resume` e `fork`, e cosa sapere sul ripristino delle sessioni tra host.

19## Scegli un approccio

21Quanto gestione della sessione hai bisogno dipende dalla forma della tua applicazione. La gestione della sessione entra in gioco quando invii più prompt che dovrebbero condividere il contesto. All'interno di una singola chiamata `query()`, l'agente già fa tutti i turni di cui ha bisogno, e i prompt di autorizzazione e `AskUserQuestion` sono [gestiti in-loop](/it/agent-sdk/user-input) (non terminano la chiamata).

23| Cosa stai costruendo | Cosa usare |

24| :------------------------------------------------------------------------------ | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

25| Attività una tantum: singolo prompt, nessun follow-up | Niente di extra. Una singola chiamata `query()` la gestisce. |

26| Chat multi-turno in un processo | [`ClaudeSDKClient` (Python) o `continue: true` (TypeScript)](#automatic-session-management). L'SDK traccia la sessione per te senza gestione degli ID. |

27| Riprendere da dove hai lasciato dopo un riavvio del processo | `continue_conversation=True` (Python) / `continue: true` (TypeScript). Riprende la sessione più recente nella directory, nessun ID necessario. |

28| Riprendere una sessione passata specifica (non la più recente) | Acquisisci l'ID di sessione e passalo a `resume`. |

29| Provare un approccio alternativo senza perdere l'originale | Fai un fork della sessione. |

30| Attività senza stato, non vuoi che nulla sia scritto su disco (solo TypeScript) | Imposta [`persistSession: false`](/it/agent-sdk/typescript#options). La sessione esiste solo in memoria per la durata della chiamata. Python persiste sempre su disco. |

32### Continue, resume e fork

34Continue, resume e fork sono campi opzionali che imposti su `query()` ([`ClaudeAgentOptions`](/it/agent-sdk/python#claudeagentoptions) in Python, [`Options`](/it/agent-sdk/typescript#options) in TypeScript).

36**Continue** e **resume** entrambi riprendono una sessione esistente e la aggiungono. La differenza è come trovano quella sessione:

38* **Continue** trova la sessione più recente nella directory corrente. Non traccia nulla. Funziona bene quando la tua app esegue una conversazione alla volta.

39* **Resume** accetta un ID di sessione specifico. Traccia l'ID. Richiesto quando hai più sessioni (ad esempio, una per utente in un'app multi-utente) o vuoi tornare a una che non è la più recente.

41**Fork** è diverso: crea una nuova sessione che inizia con una copia della cronologia dell'originale. L'originale rimane invariato. Usa fork per provare una direzione diversa mantenendo l'opzione di tornare indietro.

43## Gestione automatica della sessione

45Entrambi gli SDK offrono un'interfaccia che traccia lo stato della sessione per te tra le chiamate, quindi non passi gli ID in giro manualmente. Usali per conversazioni multi-turno all'interno di un singolo processo.

47### Python: `ClaudeSDKClient`

49[`ClaudeSDKClient`](/it/agent-sdk/python#claudesdkclient) gestisce gli ID di sessione internamente. Ogni chiamata a `client.query()` continua automaticamente la stessa sessione. Chiama [`client.receive_response()`](/it/agent-sdk/python#claudesdkclient) per iterare sui messaggi per la query corrente. Il client deve essere utilizzato come gestore di contesto asincrono.

51Questo esempio esegue due query contro lo stesso `client`. La prima chiede all'agente di analizzare un modulo; la seconda gli chiede di refactorizzare quel modulo. Poiché entrambe le chiamate passano attraverso la stessa istanza del client, la seconda query ha il contesto completo dalla prima senza alcun `resume` esplicito o ID di sessione:

53```python Python theme={null}

54import asyncio

55from claude_agent_sdk import (

56 ClaudeSDKClient,

57 ClaudeAgentOptions,

58 AssistantMessage,

59 ResultMessage,

60 TextBlock,

61)

64def print_response(message):

65 """Print only the human-readable parts of a message."""

66 if isinstance(message, AssistantMessage):

67 for block in message.content:

68 if isinstance(block, TextBlock):

69 print(block.text)

70 elif isinstance(message, ResultMessage):

71 cost = (

72 f"${message.total_cost_usd:.4f}"

73 if message.total_cost_usd is not None

74 else "N/A"

75 )

76 print(f"[done: {message.subtype}, cost: {cost}]")

79async def main():

80 options = ClaudeAgentOptions(

81 allowed_tools=["Read", "Edit", "Glob", "Grep"],

82 )

84 async with ClaudeSDKClient(options=options) as client:

85 # First query: client captures the session ID internally

86 await client.query("Analyze the auth module")

87 async for message in client.receive_response():

88 print_response(message)

90 # Second query: automatically continues the same session

91 await client.query("Now refactor it to use JWT")

92 async for message in client.receive_response():

93 print_response(message)

96asyncio.run(main())

97```

99Vedi il [riferimento Python SDK](/it/agent-sdk/python#choosing-between-query-and-claudesdkclient) per i dettagli su quando usare `ClaudeSDKClient` rispetto alla funzione standalone `query()`.

100

101### TypeScript: `continue: true`

102

103L'SDK TypeScript stabile (la funzione `query()` utilizzata in tutta questa documentazione, a volte chiamata V1) non ha un oggetto client che tiene la sessione come il `ClaudeSDKClient` di Python. Invece, passa `continue: true` su ogni successiva chiamata `query()` e l'SDK raccoglie la sessione più recente nella directory corrente. Nessun tracciamento degli ID richiesto.

104

105Questo esempio effettua due separate chiamate `query()`. La prima crea una sessione nuova; la seconda imposta `continue: true`, che dice all'SDK di trovare e riprendere la sessione più recente su disco. L'agente ha il contesto completo dalla prima chiamata:

106

107```typescript TypeScript theme={null}

108import { query } from "@anthropic-ai/claude-agent-sdk";

109

110// First query: creates a new session

111for await (const message of query({

112 prompt: "Analyze the auth module",

113 options: { allowedTools: ["Read", "Glob", "Grep"] }

114})) {

115 if (message.type === "result" && message.subtype === "success") {

116 console.log(message.result);

117 }

118}

119

120// Second query: continue: true resumes the most recent session

121for await (const message of query({

122 prompt: "Now refactor it to use JWT",

123 options: {

124 continue: true,

125 allowedTools: ["Read", "Edit", "Write", "Glob", "Grep"]

126 }

127})) {

128 if (message.type === "result" && message.subtype === "success") {

129 console.log(message.result);

130 }

131}

132```

133

134<Note>

135 L'API di sessione sperimentale [V2](/it/agent-sdk/typescript-v2-preview), che forniva `createSession()` con un pattern `send` / `stream`, è deprecata. Usa la funzione V1 `query()` e le opzioni di sessione descritte in questa pagina.

136</Note>

137

138## Usa le opzioni di sessione con `query()`

139

140### Acquisisci l'ID di sessione

141

142Resume e fork richiedono un ID di sessione. Leggilo dal campo `session_id` sul messaggio di risultato ([`ResultMessage`](/it/agent-sdk/python#resultmessage) in Python, [`SDKResultMessage`](/it/agent-sdk/typescript#sdkresultmessage) in TypeScript), che è presente su ogni risultato indipendentemente dal successo o dall'errore. In TypeScript l'ID è disponibile anche prima come campo diretto sul `SystemMessage` di init; in Python è annidato dentro `SystemMessage.data`.

143

144<CodeGroup>

145 ```python Python theme={null}

146 import asyncio

147 from claude_agent_sdk import query, ClaudeAgentOptions, ResultMessage

148

149

150 async def main():

151 session_id = None

152

153 async for message in query(

154 prompt="Analyze the auth module and suggest improvements",

155 options=ClaudeAgentOptions(

156 allowed_tools=["Read", "Glob", "Grep"],

157 ),

158 ):

159 if isinstance(message, ResultMessage):

160 session_id = message.session_id

161 if message.subtype == "success":

162 print(message.result)

163

164 print(f"Session ID: {session_id}")

165 return session_id

166

167

168 session_id = asyncio.run(main())

169 ```

170

171 ```typescript TypeScript theme={null}

172 import { query } from "@anthropic-ai/claude-agent-sdk";

173

174 let sessionId: string | undefined;

175

176 for await (const message of query({

177 prompt: "Analyze the auth module and suggest improvements",

178 options: { allowedTools: ["Read", "Glob", "Grep"] }

179 })) {

180 if (message.type === "result") {

181 sessionId = message.session_id;

182 if (message.subtype === "success") {

183 console.log(message.result);

184 }

185 }

186 }

187

188 console.log(`Session ID: ${sessionId}`);

189 ```

190</CodeGroup>

191

192### Riprendi per ID

193

194Passa un ID di sessione a `resume` per tornare a quella sessione specifica. L'agente riprende con il contesto completo da dove la sessione si è fermata. Motivi comuni per riprendere:

195

196* **Seguire un'attività completata.** L'agente ha già analizzato qualcosa; ora vuoi che agisca su quell'analisi senza rileggere i file.

197* **Recuperare da un limite.** La prima esecuzione è terminata con `error_max_turns` o `error_max_budget_usd` (vedi [Gestisci il risultato](/it/agent-sdk/agent-loop#handle-the-result)); riprendi con un limite più alto.

198* **Riavvia il tuo processo.** Hai acquisito l'ID prima dell'arresto e vuoi ripristinare la conversazione.

199

200Questo esempio riprende la sessione da [Acquisisci l'ID di sessione](#capture-the-session-id) con un prompt di follow-up. Poiché stai riprendendo, l'agente ha già l'analisi precedente nel contesto:

201

202<CodeGroup>

203 ```python Python theme={null}

204 # Earlier session analyzed the code; now build on that analysis

205 async for message in query(

206 prompt="Now implement the refactoring you suggested",

207 options=ClaudeAgentOptions(

208 resume=session_id,

209 allowed_tools=["Read", "Edit", "Write", "Glob", "Grep"],

210 ),

211 ):

212 if isinstance(message, ResultMessage) and message.subtype == "success":

213 print(message.result)

214 ```

215

216 ```typescript TypeScript theme={null}

217 // Earlier session analyzed the code; now build on that analysis

218 for await (const message of query({

219 prompt: "Now implement the refactoring you suggested",

220 options: {

221 resume: sessionId,

222 allowedTools: ["Read", "Edit", "Write", "Glob", "Grep"]

223 }

224 })) {

225 if (message.type === "result" && message.subtype === "success") {

226 console.log(message.result);

227 }

228 }

229 ```

230</CodeGroup>

231

232<Tip>

233 Se una chiamata `resume` restituisce una sessione nuova invece della cronologia prevista, la causa più comune è un `cwd` non corrispondente. Le sessioni sono archiviate sotto `~/.claude/projects/<encoded-cwd>/*.jsonl`, dove `<encoded-cwd>` è la directory di lavoro assoluta con ogni carattere non alfanumerico sostituito da `-` (quindi `/Users/me/proj` diventa `-Users-me-proj`). Se la tua chiamata resume viene eseguita da una directory diversa, l'SDK cerca nel posto sbagliato. Il file di sessione deve anche esistere sulla macchina corrente.

234</Tip>

235

236Per riprendere sessioni tra macchine o in ambienti serverless, specchia i transcript in un archivio condiviso con un adattatore [`SessionStore`](/it/agent-sdk/session-storage).

237

238### Fai un fork per esplorare alternative

239

240Il forking crea una nuova sessione che inizia con una copia della cronologia dell'originale ma diverge da quel punto. Il fork ottiene il suo proprio ID di sessione; l'ID e la cronologia dell'originale rimangono invariati. Finisci con due sessioni indipendenti che puoi riprendere separatamente.

241

242<Note>

243 Il forking dirama la cronologia della conversazione, non il filesystem. Se un agente con fork modifica i file, quei cambiamenti sono reali e visibili a qualsiasi sessione che lavora nella stessa directory. Per diramazioni e ripristino dei cambiamenti ai file, utilizza [file checkpointing](/it/agent-sdk/file-checkpointing).

244</Note>

245

246Questo esempio si basa su [Acquisisci l'ID di sessione](#capture-the-session-id): hai già analizzato un modulo di autenticazione in `session_id` e vuoi esplorare OAuth2 senza perdere il thread focalizzato su JWT. Il primo blocco fa un fork della sessione e acquisisce l'ID del fork (`forked_id`); il secondo blocco riprende il `session_id` originale per continuare lungo il percorso JWT. Ora hai due ID di sessione che puntano a due cronologie separate:

247

248<CodeGroup>

249 ```python Python theme={null}

250 # Fork: branch from session_id into a new session

251 forked_id = None

252 async for message in query(

253 prompt="Instead of JWT, implement OAuth2 for the auth module",

254 options=ClaudeAgentOptions(

255 resume=session_id,

256 fork_session=True,

257 ),

258 ):

259 if isinstance(message, ResultMessage):

260 forked_id = message.session_id # The fork's ID, distinct from session_id

261 if message.subtype == "success":

262 print(message.result)

263

264 print(f"Forked session: {forked_id}")

265

266 # Original session is untouched; resuming it continues the JWT thread

267 async for message in query(

268 prompt="Continue with the JWT approach",

269 options=ClaudeAgentOptions(resume=session_id),

270 ):

271 if isinstance(message, ResultMessage) and message.subtype == "success":

272 print(message.result)

273 ```

274

275 ```typescript TypeScript theme={null}

276 // Fork: branch from sessionId into a new session

277 let forkedId: string | undefined;

278

279 for await (const message of query({

280 prompt: "Instead of JWT, implement OAuth2 for the auth module",

281 options: {

282 resume: sessionId,

283 forkSession: true

284 }

285 })) {

286 if (message.type === "system" && message.subtype === "init") {

287 forkedId = message.session_id; // The fork's ID, distinct from sessionId

288 }

289 if (message.type === "result" && message.subtype === "success") {

290 console.log(message.result);

291 }

292 }

293

294 console.log(`Forked session: ${forkedId}`);

295

296 // Original session is untouched; resuming it continues the JWT thread

297 for await (const message of query({

298 prompt: "Continue with the JWT approach",

299 options: { resume: sessionId }

300 })) {

301 if (message.type === "result" && message.subtype === "success") {

302 console.log(message.result);

303 }

304 }

305 ```

306</CodeGroup>

307

308## Riprendi tra host

309

310I file di sessione sono locali alla macchina che li ha creati. Per riprendere una sessione su un host diverso (worker CI, container effimeri, serverless), hai due opzioni:

311

312* **Sposta il file di sessione.** Persisti `~/.claude/projects/<encoded-cwd>/<session-id>.jsonl` dalla prima esecuzione e ripristinalo nello stesso percorso sul nuovo host prima di chiamare `resume`. Il `cwd` deve corrispondere.

313* **Non fare affidamento sul ripristino della sessione.** Acquisisci i risultati di cui hai bisogno (output di analisi, decisioni, diff di file) come stato dell'applicazione e passali nel prompt di una sessione nuova. Questo è spesso più robusto che spedire file di transcript in giro.

314

315Entrambi gli SDK espongono funzioni per enumerare le sessioni su disco e leggere i loro messaggi: [`listSessions()`](/it/agent-sdk/typescript#listsessions) e [`getSessionMessages()`](/it/agent-sdk/typescript#getsessionmessages) in TypeScript, [`list_sessions()`](/it/agent-sdk/python#list_sessions) e [`get_session_messages()`](/it/agent-sdk/python#get_session_messages) in Python. Usali per costruire selettori di sessione personalizzati, logica di pulizia o visualizzatori di transcript.

316

317Entrambi gli SDK espongono anche funzioni per cercare e mutare sessioni individuali: [`get_session_info()`](/it/agent-sdk/python#get_session_info), [`rename_session()`](/it/agent-sdk/python#rename_session) e [`tag_session()`](/it/agent-sdk/python#tag_session) in Python, e [`getSessionInfo()`](/it/agent-sdk/typescript#getsessioninfo), [`renameSession()`](/it/agent-sdk/typescript#renamesession) e [`tagSession()`](/it/agent-sdk/typescript#tagsession) in TypeScript. Usali per organizzare le sessioni per tag o dare loro titoli leggibili dall'uomo.

318

319## Risorse correlate

320

321* [Come funziona il ciclo dell'agente](/it/agent-sdk/agent-loop): Comprendi i turni, i messaggi e l'accumulo del contesto all'interno di una sessione

322* [File checkpointing](/it/agent-sdk/file-checkpointing): Traccia e ripristina i cambiamenti ai file tra le sessioni

323* [Python `ClaudeAgentOptions`](/it/agent-sdk/python#claudeagentoptions): Riferimento completo delle opzioni di sessione per Python

324* [TypeScript `Options`](/it/agent-sdk/typescript#options): Riferimento completo delle opzioni di sessione per TypeScript

agent-sdk/skills.md +314 −0 created

Details

1> ## Documentation Index

2> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt

3> Use this file to discover all available pages before exploring further.

5# Agent Skills nell'SDK

7> Estendi Claude con capacità specializzate utilizzando Agent Skills nell'SDK dell'Agent Claude

9## Panoramica

11Agent Skills estendono Claude con capacità specializzate che Claude richiama autonomamente quando rilevante. Le Skills sono confezionate come file `SKILL.md` contenenti istruzioni, descrizioni e risorse di supporto opzionali.

13Per informazioni complete su Skills, inclusi vantaggi, architettura e linee guida di authoring, consulta la [panoramica di Agent Skills](https://platform.claude.com/docs/it/agents-and-tools/agent-skills/overview).

15## Come funzionano le Skills con l'SDK

17Quando si utilizza l'SDK dell'Agent Claude, le Skills sono:

191. **Definite come artefatti del filesystem**: Create come file `SKILL.md` in directory specifiche (`.claude/skills/`)

202. **Caricate dal filesystem**: Le Skills sono caricate da posizioni del filesystem governate da `settingSources` (TypeScript) o `setting_sources` (Python)

213. **Scoperte automaticamente**: Una volta caricate le impostazioni del filesystem, i metadati della Skill vengono scoperti all'avvio dalle directory dell'utente e del progetto; il contenuto completo viene caricato quando attivato

224. **Richiamate dal modello**: Claude sceglie autonomamente quando utilizzarle in base al contesto

235. **Filtrate tramite l'opzione `skills`**: Le Skills scoperte sono abilitate per impostazione predefinita. Passa un elenco di nomi di Skills, `"all"`, o `[]` per controllare quali sono disponibili nella sessione

25A differenza dei subagents (che possono essere definiti programmaticamente), le Skills devono essere create come artefatti del filesystem. L'SDK non fornisce un'API programmatica per registrare le Skills.

27<Note>

28 Le Skills vengono scoperte attraverso le fonti di impostazione del filesystem. Con le opzioni predefinite di `query()`, l'SDK carica le fonti utente e progetto, quindi le Skills in `~/.claude/skills/` e `<cwd>/.claude/skills/` sono disponibili. Se imposti `settingSources` esplicitamente, includi `'user'` o `'project'` per mantenere la scoperta delle Skills, oppure utilizza l'[opzione `plugins`](/it/agent-sdk/plugins) per caricare le Skills da un percorso specifico.

29</Note>

31## Utilizzo delle Skills con l'SDK

33Imposta l'opzione `skills` su `query()` per controllare quali Skills sono disponibili per la sessione. Se omessa, le Skills scoperte sono abilitate e lo strumento Skill è disponibile, corrispondendo al comportamento della CLI. Passa `"all"` per abilitare ogni Skill scoperta, un elenco di nomi di Skills per abilitare solo quelle, o `[]` per disabilitare tutte. Quando imposti `skills`, l'SDK abilita automaticamente lo strumento Skill, quindi non è necessario elencarlo in `allowedTools`.

35Una volta configurato, Claude scopre automaticamente le Skills dal filesystem e le richiama quando rilevante per la richiesta dell'utente.

37<CodeGroup>

38 ```python Python theme={null}

39 import asyncio

40 from claude_agent_sdk import query, ClaudeAgentOptions

43 async def main():

44 options = ClaudeAgentOptions(

45 cwd="/path/to/project", # Project with .claude/skills/

46 setting_sources=["user", "project"], # Load Skills from filesystem

47 skills="all", # Enable every discovered Skill

48 allowed_tools=["Read", "Write", "Bash"],

49 )

51 async for message in query(

52 prompt="Help me process this PDF document", options=options

53 ):

54 print(message)

57 asyncio.run(main())

58 ```

60 ```typescript TypeScript theme={null}

61 import { query } from "@anthropic-ai/claude-agent-sdk";

63 for await (const message of query({

64 prompt: "Help me process this PDF document",

65 options: {

66 cwd: "/path/to/project", // Project with .claude/skills/

67 settingSources: ["user", "project"], // Load Skills from filesystem

68 skills: "all", // Enable every discovered Skill

69 allowedTools: ["Read", "Write", "Bash"]

70 }

71 })) {

72 console.log(message);

73 }

74 ```

75</CodeGroup>

77Per abilitare solo Skills specifiche, passa i loro nomi. I nomi corrispondono al campo `name` in `SKILL.md` o al nome della directory della Skill. Utilizza `plugin:skill` per le Skills fornite da plugin.

79<CodeGroup>

80 ```python Python theme={null}

81 options = ClaudeAgentOptions(skills=["pdf", "docx"])

82 ```

84 ```typescript TypeScript theme={null}

85 const options = { skills: ["pdf", "docx"] };

86 ```

87</CodeGroup>

89L'opzione `skills` è un filtro di contesto, non una sandbox. Le Skills non elencate sono nascoste dal modello e rifiutate dallo strumento Skill, ma i loro file rimangono sul disco e sono raggiungibili tramite Read e Bash.

91## Posizioni delle Skills

93Le Skills vengono caricate dalle directory del filesystem in base alla configurazione di `settingSources`/`setting_sources`:

95* **Project Skills** (`.claude/skills/`): Condivise con il tuo team tramite git - caricate quando `setting_sources` include `"project"`

96* **User Skills** (`~/.claude/skills/`): Skills personali su tutti i progetti - caricate quando `setting_sources` include `"user"`

97* **Plugin Skills**: Fornite con i plugin Claude Code installati

99## Creazione di Skills

100

101Le Skills sono definite come directory contenenti un file `SKILL.md` con frontmatter YAML e contenuto Markdown. Il campo `description` determina quando Claude richiama la tua Skill.

102

103**Struttura di directory di esempio**:

104

105```bash theme={null}

106.claude/skills/processing-pdfs/

107└── SKILL.md

108```

109

110Per una guida completa sulla creazione di Skills, inclusa la struttura di SKILL.md, Skills multi-file ed esempi, consulta:

111

112* [Agent Skills in Claude Code](/it/skills): Guida completa con esempi

113* [Agent Skills Best Practices](https://platform.claude.com/docs/it/agents-and-tools/agent-skills/best-practices): Linee guida di authoring e convenzioni di denominazione

114

115## Restrizioni degli strumenti

116

117<Note>

118 Il campo frontmatter `allowed-tools` in SKILL.md è supportato solo quando si utilizza direttamente la CLI di Claude Code. **Non si applica quando si utilizzano Skills tramite l'SDK**.

119

120 Quando si utilizza l'SDK, controlla l'accesso agli strumenti tramite l'opzione principale `allowedTools` nella configurazione della query.

121</Note>

122

123Per controllare l'accesso agli strumenti per le Skills nelle applicazioni SDK, utilizza `allowedTools` per pre-approvare strumenti specifici. Senza un callback `canUseTool`, tutto ciò che non è nell'elenco viene negato:

124

125<Note>

126 Le istruzioni di importazione dal primo esempio sono assunte nei seguenti frammenti di codice.

127</Note>

128

129<CodeGroup>

130 ```python Python theme={null}

131 options = ClaudeAgentOptions(

132 setting_sources=["user", "project"], # Load Skills from filesystem

133 skills="all",

134 allowed_tools=["Read", "Grep", "Glob"],

135 )

136

137 async for message in query(prompt="Analyze the codebase structure", options=options):

138 print(message)

139 ```

140

141 ```typescript TypeScript theme={null}

142 for await (const message of query({

143 prompt: "Analyze the codebase structure",

144 options: {

145 settingSources: ["user", "project"], // Load Skills from filesystem

146 skills: "all",

147 allowedTools: ["Read", "Grep", "Glob"],

148 permissionMode: "dontAsk" // Deny anything not in allowedTools

149 }

150 })) {

151 console.log(message);

152 }

153 ```

154</CodeGroup>

155

156## Scoperta delle Skills disponibili

157

158Per vedere quali Skills sono disponibili nella tua applicazione SDK, chiedi semplicemente a Claude:

159

160<CodeGroup>

161 ```python Python theme={null}

162 options = ClaudeAgentOptions(

163 setting_sources=["user", "project"], # Load Skills from filesystem

164 skills="all",

165 )

166

167 async for message in query(prompt="What Skills are available?", options=options):

168 print(message)

169 ```

170

171 ```typescript TypeScript theme={null}

172 for await (const message of query({

173 prompt: "What Skills are available?",

174 options: {

175 settingSources: ["user", "project"], // Load Skills from filesystem

176 skills: "all"

177 }

178 })) {

179 console.log(message);

180 }

181 ```

182</CodeGroup>

183

184Claude elencherà le Skills disponibili in base alla tua directory di lavoro corrente e ai plugin installati.

185

186## Test delle Skills

187

188Testa le Skills ponendo domande che corrispondono alle loro descrizioni:

189

190<CodeGroup>

191 ```python Python theme={null}

192 options = ClaudeAgentOptions(

193 cwd="/path/to/project",

194 setting_sources=["user", "project"], # Load Skills from filesystem

195 skills="all",

196 allowed_tools=["Read", "Bash"],

197 )

198

199 async for message in query(prompt="Extract text from invoice.pdf", options=options):

200 print(message)

201 ```

202

203 ```typescript TypeScript theme={null}

204 for await (const message of query({

205 prompt: "Extract text from invoice.pdf",

206 options: {

207 cwd: "/path/to/project",

208 settingSources: ["user", "project"], // Load Skills from filesystem

209 skills: "all",

210 allowedTools: ["Read", "Bash"]

211 }

212 })) {

213 console.log(message);

214 }

215 ```

216</CodeGroup>

217

218Claude richiama automaticamente la Skill rilevante se la descrizione corrisponde alla tua richiesta.

219

220## Risoluzione dei problemi

221

222### Skills non trovate

223

224**Controlla la configurazione di settingSources**: Le Skills vengono scoperte attraverso le fonti di impostazione `user` e `project`. Se imposti `settingSources`/`setting_sources` esplicitamente e ometti quelle fonti, le Skills non vengono caricate:

225

226<CodeGroup>

227 ```python Python theme={null}

228 # Skills not loaded: setting_sources excludes user and project

229 options = ClaudeAgentOptions(setting_sources=[], skills="all")

230

231 # Skills loaded: user and project sources included

232 options = ClaudeAgentOptions(

233 setting_sources=["user", "project"],

234 skills="all",

235 )

236 ```

237

238 ```typescript TypeScript theme={null}

239 // Skills not loaded: settingSources excludes user and project

240 const options = {

241 settingSources: [],

242 skills: "all"

243 };

244

245 // Skills loaded: user and project sources included

246 const options = {

247 settingSources: ["user", "project"],

248 skills: "all"

249 };

250 ```

251</CodeGroup>

252

253Per ulteriori dettagli su `settingSources`/`setting_sources`, consulta il [riferimento SDK TypeScript](/it/agent-sdk/typescript#settingsource) o il [riferimento SDK Python](/it/agent-sdk/python#settingsource).

254

255**Controlla la directory di lavoro**: L'SDK carica le Skills relative all'opzione `cwd`. Assicurati che punti a una directory contenente `.claude/skills/`:

256

257<CodeGroup>

258 ```python Python theme={null}

259 # Ensure your cwd points to the directory containing .claude/skills/

260 options = ClaudeAgentOptions(

261 cwd="/path/to/project", # Must contain .claude/skills/

262 setting_sources=["user", "project"], # Loads skills from these sources

263 skills="all",

264 )

265 ```

266

267 ```typescript TypeScript theme={null}

268 // Ensure your cwd points to the directory containing .claude/skills/

269 const options = {

270 cwd: "/path/to/project", // Must contain .claude/skills/

271 settingSources: ["user", "project"], // Loads skills from these sources

272 skills: "all"

273 };

274 ```

275</CodeGroup>

276

277Consulta la sezione "Utilizzo delle Skills con l'SDK" sopra per il modello completo.

278

279**Verifica la posizione del filesystem**:

280

281```bash theme={null}

282# Check project Skills

283ls .claude/skills/*/SKILL.md

284

285# Check personal Skills

286ls ~/.claude/skills/*/SKILL.md

287```

288

289### Skill non utilizzata

290

291**Controlla l'opzione `skills`**: Se hai passato un elenco di `skills`, conferma che il nome della Skill sia incluso. Passare `[]` disabilita tutte le Skills.

292

293**Controlla la descrizione**: Assicurati che sia specifica e includa parole chiave rilevanti. Consulta [Agent Skills Best Practices](https://platform.claude.com/docs/it/agents-and-tools/agent-skills/best-practices#writing-effective-descriptions) per una guida sulla scrittura di descrizioni efficaci.

294

295### Risoluzione dei problemi aggiuntiva

296

297Per la risoluzione generale dei problemi delle Skills (sintassi YAML, debug, ecc.), consulta la [sezione di risoluzione dei problemi delle Skills di Claude Code](/it/skills#troubleshooting).

298

299## Documentazione correlata

300

301### Guide sulle Skills

302

303* [Agent Skills in Claude Code](/it/skills): Guida completa delle Skills con creazione, esempi e risoluzione dei problemi

304* [Agent Skills Overview](https://platform.claude.com/docs/it/agents-and-tools/agent-skills/overview): Panoramica concettuale, vantaggi e architettura

305* [Agent Skills Best Practices](https://platform.claude.com/docs/it/agents-and-tools/agent-skills/best-practices): Linee guida di authoring per Skills efficaci

306* [Agent Skills Cookbook](https://platform.claude.com/cookbook/skills-notebooks-01-skills-introduction): Skills di esempio e modelli

307

308### Risorse SDK

309

310* [Subagents in the SDK](/it/agent-sdk/subagents): Agenti basati su filesystem simili con opzioni programmatiche

311* [Slash Commands in the SDK](/it/agent-sdk/slash-commands): Comandi richiamati dall'utente

312* [SDK Overview](/it/agent-sdk/overview): Concetti generali dell'SDK

313* [TypeScript SDK Reference](/it/agent-sdk/typescript): Documentazione API completa

314* [Python SDK Reference](/it/agent-sdk/python): Documentazione API completa

agent-sdk/subagents.md +601 −0 created

Details

1> ## Documentation Index

2> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt

3> Use this file to discover all available pages before exploring further.

5# Subagenti nell'SDK

7> Definisci e richiama subagenti per isolare il contesto, eseguire attività in parallelo e applicare istruzioni specializzate nelle tue applicazioni Claude Agent SDK.

9I subagenti sono istanze di agente separate che il tuo agente principale può generare per gestire sottoattività mirate.

10Utilizza i subagenti per isolare il contesto per sottoattività mirate, eseguire più analisi in parallelo e applicare istruzioni specializzate senza appesantire il prompt dell'agente principale.

12Questa guida spiega come definire e utilizzare i subagenti nell'SDK utilizzando il parametro `agents`.

14## Panoramica

16Puoi creare subagenti in tre modi:

18* **A livello di programmazione**: utilizza il parametro `agents` nelle tue opzioni `query()` ([TypeScript](/it/agent-sdk/typescript#agentdefinition), [Python](/it/agent-sdk/python#agentdefinition))

19* **Basato su file system**: definisci gli agenti come file markdown nelle directory `.claude/agents/` (vedi [definizione di subagenti come file](/it/sub-agents))

20* **Generale integrato**: Claude può richiamare il subagente `general-purpose` integrato in qualsiasi momento tramite lo strumento Agent senza che tu debba definire nulla

22Questa guida si concentra sull'approccio programmatico, che è consigliato per le applicazioni SDK.

24Quando definisci i subagenti, Claude determina se richiamarli in base al campo `description` di ogni subagente. Scrivi descrizioni chiare che spieghino quando il subagente dovrebbe essere utilizzato, e Claude delegherà automaticamente i compiti appropriati. Puoi anche richiedere esplicitamente un subagente per nome nel tuo prompt (ad esempio, "Usa l'agente code-reviewer per...").

26## Vantaggi dell'utilizzo dei subagenti

28### Isolamento del contesto

30Ogni subagente viene eseguito nella propria conversazione nuova. Le chiamate agli strumenti intermedi e i risultati rimangono all'interno del subagente; solo il suo messaggio finale ritorna al genitore. Vedi [Cosa ereditano i subagenti](#what-subagents-inherit) per sapere esattamente cosa c'è nel contesto del subagente.

32**Esempio:** un subagente `research-assistant` può esplorare dozzine di file senza che nessuno di questi contenuti si accumuli nella conversazione principale. Il genitore riceve un riassunto conciso, non ogni file che il subagente ha letto.

34### Parallelizzazione

36Più subagenti possono essere eseguiti contemporaneamente, accelerando drasticamente i flussi di lavoro complessi.

38**Esempio:** durante una revisione del codice, puoi eseguire i subagenti `style-checker`, `security-scanner` e `test-coverage` simultaneamente, riducendo il tempo di revisione da minuti a secondi.

40### Istruzioni e conoscenze specializzate

42Ogni subagente può avere prompt di sistema personalizzati con competenze specifiche, best practice e vincoli.

44**Esempio:** un subagente `database-migration` può avere conoscenze dettagliate sulle best practice SQL, strategie di rollback e controlli di integrità dei dati che sarebbero rumore inutile nelle istruzioni dell'agente principale.

46### Restrizioni degli strumenti

48I subagenti possono essere limitati a strumenti specifici, riducendo il rischio di azioni indesiderate.

50**Esempio:** un subagente `doc-reviewer` potrebbe avere accesso solo agli strumenti Read e Grep, assicurando che possa analizzare ma non modifichi mai accidentalmente i tuoi file di documentazione.

52## Creazione di subagenti

54### Definizione programmatica (consigliata)

56Definisci i subagenti direttamente nel tuo codice utilizzando il parametro `agents`. Questo esempio crea due subagenti: un revisore di codice con accesso in sola lettura e un esecutore di test che può eseguire comandi. Lo strumento `Agent` deve essere incluso in `allowedTools` poiché Claude richiama i subagenti tramite lo strumento Agent.

58<CodeGroup>

59 ```python Python theme={null}

60 import asyncio

61 from claude_agent_sdk import query, ClaudeAgentOptions, AgentDefinition

64 async def main():

65 async for message in query(

66 prompt="Review the authentication module for security issues",

67 options=ClaudeAgentOptions(

68 # Agent tool is required for subagent invocation

69 allowed_tools=["Read", "Grep", "Glob", "Agent"],

70 agents={

71 "code-reviewer": AgentDefinition(

72 # description tells Claude when to use this subagent

73 description="Expert code review specialist. Use for quality, security, and maintainability reviews.",

74 # prompt defines the subagent's behavior and expertise

75 prompt="""You are a code review specialist with expertise in security, performance, and best practices.

77 When reviewing code:

78 - Identify security vulnerabilities

79 - Check for performance issues

80 - Verify adherence to coding standards

81 - Suggest specific improvements

83 Be thorough but concise in your feedback.""",

84 # tools restricts what the subagent can do (read-only here)

85 tools=["Read", "Grep", "Glob"],

86 # model overrides the default model for this subagent

87 model="sonnet",

88 ),

89 "test-runner": AgentDefinition(

90 description="Runs and analyzes test suites. Use for test execution and coverage analysis.",

91 prompt="""You are a test execution specialist. Run tests and provide clear analysis of results.

93 Focus on:

94 - Running test commands

95 - Analyzing test output

96 - Identifying failing tests

97 - Suggesting fixes for failures""",

98 # Bash access lets this subagent run test commands

99 tools=["Bash", "Read", "Grep"],

100 ),

101 },

102 ),

103 ):

104 if hasattr(message, "result"):

105 print(message.result)

106

107

108 asyncio.run(main())

109 ```

110

111 ```typescript TypeScript theme={null}

112 import { query } from "@anthropic-ai/claude-agent-sdk";

113

114 for await (const message of query({

115 prompt: "Review the authentication module for security issues",

116 options: {

117 // Agent tool is required for subagent invocation

118 allowedTools: ["Read", "Grep", "Glob", "Agent"],

119 agents: {

120 "code-reviewer": {

121 // description tells Claude when to use this subagent

122 description:

123 "Expert code review specialist. Use for quality, security, and maintainability reviews.",

124 // prompt defines the subagent's behavior and expertise

125 prompt: `You are a code review specialist with expertise in security, performance, and best practices.

126

127 When reviewing code:

128 - Identify security vulnerabilities

129 - Check for performance issues

130 - Verify adherence to coding standards

131 - Suggest specific improvements

132

133 Be thorough but concise in your feedback.`,

134 // tools restricts what the subagent can do (read-only here)

135 tools: ["Read", "Grep", "Glob"],

136 // model overrides the default model for this subagent

137 model: "sonnet"

138 },

139 "test-runner": {

140 description:

141 "Runs and analyzes test suites. Use for test execution and coverage analysis.",

142 prompt: `You are a test execution specialist. Run tests and provide clear analysis of results.

143

144 Focus on:

145 - Running test commands

146 - Analyzing test output

147 - Identifying failing tests

148 - Suggesting fixes for failures`,

149 // Bash access lets this subagent run test commands

150 tools: ["Bash", "Read", "Grep"]

151 }

152 }

153 }

154 })) {

155 if ("result" in message) console.log(message.result);

156 }

157 ```

158</CodeGroup>

159

160### Configurazione di AgentDefinition

161

163| :---------------- | :---------------------------------------------------------- | :----------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

176

177Nell'SDK Python, questi nomi di campo utilizzano camelCase per corrispondere al formato wire. Vedi il riferimento [`AgentDefinition`](/it/agent-sdk/python#agentdefinition) per i dettagli.

178

179<Note>

180 I subagenti non possono generare i propri subagenti. Non includere `Agent` nell'array `tools` di un subagente.

181</Note>

182

183### Definizione basata su file system (alternativa)

184

185Puoi anche definire i subagenti come file markdown nelle directory `.claude/agents/`. Vedi la [documentazione dei subagenti Claude Code](/it/sub-agents) per i dettagli su questo approccio. Gli agenti definiti a livello di programmazione hanno la precedenza sugli agenti basati su file system con lo stesso nome.

186

187<Note>

188 Anche senza definire subagenti personalizzati, Claude può generare il subagente `general-purpose` integrato quando `Agent` è nei tuoi `allowedTools`. Questo è utile per delegare attività di ricerca o esplorazione senza creare agenti specializzati.

189</Note>

190

191## Cosa ereditano i subagenti

192

193La finestra di contesto di un subagente inizia da zero (nessuna conversazione genitore) ma non è vuota. L'unico canale dal genitore al subagente è la stringa di prompt dello strumento Agent, quindi includi direttamente nel prompt qualsiasi percorso di file, messaggio di errore o decisione di cui il subagente ha bisogno.

194

195| Il subagente riceve | Il subagente non riceve |

196| :------------------------------------------------------------------------------------ | :-------------------------------------------------------------------------------------- |

197| Il suo prompt di sistema (`AgentDefinition.prompt`) e il prompt dello strumento Agent | La cronologia della conversazione del genitore o i risultati degli strumenti |

198| CLAUDE.md del progetto (caricato tramite `settingSources`) | Contenuto di skill precaricato, a meno che non sia elencato in `AgentDefinition.skills` |

199| Definizioni degli strumenti (ereditate dal genitore, o il sottoinsieme in `tools`) | Il prompt di sistema del genitore |

200

201<Note>

202 Il genitore riceve il messaggio finale del subagente verbatim come risultato dello strumento Agent, ma potrebbe riassumerlo nella sua risposta. Per preservare l'output del subagente verbatim nella risposta rivolta all'utente, includi un'istruzione per farlo nel prompt o nell'opzione `systemPrompt` che passi alla chiamata **principale** `query()`.

203</Note>

204

205## Richiamo dei subagenti

206

207### Richiamo automatico

208

209Claude decide automaticamente quando richiamare i subagenti in base al compito e alla `description` di ogni subagente. Ad esempio, se definisci un subagente `performance-optimizer` con la descrizione "Performance optimization specialist for query tuning", Claude lo richiamerà quando il tuo prompt menziona l'ottimizzazione delle query.

210

211Scrivi descrizioni chiare e specifiche in modo che Claude possa abbinare i compiti al subagente giusto.

212

213### Richiamo esplicito

214

215Per garantire che Claude utilizzi un subagente specifico, menzionalo per nome nel tuo prompt:

216

217```text theme={null}

218"Use the code-reviewer agent to check the authentication module"

219```

220

221Questo bypassa l'abbinamento automatico e richiama direttamente il subagente denominato.

222

223### Configurazione dinamica dell'agente

224

225Puoi creare definizioni di agente dinamicamente in base alle condizioni di runtime. Questo esempio crea un revisore di sicurezza con diversi livelli di rigore, utilizzando un modello più potente per revisioni rigorose.

226

227<CodeGroup>

228 ```python Python theme={null}

229 import asyncio

230 from claude_agent_sdk import query, ClaudeAgentOptions, AgentDefinition

231

232

233 # Factory function that returns an AgentDefinition

234 # This pattern lets you customize agents based on runtime conditions

235 def create_security_agent(security_level: str) -> AgentDefinition:

236 is_strict = security_level == "strict"

237 return AgentDefinition(

238 description="Security code reviewer",

239 # Customize the prompt based on strictness level

240 prompt=f"You are a {'strict' if is_strict else 'balanced'} security reviewer...",

241 tools=["Read", "Grep", "Glob"],

242 # Key insight: use a more capable model for high-stakes reviews

243 model="opus" if is_strict else "sonnet",

244 )

245

246

247 async def main():

248 # The agent is created at query time, so each request can use different settings

249 async for message in query(

250 prompt="Review this PR for security issues",

251 options=ClaudeAgentOptions(

252 allowed_tools=["Read", "Grep", "Glob", "Agent"],

253 agents={

254 # Call the factory with your desired configuration

255 "security-reviewer": create_security_agent("strict")

256 },

257 ),

258 ):

259 if hasattr(message, "result"):

260 print(message.result)

261

262

263 asyncio.run(main())

264 ```

265

266 ```typescript TypeScript theme={null}

267 import { query, type AgentDefinition } from "@anthropic-ai/claude-agent-sdk";

268

269 // Factory function that returns an AgentDefinition

270 // This pattern lets you customize agents based on runtime conditions

271 function createSecurityAgent(securityLevel: "basic" | "strict"): AgentDefinition {

272 const isStrict = securityLevel === "strict";

273 return {

274 description: "Security code reviewer",

275 // Customize the prompt based on strictness level

276 prompt: `You are a ${isStrict ? "strict" : "balanced"} security reviewer...`,

277 tools: ["Read", "Grep", "Glob"],

278 // Key insight: use a more capable model for high-stakes reviews

279 model: isStrict ? "opus" : "sonnet"

280 };

281 }

282

283 // The agent is created at query time, so each request can use different settings

284 for await (const message of query({

285 prompt: "Review this PR for security issues",

286 options: {

287 allowedTools: ["Read", "Grep", "Glob", "Agent"],

288 agents: {

289 // Call the factory with your desired configuration

290 "security-reviewer": createSecurityAgent("strict")

291 }

292 }

293 })) {

294 if ("result" in message) console.log(message.result);

295 }

296 ```

297</CodeGroup>

298

299## Rilevamento dell'invocazione del subagente

300

301I subagenti vengono richiamati tramite lo strumento Agent. Per rilevare quando un subagente viene richiamato, controlla i blocchi `tool_use` dove `name` è `"Agent"`. I messaggi provenienti dal contesto di un subagente includono un campo `parent_tool_use_id`.

302

303<Note>

304 Il nome dello strumento è stato rinominato da `"Task"` a `"Agent"` in Claude Code v2.1.63. Le versioni attuali dell'SDK emettono `"Agent"` nei blocchi `tool_use` ma utilizzano ancora `"Task"` nell'elenco degli strumenti `system:init` e in `result.permission_denials[].tool_name`. Controllare entrambi i valori in `block.name` garantisce la compatibilità tra le versioni dell'SDK.

305</Note>

306

307Questo esempio itera attraverso i messaggi trasmessi, registrando quando un subagente viene richiamato e quando i messaggi successivi provengono dal contesto di esecuzione di quel subagente.

308

309<Note>

310 La struttura del messaggio differisce tra gli SDK. In Python, i blocchi di contenuto sono accessibili direttamente tramite `message.content`. In TypeScript, `SDKAssistantMessage` avvolge il messaggio dell'API Claude, quindi il contenuto è accessibile tramite `message.message.content`.

311</Note>

312

313<CodeGroup>

314 ```python Python theme={null}

315 import asyncio

316 from claude_agent_sdk import query, ClaudeAgentOptions, AgentDefinition

317

318

319 async def main():

320 async for message in query(

321 prompt="Use the code-reviewer agent to review this codebase",

322 options=ClaudeAgentOptions(

323 allowed_tools=["Read", "Glob", "Grep", "Agent"],

324 agents={

325 "code-reviewer": AgentDefinition(

326 description="Expert code reviewer.",

327 prompt="Analyze code quality and suggest improvements.",

328 tools=["Read", "Glob", "Grep"],

329 )

330 },

331 ),

332 ):

333 # Check for subagent invocation. Match both names: older SDK

334 # versions emitted "Task", current versions emit "Agent".

335 if hasattr(message, "content") and message.content:

336 for block in message.content:

337 if getattr(block, "type", None) == "tool_use" and block.name in (

338 "Task",

339 "Agent",

340 ):

341 print(f"Subagent invoked: {block.input.get('subagent_type')}")

342

343 # Check if this message is from within a subagent's context

344 if hasattr(message, "parent_tool_use_id") and message.parent_tool_use_id:

345 print(" (running inside subagent)")

346

347 if hasattr(message, "result"):

348 print(message.result)

349

350

351 asyncio.run(main())

352 ```

353

354 ```typescript TypeScript theme={null}

355 import { query } from "@anthropic-ai/claude-agent-sdk";

356

357 for await (const message of query({

358 prompt: "Use the code-reviewer agent to review this codebase",

359 options: {

360 allowedTools: ["Read", "Glob", "Grep", "Agent"],

361 agents: {

362 "code-reviewer": {

363 description: "Expert code reviewer.",

364 prompt: "Analyze code quality and suggest improvements.",

365 tools: ["Read", "Glob", "Grep"]

366 }

367 }

368 }

369 })) {

370 const msg = message as any;

371

372 // Check for subagent invocation. Match both names: older SDK versions

373 // emitted "Task", current versions emit "Agent".

374 for (const block of msg.message?.content ?? []) {

375 if (block.type === "tool_use" && (block.name === "Task" || block.name === "Agent")) {

376 console.log(`Subagent invoked: ${block.input.subagent_type}`);

377 }

378 }

379

380 // Check if this message is from within a subagent's context

381 if (msg.parent_tool_use_id) {

382 console.log(" (running inside subagent)");

383 }

384

385 if ("result" in message) {

386 console.log(message.result);

387 }

388 }

389 ```

390</CodeGroup>

391

392## Ripresa dei subagenti

393

394I subagenti possono essere ripresi per continuare da dove si erano fermati. I subagenti ripresi mantengono la loro cronologia di conversazione completa, incluse tutte le chiamate agli strumenti precedenti, i risultati e il ragionamento. Il subagente riprende esattamente da dove si era fermato piuttosto che iniziare da zero.

395

396Quando un subagente si completa, Claude riceve il suo ID agente nel risultato dello strumento Agent. Per riprendere un subagente a livello di programmazione:

397

3981. **Cattura l'ID della sessione**: Estrai `session_id` dai messaggi durante la prima query

3992. **Estrai l'ID dell'agente**: Analizza `agentId` dal contenuto del messaggio

4003. **Riprendi la sessione**: Passa `resume: sessionId` nelle opzioni della seconda query e includi l'ID dell'agente nel tuo prompt

401

402<Note>

403 Devi riprendere la stessa sessione per accedere alla trascrizione del subagente. Ogni chiamata `query()` avvia una nuova sessione per impostazione predefinita, quindi passa `resume: sessionId` per continuare nella stessa sessione.

404

405 Se stai utilizzando un agente personalizzato (non uno integrato), devi anche passare la stessa definizione di agente nel parametro `agents` per entrambe le query.

406</Note>

407

408L'esempio seguente dimostra questo flusso: la prima query esegue un subagente e cattura l'ID della sessione e l'ID dell'agente, quindi la seconda query riprende la sessione per porre una domanda di follow-up che richiede il contesto della prima analisi.

409

410<CodeGroup>

411 ```typescript TypeScript theme={null}

412 import { query, type SDKMessage } from "@anthropic-ai/claude-agent-sdk";

413

414 // Helper to extract agentId from message content

415 // Stringify to avoid traversing different block types (TextBlock, ToolResultBlock, etc.)

416 function extractAgentId(message: SDKMessage): string | undefined {

417 if (!("message" in message)) return undefined;

418 // Stringify the content so we can search it without traversing nested blocks

419 const content = JSON.stringify(message.message.content);

420 const match = content.match(/agentId:\s*([a-f0-9-]+)/);

421 return match?.[1];

422 }

423

424 let agentId: string | undefined;

425 let sessionId: string | undefined;

426

427 // First invocation - use the Explore agent to find API endpoints

428 for await (const message of query({

429 prompt: "Use the Explore agent to find all API endpoints in this codebase",

430 options: { allowedTools: ["Read", "Grep", "Glob", "Agent"] }

431 })) {

432 // Capture session_id from ResultMessage (needed to resume this session)

433 if ("session_id" in message) sessionId = message.session_id;

434 // Search message content for the agentId (appears in Agent tool results)

435 const extractedId = extractAgentId(message);

436 if (extractedId) agentId = extractedId;

437 // Print the final result

438 if ("result" in message) console.log(message.result);

439 }

440

441 // Second invocation - resume and ask follow-up

442 if (agentId && sessionId) {

443 for await (const message of query({

444 prompt: `Resume agent ${agentId} and list the top 3 most complex endpoints`,

445 options: { allowedTools: ["Read", "Grep", "Glob", "Agent"], resume: sessionId }

446 })) {

447 if ("result" in message) console.log(message.result);

448 }

449 }

450 ```

451

452 ```python Python theme={null}

453 import asyncio

454 import json

455 import re

456 from claude_agent_sdk import query, ClaudeAgentOptions

457

458

459 def extract_agent_id(text: str) -> str | None:

460 """Extract agentId from Agent tool result text."""

461 match = re.search(r"agentId:\s*([a-f0-9-]+)", text)

462 return match.group(1) if match else None

463

464

465 async def main():

466 agent_id = None

467 session_id = None

468

469 # First invocation - use the Explore agent to find API endpoints

470 async for message in query(

471 prompt="Use the Explore agent to find all API endpoints in this codebase",

472 options=ClaudeAgentOptions(allowed_tools=["Read", "Grep", "Glob", "Agent"]),

473 ):

474 # Capture session_id from ResultMessage (needed to resume this session)

475 if hasattr(message, "session_id"):

476 session_id = message.session_id

477 # Search message content for the agentId (appears in Agent tool results)

478 if hasattr(message, "content"):

479 # Stringify the content so we can search it without traversing nested blocks

480 content_str = json.dumps(message.content, default=str)

481 extracted = extract_agent_id(content_str)

482 if extracted:

483 agent_id = extracted

484 # Print the final result

485 if hasattr(message, "result"):

486 print(message.result)

487

488 # Second invocation - resume and ask follow-up

489 if agent_id and session_id:

490 async for message in query(

491 prompt=f"Resume agent {agent_id} and list the top 3 most complex endpoints",

492 options=ClaudeAgentOptions(

493 allowed_tools=["Read", "Grep", "Glob", "Agent"], resume=session_id

494 ),

495 ):

496 if hasattr(message, "result"):

497 print(message.result)

498

499

500 asyncio.run(main())

501 ```

502</CodeGroup>

503

504Le trascrizioni dei subagenti persistono indipendentemente dalla conversazione principale:

505

506* **Compattazione della conversazione principale**: Quando la conversazione principale si compatta, le trascrizioni dei subagenti non sono interessate. Sono archiviate in file separati.

507* **Persistenza della sessione**: Le trascrizioni dei subagenti persistono all'interno della loro sessione. Puoi riprendere un subagente dopo il riavvio di Claude Code riprendendo la stessa sessione.

508* **Pulizia automatica**: Le trascrizioni vengono pulite in base all'impostazione `cleanupPeriodDays` (predefinito: 30 giorni).

509

510## Restrizioni degli strumenti

511

512I subagenti possono avere accesso agli strumenti limitato tramite il campo `tools`:

513

514* **Ometti il campo**: l'agente eredita tutti gli strumenti disponibili (predefinito)

515* **Specifica gli strumenti**: l'agente può utilizzare solo gli strumenti elencati

516

517Questo esempio crea un agente di analisi in sola lettura che può esaminare il codice ma non può modificare file o eseguire comandi.

518

519<CodeGroup>

520 ```python Python theme={null}

521 import asyncio

522 from claude_agent_sdk import query, ClaudeAgentOptions, AgentDefinition

523

524

525 async def main():

526 async for message in query(

527 prompt="Analyze the architecture of this codebase",

528 options=ClaudeAgentOptions(

529 allowed_tools=["Read", "Grep", "Glob", "Agent"],

530 agents={

531 "code-analyzer": AgentDefinition(

532 description="Static code analysis and architecture review",

533 prompt="""You are a code architecture analyst. Analyze code structure,

534 identify patterns, and suggest improvements without making changes.""",

535 # Read-only tools: no Edit, Write, or Bash access

536 tools=["Read", "Grep", "Glob"],

537 )

538 },

539 ),

540 ):

541 if hasattr(message, "result"):

542 print(message.result)

543

544

545 asyncio.run(main())

546 ```

547

548 ```typescript TypeScript theme={null}

549 import { query } from "@anthropic-ai/claude-agent-sdk";

550

551 for await (const message of query({

552 prompt: "Analyze the architecture of this codebase",

553 options: {

554 allowedTools: ["Read", "Grep", "Glob", "Agent"],

555 agents: {

556 "code-analyzer": {

557 description: "Static code analysis and architecture review",

558 prompt: `You are a code architecture analyst. Analyze code structure,

559 identify patterns, and suggest improvements without making changes.`,

560 // Read-only tools: no Edit, Write, or Bash access

561 tools: ["Read", "Grep", "Glob"]

562 }

563 }

564 }

565 })) {

566 if ("result" in message) console.log(message.result);

567 }

568 ```

569</CodeGroup>

570

571### Combinazioni di strumenti comuni

572

573| Caso d'uso | Strumenti | Descrizione |

574| :---------------------- | :-------------------------------------- | :----------------------------------------------------------------- |

575| Analisi in sola lettura | `Read`, `Grep`, `Glob` | Può esaminare il codice ma non modificare o eseguire |

576| Esecuzione di test | `Bash`, `Read`, `Grep` | Può eseguire comandi e analizzare l'output |

577| Modifica del codice | `Read`, `Edit`, `Write`, `Grep`, `Glob` | Accesso completo in lettura/scrittura senza esecuzione di comandi |

578| Accesso completo | Tutti gli strumenti | Eredita tutti gli strumenti dal genitore (ometti il campo `tools`) |

579

580## Risoluzione dei problemi

581

582### Claude non delega ai subagenti

583

584Se Claude completa i compiti direttamente invece di delegare al tuo subagente:

585

5861. **Includi lo strumento Agent**: i subagenti vengono richiamati tramite lo strumento Agent, quindi deve essere in `allowedTools`

5872. **Usa prompt espliciti**: menziona il subagente per nome nel tuo prompt (ad esempio, "Usa l'agente code-reviewer per...")

5883. **Scrivi una descrizione chiara**: spiega esattamente quando il subagente dovrebbe essere utilizzato in modo che Claude possa abbinare i compiti in modo appropriato

589

590### Agenti basati su file system non caricati

591

592Gli agenti definiti in `.claude/agents/` vengono caricati solo all'avvio. Se crei un nuovo file di agente mentre Claude Code è in esecuzione, riavvia la sessione per caricarlo.

593

594### Windows: errori di prompt lungo

595

596Su Windows, i subagenti con prompt molto lunghi potrebbero non riuscire a causa dei limiti di lunghezza della riga di comando (8191 caratteri). Mantieni i prompt concisi o utilizza agenti basati su file system per istruzioni complesse.

597

598## Documentazione correlata

599

600* [Subagenti Claude Code](/it/sub-agents): documentazione completa sui subagenti incluse le definizioni basate su file system

601* [Panoramica dell'SDK](/it/agent-sdk/overview): introduzione all'SDK Claude Agent

agent-sdk/typescript.md +4 −2

Details

358| `sessionStore` | [`SessionStore`](/it/agent-sdk/session-storage#the-sessionstore-interface) | `undefined` | Specchia i trascritti della sessione in un backend esterno in modo che qualsiasi host possa riprenderli. Vedi [Persisti le sessioni nell'archiviazione esterna](/it/agent-sdk/session-storage) |358| `sessionStore` | [`SessionStore`](/it/agent-sdk/session-storage#the-sessionstore-interface) | `undefined` | Specchia i trascritti della sessione in un backend esterno in modo che qualsiasi host possa riprenderli. Vedi [Persisti le sessioni nell'archiviazione esterna](/it/agent-sdk/session-storage) |

359| `settings` | `string \| Settings` | `undefined` | Oggetto [impostazioni](/it/settings) inline o percorso a un file di impostazioni. Popola il livello flag-settings nell'[ordine di precedenza](/it/settings#settings-precedence). Cambia a runtime con [`applyFlagSettings()`](#applyflagsettings) |359| `settings` | `string \| Settings` | `undefined` | Oggetto [impostazioni](/it/settings) inline o percorso a un file di impostazioni. Popola il livello flag-settings nell'[ordine di precedenza](/it/settings#settings-precedence). Cambia a runtime con [`applyFlagSettings()`](#applyflagsettings) |

360| `settingSources` | [`SettingSource`](#settingsource)`[]` | Impostazioni predefinite CLI (tutte le fonti) | Controlla quali impostazioni del filesystem caricare. Passa `[]` per disabilitare le impostazioni utente, progetto e locali. Le impostazioni della politica gestita vengono caricate indipendentemente. Vedi [Usa le funzioni Claude Code](/it/agent-sdk/claude-code-features#what-settingsources-does-not-control) |360| `settingSources` | [`SettingSource`](#settingsource)`[]` | Impostazioni predefinite CLI (tutte le fonti) | Controlla quali impostazioni del filesystem caricare. Passa `[]` per disabilitare le impostazioni utente, progetto e locali. Le impostazioni della politica gestita vengono caricate indipendentemente. Vedi [Usa le funzioni Claude Code](/it/agent-sdk/claude-code-features#what-settingsources-does-not-control) |

361| `skills` | `string[] \| 'all'` | `undefined` | Skills disponibili per la sessione. Passa `'all'` per abilitare ogni skill scoperta, o un elenco di nomi di skill. Quando impostato, l'SDK abilita automaticamente lo strumento Skill senza elencarlo in `allowedTools`. Vedi [Skills](/it/agent-sdk/skills) |

361| `spawnClaudeCodeProcess` | `(options: SpawnOptions) => SpawnedProcess` | `undefined` | Funzione personalizzata per generare il processo Claude Code. Usa per eseguire Claude Code in VM, container o ambienti remoti |362| `spawnClaudeCodeProcess` | `(options: SpawnOptions) => SpawnedProcess` | `undefined` | Funzione personalizzata per generare il processo Claude Code. Usa per eseguire Claude Code in VM, container o ambienti remoti |

528```529```

529 530

531| :------------------------------------ | :----------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |532| :------------------------------------ | :----------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

532| `description` | Sì | Descrizione in linguaggio naturale di quando usare questo agente |533| `description` | Sì | Descrizione in linguaggio naturale di quando usare questo agente |

533| `tools` | No | Array di nomi di tool consentiti. Se omesso, eredita tutti i tool dal genitore |534| `tools` | No | Array di nomi di tool consentiti. Se omesso, eredita tutti i tool dal genitore. Per precaricare Skills nel contesto dell'agente, usa il campo `skills` piuttosto che elencando `'Skill'` qui |

534| `disallowedTools` | No | Array di nomi di tool da esplicitamente disabilitare per questo agente |535| `disallowedTools` | No | Array di nomi di tool da esplicitamente disabilitare per questo agente |

535| `prompt` | Sì | Il prompt di sistema dell'agente |536| `prompt` | Sì | Il prompt di sistema dell'agente |

536| `model` | No | Override del modello per questo agente. Accetta un alias come `'sonnet'`, `'opus'`, `'haiku'`, `'inherit'`, o un ID modello completo. Se omesso o `'inherit'`, usa il modello principale |537| `model` | No | Override del modello per questo agente. Accetta un alias come `'sonnet'`, `'opus'`, `'haiku'`, `'inherit'`, o un ID modello completo. Se omesso o `'inherit'`, usa il modello principale |

1176 transcript_path: string;1177 transcript_path: string;

1177 cwd: string;1178 cwd: string;

1178 permission_mode?: string;1179 permission_mode?: string;

1180 effort?: { level: string };

1179 agent_id?: string;1181 agent_id?: string;

1180 agent_type?: string;1182 agent_type?: string;

1181};1183};

agent-sdk/typescript-v2-preview.md +5 −9

Details

2> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt2> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt

3> Use this file to discover all available pages before exploring further.3> Use this file to discover all available pages before exploring further.

4 4

~~5# Interfaccia TypeScript SDK V2 (anteprima)~~5# API sessione TypeScript SDK V2 (deprecato)

6 6

~~7> Anteprima dell'SDK Agent TypeScript V2 semplificato, con pattern send/stream basati su sessione per conversazioni multi-turno.~~7> Riferimento per l'API sessione deprecato V2 TypeScript Agent SDK, con pattern send/stream basati su sessione per conversazioni multi-turno.

8 8

9<Warning>9<Warning>

10 L'interfaccia V2 è un'**anteprima instabile**. Le API potrebbero cambiare in base al feedback prima di diventare stabili. Alcune funzionalità come il forking della sessione sono disponibili solo nell'[SDK V1](/it/agent-sdk/typescript).10 Le funzioni API V2 session `unstable_v2_createSession`, `unstable_v2_resumeSession` e `unstable_v2_prompt` sono deprecate e verranno rimosse in una versione futura. Utilizzare invece l'[API V1 `query()`](/it/agent-sdk/typescript).

11</Warning>11</Warning>

12 12

13L'SDK Agent TypeScript V2 di Claude rimuove la necessità di generatori asincroni e coordinamento yield. Questo rende le conversazioni multi-turno più semplici; invece di gestire lo stato del generatore tra i turni, ogni turno è un ciclo `send()`/`stream()` separato. La superficie API si riduce a tre concetti:13V2 era un'API sessione sperimentale che eliminava la necessità di generatori asincroni e coordinamento yield. Invece di gestire lo stato del generatore tra i turni, ogni turno era un ciclo `send()`/`stream()` separato. La superficie API si riduceva a tre concetti:

14 14

15* `createSession()` / `resumeSession()`: Avviare o continuare una conversazione15* `createSession()` / `resumeSession()`: Avviare o continuare una conversazione

16* `session.send()`: Inviare un messaggio16* `session.send()`: Inviare un messaggio

380 380

381## Disponibilità delle funzionalità381## Disponibilità delle funzionalità

382 382

383Non tutte le funzionalità V1 sono ancora disponibili in V2. Le seguenti richiedono l'utilizzo dell'[SDK V1](/it/agent-sdk/typescript):383L'API sessione V2 non supporta tutte le funzionalità V1. Le seguenti richiedono l'[SDK V1](/it/agent-sdk/typescript):

384 384

385* Forking della sessione (opzione `forkSession`)385* Forking della sessione (opzione `forkSession`)

386* Alcuni pattern di input streaming avanzati386* Alcuni pattern di input streaming avanzati

387 387

388## Feedback

~~389~~

390Condividete il vostro feedback sull'interfaccia V2 prima che diventi stabile. Segnalate problemi e suggerimenti tramite [GitHub Issues](https://github.com/anthropics/claude-code/issues).

~~391~~

392## Vedere anche388## Vedere anche

393 389

394* [Riferimento SDK TypeScript (V1)](/it/agent-sdk/typescript) - Documentazione completa dell'SDK V1390* [Riferimento SDK TypeScript (V1)](/it/agent-sdk/typescript) - Documentazione completa dell'SDK V1

agent-teams.md +1 −1

Details

420Esplorate approcci correlati per il lavoro parallelo e la delega:420Esplorate approcci correlati per il lavoro parallelo e la delega:

421 421

422* **Delega leggera**: i [subagents](/it/sub-agents) generano agenti helper per ricerca o verifica all'interno della vostra sessione, migliore per compiti che non hanno bisogno di coordinamento tra agenti422* **Delega leggera**: i [subagents](/it/sub-agents) generano agenti helper per ricerca o verifica all'interno della vostra sessione, migliore per compiti che non hanno bisogno di coordinamento tra agenti

423* **Sessioni parallele manuali**: i [Git worktrees](/it/common-workflows#run-parallel-claude-code-sessions-with-git-worktrees) vi permettono di eseguire più sessioni Claude Code voi stessi senza coordinamento automatico del team423* **Sessioni parallele manuali**: i [Git worktrees](/it/worktrees) vi permettono di eseguire più sessioni Claude Code voi stessi senza coordinamento automatico del team

424* **Confrontare gli approcci**: consultate il confronto [subagent vs agent team](/it/features-overview#compare-similar-features) per una suddivisione fianco a fianco424* **Confrontare gli approcci**: consultate il confronto [subagent vs agent team](/it/features-overview#compare-similar-features) per una suddivisione fianco a fianco

amazon-bedrock.md +1 −111

Details

76 </div>;76 </div>;

77};77};

78 78

~~79export const Experiment = ({flag, treatment, children}) => {~~79<ContactSalesCard surface="bedrock" />

~~80 const VID_KEY = 'exp_vid';~~

81 const CONSENT_COUNTRIES = new Set(['AT', 'BE', 'BG', 'HR', 'CY', 'CZ', 'DK', 'EE', 'FI', 'FR', 'DE', 'GR', 'HU', 'IE', 'IT', 'LV', 'LT', 'LU', 'MT', 'NL', 'PL', 'PT', 'RO', 'SK', 'SI', 'ES', 'SE', 'RE', 'GP', 'MQ', 'GF', 'YT', 'BL', 'MF', 'PM', 'WF', 'PF', 'NC', 'AW', 'CW', 'SX', 'FO', 'GL', 'AX', 'GB', 'UK', 'AI', 'BM', 'IO', 'VG', 'KY', 'FK', 'GI', 'MS', 'PN', 'SH', 'TC', 'GG', 'JE', 'IM', 'CA', 'BR', 'IN']);

~~82 const fnv1a = s => {~~

~~83 let h = 0x811c9dc5;~~

~~84 for (let i = 0; i < s.length; i++) {~~

~~85 h ^= s.charCodeAt(i);~~

~~86 h += (h << 1) + (h << 4) + (h << 7) + (h << 8) + (h << 24);~~

~~87 }~~

~~88 return h >>> 0;~~

~~89 };~~

~~90 const bucket = (seed, vid) => fnv1a(fnv1a(seed + vid) + '') % 10000 < 5000 ? 'control' : 'treatment';~~

~~91 const [decision] = useState(() => {~~

~~92 const params = new URLSearchParams(location.search);~~

~~93 const preBucketed = document.documentElement.dataset['gb_' + flag.replace(/-/g, '_')];~~

~~94 const force = params.get('gb-force');~~

~~95 if (force) {~~

~~96 for (const p of force.split(',')) {~~

~~97 const [k, v] = p.split(':');~~

~~98 if (k === flag) return {~~

~~99 variant: v || 'treatment',~~

100 track: false

101 };

102 }

103 }

104 if (navigator.globalPrivacyControl) {

105 return {

106 variant: 'control',

107 track: false

108 };

109 }

110 const prefsMatch = document.cookie.match(/(?:^|; )anthropic-consent-preferences=([^;]+)/);

111 if (prefsMatch) {

112 try {

113 if (JSON.parse(decodeURIComponent(prefsMatch[1])).analytics !== true) {

114 return {

115 variant: 'control',

116 track: false

117 };

118 }

119 } catch {

120 return {

121 variant: 'control',

122 track: false

123 };

124 }

125 } else {

126 const country = params.get('country')?.toUpperCase() || (document.cookie.match(/(?:^|; )cf_geo=([A-Z]{2})/) || [])[1];

127 if (!country || CONSENT_COUNTRIES.has(country)) {

128 return {

129 variant: 'control',

130 track: false

131 };

132 }

133 }

134 let vid;

135 try {

136 const ajsMatch = document.cookie.match(/(?:^|; )ajs_anonymous_id=([^;]+)/);

137 if (ajsMatch) {

138 vid = decodeURIComponent(ajsMatch[1]).replace(/^"|"$/g, '');

139 } else {

140 vid = localStorage.getItem(VID_KEY);

141 if (!vid) {

142 vid = crypto.randomUUID();

143 }

144 document.cookie = `ajs_anonymous_id=${vid}; domain=.claude.com; path=/; Secure; SameSite=Lax; max-age=31536000`;

145 }

146 try {

147 localStorage.setItem(VID_KEY, vid);

148 } catch {}

149 } catch {

150 return {

151 variant: 'control',

152 track: false

153 };

154 }

155 const variant = preBucketed === '1' ? 'treatment' : preBucketed === '0' ? 'control' : bucket(flag, vid);

156 return {

157 variant,

158 track: true,

159 vid

160 };

161 });

162 useEffect(() => {

163 if (!decision.track) return;

164 fetch('https://api.anthropic.com/api/event_logging/v2/batch', {

165 method: 'POST',

166 headers: {

167 'Content-Type': 'application/json',

168 'x-service-name': 'claude_code_docs'

169 },

170 body: JSON.stringify({

171 events: [{

172 event_type: 'GrowthbookExperimentEvent',

173 event_data: {

174 device_id: decision.vid,

175 anonymous_id: decision.vid,

176 timestamp: new Date().toISOString(),

177 experiment_id: flag,

178 variation_id: decision.variant === 'treatment' ? 1 : 0,

179 environment: 'production'

180 }

181 }]

182 }),

183 keepalive: true

184 }).catch(() => {});

185 }, []);

186 return decision.variant === 'treatment' ? treatment : children;

187};

~~188~~

189<Experiment flag="docs-contact-sales-cta" treatment={<ContactSalesCard surface="bedrock" />} />

190 80

191## Prerequisiti81## Prerequisiti

192 82

cli-reference.md +2 −2

Details

84| `--permission-mode` | Inizia in una [modalità di autorizzazione](/it/permission-modes) specificata. Accetta `default`, `acceptEdits`, `plan`, `auto`, `dontAsk` o `bypassPermissions`. Sostituisce `defaultMode` dai file di impostazioni | `claude --permission-mode plan` |84| `--permission-mode` | Inizia in una [modalità di autorizzazione](/it/permission-modes) specificata. Accetta `default`, `acceptEdits`, `plan`, `auto`, `dontAsk` o `bypassPermissions`. Sostituisce `defaultMode` dai file di impostazioni | `claude --permission-mode plan` |

85| `--permission-prompt-tool` | Specifica uno strumento MCP per gestire i prompt di autorizzazione in modalità non interattiva | `claude -p --permission-prompt-tool mcp_auth_tool "query"` |85| `--permission-prompt-tool` | Specifica uno strumento MCP per gestire i prompt di autorizzazione in modalità non interattiva | `claude -p --permission-prompt-tool mcp_auth_tool "query"` |

86| `--plugin-dir` | Carica un plugin da una directory o da un archivio `.zip` per questa sessione solo. Ogni flag accetta un percorso. Ripeti il flag per più plugin: `--plugin-dir A --plugin-dir B.zip` | `claude --plugin-dir ./my-plugin` |86| `--plugin-dir` | Carica un plugin da una directory o da un archivio `.zip` per questa sessione solo. Ogni flag accetta un percorso. Ripeti il flag per più plugin: `--plugin-dir A --plugin-dir B.zip` | `claude --plugin-dir ./my-plugin` |

87| `--plugin-url` | Recupera un archivio plugin `.zip` da un URL per questa sessione solo. Ogni flag accetta un URL. Ripeti il flag per più plugin | `claude --plugin-url https://example.com/plugin.zip` |87| `--plugin-url` | Recupera un archivio plugin `.zip` da un URL per questa sessione solo. Ripeti il flag per più plugin, o passa URL separati da spazi in un singolo valore tra virgolette | `claude --plugin-url https://example.com/plugin.zip` |

88| `--print`, `-p` | Stampa la risposta senza modalità interattiva (vedi [documentazione Agent SDK](/it/agent-sdk/overview) per i dettagli di utilizzo programmatico) | `claude -p "query"` |88| `--print`, `-p` | Stampa la risposta senza modalità interattiva (vedi [documentazione Agent SDK](/it/agent-sdk/overview) per i dettagli di utilizzo programmatico) | `claude -p "query"` |

90| `--remote-control`, `--rc` | Avvia una sessione interattiva con [Remote Control](/it/remote-control#start-a-remote-control-session) abilitato in modo da poterla controllare anche da claude.ai o dall'app Claude. Facoltativamente passa un nome per la sessione | `claude --remote-control "My Project"` |90| `--remote-control`, `--rc` | Avvia una sessione interattiva con [Remote Control](/it/remote-control#start-a-remote-control-session) abilitato in modo da poterla controllare anche da claude.ai o dall'app Claude. Facoltativamente passa un nome per la sessione | `claude --remote-control "My Project"` |

103| `--tools` | Limita quali strumenti integrati Claude può utilizzare. Usa `""` per disabilitare tutti, `"default"` per tutti, o nomi di strumenti come `"Bash,Edit,Read"` | `claude --tools "Bash,Edit,Read"` |103| `--tools` | Limita quali strumenti integrati Claude può utilizzare. Usa `""` per disabilitare tutti, `"default"` per tutti, o nomi di strumenti come `"Bash,Edit,Read"` | `claude --tools "Bash,Edit,Read"` |

104| `--verbose` | Abilita la registrazione dettagliata, mostra l'output completo turno per turno. Sostituisce l'impostazione [`viewMode`](/it/settings#available-settings) per questa sessione | `claude --verbose` |104| `--verbose` | Abilita la registrazione dettagliata, mostra l'output completo turno per turno. Sostituisce l'impostazione [`viewMode`](/it/settings#available-settings) per questa sessione | `claude --verbose` |

106| `--worktree`, `-w` | Avvia Claude in un [git worktree](/it/worktrees) isolato in `<repo>/.claude/worktrees/<name>`. Se non viene fornito alcun nome, uno viene generato automaticamente | `claude -w feature-auth` |106| `--worktree`, `-w` | Avvia Claude in un [git worktree](/it/worktrees) isolato in `<repo>/.claude/worktrees/<name>`. Se non viene fornito alcun nome, uno viene generato automaticamente. Passa `#<number>` o un URL di pull request di GitHub per recuperare quella PR da `origin` e creare un branch del worktree da essa | `claude -w feature-auth` |

107 107

108### Flag del prompt di sistema108### Flag del prompt di sistema

109 109

commands.md +21 −3

Details

12 12

13Un comando viene riconosciuto solo all'inizio del tuo messaggio. Il testo che segue il nome del comando viene passato ad esso come argomenti.13Un comando viene riconosciuto solo all'inizio del tuo messaggio. Il testo che segue il nome del comando viene passato ad esso come argomenti.

14 14

15La tabella sottostante elenca tutti i comandi inclusi in Claude Code. Le voci contrassegnate come **[Skill](/it/skills#bundled-skills)** sono skill integrate. Utilizzano lo stesso meccanismo delle skill che scrivi tu stesso: un prompt consegnato a Claude, che Claude può anche invocare automaticamente quando rilevante. Tutto il resto è un comando integrato il cui comportamento è codificato nella CLI. Per aggiungere i tuoi comandi, vedi [skills](/it/skills).15## Comandi durante un flusso di lavoro tipico

17La maggior parte dei comandi è utile in un momento specifico di una sessione, dalla configurazione di un progetto all'invio di una modifica.

19**Prima sessione in un repository.** Esegui `/init` per generare un `CLAUDE.md` iniziale, quindi `/memory` per perfezionarlo. Usa `/mcp` e `/agents` per configurare eventuali server o subagent di cui il progetto ha bisogno, e `/permissions` per impostare le regole di approvazione che desideri.

21**Durante un'attività.** `/plan` passa alla modalità plan prima di una modifica importante. `/model` e `/effort` regolano quanto ragionamento stai spendendo. Quando la conversazione diventa lunga, `/context` mostra dove sta andando la finestra e `/compact` la riassume; usa `/btw` per una rapida considerazione laterale che non dovrebbe gonfiare la cronologia.

23**Prima di inviare.** `/diff` mostra cosa è cambiato, `/simplify` esamina i file recenti e applica correzioni di qualità ed efficienza, e `/review` o `/security-review` forniscono una lettura più profonda in sola lettura.

16 24

17Non ogni comando appare per ogni utente. La disponibilità dipende dalla tua piattaforma, dal piano e dall'ambiente. Ad esempio, `/desktop` appare solo su macOS e Windows, e `/upgrade` appare solo sui piani Pro e Max.25**Tra le sessioni.** `/clear` inizia da capo su un nuovo compito mantenendo la memoria del progetto. `/resume` e `/branch` ti permettono di tornare a una conversazione precedente o di crearvi un ramo. `/teleport` estrae una sessione web in questo terminale, e `/remote-control` ti permette di continuare questa sessione locale da un altro dispositivo.

27**Quando qualcosa non va.** `/rewind` riporta il codice e la conversazione a un checkpoint precedente. `/doctor` e `/debug` diagnosticano i problemi di installazione e runtime, e `/feedback` segnala un bug con il contesto della sessione allegato.

29## Tutti i comandi

31La tabella sottostante elenca tutti i comandi inclusi in Claude Code. Le voci contrassegnate come **[Skill](/it/skills#bundled-skills)** sono skill integrate. Utilizzano lo stesso meccanismo delle skill che scrivi tu stesso: un prompt consegnato a Claude, che Claude può anche invocare automaticamente quando rilevante. Tutto il resto è un comando integrato il cui comportamento è codificato nella CLI. Per aggiungere i tuoi comandi, vedi [skills](/it/skills).

18 32

19Nella tabella sottostante, `<arg>` indica un argomento obbligatorio e `[arg]` indica uno facoltativo.33Nella tabella sottostante, `<arg>` indica un argomento obbligatorio e `[arg]` indica uno facoltativo.

20 34

35<Note>

36 Non ogni comando appare per ogni utente. La disponibilità dipende dalla tua piattaforma, dal piano e dall'ambiente. Ad esempio, `/desktop` appare solo su macOS e Windows, e `/upgrade` appare solo sui piani Pro e Max.

37</Note>

22| :---------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |40| :---------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

23| `/add-dir <path>` | Aggiungi una directory di lavoro per l'accesso ai file durante la sessione corrente. La maggior parte della configurazione `.claude/` [non viene rilevata](/it/permissions#additional-directories-grant-file-access-not-configuration) dalla directory aggiunta. Puoi successivamente riprendere la sessione dalla directory aggiunta con `--continue` o `--resume` |41| `/add-dir <path>` | Aggiungi una directory di lavoro per l'accesso ai file durante la sessione corrente. La maggior parte della configurazione `.claude/` [non viene rilevata](/it/permissions#additional-directories-grant-file-access-not-configuration) dalla directory aggiunta. Puoi successivamente riprendere la sessione dalla directory aggiunta con `--continue` o `--resume` |

80| `/review [PR]` | Rivedi una pull request localmente nella tua sessione corrente. Per una revisione più profonda basata su cloud, vedi [`/ultrareview`](/it/ultrareview) |98| `/review [PR]` | Rivedi una pull request localmente nella tua sessione corrente. Per una revisione più profonda basata su cloud, vedi [`/ultrareview`](/it/ultrareview) |

81| `/rewind` | Riavvolgi la conversazione e/o il codice a un punto precedente, o riassumi da un messaggio selezionato. Vedi [checkpointing](/it/checkpointing). Alias: `/checkpoint`, `/undo` |99| `/rewind` | Riavvolgi la conversazione e/o il codice a un punto precedente, o riassumi da un messaggio selezionato. Vedi [checkpointing](/it/checkpointing). Alias: `/checkpoint`, `/undo` |

83| `/schedule [description]` | Crea, aggiorna, elenca o esegui [routine](/it/routines). Claude ti guida attraverso la configurazione in modo conversazionale. Alias: `/routines` |101| `/schedule [description]` | Crea, aggiorna, elenca o esegui [routine](/it/routines), che si eseguono sull'infrastruttura cloud gestita da Anthropic. Claude ti guida attraverso la configurazione in modo conversazionale. Alias: `/routines` |

84| `/security-review` | Analizza le modifiche in sospeso sul ramo corrente per le vulnerabilità di sicurezza. Esamina il diff git e identifica i rischi come iniezione, problemi di autenticazione ed esposizione dei dati |102| `/security-review` | Analizza le modifiche in sospeso sul ramo corrente per le vulnerabilità di sicurezza. Esamina il diff git e identifica i rischi come iniezione, problemi di autenticazione ed esposizione dei dati |

85| `/setup-bedrock` | Configura l'autenticazione [Amazon Bedrock](/it/amazon-bedrock), la regione e i pin del modello attraverso una procedura guidata interattiva. Visibile solo quando `CLAUDE_CODE_USE_BEDROCK=1` è impostato. Gli utenti di Bedrock per la prima volta possono anche accedere a questa procedura guidata dalla schermata di accesso |103| `/setup-bedrock` | Configura l'autenticazione [Amazon Bedrock](/it/amazon-bedrock), la regione e i pin del modello attraverso una procedura guidata interattiva. Visibile solo quando `CLAUDE_CODE_USE_BEDROCK=1` è impostato. Gli utenti di Bedrock per la prima volta possono anche accedere a questa procedura guidata dalla schermata di accesso |

86| `/setup-vertex` | Configura l'autenticazione [Google Vertex AI](/it/google-vertex-ai), il progetto, la regione e i pin del modello attraverso una procedura guidata interattiva. Visibile solo quando `CLAUDE_CODE_USE_VERTEX=1` è impostato. Gli utenti di Vertex AI per la prima volta possono anche accedere a questa procedura guidata dalla schermata di accesso |104| `/setup-vertex` | Configura l'autenticazione [Google Vertex AI](/it/google-vertex-ai), il progetto, la regione e i pin del modello attraverso una procedura guidata interattiva. Visibile solo quando `CLAUDE_CODE_USE_VERTEX=1` è impostato. Gli utenti di Vertex AI per la prima volta possono anche accedere a questa procedura guidata dalla schermata di accesso |

desktop.md +18 −1

Details

564 564

565Ogni voce richiede `id`, `name` e `sshHost`. I campi `sshPort`, `sshIdentityFile` e `startDirectory` sono facoltativi. Gli utenti possono anche aggiungere `sshConfigs` al loro `~/.claude/settings.json`, che è dove vengono archiviate le connessioni aggiunte tramite la finestra di dialogo.565Ogni voce richiede `id`, `name` e `sshHost`. I campi `sshPort`, `sshIdentityFile` e `startDirectory` sono facoltativi. Gli utenti possono anche aggiungere `sshConfigs` al loro `~/.claude/settings.json`, che è dove vengono archiviate le connessioni aggiunte tramite la finestra di dialogo.

566 566

567#### Restrict which SSH hosts users can connect to

568

569Gli amministratori possono limitare le sessioni SSH di Desktop a un insieme approvato di host aggiungendo `sshHostAllowlist` a un file di [impostazioni gestite](/it/settings#settings-precedence). Quando impostato, gli utenti possono connettersi solo a host il cui nome host risolto corrisponde a uno dei modelli. Impostalo su un array vuoto per disabilitare completamente le sessioni SSH.

570

571L'esempio seguente consente connessioni a qualsiasi host sotto `devboxes.example.com` e a un singolo host bastion denominato:

572

573```json theme={null}

574{

575 "sshHostAllowlist": ["*.devboxes.example.com", "bastion.example.com"]

576}

577```

578

579I modelli sono case-insensitive. `*` corrisponde a qualsiasi host, e `*.example.com` corrisponde a `example.com` e a qualsiasi sottodominio. Tutto il resto è una corrispondenza esatta. Il controllo viene eseguito sul nome host dopo la risoluzione di `~/.ssh/config` tramite `ssh -G`, quindi gli alias `Host` e le voci `ProxyCommand`/`ProxyJump` sono consentiti purché il `HostName` risolto corrisponda.

580

581`sshHostAllowlist` viene letto solo dalle impostazioni gestite; i valori nelle impostazioni utente o progetto vengono ignorati. Solo l'app Claude Desktop onora questa impostazione; la CLI Claude Code e le estensioni IDE non la leggono, e non limita i comandi `ssh` eseguiti tramite lo strumento Bash. Governa a quali host l'app Desktop si connette, non l'uscita di rete, quindi abbinalo ai controlli di rete della tua organizzazione o zero-trust se hai bisogno di un confine rigido.

582

567## Configurazione aziendale583## Configurazione aziendale

568 584

569Le organizzazioni su piani Team o Enterprise possono gestire il comportamento dell'app desktop tramite controlli della console di amministrazione, file di impostazioni gestiti e criteri di gestione dei dispositivi.585Le organizzazioni su piani Team o Enterprise possono gestire il comportamento dell'app desktop tramite controlli della console di amministrazione, file di impostazioni gestiti e criteri di gestione dei dispositivi.

582Le impostazioni gestite sovrascrivono le impostazioni del progetto e dell'utente e si applicano quando Desktop genera sessioni CLI. Puoi impostare queste chiavi nel file [impostazioni gestite](/it/settings#settings-precedence) della tua organizzazione o inviarle in remoto tramite la console di amministrazione.598Le impostazioni gestite sovrascrivono le impostazioni del progetto e dell'utente e si applicano quando Desktop genera sessioni CLI. Puoi impostare queste chiavi nel file [impostazioni gestite](/it/settings#settings-precedence) della tua organizzazione o inviarle in remoto tramite la console di amministrazione.

583 599

584| Chiave | Descrizione |600| Chiave | Descrizione |

585| ------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |601| ------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

586| `permissions.disableBypassPermissionsMode` | imposta su `"disable"` per impedire agli utenti di abilitare la modalità bypass permissions. |602| `permissions.disableBypassPermissionsMode` | imposta su `"disable"` per impedire agli utenti di abilitare la modalità bypass permissions. |

587| `disableAutoMode` | imposta su `"disable"` per impedire agli utenti di abilitare la modalità [Auto](/it/permission-modes#eliminate-prompts-with-auto-mode). Rimuove Auto dal selettore di modalità. Accettato anche sotto `permissions`. |603| `disableAutoMode` | imposta su `"disable"` per impedire agli utenti di abilitare la modalità [Auto](/it/permission-modes#eliminate-prompts-with-auto-mode). Rimuove Auto dal selettore di modalità. Accettato anche sotto `permissions`. |

588| `autoMode` | personalizza cosa il classificatore della modalità auto si fida e blocca in tutta la tua organizzazione. Vedi [Configura la modalità auto](/it/auto-mode-config). |604| `autoMode` | personalizza cosa il classificatore della modalità auto si fida e blocca in tutta la tua organizzazione. Vedi [Configura la modalità auto](/it/auto-mode-config). |

589| `sshConfigs` | pre-configura le [connessioni SSH](#pre-configure-ssh-connections-for-your-team) che appaiono nel menu a discesa dell'ambiente. Gli utenti non possono modificare o eliminare le connessioni gestite. |605| `sshConfigs` | pre-configura le [connessioni SSH](#pre-configure-ssh-connections-for-your-team) che appaiono nel menu a discesa dell'ambiente. Gli utenti non possono modificare o eliminare le connessioni gestite. |

606| `sshHostAllowlist` | limita le [sessioni SSH](#restrict-which-ssh-hosts-users-can-connect-to) agli host il cui nome host risolto corrisponde a uno di questi modelli. Un array vuoto disabilita le sessioni SSH. Letto solo dalle impostazioni gestite. |

590 607

591Un file di impostazioni gestite distribuito su disco su ogni macchina si applica alle sessioni Desktop. Le impostazioni gestite inviate in remoto tramite la console di amministrazione attualmente raggiungono solo le sessioni CLI e IDE, quindi per le distribuzioni Desktop distribuisci il file tramite MDM o utilizza i [controlli della console di amministrazione](#admin-console-controls) sopra.608Un file di impostazioni gestite distribuito su disco su ogni macchina si applica alle sessioni Desktop. Le impostazioni gestite inviate in remoto tramite la console di amministrazione attualmente raggiungono solo le sessioni CLI e IDE, quindi per le distribuzioni Desktop distribuisci il file tramite MDM o utilizza i [controlli della console di amministrazione](#admin-console-controls) sopra.

592 609

env-vars.md +3 −1

Details

92| `CLAUDE_CODE_EFFORT_LEVEL` | Imposta il livello di sforzo per i modelli supportati. Valori: `low`, `medium`, `high`, `xhigh`, `max` o `auto` per usare il valore predefinito del modello. I livelli disponibili dipendono dal modello. Ha la precedenza su `/effort` e sull'impostazione `effortLevel`. Vedi [Regola il livello di sforzo](/it/model-config#adjust-effort-level) |92| `CLAUDE_CODE_EFFORT_LEVEL` | Imposta il livello di sforzo per i modelli supportati. Valori: `low`, `medium`, `high`, `xhigh`, `max` o `auto` per usare il valore predefinito del modello. I livelli disponibili dipendono dal modello. Ha la precedenza su `/effort` e sull'impostazione `effortLevel`. Vedi [Regola il livello di sforzo](/it/model-config#adjust-effort-level) |

93| `CLAUDE_CODE_ENABLE_AWAY_SUMMARY` | Sovrascrivi la disponibilità del [riepilogo della sessione](/it/interactive-mode#session-recap). Imposta su `0` per forzare i riepiloghi disattivati indipendentemente dall'interruttore `/config`. Imposta su `1` per forzare i riepiloghi attivati quando [`awaySummaryEnabled`](/it/settings#available-settings) è `false`. Ha la precedenza sull'impostazione e sull'interruttore `/config` |93| `CLAUDE_CODE_ENABLE_AWAY_SUMMARY` | Sovrascrivi la disponibilità del [riepilogo della sessione](/it/interactive-mode#session-recap). Imposta su `0` per forzare i riepiloghi disattivati indipendentemente dall'interruttore `/config`. Imposta su `1` per forzare i riepiloghi attivati quando [`awaySummaryEnabled`](/it/settings#available-settings) è `false`. Ha la precedenza sull'impostazione e sull'interruttore `/config` |

94| `CLAUDE_CODE_ENABLE_BACKGROUND_PLUGIN_REFRESH` | Imposta su `1` per aggiornare lo stato del plugin ai confini dei turni in [modalità non interattiva](/it/headless) dopo il completamento di un'installazione in background. Disattivato per impostazione predefinita perché l'aggiornamento cambia il prompt di sistema a metà sessione, il che invalida il [caching dei prompt](https://platform.claude.com/docs/en/build-with-claude/prompt-caching) per quel turno |94| `CLAUDE_CODE_ENABLE_BACKGROUND_PLUGIN_REFRESH` | Imposta su `1` per aggiornare lo stato del plugin ai confini dei turni in [modalità non interattiva](/it/headless) dopo il completamento di un'installazione in background. Disattivato per impostazione predefinita perché l'aggiornamento cambia il prompt di sistema a metà sessione, il che invalida il [caching dei prompt](https://platform.claude.com/docs/en/build-with-claude/prompt-caching) per quel turno |

95| `CLAUDE_CODE_ENABLE_FINE_GRAINED_TOOL_STREAMING` | Controlla se gli input delle chiamate di strumento vengono trasmessi dall'API mentre Claude li genera. Con questo disattivato, un input di strumento grande come una lunga scrittura di file arriva solo dopo che Claude finisce di generarlo, il che può sembrare che sia bloccato. Abilitato per impostazione predefinita per le connessioni API Anthropic dirette. Imposta su `0` per rinunciare. Imposta su `1` per forzare l'abilitazione anche quando il valore predefinito lato server è disattivato. Non ha effetto su Bedrock, Vertex, Foundry o connessioni [gateway](/it/llm-gateway) |95| `CLAUDE_CODE_ENABLE_FINE_GRAINED_TOOL_STREAMING` | Controlla se gli input delle chiamate di strumento vengono trasmessi dall'API mentre Claude li genera. Con questo disattivato, un input di strumento grande come una lunga scrittura di file arriva solo dopo che Claude finisce di generarlo, il che può sembrare che sia bloccato. Abilitato per impostazione predefinita sull'API Anthropic. Su Bedrock e Vertex, abilitato per modello dove il container distribuito lo supporta. Imposta su `0` per rinunciare. Imposta su `1` per forzare l'abilitazione quando instrada attraverso un proxy tramite `ANTHROPIC_BASE_URL`, `ANTHROPIC_VERTEX_BASE_URL` o `ANTHROPIC_BEDROCK_BASE_URL`. Disattivato per impostazione predefinita su Foundry e connessioni [gateway](/it/llm-gateway) |

96| `CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY` | Imposta su `1` per popolare il selettore `/model` dall'endpoint `/v1/models` del tuo gateway quando `ANTHROPIC_BASE_URL` punta a un gateway compatibile con Anthropic come LiteLLM, Kong o un proxy interno. Disattivato per impostazione predefinita perché i gateway supportati da una chiave API condivisa mostrerebbero altrimenti a ogni utente ogni modello a cui la chiave può accedere. I modelli scoperti vengono comunque filtrati dall'allowlist [`availableModels`](/it/settings#available-settings) |96| `CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY` | Imposta su `1` per popolare il selettore `/model` dall'endpoint `/v1/models` del tuo gateway quando `ANTHROPIC_BASE_URL` punta a un gateway compatibile con Anthropic come LiteLLM, Kong o un proxy interno. Disattivato per impostazione predefinita perché i gateway supportati da una chiave API condivisa mostrerebbero altrimenti a ogni utente ogni modello a cui la chiave può accedere. I modelli scoperti vengono comunque filtrati dall'allowlist [`availableModels`](/it/settings#available-settings) |

97| `CLAUDE_CODE_ENABLE_PROMPT_SUGGESTION` | Imposta su `false` per disabilitare i suggerimenti di prompt (l'interruttore "Prompt suggestions" in `/config`). Questi sono i suggerimenti predetti in grigio che appaiono nel tuo input di prompt dopo che Claude risponde. Vedi [Suggerimenti di prompt](/it/interactive-mode#prompt-suggestions) |97| `CLAUDE_CODE_ENABLE_PROMPT_SUGGESTION` | Imposta su `false` per disabilitare i suggerimenti di prompt (l'interruttore "Prompt suggestions" in `/config`). Questi sono i suggerimenti predetti in grigio che appaiono nel tuo input di prompt dopo che Claude risponde. Vedi [Suggerimenti di prompt](/it/interactive-mode#prompt-suggestions) |

98| `CLAUDE_CODE_ENABLE_TASKS` | Imposta su `1` per abilitare il sistema di tracciamento delle attività in modalità non interattiva (il flag `-p`). Le attività sono abilitate per impostazione predefinita in modalità interattiva. Vedi [Elenco attività](/it/interactive-mode#task-list) |98| `CLAUDE_CODE_ENABLE_TASKS` | Imposta su `1` per abilitare il sistema di tracciamento delle attività in modalità non interattiva (il flag `-p`). Le attività sono abilitate per impostazione predefinita in modalità interattiva. Vedi [Elenco attività](/it/interactive-mode#task-list) |

164| `CLAUDE_CODE_USE_POWERSHELL_TOOL` | Controlla lo strumento PowerShell. Su Windows senza Git Bash, lo strumento è abilitato automaticamente; imposta su `0` per disabilitarlo. Su Windows con Git Bash installato, lo strumento è in rollout progressivo: imposta su `1` per aderire o `0` per rinunciare. Su Linux, macOS e WSL, imposta su `1` per abilitarlo, che richiede `pwsh` nel tuo `PATH`. Se abilitato su Windows, Claude può eseguire i comandi PowerShell nativamente invece di instradare attraverso Git Bash. Vedi [Strumento PowerShell](/it/tools-reference#powershell-tool) |164| `CLAUDE_CODE_USE_POWERSHELL_TOOL` | Controlla lo strumento PowerShell. Su Windows senza Git Bash, lo strumento è abilitato automaticamente; imposta su `0` per disabilitarlo. Su Windows con Git Bash installato, lo strumento è in rollout progressivo: imposta su `1` per aderire o `0` per rinunciare. Su Linux, macOS e WSL, imposta su `1` per abilitarlo, che richiede `pwsh` nel tuo `PATH`. Se abilitato su Windows, Claude può eseguire i comandi PowerShell nativamente invece di instradare attraverso Git Bash. Vedi [Strumento PowerShell](/it/tools-reference#powershell-tool) |

166| `CLAUDE_CONFIG_DIR` | Sovrascrivi la directory di configurazione (predefinito: `~/.claude`). Tutte le impostazioni, le credenziali, la cronologia della sessione e i plugin sono archiviati sotto questo percorso. Utile per eseguire più account affiancati: ad esempio, `alias claude-work='CLAUDE_CONFIG_DIR=~/.claude-work claude'` |166| `CLAUDE_CONFIG_DIR` | Sovrascrivi la directory di configurazione (predefinito: `~/.claude`). Tutte le impostazioni, le credenziali, la cronologia della sessione e i plugin sono archiviati sotto questo percorso. Utile per eseguire più account affiancati: ad esempio, `alias claude-work='CLAUDE_CONFIG_DIR=~/.claude-work claude'` |

167| `CLAUDE_EFFORT` | Impostato automaticamente nei sottoprocessi dello strumento Bash e nei comandi hook al [livello di sforzo](/it/model-config#adjust-effort-level) attivo per il turno: `low`, `medium`, `high`, `xhigh` o `max`. Corrisponde al campo `effort.level` passato agli [hook](/it/hooks). Impostato solo quando il modello corrente supporta il parametro effort |

167| `CLAUDE_ENABLE_BYTE_WATCHDOG` | Imposta su `1` per forzare l'abilitazione del watchdog di inattività a livello di byte, o imposta su `0` per forzare la disabilitazione. Se non impostato, il watchdog è abilitato per impostazione predefinita per le connessioni API Anthropic. Il byte watchdog interrompe una connessione quando nessun byte arriva sul filo per la durata impostata da `CLAUDE_STREAM_IDLE_TIMEOUT_MS`, con un minimo di 5 minuti, indipendente dal watchdog a livello di evento |168| `CLAUDE_ENABLE_BYTE_WATCHDOG` | Imposta su `1` per forzare l'abilitazione del watchdog di inattività a livello di byte, o imposta su `0` per forzare la disabilitazione. Se non impostato, il watchdog è abilitato per impostazione predefinita per le connessioni API Anthropic. Il byte watchdog interrompe una connessione quando nessun byte arriva sul filo per la durata impostata da `CLAUDE_STREAM_IDLE_TIMEOUT_MS`, con un minimo di 5 minuti, indipendente dal watchdog a livello di evento |

168| `CLAUDE_ENABLE_STREAM_WATCHDOG` | Imposta su `1` per abilitare il watchdog di inattività dello streaming a livello di evento. Disattivato per impostazione predefinita. Per Bedrock, Vertex e Foundry, questo è l'unico watchdog di inattività disponibile. Configura il timeout con `CLAUDE_STREAM_IDLE_TIMEOUT_MS` |169| `CLAUDE_ENABLE_STREAM_WATCHDOG` | Imposta su `1` per abilitare il watchdog di inattività dello streaming a livello di evento. Disattivato per impostazione predefinita. Per Bedrock, Vertex e Foundry, questo è l'unico watchdog di inattività disponibile. Configura il timeout con `CLAUDE_STREAM_IDLE_TIMEOUT_MS` |

169| `CLAUDE_ENV_FILE` | Percorso di uno script di shell i cui contenuti Claude Code esegue prima di ogni comando Bash nello stesso processo di shell, in modo che gli export nel file siano visibili al comando. Utilizza per persistere l'attivazione di virtualenv o conda tra i comandi. Anche popolato dinamicamente dagli hook [SessionStart](/it/hooks#persist-environment-variables), [Setup](/it/hooks#setup), [CwdChanged](/it/hooks#cwdchanged) e [FileChanged](/it/hooks#filechanged) |170| `CLAUDE_ENV_FILE` | Percorso di uno script di shell i cui contenuti Claude Code esegue prima di ogni comando Bash nello stesso processo di shell, in modo che gli export nel file siano visibili al comando. Utilizza per persistere l'attivazione di virtualenv o conda tra i comandi. Anche popolato dinamicamente dagli hook [SessionStart](/it/hooks#persist-environment-variables), [Setup](/it/hooks#setup), [CwdChanged](/it/hooks#cwdchanged) e [FileChanged](/it/hooks#filechanged) |

205| `MAX_THINKING_TOKENS` | Sovrascrivi il budget del token di [extended thinking](https://platform.claude.com/docs/en/build-with-claude/extended-thinking). Il massimale è il [max output tokens](https://platform.claude.com/docs/en/about-claude/models/overview#latest-models-comparison) del modello meno uno. Imposta su `0` per disabilitare completamente il thinking. Sui modelli con [ragionamento adattivo](/it/model-config#adjust-effort-level), il budget viene ignorato a meno che il ragionamento adattivo non sia disabilitato tramite `CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING` |206| `MAX_THINKING_TOKENS` | Sovrascrivi il budget del token di [extended thinking](https://platform.claude.com/docs/en/build-with-claude/extended-thinking). Il massimale è il [max output tokens](https://platform.claude.com/docs/en/about-claude/models/overview#latest-models-comparison) del modello meno uno. Imposta su `0` per disabilitare completamente il thinking. Sui modelli con [ragionamento adattivo](/it/model-config#adjust-effort-level), il budget viene ignorato a meno che il ragionamento adattivo non sia disabilitato tramite `CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING` |

206| `MCP_CLIENT_SECRET` | Segreto client OAuth per i server MCP che richiedono [credenziali preconfigurate](/it/mcp#use-pre-configured-oauth-credentials). Evita il prompt interattivo quando si aggiunge un server con `--client-secret` |207| `MCP_CLIENT_SECRET` | Segreto client OAuth per i server MCP che richiedono [credenziali preconfigurate](/it/mcp#use-pre-configured-oauth-credentials). Evita il prompt interattivo quando si aggiunge un server con `--client-secret` |

207| `MCP_CONNECTION_NONBLOCKING` | Imposta su `true` in modalità non interattiva (`-p`) per saltare completamente l'attesa della connessione MCP. Utile per pipeline con script in cui gli strumenti MCP non sono necessari. Senza questa variabile, la prima query attende fino a 5 secondi per le connessioni del server `--mcp-config`. I server configurati con [`alwaysLoad: true`](/it/mcp#exempt-a-server-from-deferral) bloccano sempre l'avvio indipendentemente da questa variabile, poiché i loro strumenti devono essere presenti quando viene costruito il primo prompt |208| `MCP_CONNECTION_NONBLOCKING` | Imposta su `true` in modalità non interattiva (`-p`) per saltare completamente l'attesa della connessione MCP. Utile per pipeline con script in cui gli strumenti MCP non sono necessari. Senza questa variabile, la prima query attende fino a 5 secondi per le connessioni del server `--mcp-config`. I server configurati con [`alwaysLoad: true`](/it/mcp#exempt-a-server-from-deferral) bloccano sempre l'avvio indipendentemente da questa variabile, poiché i loro strumenti devono essere presenti quando viene costruito il primo prompt |

209| `MCP_CONNECT_TIMEOUT_MS` | Quanto tempo la prima query attende, in millisecondi, per il batch di connessione MCP prima di acquisire uno snapshot dell'elenco degli strumenti (predefinito: 5000). I server ancora in sospeso alla scadenza continuano a connettersi in background ma non appariranno fino alla query successiva. Distinto da `MCP_TIMEOUT`, che limita il tentativo di connessione di un singolo server. Più rilevante per le sessioni non interattive che emettono una singola query e hanno bisogno che i server a connessione lenta siano visibili |

208| `MCP_OAUTH_CALLBACK_PORT` | Porta fissa per il callback di reindirizzamento OAuth, come alternativa a `--callback-port` quando si aggiunge un server MCP con [credenziali preconfigurate](/it/mcp#use-pre-configured-oauth-credentials) |210| `MCP_OAUTH_CALLBACK_PORT` | Porta fissa per il callback di reindirizzamento OAuth, come alternativa a `--callback-port` quando si aggiunge un server MCP con [credenziali preconfigurate](/it/mcp#use-pre-configured-oauth-credentials) |

209| `MCP_REMOTE_SERVER_CONNECTION_BATCH_SIZE` | Numero massimo di server MCP remoti (HTTP/SSE) da connettere in parallelo durante l'avvio (predefinito: 20) |211| `MCP_REMOTE_SERVER_CONNECTION_BATCH_SIZE` | Numero massimo di server MCP remoti (HTTP/SSE) da connettere in parallelo durante l'avvio (predefinito: 20) |

210| `MCP_SERVER_CONNECTION_BATCH_SIZE` | Numero massimo di server MCP locali (stdio) da connettere in parallelo durante l'avvio (predefinito: 3) |212| `MCP_SERVER_CONNECTION_BATCH_SIZE` | Numero massimo di server MCP locali (stdio) da connettere in parallelo durante l'avvio (predefinito: 3) |

features-overview.md +1 −1

Details

249 249

250 **Costo del contesto:** Basso fino a quando non vengono utilizzate. Le skills solo utente hanno costo zero fino a quando non vengono invocate.250 **Costo del contesto:** Basso fino a quando non vengono utilizzate. Le skills solo utente hanno costo zero fino a quando non vengono invocate.

251 251

252 **Nelle subagents:** Le skills funzionano diversamente nei subagents. Invece del caricamento su richiesta, le skills passate a un subagent vengono completamente precaricate nel suo contesto all'avvio. I subagents non ereditano le skills dalla sessione principale; dovete specificarle esplicitamente.252 **Nei subagents:** Le skills funzionano diversamente nei subagents. Invece del caricamento su richiesta, le skills elencate nel campo `skills:` dell'agente vengono completamente precaricate nel suo contesto all'avvio. I subagents possono comunque scoprire e invocare skills di progetto, utente e plugin non elencate attraverso lo strumento Skill.

253 253

254 <Tip>Utilizzate `disable-model-invocation: true` per le skills con effetti collaterali. Questo risparmia contesto e assicura che solo voi le attiviate.</Tip>254 <Tip>Utilizzate `disable-model-invocation: true` per le skills con effetti collaterali. Questo risparmia contesto e assicura che solo voi le attiviate.</Tip>

255 </Tab>255 </Tab>

google-vertex-ai.md +1 −111

Details

76 </div>;76 </div>;

77};77};

78 78

~~79export const Experiment = ({flag, treatment, children}) => {~~79<ContactSalesCard surface="vertex" />

~~80 const VID_KEY = 'exp_vid';~~

~~82 const fnv1a = s => {~~

~~83 let h = 0x811c9dc5;~~

~~84 for (let i = 0; i < s.length; i++) {~~

~~85 h ^= s.charCodeAt(i);~~

~~86 h += (h << 1) + (h << 4) + (h << 7) + (h << 8) + (h << 24);~~

~~87 }~~

~~88 return h >>> 0;~~

~~89 };~~

~~90 const bucket = (seed, vid) => fnv1a(fnv1a(seed + vid) + '') % 10000 < 5000 ? 'control' : 'treatment';~~

~~91 const [decision] = useState(() => {~~

~~92 const params = new URLSearchParams(location.search);~~

~~93 const preBucketed = document.documentElement.dataset['gb_' + flag.replace(/-/g, '_')];~~

~~94 const force = params.get('gb-force');~~

~~95 if (force) {~~

~~96 for (const p of force.split(',')) {~~

~~97 const [k, v] = p.split(':');~~

~~98 if (k === flag) return {~~

~~99 variant: v || 'treatment',~~

100 track: false

101 };

102 }

103 }

104 if (navigator.globalPrivacyControl) {

105 return {

106 variant: 'control',

107 track: false

108 };

109 }

110 const prefsMatch = document.cookie.match(/(?:^|; )anthropic-consent-preferences=([^;]+)/);

111 if (prefsMatch) {

112 try {

113 if (JSON.parse(decodeURIComponent(prefsMatch[1])).analytics !== true) {

114 return {

115 variant: 'control',

116 track: false

117 };

118 }

119 } catch {

120 return {

121 variant: 'control',

122 track: false

123 };

124 }

125 } else {

126 const country = params.get('country')?.toUpperCase() || (document.cookie.match(/(?:^|; )cf_geo=([A-Z]{2})/) || [])[1];

127 if (!country || CONSENT_COUNTRIES.has(country)) {

128 return {

129 variant: 'control',

130 track: false

131 };

132 }

133 }

134 let vid;

135 try {

136 const ajsMatch = document.cookie.match(/(?:^|; )ajs_anonymous_id=([^;]+)/);

137 if (ajsMatch) {

138 vid = decodeURIComponent(ajsMatch[1]).replace(/^"|"$/g, '');

139 } else {

140 vid = localStorage.getItem(VID_KEY);

141 if (!vid) {

142 vid = crypto.randomUUID();

143 }

144 document.cookie = `ajs_anonymous_id=${vid}; domain=.claude.com; path=/; Secure; SameSite=Lax; max-age=31536000`;

145 }

146 try {

147 localStorage.setItem(VID_KEY, vid);

148 } catch {}

149 } catch {

150 return {

151 variant: 'control',

152 track: false

153 };

154 }

155 const variant = preBucketed === '1' ? 'treatment' : preBucketed === '0' ? 'control' : bucket(flag, vid);

156 return {

157 variant,

158 track: true,

159 vid

160 };

161 });

162 useEffect(() => {

163 if (!decision.track) return;

164 fetch('https://api.anthropic.com/api/event_logging/v2/batch', {

165 method: 'POST',

166 headers: {

167 'Content-Type': 'application/json',

168 'x-service-name': 'claude_code_docs'

169 },

170 body: JSON.stringify({

171 events: [{

172 event_type: 'GrowthbookExperimentEvent',

173 event_data: {

174 device_id: decision.vid,

175 anonymous_id: decision.vid,

176 timestamp: new Date().toISOString(),

177 experiment_id: flag,

178 variation_id: decision.variant === 'treatment' ? 1 : 0,

179 environment: 'production'

180 }

181 }]

182 }),

183 keepalive: true

184 }).catch(() => {});

185 }, []);

186 return decision.variant === 'treatment' ? treatment : children;

187};

~~188~~

189<Experiment flag="docs-contact-sales-cta" treatment={<ContactSalesCard surface="vertex" />} />

190 80

191## Prerequisiti81## Prerequisiti

192 82

hooks.md +5 −4

Details

518Gli hook event ricevono questi campi come JSON, oltre ai campi specifici dell'evento documentati in ogni sezione [hook event](#hook-events). Per i command hook, questo JSON arriva tramite stdin. Per gli HTTP hook, arriva come corpo della richiesta POST.518Gli hook event ricevono questi campi come JSON, oltre ai campi specifici dell'evento documentati in ogni sezione [hook event](#hook-events). Per i command hook, questo JSON arriva tramite stdin. Per gli HTTP hook, arriva come corpo della richiesta POST.

519 519

521| :---------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |521| :---------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

524| `cwd` | Directory di lavoro corrente quando l'hook viene invocato |524| `cwd` | Directory di lavoro corrente quando l'hook viene invocato |

525| `permission_mode` | [Modalità di autorizzazione](/it/permissions#permission-modes) corrente: `"default"`, `"plan"`, `"acceptEdits"`, `"auto"`, `"dontAsk"` o `"bypassPermissions"`. Non tutti gli eventi ricevono questo campo: consultare ogni esempio JSON dell'evento di seguito per controllare |525| `permission_mode` | [Modalità di autorizzazione](/it/permissions#permission-modes) corrente: `"default"`, `"plan"`, `"acceptEdits"`, `"auto"`, `"dontAsk"` o `"bypassPermissions"`. Non tutti gli eventi ricevono questo campo: consultare ogni esempio JSON dell'evento di seguito per controllare |

526| `effort` | Oggetto con un campo `level` che contiene il [livello di effort](/it/model-config#adjust-effort-level) attivo per il turno: `"low"`, `"medium"`, `"high"`, `"xhigh"` o `"max"`. Se l'effort richiesto supera quello supportato dal modello corrente, questo è il livello ridotto che il modello ha effettivamente utilizzato, non il livello che hai richiesto. L'oggetto corrisponde al campo `effort` della [riga di stato](/it/statusline#available-data). Presente per gli eventi che si attivano all'interno di un contesto di utilizzo dello strumento, come `PreToolUse`, `PostToolUse`, `Stop` e `SubagentStop`, quando il modello corrente supporta il parametro effort. Il livello è disponibile anche ai comandi hook e allo strumento Bash come variabile di ambiente `$CLAUDE_EFFORT`. |

527 528

528Quando si esegue con `--agent` o all'interno di un subagent, vengono inclusi due campi aggiuntivi:529Quando si esegue con `--agent` o all'interno di un subagent, vengono inclusi due campi aggiuntivi:

1225 1226

1226Se lo strumento rinviato non è più disponibile quando riprendi, il processo esce con `stop_reason: "tool_deferred_unavailable"` e `is_error: true` prima che l'hook si attivi. Questo accade quando un server MCP che ha fornito lo strumento non è connesso per la sessione ripresa. Il payload `deferred_tool_use` è ancora incluso in modo da poter identificare quale strumento è scomparso.1227Se lo strumento rinviato non è più disponibile quando riprendi, il processo esce con `stop_reason: "tool_deferred_unavailable"` e `is_error: true` prima che l'hook si attivi. Questo accade quando un server MCP che ha fornito lo strumento non è connesso per la sessione ripresa. Il payload `deferred_tool_use` è ancora incluso in modo da poter identificare quale strumento è scomparso.

1227 1228

1228<Warning>1229<Note>

1229 `--resume` non ripristina la modalità di autorizzazione dalla sessione precedente. Passare lo stesso flag `--permission-mode` su resume che era attivo quando lo strumento è stato rinviato. Claude Code registra un avviso se le modalità differiscono.1230 `--resume` ripristina la modalità di autorizzazione che era attiva quando lo strumento è stato rinviato, quindi non è necessario passare di nuovo `--permission-mode`. Le eccezioni sono `plan` e `bypassPermissions`, che non vengono mai trasportati. Passare `--permission-mode` esplicitamente su resume sovrascrive il valore ripristinato.

1230</Warning>1231</Note>

1231 1232

1232### PermissionRequest1233### PermissionRequest

1233 1234

memory.md +10 −0

Details

132Usa plan mode per le modifiche in `src/billing/`.132Usa plan mode per le modifiche in `src/billing/`.

133```133```

134 134

135Un symlink funziona anche se non hai bisogno di aggiungere contenuto specifico di Claude Code:

136

137```bash theme={null}

138ln -s AGENTS.md CLAUDE.md

139```

140

141Su Windows, la creazione di un symlink richiede privilegi di amministratore o modalità sviluppatore, quindi usa l'importazione `@AGENTS.md` invece.

142

143L'esecuzione di [`/init`](/it/commands) in un repository che ha già un `AGENTS.md` lo legge e incorpora le parti rilevanti nel `CLAUDE.md` generato. Legge anche altre configurazioni di strumenti come `.cursorrules` e `.windsurfrules`.

144

135### Come vengono caricati i file CLAUDE.md145### Come vengono caricati i file CLAUDE.md

136 146

137Claude Code legge i file CLAUDE.md camminando verso l'alto nell'albero delle directory dalla tua directory di lavoro corrente, controllando ogni directory lungo il percorso per i file `CLAUDE.md` e `CLAUDE.local.md`. Ciò significa che se esegui Claude Code in `foo/bar/`, carica le istruzioni da `foo/bar/CLAUDE.md`, `foo/CLAUDE.md` e qualsiasi file `CLAUDE.local.md` accanto a loro.147Claude Code legge i file CLAUDE.md camminando verso l'alto nell'albero delle directory dalla tua directory di lavoro corrente, controllando ogni directory lungo il percorso per i file `CLAUDE.md` e `CLAUDE.local.md`. Ciò significa che se esegui Claude Code in `foo/bar/`, carica le istruzioni da `foo/bar/CLAUDE.md`, `foo/CLAUDE.md` e qualsiasi file `CLAUDE.local.md` accanto a loro.

microsoft-foundry.md +1 −111

Details

76 </div>;76 </div>;

77};77};

78 78

~~79export const Experiment = ({flag, treatment, children}) => {~~79<ContactSalesCard surface="foundry" />

~~80 const VID_KEY = 'exp_vid';~~

~~82 const fnv1a = s => {~~

~~83 let h = 0x811c9dc5;~~

~~84 for (let i = 0; i < s.length; i++) {~~

~~85 h ^= s.charCodeAt(i);~~

~~86 h += (h << 1) + (h << 4) + (h << 7) + (h << 8) + (h << 24);~~

~~87 }~~

~~88 return h >>> 0;~~

~~89 };~~

~~90 const bucket = (seed, vid) => fnv1a(fnv1a(seed + vid) + '') % 10000 < 5000 ? 'control' : 'treatment';~~

~~91 const [decision] = useState(() => {~~

~~92 const params = new URLSearchParams(location.search);~~

~~93 const preBucketed = document.documentElement.dataset['gb_' + flag.replace(/-/g, '_')];~~

~~94 const force = params.get('gb-force');~~

~~95 if (force) {~~

~~96 for (const p of force.split(',')) {~~

~~97 const [k, v] = p.split(':');~~

~~98 if (k === flag) return {~~

~~99 variant: v || 'treatment',~~

100 track: false

101 };

102 }

103 }

104 if (navigator.globalPrivacyControl) {

105 return {

106 variant: 'control',

107 track: false

108 };

109 }

110 const prefsMatch = document.cookie.match(/(?:^|; )anthropic-consent-preferences=([^;]+)/);

111 if (prefsMatch) {

112 try {

113 if (JSON.parse(decodeURIComponent(prefsMatch[1])).analytics !== true) {

114 return {

115 variant: 'control',

116 track: false

117 };

118 }

119 } catch {

120 return {

121 variant: 'control',

122 track: false

123 };

124 }

125 } else {

126 const country = params.get('country')?.toUpperCase() || (document.cookie.match(/(?:^|; )cf_geo=([A-Z]{2})/) || [])[1];

127 if (!country || CONSENT_COUNTRIES.has(country)) {

128 return {

129 variant: 'control',

130 track: false

131 };

132 }

133 }

134 let vid;

135 try {

136 const ajsMatch = document.cookie.match(/(?:^|; )ajs_anonymous_id=([^;]+)/);

137 if (ajsMatch) {

138 vid = decodeURIComponent(ajsMatch[1]).replace(/^"|"$/g, '');

139 } else {

140 vid = localStorage.getItem(VID_KEY);

141 if (!vid) {

142 vid = crypto.randomUUID();

143 }

144 document.cookie = `ajs_anonymous_id=${vid}; domain=.claude.com; path=/; Secure; SameSite=Lax; max-age=31536000`;

145 }

146 try {

147 localStorage.setItem(VID_KEY, vid);

148 } catch {}

149 } catch {

150 return {

151 variant: 'control',

152 track: false

153 };

154 }

155 const variant = preBucketed === '1' ? 'treatment' : preBucketed === '0' ? 'control' : bucket(flag, vid);

156 return {

157 variant,

158 track: true,

159 vid

160 };

161 });

162 useEffect(() => {

163 if (!decision.track) return;

164 fetch('https://api.anthropic.com/api/event_logging/v2/batch', {

165 method: 'POST',

166 headers: {

167 'Content-Type': 'application/json',

168 'x-service-name': 'claude_code_docs'

169 },

170 body: JSON.stringify({

171 events: [{

172 event_type: 'GrowthbookExperimentEvent',

173 event_data: {

174 device_id: decision.vid,

175 anonymous_id: decision.vid,

176 timestamp: new Date().toISOString(),

177 experiment_id: flag,

178 variation_id: decision.variant === 'treatment' ? 1 : 0,

179 environment: 'production'

180 }

181 }]

182 }),

183 keepalive: true

184 }).catch(() => {});

185 }, []);

186 return decision.variant === 'treatment' ? treatment : children;

187};

~~188~~

189<Experiment flag="docs-contact-sales-cta" treatment={<ContactSalesCard surface="foundry" />} />

190 80

191## Prerequisiti81## Prerequisiti

192 82

model-config.md +4 −0

Details

17 * Foundry: un nome di distribuzione17 * Foundry: un nome di distribuzione

18 * Vertex: un nome di versione18 * Vertex: un nome di versione

19 19

20<Note>

21 `ANTHROPIC_BASE_URL` cambia dove vengono inviate le richieste, non quale modello le risponde. Per instradare Claude attraverso un gateway LLM, vedere [configurazione del gateway LLM](/it/llm-gateway).

22</Note>

20### Alias dei modelli24### Alias dei modelli

21 25

22Gli alias dei modelli forniscono un modo conveniente per selezionare le impostazioni del modello senza dover ricordare i numeri di versione esatti:26Gli alias dei modelli forniscono un modo conveniente per selezionare le impostazioni del modello senza dover ricordare i numeri di versione esatti:

overview.md +1 −635

Details

6 6

7> Claude Code è uno strumento di codifica agentivo che legge la tua base di codice, modifica i file, esegue comandi e si integra con i tuoi strumenti di sviluppo. Disponibile nel tuo terminale, IDE, app desktop e browser.7> Claude Code è uno strumento di codifica agentivo che legge la tua base di codice, modifica i file, esegue comandi e si integra con i tuoi strumenti di sviluppo. Disponibile nel tuo terminale, IDE, app desktop e browser.

8 8

~~9export const InstallConfigurator = ({defaultSurface = 'terminal'}) => {~~

~~10 const TERM = {~~

~~11 mac: {~~

~~12 label: 'macOS / Linux',~~

~~13 cmd: 'curl -fsSL https://claude.ai/install.sh | bash'~~

~~14 },~~

~~15 win: {~~

~~16 label: 'Windows'~~

~~17 },~~

~~18 brew: {~~

~~19 label: 'Homebrew',~~

~~20 cmd: 'brew install --cask claude-code'~~

~~21 },~~

~~22 winget: {~~

~~23 label: 'WinGet',~~

~~24 cmd: 'winget install Anthropic.ClaudeCode'~~

~~25 }~~

~~26 };~~

~~27 const WIN_VARIANTS = {~~

~~28 ps: 'irm https://claude.ai/install.ps1 | iex',~~

~~29 cmd: 'curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd && del install.cmd'~~

~~30 };~~

~~31 const TABS = [{~~

~~32 key: 'terminal',~~

~~33 label: 'Terminal'~~

~~34 }, {~~

~~35 key: 'desktop',~~

~~36 label: 'Desktop'~~

~~37 }, {~~

~~38 key: 'vscode',~~

~~39 label: 'VS Code'~~

~~40 }, {~~

~~41 key: 'jetbrains',~~

~~42 label: 'JetBrains'~~

~~43 }];~~

~~44 const ALT_TARGETS = {~~

~~45 desktop: {~~

~~46 name: 'Desktop',~~

~~47 tagline: 'The full agent in a native app for macOS and Windows.',~~

~~48 installLabel: 'Download the app',~~

~~49 installHref: 'https://claude.com/download?utm_source=claude_code&utm_medium=docs&utm_content=configurator_desktop_download',~~

~~50 guideHref: '/en/desktop-quickstart'~~

~~51 },~~

~~52 vscode: {~~

~~53 name: 'VS Code',~~

~~54 tagline: 'Review diffs, manage context, and chat without leaving your editor.',~~

~~55 installLabel: 'Install from Marketplace',~~

~~56 installHref: 'https://marketplace.visualstudio.com/items?itemName=anthropic.claude-code',~~

~~57 altCmd: 'code --install-extension anthropic.claude-code',~~

~~58 guideHref: '/en/vs-code'~~

~~59 },~~

~~60 jetbrains: {~~

~~61 name: 'JetBrains',~~

~~62 tagline: 'Native plugin for IntelliJ, PyCharm, WebStorm, and other JetBrains IDEs.',~~

~~63 installLabel: 'Install from Marketplace',~~

~~64 installHref: 'https://plugins.jetbrains.com/plugin/27310-claude-code-beta-',~~

~~65 guideHref: '/en/jetbrains'~~

~~66 }~~

~~67 };~~

~~68 const PROVIDERS = [{~~

~~69 key: 'anthropic',~~

~~70 label: 'Anthropic'~~

~~71 }, {~~

~~72 key: 'bedrock',~~

~~73 label: 'Amazon Bedrock'~~

~~74 }, {~~

~~75 key: 'foundry',~~

~~76 label: 'Microsoft Foundry'~~

~~77 }, {~~

~~78 key: 'vertex',~~

~~79 label: 'Google Vertex AI'~~

~~80 }];~~

~~81 const PROVIDER_NOTICE = {~~

~~82 bedrock: <>~~

~~83 <strong>Configure your AWS account first.</strong> Running on Bedrock~~

~~84 requires model access enabled in the AWS console and IAM credentials.{' '}~~

~~85 <a href="/en/amazon-bedrock">Bedrock setup guide →</a>~~

~~86 </>,~~

~~87 vertex: <>~~

~~88 <strong>Configure your GCP project first.</strong> Running on Vertex AI~~

~~89 requires the Vertex API enabled and a service account with the right~~

~~90 permissions.{' '}~~

~~91 <a href="/en/google-vertex-ai">Vertex setup guide →</a>~~

~~92 </>,~~

~~93 foundry: <>~~

~~94 <strong>Configure your Azure resources first.</strong> Running on~~

~~95 Microsoft Foundry requires an Azure subscription with a Foundry resource~~

~~96 and model deployments provisioned.{' '}~~

~~97 <a href="/en/microsoft-foundry">Foundry setup guide →</a>~~

~~98 </>~~

~~99 };~~

100 const iconCheck = (size = 14) => <svg width={size} height={size} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="3" strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">

101 <polyline points="20 6 9 17 4 12" />

102 </svg>;

103 const iconCopy = (size = 14) => <svg width={size} height={size} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">

104 <rect x="9" y="9" width="13" height="13" rx="2" />

105 <path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1" />

106 </svg>;

107 const iconArrowRight = (size = 13) => <svg width={size} height={size} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2.5" strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">

108 <line x1="5" y1="12" x2="19" y2="12" />

109 <polyline points="12 5 19 12 12 19" />

110 </svg>;

111 const iconArrowUpRight = (size = 14) => <svg width={size} height={size} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2.5" strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">

112 <line x1="7" y1="17" x2="17" y2="7" />

113 <polyline points="7 7 17 7 17 17" />

114 </svg>;

115 const iconInfo = (size = 16) => <svg width={size} height={size} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">

116 <circle cx="12" cy="12" r="10" />

117 <line x1="12" y1="16" x2="12" y2="12" />

118 <line x1="12" y1="8" x2="12.01" y2="8" />

119 </svg>;

120 const [target, setTarget] = useState(defaultSurface);

121 const [team, setTeam] = useState(false);

122 const [provider, setProvider] = useState('anthropic');

123 const [pkg, setPkg] = useState(() => (/Win/).test(navigator.userAgent) ? 'win' : 'mac');

124 const [winCmd, setWinCmd] = useState(false);

125 const [copied, setCopied] = useState(null);

126 const copyTimer = useRef(null);

127 const handleCopy = async (text, key) => {

128 try {

129 await navigator.clipboard.writeText(text);

130 } catch {

131 const ta = document.createElement('textarea');

132 ta.value = text;

133 document.body.appendChild(ta);

134 ta.select();

135 document.execCommand('copy');

136 document.body.removeChild(ta);

137 }

138 clearTimeout(copyTimer.current);

139 setCopied(key);

140 copyTimer.current = setTimeout(() => setCopied(null), 1800);

141 };

142 const cardBodyCmd = (cmd, prompt) => {

143 const on = copied === 'term';

144 return <div className="cc-ic-card-body">

145 <span className="cc-ic-prompt">{prompt || '$'}</span>

146 <div className="cc-ic-cmd">{cmd}</div>

147 <button type="button" className={'cc-ic-copy' + (on ? ' cc-ic-copied' : '')} onClick={() => handleCopy(cmd, 'term')}>

148 {on ? iconCheck(13) : iconCopy(13)}

149 <span>{on ? 'Copied' : 'Copy'}</span>

150 </button>

151 </div>;

152 };

153 const isWinInstaller = pkg === 'win';

154 const isWinPrompt = pkg === 'win' || pkg === 'winget';

155 const terminalCmd = isWinInstaller ? WIN_VARIANTS[winCmd ? 'cmd' : 'ps'] : TERM[pkg].cmd;

156 const alt = ALT_TARGETS[target];

157 const showNotice = team && provider !== 'anthropic';

158 const STYLES = `

159.cc-ic {

160 --ic-slate: #141413;

161 --ic-clay: #d97757;

162 --ic-clay-deep: #c6613f;

163 --ic-gray-000: #ffffff;

164 --ic-gray-150: #f0eee6;

165 --ic-gray-550: #73726c;

166 --ic-gray-700: #3d3d3a;

167 --ic-border-subtle: rgba(31, 30, 29, 0.08);

168 --ic-border-default: rgba(31, 30, 29, 0.15);

169 --ic-border-strong: rgba(31, 30, 29, 0.3);

170 --ic-font-mono: ui-monospace, SFMono-Regular, Menlo, Monaco, 'Courier New', monospace;

171 font-family: 'Anthropic Sans', -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;

172 font-size: 14px; line-height: 1.5; color: var(--ic-slate);

173 margin: 8px 0 32px;

174}

175.dark .cc-ic {

176 --ic-slate: #f0eee6;

177 --ic-gray-000: #262624;

178 --ic-gray-150: #1f1e1d;

179 --ic-gray-550: #91908a;

180 --ic-gray-700: #bfbdb4;

181 --ic-border-subtle: rgba(240, 238, 230, 0.08);

182 --ic-border-default: rgba(240, 238, 230, 0.14);

183 --ic-border-strong: rgba(240, 238, 230, 0.28);

184}

185.dark .cc-ic-check { background: transparent; }

186.dark .cc-ic-card { border: 0.5px solid var(--ic-border-subtle); }

187.dark .cc-ic-p-pill.cc-ic-active { box-shadow: 0 1px 2px rgba(0, 0, 0, 0.3); }

188.cc-ic *, .cc-ic *::before, .cc-ic *::after { box-sizing: border-box; }

189.cc-ic a { text-decoration: none; }

190.cc-ic a:not([class]) { color: inherit; }

191.cc-ic button { font-family: inherit; cursor: pointer; }

~~192~~

193.cc-ic-tab-strip {

194 display: inline-flex; gap: 2px;

195 padding: 4px; background: var(--ic-gray-150);

196 border-radius: 10px; overflow-x: auto;

197 max-width: 100%;

198}

199.cc-ic-tab {

200 appearance: none; background: none; border: none;

201 padding: 10px 18px; font-size: 15px; font-weight: 430;

202 color: var(--ic-gray-550); border-radius: 7px;

203 white-space: nowrap;

204 transition: color 0.12s, background-color 0.12s;

205}

206.cc-ic-tab:hover { color: var(--ic-gray-700); }

207.cc-ic-tab.cc-ic-active {

208 color: var(--ic-slate); font-weight: 500;

209 background: var(--ic-gray-000);

210 box-shadow: 0 1px 3px rgba(0, 0, 0, 0.08);

211}

212.dark .cc-ic-tab.cc-ic-active { box-shadow: 0 1px 3px rgba(0, 0, 0, 0.4); }

~~213~~

214.cc-ic-team-wrap { padding: 16px 0 20px; }

215.cc-ic-team-toggle {

216 display: flex; align-items: center; gap: 12px; font-family: inherit;

217 padding: 12px 16px; font-size: 14px; font-weight: 430;

218 color: var(--ic-gray-700); cursor: pointer; user-select: none;

219 width: fit-content; background: var(--ic-gray-150);

220 border: 0.5px solid var(--ic-border-subtle); border-radius: 8px;

221 transition: border-color 0.15s;

222}

223.cc-ic-team-toggle:hover { border-color: var(--ic-border-default); }

224.cc-ic-team-toggle.cc-ic-checked {

225 background: rgba(217, 119, 87, 0.08);

226 border-color: rgba(217, 119, 87, 0.25);

227}

228.cc-ic-check {

229 width: 16px; height: 16px;

230 border: 1px solid var(--ic-border-strong); border-radius: 4px;

231 background: var(--ic-gray-000);

232 display: flex; align-items: center; justify-content: center;

233 flex-shrink: 0;

234}

235.cc-ic-check svg { color: #fff; display: none; }

236.cc-ic-team-toggle.cc-ic-checked .cc-ic-check { background: var(--ic-clay-deep); border-color: var(--ic-clay-deep); }

237.cc-ic-team-toggle.cc-ic-checked .cc-ic-check svg { display: block; }

~~238~~

239.cc-ic-team-reveal { display: flex; flex-direction: column; gap: 12px; margin-bottom: 16px; }

240.cc-ic-sales {

241 display: flex; align-items: center; justify-content: space-between;

242 gap: 16px; padding: 14px 16px;

243 background: var(--ic-gray-000); border: 0.5px solid var(--ic-border-default);

244 border-radius: 8px; flex-wrap: wrap;

245}

246.cc-ic-sales-text { font-size: 13px; color: var(--ic-gray-700); line-height: 1.5; flex: 1; min-width: 200px; }

247.cc-ic-sales-text strong { font-weight: 550; color: var(--ic-slate); }

248.cc-ic-sales-actions { display: flex; align-items: center; gap: 8px; flex-shrink: 0; }

249.cc-ic-btn-clay {

250 display: inline-flex; align-items: center; gap: 8px;

251 background: var(--ic-clay-deep); color: #fff; border: none;

252 border-radius: 8px; padding: 8px 14px;

253 font-size: 13px; font-weight: 500;

254 transition: background-color 0.15s; white-space: nowrap;

255}

256.cc-ic-btn-clay:hover { background: var(--ic-clay); }

257.cc-ic-btn-ghost {

258 display: inline-flex; align-items: center; gap: 8px;

259 background: transparent; color: var(--ic-gray-700);

260 border: 0.5px solid var(--ic-border-default);

261 border-radius: 8px; padding: 8px 14px;

262 font-size: 13px; font-weight: 500;

263}

264.cc-ic-btn-ghost:hover { background: rgba(0, 0, 0, 0.04); }

~~265~~

266.cc-ic-provider-bar {

267 display: flex; align-items: center; gap: 12px;

268 padding: 14px 16px; background: var(--ic-gray-150);

269 border-radius: 8px; font-size: 13px; flex-wrap: wrap;

270}

271.cc-ic-provider-bar .cc-ic-label { color: var(--ic-gray-550); flex-shrink: 0; }

272.cc-ic-provider-pills { display: flex; gap: 4px; flex-wrap: wrap; }

273.cc-ic-p-pill {

274 appearance: none; border: none; background: transparent;

275 padding: 6px 12px; border-radius: 6px;

276 font-size: 13px; font-weight: 430; color: var(--ic-gray-700);

277 white-space: nowrap;

278}

279.cc-ic-p-pill:hover { background: rgba(0, 0, 0, 0.04); }

280.cc-ic-p-pill.cc-ic-active {

281 background: var(--ic-gray-000); color: var(--ic-slate);

282 font-weight: 500; box-shadow: 0 1px 2px rgba(0, 0, 0, 0.05);

283}

284.cc-ic-provider-notice {

285 display: flex; padding: 16px 18px;

286 background: var(--ic-gray-000); border: 0.5px solid var(--ic-border-default);

287 border-radius: 8px; gap: 14px; align-items: flex-start;

288}

289.cc-ic-provider-notice > svg { color: var(--ic-gray-550); margin-top: 2px; flex-shrink: 0; }

290.cc-ic-provider-notice-body { font-size: 14px; line-height: 1.55; color: var(--ic-gray-700); }

291.cc-ic-provider-notice-body strong { font-weight: 550; color: var(--ic-slate); }

292.cc-ic-provider-notice-body a { color: var(--ic-clay-deep); font-weight: 500; }

293.cc-ic-provider-notice-body a:hover { text-decoration: underline; }

~~294~~

295.cc-ic-card { background: #141413; border-radius: 12px; overflow: hidden; }

296.cc-ic-subtabs {

297 display: flex; align-items: center;

298 background: #1a1918;

299 border-bottom: 0.5px solid rgba(255, 255, 255, 0.08);

300 padding: 0 8px; overflow-x: auto;

301}

302.cc-ic-subtab {

303 appearance: none; background: none; border: none;

304 padding: 12px 16px; font-size: 12px;

305 color: rgba(255, 255, 255, 0.5);

306 position: relative; white-space: nowrap;

307}

308.cc-ic-subtab:hover { color: rgba(255, 255, 255, 0.75); }

309.cc-ic-subtab.cc-ic-active { color: #fff; }

310.cc-ic-subtab.cc-ic-active::after {

311 content: ''; position: absolute;

312 left: 12px; right: 12px; bottom: -0.5px;

313 height: 2px; background: var(--ic-clay);

314}

315.cc-ic-shell-switch {

316 display: inline-flex; gap: 2px;

317 margin: 14px 26px 0; padding: 3px;

318 background: rgba(255, 255, 255, 0.06);

319 border: 0.5px solid rgba(255, 255, 255, 0.08);

320 border-radius: 8px;

321 font-family: inherit;

322}

323.cc-ic-shell-option {

324 font: inherit; font-size: 12px; font-weight: 500;

325 padding: 5px 12px; border-radius: 6px;

326 background: transparent; border: none;

327 color: rgba(255, 255, 255, 0.55);

328 cursor: pointer; user-select: none; white-space: nowrap;

329 transition: color 120ms ease, background-color 120ms ease;

330}

331.cc-ic-shell-option:hover { color: rgba(255, 255, 255, 0.85); }

332.cc-ic-shell-option.cc-ic-active {

333 background: rgba(255, 255, 255, 0.12);

334 color: #fff;

335 box-shadow: 0 1px 2px rgba(0, 0, 0, 0.25);

336}

~~337~~

338.cc-ic-card-body { padding: 24px 26px; display: flex; align-items: flex-start; gap: 14px; }

339.cc-ic-prompt {

340 color: var(--ic-clay); font-family: var(--ic-font-mono);

341 font-size: 17px; user-select: none; padding-top: 2px;

342}

343.cc-ic-cmd {

344 flex: 1; font-family: var(--ic-font-mono);

345 font-size: 17px; color: #f0eee6;

346 line-height: 1.55; white-space: pre-wrap; word-break: break-word;

347}

348.cc-ic-copy {

349 display: inline-flex; align-items: center; gap: 6px;

350 background: rgba(255, 255, 255, 0.08);

351 border: 0.5px solid rgba(255, 255, 255, 0.12);

352 color: rgba(255, 255, 255, 0.85);

353 padding: 7px 13px; border-radius: 8px;

354 font-size: 13px; font-weight: 500; flex-shrink: 0;

355}

356.cc-ic-copy:hover { background: rgba(255, 255, 255, 0.14); }

357.cc-ic-copy.cc-ic-copied { background: var(--ic-clay-deep); border-color: var(--ic-clay-deep); color: #fff; }

~~358~~

359.cc-ic-below {

360 margin-top: 12px; font-size: 13px; color: var(--ic-gray-550);

361 display: flex; gap: 16px; flex-wrap: wrap; align-items: baseline;

362}

363.cc-ic-below a { color: var(--ic-gray-700); border-bottom: 0.5px solid var(--ic-border-default); }

364.cc-ic-below a:hover { color: var(--ic-clay-deep); border-bottom-color: var(--ic-clay-deep); }

365.cc-ic-handoff {

366 padding: 22px 24px;

367 background: linear-gradient(180deg, #faf9f4 0%, #f3f1e9 100%);

368 border: 0.5px solid var(--ic-border-default);

369 border-radius: 12px;

370 box-shadow: 0 1px 2px rgba(31, 30, 29, 0.04), 0 6px 16px -4px rgba(31, 30, 29, 0.06);

371}

372.dark .cc-ic-handoff {

373 background: linear-gradient(180deg, #262624 0%, #1f1e1d 100%);

374 box-shadow: 0 1px 2px rgba(0, 0, 0, 0.3), 0 6px 16px -4px rgba(0, 0, 0, 0.4);

375}

376.cc-ic-handoff-title {

377 font-size: 16px; font-weight: 550; color: var(--ic-slate);

378 letter-spacing: -0.01em; margin-bottom: 4px;

379}

380.cc-ic-handoff-sub {

381 font-size: 14px; line-height: 1.5; color: var(--ic-gray-700);

382 margin-bottom: 18px;

383}

384.cc-ic-handoff-actions { display: flex; gap: 10px; flex-wrap: wrap; }

385.cc-ic-handoff-alt {

386 margin-top: 12px; font-size: 12px; color: var(--ic-gray-550);

387}

388.cc-ic-handoff-alt code {

389 font-family: var(--ic-font-mono); font-size: 11px;

390 background: var(--ic-gray-150); padding: 2px 6px;

391 border-radius: 4px; color: var(--ic-gray-700);

392}

393.cc-ic-copy-sm {

394 appearance: none; border: none;

395 display: inline-flex; align-items: center; justify-content: center;

396 width: 22px; height: 22px;

397 margin-left: 4px; vertical-align: middle;

398 background: var(--ic-gray-150); color: var(--ic-gray-550);

399 border-radius: 4px;

400 transition: color 0.1s, background-color 0.1s;

401}

402.cc-ic-copy-sm:hover { color: var(--ic-gray-700); background: var(--ic-border-default); }

403.cc-ic-copy-sm.cc-ic-copied { background: var(--ic-clay-deep); color: #fff; }

~~404~~

405@media (max-width: 720px) {

406 .cc-ic-tab { padding: 12px 14px; font-size: 14px; }

407 .cc-ic-sales-actions { width: 100%; }

408 .cc-ic-card-body { padding: 20px; }

409 .cc-ic-cmd { font-size: 15px; }

410}

411`;

412 return <div className="cc-ic not-prose">

413 <style>{STYLES}</style>

~~414~~

415 {}

416 <div className="cc-ic-tab-strip" role="tablist">

417 {TABS.map(t => <button key={t.key} type="button" role="tab" aria-selected={target === t.key} className={'cc-ic-tab' + (target === t.key ? ' cc-ic-active' : '')} onClick={() => setTarget(t.key)}>

418 {t.label}

419 </button>)}

420 </div>

~~421~~

422 {}

423 <div className="cc-ic-team-wrap">

424 <button type="button" role="switch" aria-checked={team} className={'cc-ic-team-toggle' + (team ? ' cc-ic-checked' : '')} onClick={() => setTeam(!team)}>

425 <span className="cc-ic-check">{iconCheck(11)}</span>

426 <span>

427 I’m buying for a team or company (SSO, AWS/Azure/GCP, central billing)

428 </span>

429 </button>

430 </div>

~~431~~

432 {}

433 {team && <div className="cc-ic-team-reveal">

434 <div className="cc-ic-sales">

435 <div className="cc-ic-sales-text">

436 <strong>Set up your team:</strong> self-serve or talk to sales.

437 </div>

438 <div className="cc-ic-sales-actions">

439 <a href="https://claude.ai/upgrade?initialPlanType=team&utm_source=claude_code&utm_medium=docs&utm_content=configurator_team_get_started" className="cc-ic-btn-ghost">

440 Get started

441 </a>

442 <a href="https://www.anthropic.com/contact-sales?utm_source=claude_code&utm_medium=docs&utm_content=configurator_team_contact_sales" className="cc-ic-btn-clay">

443 Contact sales {iconArrowRight()}

444 </a>

445 </div>

446 </div>

~~447~~

448 <div className="cc-ic-provider-bar">

449 <span className="cc-ic-label">Run on</span>

450 <div className="cc-ic-provider-pills" role="radiogroup" aria-label="Provider">

451 {PROVIDERS.map(p => <button key={p.key} type="button" role="radio" aria-checked={provider === p.key} className={'cc-ic-p-pill' + (provider === p.key ? ' cc-ic-active' : '')} onClick={() => setProvider(p.key)}>

452 {p.label}

453 </button>)}

454 </div>

455 </div>

~~456~~

457 {showNotice && <div className="cc-ic-provider-notice">

458 {iconInfo()}

459 <div className="cc-ic-provider-notice-body">

460 {PROVIDER_NOTICE[provider]}

461 </div>

462 </div>}

463 </div>}

~~464~~

465 {}

466 {target === 'terminal' && <div className="cc-ic-card">

467 <div className="cc-ic-subtabs" role="tablist" aria-label="Install method">

468 {Object.keys(TERM).map(k => <button key={k} type="button" role="tab" aria-selected={pkg === k} className={'cc-ic-subtab' + (pkg === k ? ' cc-ic-active' : '')} onClick={() => setPkg(k)}>

469 {TERM[k].label}

470 </button>)}

471 </div>

472 {isWinInstaller && <div className="cc-ic-shell-switch" role="tablist" aria-label="Shell">

473 {[{

474 k: 'ps',

475 label: 'PowerShell'

476 }, {

477 k: 'cmd',

478 label: 'CMD'

479 }].map(({k, label}) => {

480 const active = k === 'cmd' === winCmd;

481 return <button key={k} type="button" role="tab" aria-selected={active} className={'cc-ic-shell-option' + (active ? ' cc-ic-active' : '')} onClick={() => setWinCmd(k === 'cmd')}>

482 {label}

483 </button>;

484 })}

485 </div>}

486 {cardBodyCmd(terminalCmd, isWinPrompt ? '>' : '$')}

487 </div>}

~~488~~

489 {}

490 {target === 'terminal' && <div className="cc-ic-below">

491 {isWinInstaller && <span>

492 <a href="https://git-scm.com/downloads/win" target="_blank" rel="noopener">

493 Git for Windows

494 </a>{' '}

495 recommended. PowerShell is used if Git Bash is absent.

496 </span>}

497 {(pkg === 'brew' || pkg === 'winget') && <span>

498 Does not auto-update. Run{' '}

499 <code>{pkg === 'brew' ? 'brew upgrade claude-code' : 'winget upgrade Anthropic.ClaudeCode'}</code>{' '}

500 periodically.

501 </span>}

502 <a href="/en/troubleshoot-install">Installation troubleshooting</a>

503 </div>}

~~504~~

505 {alt && <div className="cc-ic-handoff">

506 <div className="cc-ic-handoff-title">Claude Code for {alt.name}</div>

507 <div className="cc-ic-handoff-sub">{alt.tagline}</div>

508 <div className="cc-ic-handoff-actions">

509 <a href={alt.installHref} className="cc-ic-btn-clay" {...alt.installHref.startsWith('http') ? {

510 target: '_blank',

511 rel: 'noopener'

512 } : {}}>

513 {alt.installLabel} {iconArrowUpRight(13)}

514 </a>

515 <a href={alt.guideHref} className="cc-ic-btn-ghost">

516 {alt.name} guide {iconArrowRight(12)}

517 </a>

518 </div>

519 {alt.altCmd && <div className="cc-ic-handoff-alt">

520 or run <code>{alt.altCmd}</code>

521 <button type="button" className={'cc-ic-copy-sm' + (copied === 'alt' ? ' cc-ic-copied' : '')} onClick={() => handleCopy(alt.altCmd, 'alt')} aria-label="Copy command">

522 {copied === 'alt' ? iconCheck(11) : iconCopy(11)}

523 </button>

524 </div>}

525 </div>}

526 </div>;

527};

~~528~~

529export const Experiment = ({flag, treatment, children}) => {

530 const VID_KEY = 'exp_vid';

531 const CONSENT_COUNTRIES = new Set(['AT', 'BE', 'BG', 'HR', 'CY', 'CZ', 'DK', 'EE', 'FI', 'FR', 'DE', 'GR', 'HU', 'IE', 'IT', 'LV', 'LT', 'LU', 'MT', 'NL', 'PL', 'PT', 'RO', 'SK', 'SI', 'ES', 'SE', 'RE', 'GP', 'MQ', 'GF', 'YT', 'BL', 'MF', 'PM', 'WF', 'PF', 'NC', 'AW', 'CW', 'SX', 'FO', 'GL', 'AX', 'GB', 'UK', 'AI', 'BM', 'IO', 'VG', 'KY', 'FK', 'GI', 'MS', 'PN', 'SH', 'TC', 'GG', 'JE', 'IM', 'CA', 'BR', 'IN']);

532 const fnv1a = s => {

533 let h = 0x811c9dc5;

534 for (let i = 0; i < s.length; i++) {

535 h ^= s.charCodeAt(i);

536 h += (h << 1) + (h << 4) + (h << 7) + (h << 8) + (h << 24);

537 }

538 return h >>> 0;

539 };

540 const bucket = (seed, vid) => fnv1a(fnv1a(seed + vid) + '') % 10000 < 5000 ? 'control' : 'treatment';

541 const [decision] = useState(() => {

542 const params = new URLSearchParams(location.search);

543 const preBucketed = document.documentElement.dataset['gb_' + flag.replace(/-/g, '_')];

544 const force = params.get('gb-force');

545 if (force) {

546 for (const p of force.split(',')) {

547 const [k, v] = p.split(':');

548 if (k === flag) return {

549 variant: v || 'treatment',

550 track: false

551 };

552 }

553 }

554 if (navigator.globalPrivacyControl) {

555 return {

556 variant: 'control',

557 track: false

558 };

559 }

560 const prefsMatch = document.cookie.match(/(?:^|; )anthropic-consent-preferences=([^;]+)/);

561 if (prefsMatch) {

562 try {

563 if (JSON.parse(decodeURIComponent(prefsMatch[1])).analytics !== true) {

564 return {

565 variant: 'control',

566 track: false

567 };

568 }

569 } catch {

570 return {

571 variant: 'control',

572 track: false

573 };

574 }

575 } else {

576 const country = params.get('country')?.toUpperCase() || (document.cookie.match(/(?:^|; )cf_geo=([A-Z]{2})/) || [])[1];

577 if (!country || CONSENT_COUNTRIES.has(country)) {

578 return {

579 variant: 'control',

580 track: false

581 };

582 }

583 }

584 let vid;

585 try {

586 const ajsMatch = document.cookie.match(/(?:^|; )ajs_anonymous_id=([^;]+)/);

587 if (ajsMatch) {

588 vid = decodeURIComponent(ajsMatch[1]).replace(/^"|"$/g, '');

589 } else {

590 vid = localStorage.getItem(VID_KEY);

591 if (!vid) {

592 vid = crypto.randomUUID();

593 }

594 document.cookie = `ajs_anonymous_id=${vid}; domain=.claude.com; path=/; Secure; SameSite=Lax; max-age=31536000`;

595 }

596 try {

597 localStorage.setItem(VID_KEY, vid);

598 } catch {}

599 } catch {

600 return {

601 variant: 'control',

602 track: false

603 };

604 }

605 const variant = preBucketed === '1' ? 'treatment' : preBucketed === '0' ? 'control' : bucket(flag, vid);

606 return {

607 variant,

608 track: true,

609 vid

610 };

611 });

612 useEffect(() => {

613 if (!decision.track) return;

614 fetch('https://api.anthropic.com/api/event_logging/v2/batch', {

615 method: 'POST',

616 headers: {

617 'Content-Type': 'application/json',

618 'x-service-name': 'claude_code_docs'

619 },

620 body: JSON.stringify({

621 events: [{

622 event_type: 'GrowthbookExperimentEvent',

623 event_data: {

624 device_id: decision.vid,

625 anonymous_id: decision.vid,

626 timestamp: new Date().toISOString(),

627 experiment_id: flag,

628 variation_id: decision.variant === 'treatment' ? 1 : 0,

629 environment: 'production'

630 }

631 }]

632 }),

633 keepalive: true

634 }).catch(() => {});

635 }, []);

636 return decision.variant === 'treatment' ? treatment : children;

637};

~~638~~

639Claude Code è un assistente di codifica alimentato da IA che ti aiuta a creare funzionalità, correggere bug e automatizzare attività di sviluppo. Comprende l'intera tua base di codice e può lavorare su più file e strumenti per portare a termine le cose.9Claude Code è un assistente di codifica alimentato da IA che ti aiuta a creare funzionalità, correggere bug e automatizzare attività di sviluppo. Comprende l'intera tua base di codice e può lavorare su più file e strumenti per portare a termine le cose.

640 10

641<div data-gb-slot="overview-install-configurator">

642 <Experiment flag="overview-install-configurator" treatment={<InstallConfigurator />} />

643</div>

~~644~~

645## Inizia11## Inizia

646 12

647Scegli il tuo ambiente per iniziare. La maggior parte delle superfici richiede un [abbonamento a Claude](https://claude.com/pricing?utm_source=claude_code\&utm_medium=docs\&utm_content=overview_pricing) o un account [Anthropic Console](https://console.anthropic.com/). Il Terminal CLI e VS Code supportano anche [provider di terze parti](/it/third-party-integrations).13Scegli il tuo ambiente per iniziare. La maggior parte delle superfici richiede un [abbonamento a Claude](https://claude.com/pricing?utm_source=claude_code\&utm_medium=docs\&utm_content=overview_pricing) o un account [Anthropic Console](https://console.anthropic.com/). Il Terminal CLI e VS Code supportano anche [provider di terze parti](/it/third-party-integrations).

798 <Accordion title="Personalizza con istruzioni, skills e hooks" icon="sliders">164 <Accordion title="Personalizza con istruzioni, skills e hooks" icon="sliders">

799 [`CLAUDE.md`](/it/memory) è un file markdown che aggiungi alla radice del tuo progetto che Claude Code legge all'inizio di ogni sessione. Usalo per impostare standard di codifica, decisioni architettoniche, librerie preferite e checklist di revisione. Claude costruisce anche [memoria automatica](/it/memory#auto-memory) mentre lavora, salvando insegnamenti come comandi di build e intuizioni di debug tra le sessioni senza che tu debba scrivere nulla.165 [`CLAUDE.md`](/it/memory) è un file markdown che aggiungi alla radice del tuo progetto che Claude Code legge all'inizio di ogni sessione. Usalo per impostare standard di codifica, decisioni architettoniche, librerie preferite e checklist di revisione. Claude costruisce anche [memoria automatica](/it/memory#auto-memory) mentre lavora, salvando insegnamenti come comandi di build e intuizioni di debug tra le sessioni senza che tu debba scrivere nulla.

800 166

801 Crea [comandi personalizzati](/it/skills) per pacchettizzare flussi di lavoro ripetibili che il tuo team può condividere, come `/review-pr` o `/deploy-staging`.167 Crea [skills](/it/skills) per pacchettizzare flussi di lavoro ripetibili che il tuo team può condividere, come `/review-pr` o `/deploy-staging`.

802 168

803 [Hooks](/it/hooks) ti permettono di eseguire comandi shell prima o dopo le azioni di Claude Code, come la formattazione automatica dopo ogni modifica di file o l'esecuzione di lint prima di un commit.169 [Hooks](/it/hooks) ti permettono di eseguire comandi shell prima o dopo le azioni di Claude Code, come la formattazione automatica dopo ogni modifica di file o l'esecuzione di lint prima di un commit.

804 </Accordion>170 </Accordion>

plugins.md +9 −1

Details

317 317

318Per testare un plugin che è già stato confezionato come archivio `.zip` e ospitato su un URL, come un artefatto di build CI, usa `--plugin-url` invece. Claude Code recupera l'archivio all'avvio e lo carica solo per quella sessione. Se il recupero fallisce o l'archivio non è valido, Claude Code segnala un errore di caricamento del plugin e si avvia senza di esso. Le stesse [considerazioni sulla fiducia](/it/discover-plugins#security) si applicano come per qualsiasi fonte di plugin: punta questo flag solo ad archivi che controlli o di cui ti fidi.318Per testare un plugin che è già stato confezionato come archivio `.zip` e ospitato su un URL, come un artefatto di build CI, usa `--plugin-url` invece. Claude Code recupera l'archivio all'avvio e lo carica solo per quella sessione. Se il recupero fallisce o l'archivio non è valido, Claude Code segnala un errore di caricamento del plugin e si avvia senza di esso. Le stesse [considerazioni sulla fiducia](/it/discover-plugins#security) si applicano come per qualsiasi fonte di plugin: punta questo flag solo ad archivi che controlli o di cui ti fidi.

319 319

320Per caricare più plugin, ripeti il flag per ogni URL:

321

322```bash theme={null}

323claude --plugin-url https://example.com/my-plugin.zip --plugin-url https://example.com/other.zip

324```

325

326Oppure passa URL separati da spazi come un singolo argomento tra virgolette:

327

320```bash theme={null}328```bash theme={null}

321claude --plugin-url https://example.com/my-plugin.zip329claude --plugin-url "https://example.com/my-plugin.zip https://example.com/other.zip"

322```330```

323 331

324### Esegui il debug dei problemi del plugin332### Esegui il debug dei problemi del plugin

quickstart.md +3 −636

Details

6 6

7> Benvenuto in Claude Code!7> Benvenuto in Claude Code!

8 8

~~9export const InstallConfigurator = ({defaultSurface = 'terminal'}) => {~~

~~10 const TERM = {~~

~~11 mac: {~~

~~12 label: 'macOS / Linux',~~

~~13 cmd: 'curl -fsSL https://claude.ai/install.sh | bash'~~

~~14 },~~

~~15 win: {~~

~~16 label: 'Windows'~~

~~17 },~~

~~18 brew: {~~

~~19 label: 'Homebrew',~~

~~20 cmd: 'brew install --cask claude-code'~~

~~21 },~~

~~22 winget: {~~

~~23 label: 'WinGet',~~

~~24 cmd: 'winget install Anthropic.ClaudeCode'~~

~~25 }~~

~~26 };~~

~~27 const WIN_VARIANTS = {~~

~~28 ps: 'irm https://claude.ai/install.ps1 | iex',~~

~~29 cmd: 'curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd && del install.cmd'~~

~~30 };~~

~~31 const TABS = [{~~

~~32 key: 'terminal',~~

~~33 label: 'Terminal'~~

~~34 }, {~~

~~35 key: 'desktop',~~

~~36 label: 'Desktop'~~

~~37 }, {~~

~~38 key: 'vscode',~~

~~39 label: 'VS Code'~~

~~40 }, {~~

~~41 key: 'jetbrains',~~

~~42 label: 'JetBrains'~~

~~43 }];~~

~~44 const ALT_TARGETS = {~~

~~45 desktop: {~~

~~46 name: 'Desktop',~~

~~47 tagline: 'The full agent in a native app for macOS and Windows.',~~

~~48 installLabel: 'Download the app',~~

~~49 installHref: 'https://claude.com/download?utm_source=claude_code&utm_medium=docs&utm_content=configurator_desktop_download',~~

~~50 guideHref: '/en/desktop-quickstart'~~

~~51 },~~

~~52 vscode: {~~

~~53 name: 'VS Code',~~

~~54 tagline: 'Review diffs, manage context, and chat without leaving your editor.',~~

~~55 installLabel: 'Install from Marketplace',~~

~~56 installHref: 'https://marketplace.visualstudio.com/items?itemName=anthropic.claude-code',~~

~~57 altCmd: 'code --install-extension anthropic.claude-code',~~

~~58 guideHref: '/en/vs-code'~~

~~59 },~~

~~60 jetbrains: {~~

~~61 name: 'JetBrains',~~

~~62 tagline: 'Native plugin for IntelliJ, PyCharm, WebStorm, and other JetBrains IDEs.',~~

~~63 installLabel: 'Install from Marketplace',~~

~~64 installHref: 'https://plugins.jetbrains.com/plugin/27310-claude-code-beta-',~~

~~65 guideHref: '/en/jetbrains'~~

~~66 }~~

~~67 };~~

~~68 const PROVIDERS = [{~~

~~69 key: 'anthropic',~~

~~70 label: 'Anthropic'~~

~~71 }, {~~

~~72 key: 'bedrock',~~

~~73 label: 'Amazon Bedrock'~~

~~74 }, {~~

~~75 key: 'foundry',~~

~~76 label: 'Microsoft Foundry'~~

~~77 }, {~~

~~78 key: 'vertex',~~

~~79 label: 'Google Vertex AI'~~

~~80 }];~~

~~81 const PROVIDER_NOTICE = {~~

~~82 bedrock: <>~~

~~83 <strong>Configure your AWS account first.</strong> Running on Bedrock~~

~~84 requires model access enabled in the AWS console and IAM credentials.{' '}~~

~~85 <a href="/en/amazon-bedrock">Bedrock setup guide →</a>~~

~~86 </>,~~

~~87 vertex: <>~~

~~88 <strong>Configure your GCP project first.</strong> Running on Vertex AI~~

~~89 requires the Vertex API enabled and a service account with the right~~

~~90 permissions.{' '}~~

~~91 <a href="/en/google-vertex-ai">Vertex setup guide →</a>~~

~~92 </>,~~

~~93 foundry: <>~~

~~94 <strong>Configure your Azure resources first.</strong> Running on~~

~~95 Microsoft Foundry requires an Azure subscription with a Foundry resource~~

~~96 and model deployments provisioned.{' '}~~

~~97 <a href="/en/microsoft-foundry">Foundry setup guide →</a>~~

~~98 </>~~

~~99 };~~

101 <polyline points="20 6 9 17 4 12" />

102 </svg>;

104 <rect x="9" y="9" width="13" height="13" rx="2" />

105 <path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1" />

106 </svg>;

108 <line x1="5" y1="12" x2="19" y2="12" />

109 <polyline points="12 5 19 12 12 19" />

110 </svg>;

112 <line x1="7" y1="17" x2="17" y2="7" />

113 <polyline points="7 7 17 7 17 17" />

114 </svg>;

116 <circle cx="12" cy="12" r="10" />

117 <line x1="12" y1="16" x2="12" y2="12" />

118 <line x1="12" y1="8" x2="12.01" y2="8" />

119 </svg>;

120 const [target, setTarget] = useState(defaultSurface);

121 const [team, setTeam] = useState(false);

122 const [provider, setProvider] = useState('anthropic');

123 const [pkg, setPkg] = useState(() => (/Win/).test(navigator.userAgent) ? 'win' : 'mac');

124 const [winCmd, setWinCmd] = useState(false);

125 const [copied, setCopied] = useState(null);

126 const copyTimer = useRef(null);

127 const handleCopy = async (text, key) => {

128 try {

129 await navigator.clipboard.writeText(text);

130 } catch {

131 const ta = document.createElement('textarea');

132 ta.value = text;

133 document.body.appendChild(ta);

134 ta.select();

135 document.execCommand('copy');

136 document.body.removeChild(ta);

137 }

138 clearTimeout(copyTimer.current);

139 setCopied(key);

140 copyTimer.current = setTimeout(() => setCopied(null), 1800);

141 };

142 const cardBodyCmd = (cmd, prompt) => {

143 const on = copied === 'term';

144 return <div className="cc-ic-card-body">

145 <span className="cc-ic-prompt">{prompt || '$'}</span>

146 <div className="cc-ic-cmd">{cmd}</div>

147 <button type="button" className={'cc-ic-copy' + (on ? ' cc-ic-copied' : '')} onClick={() => handleCopy(cmd, 'term')}>

148 {on ? iconCheck(13) : iconCopy(13)}

149 <span>{on ? 'Copied' : 'Copy'}</span>

150 </button>

151 </div>;

152 };

153 const isWinInstaller = pkg === 'win';

154 const isWinPrompt = pkg === 'win' || pkg === 'winget';

155 const terminalCmd = isWinInstaller ? WIN_VARIANTS[winCmd ? 'cmd' : 'ps'] : TERM[pkg].cmd;

156 const alt = ALT_TARGETS[target];

157 const showNotice = team && provider !== 'anthropic';

158 const STYLES = `

159.cc-ic {

160 --ic-slate: #141413;

161 --ic-clay: #d97757;

162 --ic-clay-deep: #c6613f;

163 --ic-gray-000: #ffffff;

164 --ic-gray-150: #f0eee6;

165 --ic-gray-550: #73726c;

166 --ic-gray-700: #3d3d3a;

167 --ic-border-subtle: rgba(31, 30, 29, 0.08);

168 --ic-border-default: rgba(31, 30, 29, 0.15);

169 --ic-border-strong: rgba(31, 30, 29, 0.3);

170 --ic-font-mono: ui-monospace, SFMono-Regular, Menlo, Monaco, 'Courier New', monospace;

171 font-family: 'Anthropic Sans', -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;

172 font-size: 14px; line-height: 1.5; color: var(--ic-slate);

173 margin: 8px 0 32px;

174}

175.dark .cc-ic {

176 --ic-slate: #f0eee6;

177 --ic-gray-000: #262624;

178 --ic-gray-150: #1f1e1d;

179 --ic-gray-550: #91908a;

180 --ic-gray-700: #bfbdb4;

181 --ic-border-subtle: rgba(240, 238, 230, 0.08);

182 --ic-border-default: rgba(240, 238, 230, 0.14);

183 --ic-border-strong: rgba(240, 238, 230, 0.28);

184}

185.dark .cc-ic-check { background: transparent; }

186.dark .cc-ic-card { border: 0.5px solid var(--ic-border-subtle); }

187.dark .cc-ic-p-pill.cc-ic-active { box-shadow: 0 1px 2px rgba(0, 0, 0, 0.3); }

188.cc-ic *, .cc-ic *::before, .cc-ic *::after { box-sizing: border-box; }

189.cc-ic a { text-decoration: none; }

190.cc-ic a:not([class]) { color: inherit; }

191.cc-ic button { font-family: inherit; cursor: pointer; }

~~192~~

193.cc-ic-tab-strip {

194 display: inline-flex; gap: 2px;

195 padding: 4px; background: var(--ic-gray-150);

196 border-radius: 10px; overflow-x: auto;

197 max-width: 100%;

198}

199.cc-ic-tab {

200 appearance: none; background: none; border: none;

201 padding: 10px 18px; font-size: 15px; font-weight: 430;

202 color: var(--ic-gray-550); border-radius: 7px;

203 white-space: nowrap;

204 transition: color 0.12s, background-color 0.12s;

205}

206.cc-ic-tab:hover { color: var(--ic-gray-700); }

207.cc-ic-tab.cc-ic-active {

208 color: var(--ic-slate); font-weight: 500;

209 background: var(--ic-gray-000);

210 box-shadow: 0 1px 3px rgba(0, 0, 0, 0.08);

211}

212.dark .cc-ic-tab.cc-ic-active { box-shadow: 0 1px 3px rgba(0, 0, 0, 0.4); }

~~213~~

214.cc-ic-team-wrap { padding: 16px 0 20px; }

215.cc-ic-team-toggle {

216 display: flex; align-items: center; gap: 12px; font-family: inherit;

217 padding: 12px 16px; font-size: 14px; font-weight: 430;

218 color: var(--ic-gray-700); cursor: pointer; user-select: none;

219 width: fit-content; background: var(--ic-gray-150);

220 border: 0.5px solid var(--ic-border-subtle); border-radius: 8px;

221 transition: border-color 0.15s;

222}

223.cc-ic-team-toggle:hover { border-color: var(--ic-border-default); }

224.cc-ic-team-toggle.cc-ic-checked {

225 background: rgba(217, 119, 87, 0.08);

226 border-color: rgba(217, 119, 87, 0.25);

227}

228.cc-ic-check {

229 width: 16px; height: 16px;

230 border: 1px solid var(--ic-border-strong); border-radius: 4px;

231 background: var(--ic-gray-000);

232 display: flex; align-items: center; justify-content: center;

233 flex-shrink: 0;

234}

235.cc-ic-check svg { color: #fff; display: none; }

236.cc-ic-team-toggle.cc-ic-checked .cc-ic-check { background: var(--ic-clay-deep); border-color: var(--ic-clay-deep); }

237.cc-ic-team-toggle.cc-ic-checked .cc-ic-check svg { display: block; }

~~238~~

239.cc-ic-team-reveal { display: flex; flex-direction: column; gap: 12px; margin-bottom: 16px; }

240.cc-ic-sales {

241 display: flex; align-items: center; justify-content: space-between;

242 gap: 16px; padding: 14px 16px;

243 background: var(--ic-gray-000); border: 0.5px solid var(--ic-border-default);

244 border-radius: 8px; flex-wrap: wrap;

245}

246.cc-ic-sales-text { font-size: 13px; color: var(--ic-gray-700); line-height: 1.5; flex: 1; min-width: 200px; }

247.cc-ic-sales-text strong { font-weight: 550; color: var(--ic-slate); }

248.cc-ic-sales-actions { display: flex; align-items: center; gap: 8px; flex-shrink: 0; }

249.cc-ic-btn-clay {

250 display: inline-flex; align-items: center; gap: 8px;

251 background: var(--ic-clay-deep); color: #fff; border: none;

252 border-radius: 8px; padding: 8px 14px;

253 font-size: 13px; font-weight: 500;

254 transition: background-color 0.15s; white-space: nowrap;

255}

256.cc-ic-btn-clay:hover { background: var(--ic-clay); }

257.cc-ic-btn-ghost {

258 display: inline-flex; align-items: center; gap: 8px;

259 background: transparent; color: var(--ic-gray-700);

260 border: 0.5px solid var(--ic-border-default);

261 border-radius: 8px; padding: 8px 14px;

262 font-size: 13px; font-weight: 500;

263}

264.cc-ic-btn-ghost:hover { background: rgba(0, 0, 0, 0.04); }

~~265~~

266.cc-ic-provider-bar {

267 display: flex; align-items: center; gap: 12px;

268 padding: 14px 16px; background: var(--ic-gray-150);

269 border-radius: 8px; font-size: 13px; flex-wrap: wrap;

270}

271.cc-ic-provider-bar .cc-ic-label { color: var(--ic-gray-550); flex-shrink: 0; }

272.cc-ic-provider-pills { display: flex; gap: 4px; flex-wrap: wrap; }

273.cc-ic-p-pill {

274 appearance: none; border: none; background: transparent;

275 padding: 6px 12px; border-radius: 6px;

276 font-size: 13px; font-weight: 430; color: var(--ic-gray-700);

277 white-space: nowrap;

278}

279.cc-ic-p-pill:hover { background: rgba(0, 0, 0, 0.04); }

280.cc-ic-p-pill.cc-ic-active {

281 background: var(--ic-gray-000); color: var(--ic-slate);

282 font-weight: 500; box-shadow: 0 1px 2px rgba(0, 0, 0, 0.05);

283}

284.cc-ic-provider-notice {

285 display: flex; padding: 16px 18px;

286 background: var(--ic-gray-000); border: 0.5px solid var(--ic-border-default);

287 border-radius: 8px; gap: 14px; align-items: flex-start;

288}

289.cc-ic-provider-notice > svg { color: var(--ic-gray-550); margin-top: 2px; flex-shrink: 0; }

290.cc-ic-provider-notice-body { font-size: 14px; line-height: 1.55; color: var(--ic-gray-700); }

291.cc-ic-provider-notice-body strong { font-weight: 550; color: var(--ic-slate); }

292.cc-ic-provider-notice-body a { color: var(--ic-clay-deep); font-weight: 500; }

293.cc-ic-provider-notice-body a:hover { text-decoration: underline; }

~~294~~

295.cc-ic-card { background: #141413; border-radius: 12px; overflow: hidden; }

296.cc-ic-subtabs {

297 display: flex; align-items: center;

298 background: #1a1918;

299 border-bottom: 0.5px solid rgba(255, 255, 255, 0.08);

300 padding: 0 8px; overflow-x: auto;

301}

302.cc-ic-subtab {

303 appearance: none; background: none; border: none;

304 padding: 12px 16px; font-size: 12px;

305 color: rgba(255, 255, 255, 0.5);

306 position: relative; white-space: nowrap;

307}

308.cc-ic-subtab:hover { color: rgba(255, 255, 255, 0.75); }

309.cc-ic-subtab.cc-ic-active { color: #fff; }

310.cc-ic-subtab.cc-ic-active::after {

311 content: ''; position: absolute;

312 left: 12px; right: 12px; bottom: -0.5px;

313 height: 2px; background: var(--ic-clay);

314}

315.cc-ic-shell-switch {

316 display: inline-flex; gap: 2px;

317 margin: 14px 26px 0; padding: 3px;

318 background: rgba(255, 255, 255, 0.06);

319 border: 0.5px solid rgba(255, 255, 255, 0.08);

320 border-radius: 8px;

321 font-family: inherit;

322}

323.cc-ic-shell-option {

324 font: inherit; font-size: 12px; font-weight: 500;

325 padding: 5px 12px; border-radius: 6px;

326 background: transparent; border: none;

327 color: rgba(255, 255, 255, 0.55);

328 cursor: pointer; user-select: none; white-space: nowrap;

329 transition: color 120ms ease, background-color 120ms ease;

330}

331.cc-ic-shell-option:hover { color: rgba(255, 255, 255, 0.85); }

332.cc-ic-shell-option.cc-ic-active {

333 background: rgba(255, 255, 255, 0.12);

334 color: #fff;

335 box-shadow: 0 1px 2px rgba(0, 0, 0, 0.25);

336}

~~337~~

338.cc-ic-card-body { padding: 24px 26px; display: flex; align-items: flex-start; gap: 14px; }

339.cc-ic-prompt {

340 color: var(--ic-clay); font-family: var(--ic-font-mono);

341 font-size: 17px; user-select: none; padding-top: 2px;

342}

343.cc-ic-cmd {

344 flex: 1; font-family: var(--ic-font-mono);

345 font-size: 17px; color: #f0eee6;

346 line-height: 1.55; white-space: pre-wrap; word-break: break-word;

347}

348.cc-ic-copy {

349 display: inline-flex; align-items: center; gap: 6px;

350 background: rgba(255, 255, 255, 0.08);

351 border: 0.5px solid rgba(255, 255, 255, 0.12);

352 color: rgba(255, 255, 255, 0.85);

353 padding: 7px 13px; border-radius: 8px;

354 font-size: 13px; font-weight: 500; flex-shrink: 0;

355}

356.cc-ic-copy:hover { background: rgba(255, 255, 255, 0.14); }

357.cc-ic-copy.cc-ic-copied { background: var(--ic-clay-deep); border-color: var(--ic-clay-deep); color: #fff; }

~~358~~

359.cc-ic-below {

360 margin-top: 12px; font-size: 13px; color: var(--ic-gray-550);

361 display: flex; gap: 16px; flex-wrap: wrap; align-items: baseline;

362}

363.cc-ic-below a { color: var(--ic-gray-700); border-bottom: 0.5px solid var(--ic-border-default); }

364.cc-ic-below a:hover { color: var(--ic-clay-deep); border-bottom-color: var(--ic-clay-deep); }

365.cc-ic-handoff {

366 padding: 22px 24px;

367 background: linear-gradient(180deg, #faf9f4 0%, #f3f1e9 100%);

368 border: 0.5px solid var(--ic-border-default);

369 border-radius: 12px;

370 box-shadow: 0 1px 2px rgba(31, 30, 29, 0.04), 0 6px 16px -4px rgba(31, 30, 29, 0.06);

371}

372.dark .cc-ic-handoff {

373 background: linear-gradient(180deg, #262624 0%, #1f1e1d 100%);

374 box-shadow: 0 1px 2px rgba(0, 0, 0, 0.3), 0 6px 16px -4px rgba(0, 0, 0, 0.4);

375}

376.cc-ic-handoff-title {

377 font-size: 16px; font-weight: 550; color: var(--ic-slate);

378 letter-spacing: -0.01em; margin-bottom: 4px;

379}

380.cc-ic-handoff-sub {

381 font-size: 14px; line-height: 1.5; color: var(--ic-gray-700);

382 margin-bottom: 18px;

383}

384.cc-ic-handoff-actions { display: flex; gap: 10px; flex-wrap: wrap; }

385.cc-ic-handoff-alt {

386 margin-top: 12px; font-size: 12px; color: var(--ic-gray-550);

387}

388.cc-ic-handoff-alt code {

389 font-family: var(--ic-font-mono); font-size: 11px;

390 background: var(--ic-gray-150); padding: 2px 6px;

391 border-radius: 4px; color: var(--ic-gray-700);

392}

393.cc-ic-copy-sm {

394 appearance: none; border: none;

395 display: inline-flex; align-items: center; justify-content: center;

396 width: 22px; height: 22px;

397 margin-left: 4px; vertical-align: middle;

398 background: var(--ic-gray-150); color: var(--ic-gray-550);

399 border-radius: 4px;

400 transition: color 0.1s, background-color 0.1s;

401}

402.cc-ic-copy-sm:hover { color: var(--ic-gray-700); background: var(--ic-border-default); }

403.cc-ic-copy-sm.cc-ic-copied { background: var(--ic-clay-deep); color: #fff; }

~~404~~

405@media (max-width: 720px) {

406 .cc-ic-tab { padding: 12px 14px; font-size: 14px; }

407 .cc-ic-sales-actions { width: 100%; }

408 .cc-ic-card-body { padding: 20px; }

409 .cc-ic-cmd { font-size: 15px; }

410}

411`;

412 return <div className="cc-ic not-prose">

413 <style>{STYLES}</style>

~~414~~

415 {}

416 <div className="cc-ic-tab-strip" role="tablist">

418 {t.label}

419 </button>)}

420 </div>

~~421~~

422 {}

423 <div className="cc-ic-team-wrap">

424 <button type="button" role="switch" aria-checked={team} className={'cc-ic-team-toggle' + (team ? ' cc-ic-checked' : '')} onClick={() => setTeam(!team)}>

425 <span className="cc-ic-check">{iconCheck(11)}</span>

426 <span>

427 I’m buying for a team or company (SSO, AWS/Azure/GCP, central billing)

428 </span>

429 </button>

430 </div>

~~431~~

432 {}

433 {team && <div className="cc-ic-team-reveal">

434 <div className="cc-ic-sales">

435 <div className="cc-ic-sales-text">

436 <strong>Set up your team:</strong> self-serve or talk to sales.

437 </div>

438 <div className="cc-ic-sales-actions">

439 <a href="https://claude.ai/upgrade?initialPlanType=team&utm_source=claude_code&utm_medium=docs&utm_content=configurator_team_get_started" className="cc-ic-btn-ghost">

440 Get started

441 </a>

442 <a href="https://www.anthropic.com/contact-sales?utm_source=claude_code&utm_medium=docs&utm_content=configurator_team_contact_sales" className="cc-ic-btn-clay">

443 Contact sales {iconArrowRight()}

444 </a>

445 </div>

446 </div>

~~447~~

448 <div className="cc-ic-provider-bar">

449 <span className="cc-ic-label">Run on</span>

450 <div className="cc-ic-provider-pills" role="radiogroup" aria-label="Provider">

452 {p.label}

453 </button>)}

454 </div>

455 </div>

~~456~~

457 {showNotice && <div className="cc-ic-provider-notice">

458 {iconInfo()}

459 <div className="cc-ic-provider-notice-body">

460 {PROVIDER_NOTICE[provider]}

461 </div>

462 </div>}

463 </div>}

~~464~~

465 {}

466 {target === 'terminal' && <div className="cc-ic-card">

467 <div className="cc-ic-subtabs" role="tablist" aria-label="Install method">

468 {Object.keys(TERM).map(k => <button key={k} type="button" role="tab" aria-selected={pkg === k} className={'cc-ic-subtab' + (pkg === k ? ' cc-ic-active' : '')} onClick={() => setPkg(k)}>

469 {TERM[k].label}

470 </button>)}

471 </div>

472 {isWinInstaller && <div className="cc-ic-shell-switch" role="tablist" aria-label="Shell">

473 {[{

474 k: 'ps',

475 label: 'PowerShell'

476 }, {

477 k: 'cmd',

478 label: 'CMD'

479 }].map(({k, label}) => {

480 const active = k === 'cmd' === winCmd;

481 return <button key={k} type="button" role="tab" aria-selected={active} className={'cc-ic-shell-option' + (active ? ' cc-ic-active' : '')} onClick={() => setWinCmd(k === 'cmd')}>

482 {label}

483 </button>;

484 })}

485 </div>}

486 {cardBodyCmd(terminalCmd, isWinPrompt ? '>' : '$')}

487 </div>}

~~488~~

489 {}

490 {target === 'terminal' && <div className="cc-ic-below">

491 {isWinInstaller && <span>

492 <a href="https://git-scm.com/downloads/win" target="_blank" rel="noopener">

493 Git for Windows

494 </a>{' '}

495 recommended. PowerShell is used if Git Bash is absent.

496 </span>}

497 {(pkg === 'brew' || pkg === 'winget') && <span>

498 Does not auto-update. Run{' '}

499 <code>{pkg === 'brew' ? 'brew upgrade claude-code' : 'winget upgrade Anthropic.ClaudeCode'}</code>{' '}

500 periodically.

501 </span>}

502 <a href="/en/troubleshoot-install">Installation troubleshooting</a>

503 </div>}

~~504~~

505 {alt && <div className="cc-ic-handoff">

506 <div className="cc-ic-handoff-title">Claude Code for {alt.name}</div>

507 <div className="cc-ic-handoff-sub">{alt.tagline}</div>

508 <div className="cc-ic-handoff-actions">

509 <a href={alt.installHref} className="cc-ic-btn-clay" {...alt.installHref.startsWith('http') ? {

510 target: '_blank',

511 rel: 'noopener'

512 } : {}}>

513 {alt.installLabel} {iconArrowUpRight(13)}

514 </a>

515 <a href={alt.guideHref} className="cc-ic-btn-ghost">

516 {alt.name} guide {iconArrowRight(12)}

517 </a>

518 </div>

519 {alt.altCmd && <div className="cc-ic-handoff-alt">

520 or run <code>{alt.altCmd}</code>

521 <button type="button" className={'cc-ic-copy-sm' + (copied === 'alt' ? ' cc-ic-copied' : '')} onClick={() => handleCopy(alt.altCmd, 'alt')} aria-label="Copy command">

522 {copied === 'alt' ? iconCheck(11) : iconCopy(11)}

523 </button>

524 </div>}

525 </div>}

526 </div>;

527};

~~528~~

529export const Experiment = ({flag, treatment, children}) => {

530 const VID_KEY = 'exp_vid';

532 const fnv1a = s => {

533 let h = 0x811c9dc5;

534 for (let i = 0; i < s.length; i++) {

535 h ^= s.charCodeAt(i);

536 h += (h << 1) + (h << 4) + (h << 7) + (h << 8) + (h << 24);

537 }

538 return h >>> 0;

539 };

540 const bucket = (seed, vid) => fnv1a(fnv1a(seed + vid) + '') % 10000 < 5000 ? 'control' : 'treatment';

541 const [decision] = useState(() => {

542 const params = new URLSearchParams(location.search);

543 const preBucketed = document.documentElement.dataset['gb_' + flag.replace(/-/g, '_')];

544 const force = params.get('gb-force');

545 if (force) {

546 for (const p of force.split(',')) {

547 const [k, v] = p.split(':');

548 if (k === flag) return {

549 variant: v || 'treatment',

550 track: false

551 };

552 }

553 }

554 if (navigator.globalPrivacyControl) {

555 return {

556 variant: 'control',

557 track: false

558 };

559 }

560 const prefsMatch = document.cookie.match(/(?:^|; )anthropic-consent-preferences=([^;]+)/);

561 if (prefsMatch) {

562 try {

563 if (JSON.parse(decodeURIComponent(prefsMatch[1])).analytics !== true) {

564 return {

565 variant: 'control',

566 track: false

567 };

568 }

569 } catch {

570 return {

571 variant: 'control',

572 track: false

573 };

574 }

575 } else {

576 const country = params.get('country')?.toUpperCase() || (document.cookie.match(/(?:^|; )cf_geo=([A-Z]{2})/) || [])[1];

577 if (!country || CONSENT_COUNTRIES.has(country)) {

578 return {

579 variant: 'control',

580 track: false

581 };

582 }

583 }

584 let vid;

585 try {

586 const ajsMatch = document.cookie.match(/(?:^|; )ajs_anonymous_id=([^;]+)/);

587 if (ajsMatch) {

588 vid = decodeURIComponent(ajsMatch[1]).replace(/^"|"$/g, '');

589 } else {

590 vid = localStorage.getItem(VID_KEY);

591 if (!vid) {

592 vid = crypto.randomUUID();

593 }

594 document.cookie = `ajs_anonymous_id=${vid}; domain=.claude.com; path=/; Secure; SameSite=Lax; max-age=31536000`;

595 }

596 try {

597 localStorage.setItem(VID_KEY, vid);

598 } catch {}

599 } catch {

600 return {

601 variant: 'control',

602 track: false

603 };

604 }

605 const variant = preBucketed === '1' ? 'treatment' : preBucketed === '0' ? 'control' : bucket(flag, vid);

606 return {

607 variant,

608 track: true,

609 vid

610 };

611 });

612 useEffect(() => {

613 if (!decision.track) return;

614 fetch('https://api.anthropic.com/api/event_logging/v2/batch', {

615 method: 'POST',

616 headers: {

617 'Content-Type': 'application/json',

618 'x-service-name': 'claude_code_docs'

619 },

620 body: JSON.stringify({

621 events: [{

622 event_type: 'GrowthbookExperimentEvent',

623 event_data: {

624 device_id: decision.vid,

625 anonymous_id: decision.vid,

626 timestamp: new Date().toISOString(),

627 experiment_id: flag,

628 variation_id: decision.variant === 'treatment' ? 1 : 0,

629 environment: 'production'

630 }

631 }]

632 }),

633 keepalive: true

634 }).catch(() => {});

635 }, []);

636 return decision.variant === 'treatment' ? treatment : children;

637};

~~638~~

639Questa guida rapida ti permetterà di utilizzare l'assistenza alla codifica basata su IA in pochi minuti. Alla fine, comprenderai come utilizzare Claude Code per le attività di sviluppo comuni.9Questa guida rapida ti permetterà di utilizzare l'assistenza alla codifica basata su IA in pochi minuti. Alla fine, comprenderai come utilizzare Claude Code per le attività di sviluppo comuni.

640 10

641<Experiment flag="quickstart-install-configurator" treatment={<InstallConfigurator />} />

~~642~~

643## Prima di iniziare11## Prima di iniziare

644 12

645Assicurati di avere:13Assicurati di avere:

647* Un terminale o un prompt dei comandi aperto15* Un terminale o un prompt dei comandi aperto

648 * Se non hai mai utilizzato il terminale prima, consulta la [guida del terminale](/it/terminal-guide)16 * Se non hai mai utilizzato il terminale prima, consulta la [guida del terminale](/it/terminal-guide)

649* Un progetto di codice con cui lavorare17* Un progetto di codice con cui lavorare

650* Un [abbonamento Claude](https://claude.com/pricing?utm_source=claude_code\&utm_medium=docs\&utm_content=quickstart_prereq) (Pro, Max, Teams o Enterprise), un account [Claude Console](https://console.anthropic.com/) o accesso tramite un [provider cloud supportato](/it/third-party-integrations)18* Un [abbonamento Claude](https://claude.com/pricing?utm_source=claude_code\&utm_medium=docs\&utm_content=quickstart_prereq) (Pro, Max, Team o Enterprise), un account [Claude Console](https://console.anthropic.com/) o accesso tramite un [provider cloud supportato](/it/third-party-integrations)

651 19

652<Note>20<Note>

653 Questa guida copre il CLI del terminale. Claude Code è disponibile anche sul [web](https://claude.ai/code), come [app desktop](/it/desktop), in [VS Code](/it/vs-code) e [IDE JetBrains](/it/jetbrains), in [Slack](/it/slack) e in CI/CD con [GitHub Actions](/it/github-actions) e [GitLab](/it/gitlab-ci-cd). Vedi [tutte le interfacce](/it/overview#use-claude-code-everywhere).21 Questa guida copre il CLI del terminale. Claude Code è disponibile anche sul [web](https://claude.ai/code), come [app desktop](/it/desktop), in [VS Code](/it/vs-code) e [IDE JetBrains](/it/jetbrains), in [Slack](/it/slack) e in CI/CD con [GitHub Actions](/it/github-actions) e [GitLab](/it/gitlab-ci-cd). Vedi [tutte le interfacce](/it/overview#use-claude-code-everywhere).

727 95

728Puoi accedere utilizzando uno di questi tipi di account:96Puoi accedere utilizzando uno di questi tipi di account:

729 97

730* [Claude Pro, Max, Teams o Enterprise](https://claude.com/pricing?utm_source=claude_code\&utm_medium=docs\&utm_content=quickstart_login) (consigliato)98* [Claude Pro, Max, Team o Enterprise](https://claude.com/pricing?utm_source=claude_code\&utm_medium=docs\&utm_content=quickstart_login) (consigliato)

731* [Claude Console](https://console.anthropic.com/) (accesso API con crediti prepagati). Al primo accesso, uno spazio di lavoro "Claude Code" viene creato automaticamente nella Console per il tracciamento centralizzato dei costi.99* [Claude Console](https://console.anthropic.com/) (accesso API con crediti prepagati). Al primo accesso, uno spazio di lavoro "Claude Code" viene creato automaticamente nella Console per il tracciamento centralizzato dei costi.

732* [Amazon Bedrock, Google Vertex AI o Microsoft Foundry](/it/third-party-integrations) (provider cloud aziendali)100* [Amazon Bedrock, Google Vertex AI o Microsoft Foundry](/it/third-party-integrations) (provider cloud aziendali)

733 101

902| `claude commit` | Crea un commit Git | `claude commit` |

906 273

907Vedi il [riferimento CLI](/it/cli-reference) per un elenco completo dei comandi.274Vedi il [riferimento CLI](/it/cli-reference) per un elenco completo dei comandi.

908 275

settings.md +7 −3

Details

156`settings.json` supporta un numero di opzioni:156`settings.json` supporta un numero di opzioni:

157 157

159| :-------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------- |159| :-------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------- |

160| `agent` | Esegui il thread principale come un subagent denominato. Applica il prompt di sistema, le restrizioni degli strumenti e il modello di quel subagent. Vedi [Invoca i subagent esplicitamente](/it/sub-agents#invoke-subagents-explicitly) | `"code-reviewer"` |160| `agent` | Esegui il thread principale come un subagent denominato. Applica il prompt di sistema, le restrizioni degli strumenti e il modello di quel subagent. Vedi [Invoca i subagent esplicitamente](/it/sub-agents#invoke-subagents-explicitly) | `"code-reviewer"` |

161| `allowedChannelPlugins` | (Solo impostazioni gestite) Elenco di autorizzazione dei plugin di canale che possono inviare messaggi. Sostituisce l'elenco di autorizzazione predefinito di Anthropic quando impostato. Non definito = ricaduta al predefinito, array vuoto = blocca tutti i plugin di canale. Richiede `channelsEnabled: true`. Vedi [Limita quali plugin di canale possono essere eseguiti](/it/channels#restrict-which-channel-plugins-can-run) | `[{ "marketplace": "claude-plugins-official", "plugin": "telegram" }]` |161| `allowedChannelPlugins` | (Solo impostazioni gestite) Elenco di autorizzazione dei plugin di canale che possono inviare messaggi. Sostituisce l'elenco di autorizzazione predefinito di Anthropic quando impostato. Non definito = ricaduta al predefinito, array vuoto = blocca tutti i plugin di canale. Richiede `channelsEnabled: true`. Vedi [Limita quali plugin di canale possono essere eseguiti](/it/channels#restrict-which-channel-plugins-can-run) | `[{ "marketplace": "claude-plugins-official", "plugin": "telegram" }]` |

162| `allowedHttpHookUrls` | Elenco di autorizzazione dei modelli di URL che gli hook HTTP possono indirizzare. Supporta `*` come carattere jolly. Quando impostato, gli hook con URL non corrispondenti vengono bloccati. Non definito = nessuna restrizione, array vuoto = blocca tutti gli hook HTTP. Gli array si uniscono tra le fonti di impostazioni. Vedi [Configurazione hook](#hook-configuration) | `["https://hooks.example.com/*"]` |162| `allowedHttpHookUrls` | Elenco di autorizzazione dei modelli di URL che gli hook HTTP possono indirizzare. Supporta `*` come carattere jolly. Quando impostato, gli hook con URL non corrispondenti vengono bloccati. Non definito = nessuna restrizione, array vuoto = blocca tutti gli hook HTTP. Gli array si uniscono tra le fonti di impostazioni. Vedi [Configurazione hook](#hook-configuration) | `["https://hooks.example.com/*"]` |

211| `modelOverrides` | Mappa gli ID dei modelli Anthropic agli ID dei modelli specifici del provider come gli ARN del profilo di inferenza Bedrock. Ogni voce del selettore di modello utilizza il suo valore mappato quando chiama l'API del provider. Vedi [Ignora gli ID dei modelli per versione](/it/model-config#override-model-ids-per-version) | `{"claude-opus-4-6": "arn:aws:bedrock:..."}` |211| `modelOverrides` | Mappa gli ID dei modelli Anthropic agli ID dei modelli specifici del provider come gli ARN del profilo di inferenza Bedrock. Ogni voce del selettore di modello utilizza il suo valore mappato quando chiama l'API del provider. Vedi [Ignora gli ID dei modelli per versione](/it/model-config#override-model-ids-per-version) | `{"claude-opus-4-6": "arn:aws:bedrock:..."}` |

212| `otelHeadersHelper` | Script per generare intestazioni OpenTelemetry dinamiche. Viene eseguito all'avvio e periodicamente. Imposta l'intervallo di aggiornamento con [`CLAUDE_CODE_OTEL_HEADERS_HELPER_DEBOUNCE_MS`](/it/env-vars). Vedi [Intestazioni dinamiche](/it/monitoring-usage#dynamic-headers) | `/bin/generate_otel_headers.sh` |212| `otelHeadersHelper` | Script per generare intestazioni OpenTelemetry dinamiche. Viene eseguito all'avvio e periodicamente. Imposta l'intervallo di aggiornamento con [`CLAUDE_CODE_OTEL_HEADERS_HELPER_DEBOUNCE_MS`](/it/env-vars). Vedi [Intestazioni dinamiche](/it/monitoring-usage#dynamic-headers) | `/bin/generate_otel_headers.sh` |

214| `parentSettingsBehavior` | {/* min-version: 2.1.133 */}(Solo impostazioni gestite) Controlla se le impostazioni gestite fornite programmaticamente da un processo host di incorporamento, come l'Agent SDK o un'estensione IDE, si applicano quando è presente anche un livello gestito distribuito da un amministratore. `"first-wins"`: le impostazioni fornite dal parent vengono eliminate e si applica solo il livello amministrativo. `"merge"`: le impostazioni fornite dal parent si applicano sotto il livello amministrativo, filtrate in modo che possano stringere la politica ma non allentarla. Non ha effetto quando non è distribuito alcun livello amministrativo. Predefinito: `"first-wins"`. Richiede Claude Code v2.1.133 o successivo | `"merge"` |

215| `plansDirectory` | Personalizza dove vengono archiviati i file di piano. Il percorso è relativo alla radice del progetto. Predefinito: `~/.claude/plans` | `"./plans"` |216| `plansDirectory` | Personalizza dove vengono archiviati i file di piano. Il percorso è relativo alla radice del progetto. Predefinito: `~/.claude/plans` | `"./plans"` |

216| `pluginTrustMessage` | (Solo impostazioni gestite) Messaggio personalizzato aggiunto all'avviso di fiducia del plugin mostrato prima dell'installazione. Usa questo per aggiungere contesto specifico dell'organizzazione, ad esempio per confermare che i plugin dal tuo marketplace interno sono controllati. | `"All plugins from our marketplace are approved by IT"` |217| `pluginTrustMessage` | (Solo impostazioni gestite) Messaggio personalizzato aggiunto all'avviso di fiducia del plugin mostrato prima dell'installazione. Usa questo per aggiungere contesto specifico dell'organizzazione, ad esempio per confermare che i plugin dal tuo marketplace interno sono controllati. | `"All plugins from our marketplace are approved by IT"` |

255 256

256### Impostazioni worktree257### Impostazioni worktree

257 258

258Configura come `--worktree` crea e gestisce i git worktrees. Usa queste impostazioni per ridurre l'utilizzo del disco e il tempo di avvio nei grandi monorepo.259Configura come `--worktree` crea e gestisce i git worktrees.

259 260

261| :---------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------ |262| :---------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------ |

263| `worktree.baseRef` | Quale ref i nuovi worktrees si diramano da. `"fresh"` (predefinito) si dirama da `origin/<default-branch>` per un albero pulito che corrisponde al remoto. `"head"` si dirama dal tuo `HEAD` locale corrente, quindi i commit non spinti e lo stato del ramo di funzionalità sono presenti nel worktree. Si applica a `--worktree`, lo strumento `EnterWorktree`, e l'isolamento del subagent | `"head"` |

262| `worktree.symlinkDirectories` | Directory da collegare simbolicamente dal repository principale in ogni worktree per evitare di duplicare grandi directory su disco. Nessuna directory viene collegata simbolicamente per impostazione predefinita | `["node_modules", ".cache"]` |264| `worktree.symlinkDirectories` | Directory da collegare simbolicamente dal repository principale in ogni worktree per evitare di duplicare grandi directory su disco. Nessuna directory viene collegata simbolicamente per impostazione predefinita | `["node_modules", ".cache"]` |

263| `worktree.sparsePaths` | Directory da estrarre in ogni worktree tramite git sparse-checkout (modalità cone). Solo i percorsi elencati vengono scritti su disco, il che è più veloce nei grandi monorepo | `["packages/my-app", "shared/utils"]` |265| `worktree.sparsePaths` | Directory da estrarre in ogni worktree tramite git sparse-checkout (modalità cone). Solo i percorsi elencati vengono scritti su disco, il che è più veloce nei grandi monorepo | `["packages/my-app", "shared/utils"]` |

264 266

318| `network.socksProxyPort` | Porta del proxy SOCKS5 utilizzata se desideri portare il tuo proxy. Se non specificato, Claude eseguirà il suo proxy. | `8081` |320| `network.socksProxyPort` | Porta del proxy SOCKS5 utilizzata se desideri portare il tuo proxy. Se non specificato, Claude eseguirà il suo proxy. | `8081` |

319| `enableWeakerNestedSandbox` | Abilita una sandbox più debole per gli ambienti Docker senza privilegi (solo Linux e WSL2). **Riduce la sicurezza.** Predefinito: false | `true` |321| `enableWeakerNestedSandbox` | Abilita una sandbox più debole per gli ambienti Docker senza privilegi (solo Linux e WSL2). **Riduce la sicurezza.** Predefinito: false | `true` |

320| `enableWeakerNetworkIsolation` | (Solo macOS) Consenti l'accesso al servizio di fiducia TLS del sistema (`com.apple.trustd.agent`) nella sandbox. Richiesto affinché gli strumenti basati su Go come `gh`, `gcloud` e `terraform` verifichino i certificati TLS quando si utilizza `httpProxyPort` con un proxy MITM e una CA personalizzata. **Riduce la sicurezza** aprendo un potenziale percorso di esfiltrazione dei dati. Predefinito: false | `true` |322| `enableWeakerNetworkIsolation` | (Solo macOS) Consenti l'accesso al servizio di fiducia TLS del sistema (`com.apple.trustd.agent`) nella sandbox. Richiesto affinché gli strumenti basati su Go come `gh`, `gcloud` e `terraform` verifichino i certificati TLS quando si utilizza `httpProxyPort` con un proxy MITM e una CA personalizzata. **Riduce la sicurezza** aprendo un potenziale percorso di esfiltrazione dei dati. Predefinito: false | `true` |

323| `bwrapPath` | (Solo impostazioni gestite, Linux/WSL2) Percorso assoluto al binario bubblewrap (`bwrap`). Ignora il rilevamento automatico tramite `PATH`. Onorato solo dalle [impostazioni gestite](/it/settings#settings-files), non dalle impostazioni utente o di progetto. Utile quando `bwrap` è installato in una posizione non standard negli ambienti gestiti. | `/opt/admin/bwrap` |

324| `socatPath` | (Solo impostazioni gestite, Linux/WSL2) Percorso assoluto al binario `socat` utilizzato per il proxy di rete della sandbox. Ignora il rilevamento automatico tramite `PATH`. Onorato solo dalle impostazioni gestite. | `/opt/admin/socat` |

321 325

322#### Prefissi di percorso sandbox326#### Prefissi di percorso sandbox

323 327

setup.md +2 −0

Details

398 398

399Le piattaforme di installazione npm supportate sono `darwin-arm64`, `darwin-x64`, `linux-x64`, `linux-arm64`, `linux-x64-musl`, `linux-arm64-musl`, `win32-x64` e `win32-arm64`. Il vostro gestore di pacchetti deve consentire dipendenze opzionali. Consultate la [risoluzione dei problemi](/it/troubleshoot-install#native-binary-not-found-after-npm-install) se il binario manca dopo l'installazione.399Le piattaforme di installazione npm supportate sono `darwin-arm64`, `darwin-x64`, `linux-x64`, `linux-arm64`, `linux-x64-musl`, `linux-arm64-musl`, `win32-x64` e `win32-arm64`. Il vostro gestore di pacchetti deve consentire dipendenze opzionali. Consultate la [risoluzione dei problemi](/it/troubleshoot-install#native-binary-not-found-after-npm-install) se il binario manca dopo l'installazione.

400 400

401Per aggiornare un'installazione npm, eseguite `npm install -g @anthropic-ai/claude-code@latest`. Evitate `npm update -g`, che rispetta l'intervallo semver dall'installazione originale e potrebbe non portarvi al rilascio più recente.

402

401<Warning>403<Warning>

402 NON utilizzate `sudo npm install -g` poiché ciò può portare a problemi di permessi e rischi di sicurezza. Se riscontrate errori di permessi, consultate la [risoluzione dei problemi di permessi](/it/troubleshoot-install#permission-errors-during-installation).404 NON utilizzate `sudo npm install -g` poiché ciò può portare a problemi di permessi e rischi di sicurezza. Se riscontrate errori di permessi, consultate la [risoluzione dei problemi di permessi](/it/troubleshoot-install#permission-errors-during-installation).

403</Warning>405</Warning>

sub-agents.md +3 −3

Details

262| :---------------- | :------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |262| :---------------- | :------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

263| `name` | Yes | Identificatore univoco utilizzando lettere minuscole e trattini |263| `name` | Yes | Identificatore univoco utilizzando lettere minuscole e trattini |

264| `description` | Yes | Quando Claude dovrebbe delegare a questo subagent |264| `description` | Yes | Quando Claude dovrebbe delegare a questo subagent |

265| `tools` | No | [Strumenti](#available-tools) che il subagent può utilizzare. Eredita tutti gli strumenti se omesso |265| `tools` | No | [Strumenti](#available-tools) che il subagent può utilizzare. Eredita tutti gli strumenti se omesso. Per precaricare Skills nel contesto, usi il campo `skills` piuttosto che elencare `Skill` qui |

266| `disallowedTools` | No | Strumenti da negare, rimossi dall'elenco ereditato o specificato |266| `disallowedTools` | No | Strumenti da negare, rimossi dall'elenco ereditato o specificato |

267| `model` | No | [Modello](#choose-a-model) da utilizzare: `sonnet`, `opus`, `haiku`, un ID modello completo (ad esempio, `claude-opus-4-7`), o `inherit`. Predefinito: `inherit` |267| `model` | No | [Modello](#choose-a-model) da utilizzare: `sonnet`, `opus`, `haiku`, un ID modello completo (ad esempio, `claude-opus-4-7`), o `inherit`. Predefinito: `inherit` |

268| `permissionMode` | No | [Modalità di autorizzazione](#permission-modes): `default`, `acceptEdits`, `auto`, `dontAsk`, `bypassPermissions`, o `plan`. Ignorato per [subagent plugin](#choose-the-subagent-scope) |268| `permissionMode` | No | [Modalità di autorizzazione](#permission-modes): `default`, `acceptEdits`, `auto`, `dontAsk`, `bypassPermissions`, o `plan`. Ignorato per [subagent plugin](#choose-the-subagent-scope) |

269| `maxTurns` | No | Numero massimo di turni agentici prima che il subagent si fermi |269| `maxTurns` | No | Numero massimo di turni agentici prima che il subagent si fermi |

270| `skills` | No | [Skills](/it/skills) da caricare nel contesto del subagent all'avvio. Il contenuto completo della skill viene iniettato, non solo reso disponibile per l'invocazione. I subagent non ereditano skills dalla conversazione principale |270| `skills` | No | [Skills](/it/skills) da precaricare nel contesto del subagent all'avvio. Il contenuto completo della skill viene iniettato, non solo la descrizione. I subagent possono ancora invocare skills di progetto, utente e plugin non elencate tramite lo strumento Skill |

271| `mcpServers` | No | [MCP servers](/it/mcp) disponibili per questo subagent. Ogni voce è un nome di server che fa riferimento a un server già configurato (ad esempio, `"slack"`) o una definizione inline con il nome del server come chiave e una [configurazione MCP server](/it/mcp#installing-mcp-servers) completa come valore. Ignorato per [subagent plugin](#choose-the-subagent-scope) |271| `mcpServers` | No | [MCP servers](/it/mcp) disponibili per questo subagent. Ogni voce è un nome di server che fa riferimento a un server già configurato (ad esempio, `"slack"`) o una definizione inline con il nome del server come chiave e una [configurazione MCP server](/it/mcp#installing-mcp-servers) completa come valore. Ignorato per [subagent plugin](#choose-the-subagent-scope) |

272| `hooks` | No | [Lifecycle hooks](#define-hooks-for-subagents) limitati a questo subagent. Ignorato per [subagent plugin](#choose-the-subagent-scope) |272| `hooks` | No | [Lifecycle hooks](#define-hooks-for-subagents) limitati a questo subagent. Ignorato per [subagent plugin](#choose-the-subagent-scope) |

273| `memory` | No | [Ambito di memoria persistente](#enable-persistent-memory): `user`, `project`, o `local`. Abilita l'apprendimento tra sessioni |273| `memory` | No | [Ambito di memoria persistente](#enable-persistent-memory): `user`, `project`, o `local`. Abilita l'apprendimento tra sessioni |

418Implement API endpoints. Follow the conventions and patterns from the preloaded skills.418Implement API endpoints. Follow the conventions and patterns from the preloaded skills.

419```419```

420 420

421Il contenuto completo di ogni skill viene iniettato nel contesto del subagent, non solo reso disponibile per l'invocazione. I subagent non ereditano skills dalla conversazione principale; deve elencarle esplicitamente.421Il contenuto completo di ogni skill elencata viene iniettato nel contesto del subagent all'avvio. Questo campo controlla quali skills vengono precaricate, non quali skills il subagent può accedere: senza di esso, il subagent può comunque scoprire e invocare skills di progetto, utente e plugin tramite lo strumento Skill durante l'esecuzione. Per impedire a un subagent di invocare skills interamente, ometta `Skill` dall'elenco [`tools`](#available-tools) o aggiunga a `disallowedTools`.

422 422

423Non può precaricare skills che impostano [`disable-model-invocation: true`](/it/skills#control-who-invokes-a-skill), poiché il precaricamento attinge dallo stesso insieme di skills che Claude può invocare. Se una skill elencata è mancante o disabilitata, Claude Code la salta e registra un avviso nel log di debug.423Non può precaricare skills che impostano [`disable-model-invocation: true`](/it/skills#control-who-invokes-a-skill), poiché il precaricamento attinge dallo stesso insieme di skills che Claude può invocare. Se una skill elencata è mancante o disabilitata, Claude Code la salta e registra un avviso nel log di debug.

424 424

terminal-config.md +1 −1

Details

107set -as terminal-features 'xterm*:extkeys'107set -as terminal-features 'xterm*:extkeys'

108```108```

109 109

110La riga `allow-passthrough` consente alle notifiche e agli aggiornamenti di avanzamento di raggiungere iTerm2, Ghostty o Kitty invece di essere inghiottiti da tmux. Le righe `extended-keys` consentono a tmux di distinguere Shift+Invio da Invio semplice in modo che la scorciatoia della nuova riga funzioni.110La riga `allow-passthrough` consente alle notifiche e agli aggiornamenti di avanzamento di raggiungere il terminale esterno invece di essere inghiottiti da tmux. Le righe `extended-keys` consentono a tmux di distinguere Shift+Invio da Invio semplice in modo che la scorciatoia della nuova riga funzioni.

111 111

112## Abbina il tema dei colori112## Abbina il tema dei colori

113 113

third-party-integrations.md +73 −1

Details

6 6

7> Scopri come Claude Code può integrarsi con vari servizi di terze parti e infrastrutture per soddisfare i requisiti di distribuzione aziendale.7> Scopri come Claude Code può integrarsi con vari servizi di terze parti e infrastrutture per soddisfare i requisiti di distribuzione aziendale.

8 8

9export const ContactSalesCard = ({surface}) => {

10 const utm = content => `utm_source=claude_code&utm_medium=docs&utm_content=${surface}_${content}`;

11 const iconArrowRight = (size = 13) => <svg width={size} height={size} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2.5" strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">

12 <line x1="5" y1="12" x2="19" y2="12" />

13 <polyline points="12 5 19 12 12 19" />

14 </svg>;

15 const STYLES = `

16.cc-cs {

17 --cs-slate: #141413;

18 --cs-clay: #d97757;

19 --cs-clay-deep: #c6613f;

20 --cs-gray-000: #ffffff;

21 --cs-gray-700: #3d3d3a;

22 --cs-border-default: rgba(31, 30, 29, 0.15);

23 font-family: inherit;

24}

25.dark .cc-cs {

26 --cs-slate: #f0eee6;

27 --cs-gray-000: #262624;

28 --cs-gray-700: #bfbdb4;

29 --cs-border-default: rgba(240, 238, 230, 0.14);

30}

31.cc-cs-card {

32 display: flex; align-items: center; justify-content: space-between;

33 gap: 16px; padding: 14px 16px; margin: 0;

34 background: var(--cs-gray-000); border: 0.5px solid var(--cs-border-default);

35 border-radius: 8px; flex-wrap: wrap;

36}

37.cc-cs-text { font-size: 13px; color: var(--cs-gray-700); line-height: 1.5; flex: 1; min-width: 240px; }

38.cc-cs-text strong { font-weight: 550; color: var(--cs-slate); }

39.cc-cs-actions { display: flex; align-items: center; gap: 8px; flex-shrink: 0; }

40.cc-cs-btn-clay {

41 display: inline-flex; align-items: center; gap: 8px;

42 background: var(--cs-clay-deep); color: #fff; border: none;

43 border-radius: 8px; padding: 8px 14px;

44 font-size: 13px; font-weight: 500;

45 transition: background-color 0.15s; white-space: nowrap;

46}

47.cc-cs-btn-clay:hover { background: var(--cs-clay); }

48.cc-cs-btn-ghost {

49 display: inline-flex; align-items: center; gap: 8px;

50 background: transparent; color: var(--cs-gray-700);

51 border: 0.5px solid var(--cs-border-default);

52 border-radius: 8px; padding: 8px 14px;

53 font-size: 13px; font-weight: 500;

54}

55.cc-cs-btn-ghost:hover { background: rgba(0, 0, 0, 0.04); }

56.dark .cc-cs-btn-ghost:hover { background: rgba(255, 255, 255, 0.04); }

57@media (max-width: 720px) {

58 .cc-cs-actions { width: 100%; }

59}

60`;

61 return <div className="cc-cs not-prose">

62 <style>{STYLES}</style>

63 <div className="cc-cs-card">

64 <div className="cc-cs-text">

65 <strong>Deploying Claude Code across your organization?</strong> Talk to sales about enterprise plans, SSO, and centralized billing.

66 </div>

67 <div className="cc-cs-actions">

68 <a href={`https://claude.com/pricing?${utm('view_plans')}#plans-business`} className="cc-cs-btn-ghost">

69 View plans

70 </a>

71 <a href={`https://claude.com/contact-sales?${utm('contact_sales')}`} className="cc-cs-btn-clay">

72 Contact sales {iconArrowRight()}

73 </a>

74 </div>

75 </div>

76 </div>;

77};

9Le organizzazioni possono distribuire Claude Code direttamente tramite Anthropic o tramite un provider cloud. Questa pagina ti aiuta a scegliere la configurazione giusta.79Le organizzazioni possono distribuire Claude Code direttamente tramite Anthropic o tramite un provider cloud. Questa pagina ti aiuta a scegliere la configurazione giusta.

10 80

81<ContactSalesCard surface="third_party_overview" />

11## Confronta le opzioni di distribuzione83## Confronta le opzioni di distribuzione

12 84

13Per la maggior parte delle organizzazioni, Claude for Teams o Claude for Enterprise offre la migliore esperienza. I membri del team ottengono accesso sia a Claude Code che a Claude sul web con un'unica sottoscrizione, fatturazione centralizzata e nessuna configurazione dell'infrastruttura richiesta.85Per la maggior parte delle organizzazioni, Claude for Teams o Claude for Enterprise offre la migliore esperienza. I membri del team ottengono accesso sia a Claude Code che a Claude sul web con un'unica sottoscrizione, fatturazione centralizzata e nessuna configurazione dell'infrastruttura richiesta.

241 313

242### Fissa le versioni dei modelli per i provider cloud314### Fissa le versioni dei modelli per i provider cloud

243 315

244Se distribuisci tramite [Bedrock](/it/amazon-bedrock), [Vertex AI](/it/google-vertex-ai), o [Foundry](/it/microsoft-foundry), fissa versioni specifiche dei modelli utilizzando `ANTHROPIC_DEFAULT_OPUS_MODEL`, `ANTHROPIC_DEFAULT_SONNET_MODEL`, e `ANTHROPIC_DEFAULT_HAIKU_MODEL`. Senza fissare, gli alias dei modelli Claude Code si risolvono nella versione più recente, che può interrompere gli utenti quando Anthropic rilascia un nuovo modello che non è ancora abilitato nel tuo account. Vedi [Model configuration](/it/model-config#pin-models-for-third-party-deployments) per i dettagli.316Se distribuisci tramite [Bedrock](/it/amazon-bedrock), [Vertex AI](/it/google-vertex-ai), o [Foundry](/it/microsoft-foundry), fissa versioni specifiche dei modelli utilizzando `ANTHROPIC_DEFAULT_OPUS_MODEL`, `ANTHROPIC_DEFAULT_SONNET_MODEL`, e `ANTHROPIC_DEFAULT_HAIKU_MODEL`. Senza fissare, gli alias dei modelli si risolvono nella versione più recente, che potrebbe non essere ancora abilitata nel tuo account quando Anthropic rilascia un aggiornamento. Fissare le versioni ti consente di controllare quando i tuoi utenti passano a un nuovo modello. Vedi [Model configuration](/it/model-config#pin-models-for-third-party-deployments) per ciò che ogni provider fa quando la versione più recente non è disponibile.

245 317

246### Configura le policy di sicurezza318### Configura le policy di sicurezza

247 319

vs-code.md +3 −1

Details

32 32

33Oppure in VS Code, premi `Cmd+Shift+X` (Mac) o `Ctrl+Shift+X` (Windows/Linux) per aprire la visualizzazione Estensioni, cerca "Claude Code" e fai clic su **Installa**.33Oppure in VS Code, premi `Cmd+Shift+X` (Mac) o `Ctrl+Shift+X` (Windows/Linux) per aprire la visualizzazione Estensioni, cerca "Claude Code" e fai clic su **Installa**.

34 34

35L'estensione si installa anche in altri fork di VS Code come Windsurf o Kiro. Cerca "Claude Code" nella visualizzazione Estensioni dell'editor, oppure installa dal [registro Open VSX](https://open-vsx.org/extension/Anthropic/claude-code). Se il tuo editor non riesce a installare l'estensione, esegui `claude` nel suo terminale integrato. La [CLI](/it/quickstart) funziona in qualsiasi terminale.

35<Note>Se l'estensione non appare dopo l'installazione, riavvia VS Code o esegui "Developer: Reload Window" dalla Tavolozza dei comandi.</Note>37<Note>Se l'estensione non appare dopo l'installazione, riavvia VS Code o esegui "Developer: Reload Window" dalla Tavolozza dei comandi.</Note>

36 38

37## Inizia39## Inizia

318| `environmentVariables` | `[]` | Imposta le variabili di ambiente per il processo Claude. Usa invece le impostazioni Claude Code per la configurazione condivisa. |320| `environmentVariables` | `[]` | Imposta le variabili di ambiente per il processo Claude. Usa invece le impostazioni Claude Code per la configurazione condivisa. |

320| `allowDangerouslySkipPermissions` | `false` | Aggiunge la modalità [Auto](/it/permission-modes#eliminate-prompts-with-auto-mode) e Bypass permissions al selettore di modalità. Auto mode ha [requisiti di piano, admin, modello e provider](/it/permission-modes#eliminate-prompts-with-auto-mode), quindi potrebbe rimanere non disponibile anche con questo interruttore attivato. Usa Bypass permissions solo in sandbox senza accesso a Internet. |322| `allowDangerouslySkipPermissions` | `false` | Aggiunge la modalità [Auto](/it/permission-modes#eliminate-prompts-with-auto-mode) e Bypass permissions al selettore di modalità. Auto mode ha [requisiti di piano, admin, modello e provider](/it/permission-modes#eliminate-prompts-with-auto-mode), quindi potrebbe rimanere non disponibile anche con questo interruttore attivato. Usa Bypass permissions solo in sandbox senza accesso a Internet. |

321| `claudeProcessWrapper` | - | Percorso eseguibile utilizzato per avviare il processo Claude |323| `claudeProcessWrapper` | - | Eseguibile utilizzato per avviare il processo Claude. Il percorso del binario in bundle viene passato come argomento quando presente. Impostalo su un binario `claude` installato separatamente se la build dell'estensione non ne include uno per la tua piattaforma. |

322 324

323## Estensione VS Code vs. Claude Code CLI325## Estensione VS Code vs. Claude Code CLI

324 326

Documentation 2026-05-07 22:59 UTC to 2026-05-08 22:00 UTC