6 6
7> Costruisci agenti AI di produzione con Claude Code come libreria7> Costruisci agenti AI di produzione con Claude Code come libreria
8 8
9Costruisci agenti AI che leggono autonomamente file, eseguono comandi, cercano sul web, modificano codice e molto altro. L'Agent SDK ti offre gli stessi strumenti, il ciclo dell'agente e la gestione del contesto che alimentano Claude Code, programmabili in Python e TypeScript. Per il ragionamento dietro la progettazione dell'harness dell'agente, vedi [A harness for every task: dynamic workflows in Claude Code](https://claude.com/blog/a-harness-for-every-task-dynamic-workflows-in-claude-code) sul blog.9Un agente è un'applicazione che completa un'attività pianificando i propri passaggi e chiamando strumenti che leggono file, eseguono comandi o modificano codice. L'Agent SDK ti offre gli stessi strumenti, il [ciclo dell'agente](/docs/it/agent-sdk/agent-loop) e la gestione del contesto che alimentano Claude Code, programmabili in Python e TypeScript.
10 10
11<CodeGroup>11<h2 id="compare-the-agent-sdk-to-other-claude-tools">
12 ```python Python theme={null}12 Confronta l'Agent SDK con altri strumenti Claude
13 import asyncio
14 from claude_agent_sdk import query, ClaudeAgentOptions
15
16
17 async def main():
18 async for message in query(
19 prompt="Find and fix the bug in auth.py",
20 options=ClaudeAgentOptions(allowed_tools=["Read", "Edit", "Bash"]),
21 ):
22 print(message) # Claude reads the file, finds the bug, edits it
23
24
25 asyncio.run(main())
26 ```
27
28 ```typescript TypeScript theme={null}
29 import { query } from "@anthropic-ai/claude-agent-sdk";
30
31 for await (const message of query({
32 prompt: "Find and fix the bug in auth.ts",
33 options: { allowedTools: ["Read", "Edit", "Bash"] }
34 })) {
35 console.log(message); // Claude reads the file, finds the bug, edits it
36 }
37 ```
38</CodeGroup>
39
40L'Agent SDK include strumenti integrati per leggere file, eseguire comandi e modificare codice, quindi il tuo agente può iniziare a lavorare immediatamente senza che tu implementi l'esecuzione degli strumenti. Tuffati nella guida rapida o esplora agenti reali costruiti con l'SDK:
41
42<CardGroup cols={2}>
43 <Card title="Quickstart" icon="play" href="/it/agent-sdk/quickstart">
44 Costruisci un agente di correzione dei bug in pochi minuti
45 </Card>
46
47 <Card title="Example agents" icon="star" href="https://github.com/anthropics/claude-agent-sdk-demos">
48 Assistente email, agente di ricerca e altro ancora
49 </Card>
50</CardGroup>
51
52<h2 id="get-started">
53 Inizia
54</h2>13</h2>
55 14
56<Steps>15L'Agent SDK, la CLI, il Client SDK e gli Managed Agents si adattano a esigenze diverse. Utilizza la tabella per trovare quello che corrisponde a ciò che stai costruendo.
57 <Step title="Installa l'SDK">
58 <Tabs>
59 <Tab title="TypeScript">
60 ```bash theme={null}
61 npm install @anthropic-ai/claude-agent-sdk
62 ```
63 </Tab>
64
65 <Tab title="Python (uv)">
66 [uv](https://docs.astral.sh/uv/) è un gestore di pacchetti Python veloce che gestisce automaticamente gli ambienti virtuali:
67
68 ```bash theme={null}
69 uv init
70 uv add claude-agent-sdk
71 ```
72 </Tab>
73
74 <Tab title="Python (pip)">
75 Crea e attiva un ambiente virtuale, quindi installa il pacchetto. L'installazione in un ambiente virtuale evita l'errore `error: externally-managed-environment` che Python di sistema su recenti installazioni Debian, Ubuntu e Homebrew restituisce per `pip install` al di fuori di un venv.
76
77 Su macOS o Linux:
78
79 ```bash theme={null}
80 python3 -m venv .venv
81 source .venv/bin/activate
82 pip install claude-agent-sdk
83 ```
84
85 Su Windows:
86
87 ```powershell theme={null}
88 py -m venv .venv
89 .venv\Scripts\Activate.ps1
90 pip install claude-agent-sdk
91 ```
92
93 Se PowerShell blocca `Activate.ps1` con un errore di criterio di esecuzione, esegui prima `Set-ExecutionPolicy -Scope Process RemoteSigned`.
94
95 Il pacchetto Python richiede Python 3.10 o versioni successive. Se pip segnala `No matching distribution found for claude-agent-sdk`, il tuo interprete è più vecchio di 3.10. Esegui `python3 --version` su macOS o Linux, oppure `py --version` su Windows, per verificare.
96 </Tab>
97 </Tabs>
98
99 <Note>
100 L'SDK TypeScript raggruppa un binario nativo di Claude Code per la tua piattaforma come dipendenza opzionale, quindi non è necessario installare Claude Code separatamente.
101 </Note>
102 </Step>
103
104 <Step title="Imposta la tua chiave API">
105 Ottieni una chiave API dalla [Console](https://platform.claude.com/), quindi impostala come variabile di ambiente.
106
107 Su macOS o Linux:
108
109 ```bash theme={null}
110 export ANTHROPIC_API_KEY=sk-ant-xxxxx
111 ```
112
113 Su Windows PowerShell:
114
115 ```powershell theme={null}
116 $env:ANTHROPIC_API_KEY = "sk-ant-xxxxx"
117 ```
118
119 L'SDK supporta anche l'autenticazione tramite provider API di terze parti:
120
121 * **Amazon Bedrock**: imposta la variabile di ambiente `CLAUDE_CODE_USE_BEDROCK=1` e configura le credenziali AWS
122 * **Claude Platform on AWS**: imposta `CLAUDE_CODE_USE_ANTHROPIC_AWS=1` e `ANTHROPIC_AWS_WORKSPACE_ID`, quindi configura le credenziali AWS
123 * **Google Cloud's Agent Platform**: imposta la variabile di ambiente `CLAUDE_CODE_USE_VERTEX=1` e configura le credenziali di Google Cloud
124 * **Microsoft Azure**: imposta la variabile di ambiente `CLAUDE_CODE_USE_FOUNDRY=1` e configura le credenziali di Azure
125
126 Consulta le guide di configurazione per [Amazon Bedrock](/it/amazon-bedrock), [Claude Platform on AWS](/it/claude-platform-on-aws), [Google Cloud's Agent Platform](/it/google-vertex-ai), o [Microsoft Foundry](/it/microsoft-foundry) per i dettagli.
127
128 <Note>
129 Se non precedentemente approvato, Anthropic non consente agli sviluppatori di terze parti di offrire l'accesso a claude.ai o limiti di velocità per i loro prodotti, inclusi gli agenti costruiti su Claude Agent SDK. Utilizza invece i metodi di autenticazione con chiave API descritti in questo documento.
130 </Note>
131 </Step>
132 16
133 <Step title="Esegui il tuo primo agente">17| Se stai... | Usa | Perché |
134 Questo esempio crea un agente che elenca i file nella tua directory corrente utilizzando strumenti integrati.18| ----------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------- |
19| Costruendo un agente senza implementare il tool loop da solo | **Agent SDK** | Una libreria che esegue il ciclo dell'agente nel tuo processo, in Python o TypeScript. |
20| Facendo sviluppo interattivo o eseguendo attività una tantum da un terminale | [**Claude Code CLI**](/docs/it/overview) | L'interfaccia del terminale, costruita per l'uso interattivo quotidiano. |
21| Chiamando l'API direttamente e implementando il tool loop da solo | [**Client SDK**](https://platform.claude.com/docs/en/api/client-sdks) | Accesso diretto all'API Anthropic piuttosto che a Claude Code. Implementi il tool loop da solo. |
22| Eseguendo agenti a lunga durata o asincroni senza gestire la tua sandbox o infrastruttura di sessione | [**Managed Agents**](https://platform.claude.com/docs/en/managed-agents/overview) | API REST ospitata, un prodotto separato dall'Agent SDK. Anthropic esegue l'agente e la sandbox. |
135 23
136 <CodeGroup>24L'SDK è disponibile come libreria solo per Python e TypeScript. Per guidare lo stesso ciclo dell'agente da un altro linguaggio, [esegui la CLI come sottoprocesso](/docs/it/headless) con il flag `-p` e `--output-format json`.
137 ```python Python theme={null}
138 import asyncio
139 from claude_agent_sdk import query, ClaudeAgentOptions
140
141
142 async def main():
143 async for message in query(
144 prompt="What files are in this directory?",
145 options=ClaudeAgentOptions(allowed_tools=["Bash", "Glob"]),
146 ):
147 if hasattr(message, "result"):
148 print(message.result)
149
150
151 asyncio.run(main())
152 ```
153
154 ```typescript TypeScript theme={null}
155 import { query } from "@anthropic-ai/claude-agent-sdk";
156
157 for await (const message of query({
158 prompt: "What files are in this directory?",
159 options: { allowedTools: ["Bash", "Glob"] }
160 })) {
161 if ("result" in message) console.log(message.result);
162 }
163 ```
164 </CodeGroup>
165 </Step>
166</Steps>
167
168**Pronto a costruire?** Segui il [Quickstart](/it/agent-sdk/quickstart) per creare un agente che trova e corregge i bug in pochi minuti.
169 25
170<h2 id="capabilities">26<h2 id="capabilities">
171 Capacità27 Capacità
172</h2>28</h2>
173 29
174Tutto ciò che rende Claude Code potente è disponibile nell'SDK:30Queste capacità di Claude Code sono disponibili nell'SDK:
175
176<Tabs>
177 <Tab title="Built-in tools">
178 Il tuo agente può leggere file, eseguire comandi e cercare codebase subito. Gli strumenti chiave includono:
179
180 | Tool | Cosa fa |
181 | --------------------------------------------------------------------------- | ----------------------------------------------------------------------------- |
182 | **Read** | Leggi qualsiasi file nella directory di lavoro |
183 | **Write** | Crea nuovi file |
184 | **Edit** | Apporta modifiche precise ai file esistenti |
185 | **Bash** | Esegui comandi di terminale, script, operazioni git |
186 | **Monitor** | Osserva uno script in background e reagisci a ogni riga di output come evento |
187 | **Glob** | Trova file per pattern (`**/*.ts`, `src/**/*.py`) |
188 | **Grep** | Cerca contenuti di file con regex |
189 | **WebSearch** | Cerca sul web informazioni attuali |
190 | **WebFetch** | Recupera e analizza il contenuto della pagina web |
191 | **[AskUserQuestion](/it/agent-sdk/user-input#handle-clarifying-questions)** | Poni all'utente domande di chiarimento con opzioni a scelta multipla |
192
193 Questo esempio crea un agente che cerca nella tua codebase i commenti TODO:
194
195 <CodeGroup>
196 ```python Python theme={null}
197 import asyncio
198 from claude_agent_sdk import query, ClaudeAgentOptions
199
200
201 async def main():
202 async for message in query(
203 prompt="Find all TODO comments and create a summary",
204 options=ClaudeAgentOptions(allowed_tools=["Read", "Glob", "Grep"]),
205 ):
206 if hasattr(message, "result"):
207 print(message.result)
208
209
210 asyncio.run(main())
211 ```
212
213 ```typescript TypeScript theme={null}
214 import { query } from "@anthropic-ai/claude-agent-sdk";
215
216 for await (const message of query({
217 prompt: "Find all TODO comments and create a summary",
218 options: { allowedTools: ["Read", "Glob", "Grep"] }
219 })) {
220 if ("result" in message) console.log(message.result);
221 }
222 ```
223 </CodeGroup>
224 </Tab>
225
226 <Tab title="Hooks">
227 Esegui codice personalizzato in punti chiave del ciclo di vita dell'agente. Gli hooks dell'SDK utilizzano funzioni di callback per convalidare, registrare, bloccare o trasformare il comportamento dell'agente.
228
229 **Hook disponibili:** `PreToolUse`, `PostToolUse`, `Stop`, `SessionStart`, `SessionEnd`, `UserPromptSubmit` e altri.
230
231 Questo esempio registra tutte le modifiche ai file in un file di audit:
232
233 <CodeGroup>
234 ```python Python theme={null}
235 import asyncio
236 from datetime import datetime
237 from claude_agent_sdk import query, ClaudeAgentOptions, HookMatcher
238
239
240 async def log_file_change(input_data, tool_use_id, context):
241 file_path = input_data.get("tool_input", {}).get("file_path", "unknown")
242 with open("./audit.log", "a") as f:
243 f.write(f"{datetime.now()}: modified {file_path}\n")
244 return {}
245
246
247 async def main():
248 async for message in query(
249 prompt="Refactor utils.py to improve readability",
250 options=ClaudeAgentOptions(
251 permission_mode="acceptEdits",
252 hooks={
253 "PostToolUse": [
254 HookMatcher(matcher="Edit|Write", hooks=[log_file_change])
255 ]
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, HookCallback } from "@anthropic-ai/claude-agent-sdk";
268 import { appendFile } from "fs/promises";
269
270 const logFileChange: HookCallback = async (input) => {
271 const filePath = (input as any).tool_input?.file_path ?? "unknown";
272 await appendFile("./audit.log", `${new Date().toISOString()}: modified ${filePath}\n`);
273 return {};
274 };
275
276 for await (const message of query({
277 prompt: "Refactor utils.py to improve readability",
278 options: {
279 permissionMode: "acceptEdits",
280 hooks: {
281 PostToolUse: [{ matcher: "Edit|Write", hooks: [logFileChange] }]
282 }
283 }
284 })) {
285 if ("result" in message) console.log(message.result);
286 }
287 ```
288 </CodeGroup>
289
290 [Scopri di più su hooks →](/it/agent-sdk/hooks)
291 </Tab>
292
293 <Tab title="Subagents">
294 Genera agenti specializzati per gestire sottoattività mirate. Il tuo agente principale delega il lavoro e i subagenti riferiscono i risultati.
295 31
296 Definisci agenti personalizzati con istruzioni specializzate. I subagenti vengono invocati tramite lo strumento Agent, quindi includi `Agent` in `allowedTools` per approvare automaticamente quelle invocazioni:32| Capacità | Cosa fa | Scopri di più |
33| ---------------------------- | ----------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
34| Built-in tools | Leggi, scrivi, modifica file, esegui comandi e cerca sul web | [Tools reference](/docs/it/tools-reference) |
35| Hooks | Esegui codice personalizzato in punti chiave del ciclo di vita dell'agente | [Hooks](/docs/it/agent-sdk/hooks) |
36| Subagents | Genera agenti specializzati per sottoattività mirate | [Subagents](/docs/it/agent-sdk/subagents) |
37| MCP | Connetti strumenti e fonti di dati esterne tramite il Model Context Protocol | [MCP](/docs/it/agent-sdk/mcp) |
38| Permissions | Controlla quali strumenti vengono eseguiti automaticamente, quali richiedono approvazione | [Permissions](/docs/it/agent-sdk/permissions) |
39| Sessions | Mantieni il contesto tra gli scambi, riprendi o dividi in seguito | [Sessions](/docs/it/agent-sdk/sessions) |
40| Skills, commands, and memory | Carica automaticamente da `.claude/` del tuo progetto e da `~/.claude/`, come Claude Code | [Skills](/docs/it/agent-sdk/skills), [Commands](/docs/it/agent-sdk/skills#commands-in-agent-sdk-sessions), [Memory](/docs/it/agent-sdk/modifying-system-prompts), [Configuration loading](/docs/it/agent-sdk/claude-code-features) |
41| Plugins | Pacchetto skills, agenti, hooks e server MCP, e caricali per percorso locale | [Plugins](/docs/it/agent-sdk/plugins) |
297 42
298 <CodeGroup>43<h2 id="get-started">
299 ```python Python theme={null}44 Iniziare
300 import asyncio
301 from claude_agent_sdk import query, ClaudeAgentOptions, AgentDefinition
302
303
304 async def main():
305 async for message in query(
306 prompt="Use the code-reviewer agent to review this codebase",
307 options=ClaudeAgentOptions(
308 allowed_tools=["Read", "Glob", "Grep", "Agent"],
309 agents={
310 "code-reviewer": AgentDefinition(
311 description="Expert code reviewer for quality and security reviews.",
312 prompt="Analyze code quality and suggest improvements.",
313 tools=["Read", "Glob", "Grep"],
314 )
315 },
316 ),
317 ):
318 if hasattr(message, "result"):
319 print(message.result)
320
321
322 asyncio.run(main())
323 ```
324
325 ```typescript TypeScript theme={null}
326 import { query } from "@anthropic-ai/claude-agent-sdk";
327
328 for await (const message of query({
329 prompt: "Use the code-reviewer agent to review this codebase",
330 options: {
331 allowedTools: ["Read", "Glob", "Grep", "Agent"],
332 agents: {
333 "code-reviewer": {
334 description: "Expert code reviewer for quality and security reviews.",
335 prompt: "Analyze code quality and suggest improvements.",
336 tools: ["Read", "Glob", "Grep"]
337 }
338 }
339 }
340 })) {
341 if ("result" in message) console.log(message.result);
342 }
343 ```
344 </CodeGroup>
345
346 I messaggi dal contesto di un subagente includono un campo `parent_tool_use_id`, che ti consente di tracciare quali messaggi appartengono a quale esecuzione di subagente.
347
348 [Scopri di più su subagenti →](/it/agent-sdk/subagents)
349 </Tab>
350
351 <Tab title="MCP">
352 Connettiti a sistemi esterni tramite il Model Context Protocol: database, browser, API e [centinaia di altri](https://github.com/modelcontextprotocol/servers).
353
354 Questo esempio connette il [server Playwright MCP](https://github.com/microsoft/playwright-mcp) per dare al tuo agente capacità di automazione del browser:
355
356 <CodeGroup>
357 ```python Python theme={null}
358 import asyncio
359 from claude_agent_sdk import query, ClaudeAgentOptions
360
361
362 async def main():
363 async for message in query(
364 prompt="Open example.com and describe what you see",
365 options=ClaudeAgentOptions(
366 mcp_servers={
367 "playwright": {"command": "npx", "args": ["@playwright/mcp@latest"]}
368 }
369 ),
370 ):
371 if hasattr(message, "result"):
372 print(message.result)
373
374
375 asyncio.run(main())
376 ```
377
378 ```typescript TypeScript theme={null}
379 import { query } from "@anthropic-ai/claude-agent-sdk";
380
381 for await (const message of query({
382 prompt: "Open example.com and describe what you see",
383 options: {
384 mcpServers: {
385 playwright: { command: "npx", args: ["@playwright/mcp@latest"] }
386 }
387 }
388 })) {
389 if ("result" in message) console.log(message.result);
390 }
391 ```
392 </CodeGroup>
393
394 [Scopri di più su MCP →](/it/agent-sdk/mcp)
395 </Tab>
396
397 <Tab title="Permissions">
398 Controlla esattamente quali strumenti il tuo agente può utilizzare. Consenti operazioni sicure, blocca quelle pericolose o richiedi approvazione per azioni sensibili.
399
400 <Note>
401 Per prompt di approvazione interattivi e lo strumento `AskUserQuestion`, consulta [Gestisci approvazioni e input dell'utente](/it/agent-sdk/user-input).
402 </Note>
403
404 Questo esempio crea un agente di sola lettura che può analizzare ma non modificare il codice. `allowed_tools` pre-approva `Read`, `Glob` e `Grep`.
405
406 <CodeGroup>
407 ```python Python theme={null}
408 import asyncio
409 from claude_agent_sdk import query, ClaudeAgentOptions
410
411
412 async def main():
413 async for message in query(
414 prompt="Review this code for best practices",
415 options=ClaudeAgentOptions(
416 allowed_tools=["Read", "Glob", "Grep"],
417 ),
418 ):
419 if hasattr(message, "result"):
420 print(message.result)
421
422
423 asyncio.run(main())
424 ```
425
426 ```typescript TypeScript theme={null}
427 import { query } from "@anthropic-ai/claude-agent-sdk";
428
429 for await (const message of query({
430 prompt: "Review this code for best practices",
431 options: {
432 allowedTools: ["Read", "Glob", "Grep"]
433 }
434 })) {
435 if ("result" in message) console.log(message.result);
436 }
437 ```
438 </CodeGroup>
439
440 [Scopri di più su permessi →](/it/agent-sdk/permissions)
441 </Tab>
442
443 <Tab title="Sessions">
444 Mantieni il contesto su più scambi. Claude ricorda i file letti, l'analisi eseguita e la cronologia della conversazione. Riprendi le sessioni in seguito o dividile per esplorare approcci diversi.
445
446 Questo esempio acquisisce l'ID della sessione dalla prima query, quindi riprende per continuare con il contesto completo:
447
448 <CodeGroup>
449 ```python Python theme={null}
450 import asyncio
451 from claude_agent_sdk import query, ClaudeAgentOptions, SystemMessage, ResultMessage
452
453
454 async def main():
455 session_id = None
456
457 # First query: capture the session ID
458 async for message in query(
459 prompt="Read the authentication module",
460 options=ClaudeAgentOptions(allowed_tools=["Read", "Glob"]),
461 ):
462 if isinstance(message, SystemMessage) and message.subtype == "init":
463 session_id = message.data["session_id"]
464
465 # Resume with full context from the first query
466 async for message in query(
467 prompt="Now find all places that call it", # "it" = auth module
468 options=ClaudeAgentOptions(resume=session_id),
469 ):
470 if isinstance(message, ResultMessage):
471 print(message.result)
472
473
474 asyncio.run(main())
475 ```
476
477 ```typescript TypeScript theme={null}
478 import { query } from "@anthropic-ai/claude-agent-sdk";
479
480 let sessionId: string | undefined;
481
482 // First query: capture the session ID
483 for await (const message of query({
484 prompt: "Read the authentication module",
485 options: { allowedTools: ["Read", "Glob"] }
486 })) {
487 if (message.type === "system" && message.subtype === "init") {
488 sessionId = message.session_id;
489 }
490 }
491
492 // Resume with full context from the first query
493 for await (const message of query({
494 prompt: "Now find all places that call it", // "it" = auth module
495 options: { resume: sessionId }
496 })) {
497 if ("result" in message) console.log(message.result);
498 }
499 ```
500 </CodeGroup>
501
502 [Scopri di più su sessioni →](/it/agent-sdk/sessions)
503 </Tab>
504</Tabs>
505
506<h3 id="claude-code-features">
507 Funzionalità di Claude Code
508</h3>
509
510L'SDK supporta anche la configurazione basata su filesystem di Claude Code. Con le opzioni predefinite, l'SDK carica questi da `.claude/` nella tua directory di lavoro e `~/.claude/`. Per limitare quali fonti caricare, imposta `setting_sources` (Python) o `settingSources` (TypeScript) nelle tue opzioni.
511
512| Funzionalità | Descrizione | Posizione |
513| ------------------------------------------------ | ------------------------------------------------------------------------------------------- | --------------------------------------- |
514| [Skills](/it/agent-sdk/skills) | Capacità specializzate che Claude utilizza automaticamente o che invochi con `/name` | `.claude/skills/*/SKILL.md` |
515| [Commands](/it/agent-sdk/slash-commands) | Comandi personalizzati nel formato legacy. Utilizza skills per nuovi comandi personalizzati | `.claude/commands/*.md` |
516| [Memory](/it/agent-sdk/modifying-system-prompts) | Contesto del progetto e istruzioni | `CLAUDE.md` o `.claude/CLAUDE.md` |
517| [Plugins](/it/agent-sdk/plugins) | Estendi con skills, agenti, hooks e server MCP | Programmatico tramite opzione `plugins` |
518
519<h2 id="compare-the-agent-sdk-to-other-claude-tools">
520 Confronta l'Agent SDK con altri strumenti Claude
521</h2>45</h2>
522 46
523La piattaforma Claude offre più modi per costruire con Claude. Ecco come si inserisce l'Agent SDK:47Segui la [Guida rapida](/docs/it/agent-sdk/quickstart) per installare l'SDK, impostare la tua chiave API e costruire il tuo primo agente, uno che trova e corregge i bug nel codice esistente.
524
525<Tabs>
526 <Tab title="Agent SDK vs Client SDK">
527 L'[Anthropic Client SDK](https://platform.claude.com/docs/it/api/client-sdks) ti offre accesso diretto all'API: invii prompt e implementi tu stesso l'esecuzione degli strumenti. L'**Agent SDK** ti offre Claude con esecuzione degli strumenti integrata.
528
529 Con il Client SDK, implementi un ciclo di strumenti. Con l'Agent SDK, Claude lo gestisce:
530
531 <CodeGroup>
532 ```python Python theme={null}
533 # Client SDK: You implement the tool loop
534 response = client.messages.create(...)
535 while response.stop_reason == "tool_use":
536 result = your_tool_executor(response.tool_use)
537 response = client.messages.create(tool_result=result, **params)
538
539 # Agent SDK: Claude handles tools autonomously
540 async for message in query(prompt="Fix the bug in auth.py"):
541 print(message)
542 ```
543
544 ```typescript TypeScript theme={null}
545 // Client SDK: You implement the tool loop
546 let response = await client.messages.create({ ...params });
547 while (response.stop_reason === "tool_use") {
548 const result = yourToolExecutor(response.tool_use);
549 response = await client.messages.create({ tool_result: result, ...params });
550 }
551
552 // Agent SDK: Claude handles tools autonomously
553 for await (const message of query({ prompt: "Fix the bug in auth.ts" })) {
554 console.log(message);
555 }
556 ```
557 </CodeGroup>
558 </Tab>
559 48
560 <Tab title="Agent SDK vs Claude Code CLI">49<Note>
561 Stesse capacità, interfaccia diversa:50 Se non precedentemente approvato, Anthropic non consente ai sviluppatori di terze parti di offrire l'accesso a claude.ai o limiti di velocità per i loro prodotti, inclusi gli agenti costruiti su Claude Agent SDK. Utilizza invece i metodi di autenticazione con chiave API descritti nella [Guida rapida](/docs/it/agent-sdk/quickstart).
562 51</Note>
563 | Caso d'uso | Scelta migliore |
564 | --------------------------- | --------------- |
565 | Sviluppo interattivo | CLI |
566 | Pipeline CI/CD | SDK |
567 | Applicazioni personalizzate | SDK |
568 | Attività una tantum | CLI |
569 | Automazione di produzione | SDK |
570
571 Molti team utilizzano entrambi: CLI per lo sviluppo quotidiano, SDK per la produzione. I flussi di lavoro si traducono direttamente tra loro.
572 </Tab>
573
574 <Tab title="Agent SDK vs Managed Agents">
575 [Managed Agents](https://platform.claude.com/docs/it/managed-agents/overview) è un'API REST ospitata: Anthropic esegue l'agente e la sandbox, e la tua applicazione invia eventi e riceve i risultati in streaming. L'**Agent SDK** è una libreria che esegue il ciclo dell'agente all'interno del tuo processo.
576
577 | | Agent SDK | Managed Agents |
578 | ---------------------------- | ------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------ |
579 | **Viene eseguito in** | Il tuo processo, la tua infrastruttura | Infrastruttura gestita da Anthropic |
580 | **Interfaccia** | Libreria Python o TypeScript | API REST |
581 | **L'agente lavora su** | File sulla tua infrastruttura | Una sandbox gestita per sessione |
582 | **Stato della sessione** | JSONL sul tuo filesystem | Log degli eventi ospitato da Anthropic |
583 | **Strumenti personalizzati** | Funzioni Python o TypeScript in-process | Claude attiva lo strumento; tu esegui e restituisci i risultati |
584 | **Ideale per** | Prototipazione locale, agenti che lavorano direttamente sul tuo filesystem e servizi | Agenti di produzione senza gestire infrastruttura di sandbox o sessione, sessioni a lunga durata e asincrone |
585
586 Un percorso comune è prototipare con l'Agent SDK localmente, quindi passare a Managed Agents per la produzione.
587 </Tab>
588</Tabs>
589 52
590<h2 id="changelog">53<h2 id="changelog">
591 Changelog54 Changelog
596* **TypeScript SDK**: [visualizza CHANGELOG.md](https://github.com/anthropics/claude-agent-sdk-typescript/blob/main/CHANGELOG.md)59* **TypeScript SDK**: [visualizza CHANGELOG.md](https://github.com/anthropics/claude-agent-sdk-typescript/blob/main/CHANGELOG.md)
597* **Python SDK**: [visualizza CHANGELOG.md](https://github.com/anthropics/claude-agent-sdk-python/blob/main/CHANGELOG.md)60* **Python SDK**: [visualizza CHANGELOG.md](https://github.com/anthropics/claude-agent-sdk-python/blob/main/CHANGELOG.md)
598 61
599<h2 id="reporting-bugs">62<h2 id="report-bugs">
600 Segnalazione di bug63 Segnalazione di bug
601</h2>64</h2>
602 65
613 76
614**Consentito:**77**Consentito:**
615 78
616* "Claude Agent" (preferito per i menu a discesa)79* "Claude Agent", preferito per i menu a discesa
617* "Claude" (quando già all'interno di un menu etichettato "Agents")80* "Claude", quando già all'interno di un menu etichettato "Agents"
618* "{YourAgentName} Powered by Claude" (se hai un nome di agente esistente)81* "{YourAgentName} Powered by Claude", se hai un nome di agente esistente
619 82
620**Non consentito:**83**Non consentito:**
621 84
634 Passaggi successivi97 Passaggi successivi
635</h2>98</h2>
636 99
637<CardGroup cols={2}>100Queste risorse coprono dettagli tecnici più approfonditi e progetti di esempio per la creazione con l'Agent SDK.
638 <Card title="Quickstart" icon="play" href="/it/agent-sdk/quickstart">
639 Costruisci un agente che trova e corregge i bug in pochi minuti
640 </Card>
641
642 <Card title="Example agents" icon="star" href="https://github.com/anthropics/claude-agent-sdk-demos">
643 Assistente email, agente di ricerca e altro ancora
644 </Card>
645
646 <Card title="TypeScript SDK" icon="code" href="/it/agent-sdk/typescript">
647 Riferimento API TypeScript completo ed esempi
648 </Card>
649 101
650 <Card title="Python SDK" icon="code" href="/it/agent-sdk/python">102* [Quickstart](/docs/it/agent-sdk/quickstart): costruisci il tuo primo agente che trova e corregge i bug
651 Riferimento API Python completo ed esempi103* [Guida alla migrazione](/docs/it/agent-sdk/migration-guide): migra dai pacchetti Claude Code SDK all'Agent SDK
652 </Card>104* [Agent loop](/docs/it/agent-sdk/agent-loop): come Claude pianifica, chiama gli strumenti e decide quando un'attività è completata
653</CardGroup>105* [Example agents](https://github.com/anthropics/claude-agent-sdk-demos): app demo per lo sviluppo locale
106* [TypeScript SDK](/docs/it/agent-sdk/typescript): riferimento API TypeScript completo ed esempi
107* [Python SDK](/docs/it/agent-sdk/python): riferimento API Python completo ed esempi
108* [Agent harness design](https://claude.com/blog/a-harness-for-every-task-dynamic-workflows-in-claude-code): come il team Claude Code utilizza i flussi di lavoro dinamici per orchestrare molti subagenti contemporaneamente
