6 6
7> Créez des agents IA de production avec Claude Code en tant que bibliothèque7> Créez des agents IA de production avec Claude Code en tant que bibliothèque
8 8
9Créez des agents IA qui lisent autonomement les fichiers, exécutent des commandes, recherchent sur le web, modifient le code, et bien plus. Le SDK Agent vous offre les mêmes outils, boucle d'agent et gestion du contexte qui alimentent Claude Code, programmables en Python et TypeScript. Pour en savoir plus sur la réflexion derrière la conception du harnais d'agent, consultez [Un harnais pour chaque tâche : flux de travail dynamiques dans Claude Code](https://claude.com/blog/a-harness-for-every-task-dynamic-workflows-in-claude-code) sur le blog.9Un agent est une application qui complète une tâche en planifiant ses propres étapes et en appelant des outils qui lisent des fichiers, exécutent des commandes ou modifient du code. Le SDK Agent vous offre les mêmes outils, [boucle d'agent](/docs/fr/agent-sdk/agent-loop), et gestion du contexte qui alimentent Claude Code, programmables en Python et TypeScript.
10 10
11<CodeGroup>11<h2 id="compare-the-agent-sdk-to-other-claude-tools">
12 ```python Python theme={null}12 Comparer le SDK Agent à d'autres outils 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
40Le SDK Agent inclut des outils intégrés pour lire les fichiers, exécuter des commandes et modifier le code, afin que votre agent puisse commencer à travailler immédiatement sans que vous ayez besoin d'implémenter l'exécution des outils. Plongez dans le guide de démarrage rapide ou explorez des agents réels construits avec le SDK :
41
42<CardGroup cols={2}>
43 <Card title="Guide de démarrage rapide" icon="play" href="/fr/agent-sdk/quickstart">
44 Créez un agent de correction de bugs en quelques minutes
45 </Card>
46
47 <Card title="Agents d'exemple" icon="star" href="https://github.com/anthropics/claude-agent-sdk-demos">
48 Assistant e-mail, agent de recherche, et bien plus
49 </Card>
50</CardGroup>
51
52<h2 id="get-started">
53 Commencer
54</h2>13</h2>
55 14
56<Steps>15Le SDK Agent, la CLI, le SDK Client et les Agents Gérés répondent chacun à des besoins différents. Utilisez le tableau pour trouver celui qui correspond à ce que vous construisez.
57 <Step title="Installer le 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/) est un gestionnaire de paquets Python rapide qui gère automatiquement les environnements virtuels :
67
68 ```bash theme={null}
69 uv init
70 uv add claude-agent-sdk
71 ```
72 </Tab>
73
74 <Tab title="Python (pip)">
75 Créez et activez un environnement virtuel, puis installez le paquet. L'installation dans un environnement virtuel évite l'erreur `error: externally-managed-environment` que Python système sur les installations récentes de Debian, Ubuntu et Homebrew retourne pour `pip install` en dehors d'un venv.
76
77 Sur macOS ou 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 Sur 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 Si PowerShell bloque `Activate.ps1` avec une erreur de politique d'exécution, exécutez d'abord `Set-ExecutionPolicy -Scope Process RemoteSigned`.
94
95 Le package Python nécessite Python 3.10 ou une version ultérieure. Si pip signale `No matching distribution found for claude-agent-sdk`, votre interpréteur est plus ancien que 3.10. Exécutez `python3 --version` sur macOS ou Linux, ou `py --version` sur Windows, pour vérifier.
96 </Tab>
97 </Tabs>
98
99 <Note>
100 Le SDK TypeScript regroupe un binaire Claude Code natif pour votre plateforme en tant que dépendance optionnelle, vous n'avez donc pas besoin d'installer Claude Code séparément.
101 </Note>
102 </Step>
103
104 <Step title="Définir votre clé API">
105 Obtenez une clé API à partir de la [Console](https://platform.claude.com/), puis définissez-la comme variable d'environnement.
106
107 Sur macOS ou Linux :
108
109 ```bash theme={null}
110 export ANTHROPIC_API_KEY=sk-ant-xxxxx
111 ```
112
113 Sur Windows PowerShell :
114
115 ```powershell theme={null}
116 $env:ANTHROPIC_API_KEY = "sk-ant-xxxxx"
117 ```
118
119 Le SDK prend également en charge l'authentification via des fournisseurs d'API tiers :
120
121 * **Amazon Bedrock** : définissez la variable d'environnement `CLAUDE_CODE_USE_BEDROCK=1` et configurez les identifiants AWS
122 * **Claude Platform on AWS** : définissez `CLAUDE_CODE_USE_ANTHROPIC_AWS=1` et `ANTHROPIC_AWS_WORKSPACE_ID`, puis configurez les identifiants AWS
123 * **Google Cloud's Agent Platform** : définissez la variable d'environnement `CLAUDE_CODE_USE_VERTEX=1` et configurez les identifiants Google Cloud
124 * **Microsoft Azure** : définissez la variable d'environnement `CLAUDE_CODE_USE_FOUNDRY=1` et configurez les identifiants Azure
125
126 Consultez les guides de configuration pour [Amazon Bedrock](/fr/amazon-bedrock), [Claude Platform on AWS](/fr/claude-platform-on-aws), [Google Cloud's Agent Platform](/fr/google-vertex-ai), ou [Microsoft Foundry](/fr/microsoft-foundry) pour plus de détails.
127
128 <Note>
129 Sauf approbation préalable, Anthropic n'autorise pas les développeurs tiers à proposer la connexion claude.ai ou les limites de débit pour leurs produits, y compris les agents construits sur le SDK Claude Agent. Veuillez utiliser les méthodes d'authentification par clé API décrites dans ce document à la place.
130 </Note>
131 </Step>
132 16
133 <Step title="Exécuter votre premier agent">17| Si vous... | Utilisez | Pourquoi |
134 Cet exemple crée un agent qui liste les fichiers de votre répertoire courant en utilisant les outils intégrés.18| ------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ |
19| Construisez un agent sans implémenter vous-même la boucle d'outils | **SDK Agent** | Une bibliothèque qui exécute la boucle d'agent dans votre propre processus, en Python ou TypeScript. |
20| Faites du développement interactif ou exécutez des tâches ponctuelles depuis un terminal | [**Claude Code CLI**](/docs/fr/overview) | L'interface de terminal, conçue pour une utilisation interactive quotidienne. |
21| Appelez l'API directement et implémentez vous-même la boucle d'outils | [**SDK Client**](https://platform.claude.com/docs/en/api/client-sdks) | Accès direct à l'API Anthropic plutôt qu'à Claude Code. Vous implémentez vous-même la boucle d'outils. |
22| Exécutez des agents de longue durée ou asynchrones sans gérer votre propre infrastructure de sandbox ou de session | [**Agents Gérés**](https://platform.claude.com/docs/en/managed-agents/overview) | API REST hébergée, un produit distinct du SDK Agent. Anthropic exécute l'agent et le sandbox. |
135 23
136 <CodeGroup>24Le SDK est disponible en tant que bibliothèque pour Python et TypeScript uniquement. Pour piloter la même boucle d'agent à partir d'un autre langage, [exécutez la CLI en tant que sous-processus](/docs/fr/headless) avec le drapeau `-p` et `--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**Prêt à construire ?** Suivez le [Guide de démarrage rapide](/fr/agent-sdk/quickstart) pour créer un agent qui trouve et corrige les bugs en quelques minutes.
169 25
170<h2 id="capabilities">26<h2 id="capabilities">
171 Capacités27 Capacités
172</h2>28</h2>
173 29
174Tout ce qui rend Claude Code puissant est disponible dans le SDK :30Ces capacités de Claude Code sont disponibles dans le SDK :
175
176<Tabs>
177 <Tab title="Outils intégrés">
178 Votre agent peut lire des fichiers, exécuter des commandes et rechercher dans les bases de code dès le départ. Les outils clés incluent :
179
180 | Outil | Ce qu'il fait |
181 | --------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------- |
182 | **Read** | Lire n'importe quel fichier du répertoire de travail |
183 | **Write** | Créer de nouveaux fichiers |
184 | **Edit** | Effectuer des modifications précises aux fichiers existants |
185 | **Bash** | Exécuter des commandes de terminal, des scripts, des opérations git |
186 | **Monitor** | Surveiller un script en arrière-plan et réagir à chaque ligne de sortie en tant qu'événement |
187 | **Glob** | Trouver des fichiers par motif (`**/*.ts`, `src/**/*.py`) |
188 | **Grep** | Rechercher le contenu des fichiers avec regex |
189 | **WebSearch** | Rechercher sur le web pour obtenir des informations actuelles |
190 | **WebFetch** | Récupérer et analyser le contenu des pages web |
191 | **[AskUserQuestion](/fr/agent-sdk/user-input#handle-clarifying-questions)** | Poser à l'utilisateur des questions de clarification avec des options à choix multiples |
192
193 Cet exemple crée un agent qui recherche les commentaires TODO dans votre base de code :
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 Exécutez du code personnalisé à des points clés du cycle de vie de l'agent. Les hooks du SDK utilisent des fonctions de rappel pour valider, enregistrer, bloquer ou transformer le comportement de l'agent.
228
229 **Hooks disponibles :** `PreToolUse`, `PostToolUse`, `Stop`, `SessionStart`, `SessionEnd`, `UserPromptSubmit`, et bien d'autres.
230
231 Cet exemple enregistre tous les changements de fichiers dans un fichier d'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 [En savoir plus sur les hooks →](/fr/agent-sdk/hooks)
291 </Tab>
292
293 <Tab title="Sous-agents">
294 Générez des agents spécialisés pour gérer des sous-tâches ciblées. Votre agent principal délègue le travail, et les sous-agents rapportent les résultats.
295 31
296 Définissez des agents personnalisés avec des instructions spécialisées. Les sous-agents sont invoqués via l'outil Agent, donc incluez `Agent` dans `allowedTools` pour approuver automatiquement ces invocations :32| Capacité | Ce qu'elle fait | En savoir plus |
33| ---------------------------- | --------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
34| Outils intégrés | Lire, écrire, modifier des fichiers, exécuter des commandes et rechercher sur le web | [Référence des outils](/docs/fr/tools-reference) |
35| Hooks | Exécuter du code personnalisé à des points clés du cycle de vie de l'agent | [Hooks](/docs/fr/agent-sdk/hooks) |
36| Sous-agents | Générer des agents spécialisés pour des sous-tâches ciblées | [Sous-agents](/docs/fr/agent-sdk/subagents) |
37| MCP | Connecter des outils externes et des sources de données via le Model Context Protocol | [MCP](/docs/fr/agent-sdk/mcp) |
38| Permissions | Contrôler quels outils s'exécutent automatiquement, lesquels nécessitent une approbation | [Permissions](/docs/fr/agent-sdk/permissions) |
39| Sessions | Maintenir le contexte sur plusieurs échanges, reprendre ou diviser plus tard | [Sessions](/docs/fr/agent-sdk/sessions) |
40| Skills, commandes et mémoire | Charger automatiquement à partir du répertoire `.claude/` de votre projet et de `~/.claude/`, comme Claude Code | [Skills](/docs/fr/agent-sdk/skills), [Commandes](/docs/fr/agent-sdk/skills#commands-in-agent-sdk-sessions), [Mémoire](/docs/fr/agent-sdk/modifying-system-prompts), [Chargement de la configuration](/docs/fr/agent-sdk/claude-code-features) |
41| Plugins | Empaqueter les skills, les agents, les hooks et les serveurs MCP, et les charger par chemin local | [Plugins](/docs/fr/agent-sdk/plugins) |
297 42
298 <CodeGroup>43<h2 id="get-started">
299 ```python Python theme={null}44 Commencer
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 Les messages provenant du contexte d'un sous-agent incluent un champ `parent_tool_use_id`, ce qui vous permet de suivre les messages appartenant à l'exécution de quel sous-agent.
347
348 [En savoir plus sur les sous-agents →](/fr/agent-sdk/subagents)
349 </Tab>
350
351 <Tab title="MCP">
352 Connectez-vous à des systèmes externes via le Model Context Protocol : bases de données, navigateurs, API, et [des centaines d'autres](https://github.com/modelcontextprotocol/servers).
353
354 Cet exemple connecte le [serveur Playwright MCP](https://github.com/microsoft/playwright-mcp) pour donner à votre agent des capacités d'automatisation de navigateur :
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 [En savoir plus sur MCP →](/fr/agent-sdk/mcp)
395 </Tab>
396
397 <Tab title="Permissions">
398 Contrôlez exactement quels outils votre agent peut utiliser. Autorisez les opérations sûres, bloquez les opérations dangereuses, ou exigez une approbation pour les actions sensibles.
399
400 <Note>
401 Pour les invites d'approbation interactives et l'outil `AskUserQuestion`, consultez [Gérer les approbations et l'entrée utilisateur](/fr/agent-sdk/user-input).
402 </Note>
403
404 Cet exemple crée un agent en lecture seule qui peut analyser mais pas modifier le code. `allowed_tools` pré-approuve `Read`, `Glob`, et `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 [En savoir plus sur les permissions →](/fr/agent-sdk/permissions)
441 </Tab>
442
443 <Tab title="Sessions">
444 Maintenez le contexte sur plusieurs échanges. Claude se souvient des fichiers lus, de l'analyse effectuée et de l'historique de la conversation. Reprenez les sessions plus tard, ou divisez-les pour explorer différentes approches.
445
446 Cet exemple capture l'ID de session de la première requête, puis reprend pour continuer avec le contexte complet :
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 [En savoir plus sur les sessions →](/fr/agent-sdk/sessions)
503 </Tab>
504</Tabs>
505
506<h3 id="claude-code-features">
507 Fonctionnalités de Claude Code
508</h3>
509
510Le SDK prend également en charge la configuration basée sur le système de fichiers de Claude Code. Avec les options par défaut, le SDK les charge à partir de `.claude/` dans votre répertoire de travail et `~/.claude/`. Pour restreindre les sources qui se chargent, définissez `setting_sources` (Python) ou `settingSources` (TypeScript) dans vos options.
511
512| Fonctionnalité | Description | Emplacement |
513| ------------------------------------------------ | ---------------------------------------------------------------------------------------------------------- | ------------------------------------- |
514| [Skills](/fr/agent-sdk/skills) | Capacités spécialisées que Claude utilise automatiquement ou que vous invoquez avec `/name` | `.claude/skills/*/SKILL.md` |
515| [Commands](/fr/agent-sdk/slash-commands) | Commandes personnalisées au format hérité. Utilisez les skills pour les nouvelles commandes personnalisées | `.claude/commands/*.md` |
516| [Memory](/fr/agent-sdk/modifying-system-prompts) | Contexte du projet et instructions | `CLAUDE.md` ou `.claude/CLAUDE.md` |
517| [Plugins](/fr/agent-sdk/plugins) | Étendre avec des skills, des agents, des hooks et des serveurs MCP | Programmatique via l'option `plugins` |
518
519<h2 id="compare-the-agent-sdk-to-other-claude-tools">
520 Comparer le SDK Agent à d'autres outils Claude
521</h2>45</h2>
522 46
523La plateforme Claude offre plusieurs façons de construire avec Claude. Voici comment le SDK Agent s'intègre :47Suivez le [Démarrage rapide](/docs/fr/agent-sdk/quickstart) pour installer le SDK, définir votre clé API et créer votre premier agent, un agent qui trouve et corrige les bugs dans le code existant.
524
525<Tabs>
526 <Tab title="SDK Agent vs SDK Client">
527 Le [SDK Client Anthropic](https://platform.claude.com/docs/fr/api/client-sdks) vous donne un accès direct à l'API : vous envoyez des invites et implémentez vous-même l'exécution des outils. Le **SDK Agent** vous donne Claude avec l'exécution des outils intégrée.
528
529 Avec le SDK Client, vous implémentez une boucle d'outils. Avec le SDK Agent, Claude la gère :
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 48
552 // Agent SDK: Claude handles tools autonomously49<Note>
553 for await (const message of query({ prompt: "Fix the bug in auth.ts" })) {50 Sauf approbation préalable, Anthropic n'autorise pas les développeurs tiers à proposer la connexion claude.ai ou les limites de débit pour leurs produits, y compris les agents construits sur le SDK Agent Claude. Utilisez plutôt les méthodes d'authentification par clé API décrites dans le [Démarrage rapide](/docs/fr/agent-sdk/quickstart).
554 console.log(message);51</Note>
555 }
556 ```
557 </CodeGroup>
558 </Tab>
559
560 <Tab title="SDK Agent vs CLI Claude Code">
561 Mêmes capacités, interface différente :
562
563 | Cas d'usage | Meilleur choix |
564 | ---------------------------- | -------------- |
565 | Développement interactif | CLI |
566 | Pipelines CI/CD | SDK |
567 | Applications personnalisées | SDK |
568 | Tâches ponctuelles | CLI |
569 | Automatisation de production | SDK |
570
571 De nombreuses équipes utilisent les deux : CLI pour le développement quotidien, SDK pour la production. Les flux de travail se traduisent directement entre eux.
572 </Tab>
573
574 <Tab title="SDK Agent vs Agents gérés">
575 [Agents gérés](https://platform.claude.com/docs/fr/managed-agents/overview) est une API REST hébergée : Anthropic exécute l'agent et le sandbox, et votre application envoie des événements et reçoit les résultats en streaming. Le **SDK Agent** est une bibliothèque qui exécute la boucle d'agent à l'intérieur de votre propre processus.
576
577 | | SDK Agent | Agents gérés |
578 | ------------------------- | --------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------- |
579 | **S'exécute dans** | Votre processus, votre infrastructure | Infrastructure gérée par Anthropic |
580 | **Interface** | Bibliothèque Python ou TypeScript | API REST |
581 | **L'agent travaille sur** | Fichiers sur votre infrastructure | Un sandbox géré par session |
582 | **État de la session** | JSONL sur votre système de fichiers | Journal des événements hébergé par Anthropic |
583 | **Outils personnalisés** | Fonctions Python ou TypeScript en processus | Claude déclenche l'outil ; vous exécutez et retournez les résultats |
584 | **Idéal pour** | Prototypage local, agents qui travaillent directement sur votre système de fichiers et vos services | Agents de production sans gérer l'infrastructure du sandbox ou de la session, sessions longues et asynchrones |
585
586 Un chemin courant est de prototyper avec le SDK Agent localement, puis de passer aux Agents gérés pour la production.
587 </Tab>
588</Tabs>
589 52
590<h2 id="changelog">53<h2 id="changelog">
591 Journal des modifications54 Journal des modifications
596* **SDK TypeScript** : [voir CHANGELOG.md](https://github.com/anthropics/claude-agent-sdk-typescript/blob/main/CHANGELOG.md)59* **SDK TypeScript** : [voir CHANGELOG.md](https://github.com/anthropics/claude-agent-sdk-typescript/blob/main/CHANGELOG.md)
597* **SDK Python** : [voir CHANGELOG.md](https://github.com/anthropics/claude-agent-sdk-python/blob/main/CHANGELOG.md)60* **SDK Python** : [voir 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 Signaler les bugs63 Signaler les bugs
601</h2>64</h2>
602 65
613 76
614**Autorisé :**77**Autorisé :**
615 78
616* « Claude Agent » (préféré pour les menus déroulants)79* « Claude Agent », préféré pour les menus déroulants
617* « Claude » (lorsque vous êtes déjà dans un menu étiqueté « Agents »)80* « Claude », lorsque vous êtes déjà dans un menu étiqueté « Agents »
618* « {YourAgentName} Powered by Claude » (si vous avez un nom d'agent existant)81* « {YourAgentName} Powered by Claude », si vous avez un nom d'agent existant
619 82
620**Non autorisé :**83**Non autorisé :**
621 84
634 Prochaines étapes97 Prochaines étapes
635</h2>98</h2>
636 99
637<CardGroup cols={2}>100Ces ressources couvrent des détails techniques plus approfondis et des projets d'exemple pour construire avec le SDK Agent.
638 <Card title="Guide de démarrage rapide" icon="play" href="/fr/agent-sdk/quickstart">
639 Créez un agent qui trouve et corrige les bugs en quelques minutes
640 </Card>
641
642 <Card title="Agents d'exemple" icon="star" href="https://github.com/anthropics/claude-agent-sdk-demos">
643 Assistant e-mail, agent de recherche, et bien plus
644 </Card>
645
646 <Card title="SDK TypeScript" icon="code" href="/fr/agent-sdk/typescript">
647 Référence API TypeScript complète et exemples
648 </Card>
649 101
650 <Card title="SDK Python" icon="code" href="/fr/agent-sdk/python">102* [Guide de démarrage](/docs/fr/agent-sdk/quickstart) : créez votre premier agent qui trouve et corrige les bugs
651 Référence API Python complète et exemples103* [Guide de migration](/docs/fr/agent-sdk/migration-guide) : migrez des packages Claude Code SDK vers le SDK Agent
652 </Card>104* [Boucle d'agent](/docs/fr/agent-sdk/agent-loop) : comment Claude planifie, appelle les outils et décide quand une tâche est terminée
653</CardGroup>105* [Agents d'exemple](https://github.com/anthropics/claude-agent-sdk-demos) : applications de démonstration pour le développement local
106* [SDK TypeScript](/docs/fr/agent-sdk/typescript) : référence API TypeScript complète et exemples
107* [SDK Python](/docs/fr/agent-sdk/python) : référence API Python complète et exemples
108* [Conception du harnais d'agent](https://claude.com/blog/a-harness-for-every-task-dynamic-workflows-in-claude-code) : comment l'équipe Claude Code utilise les workflows dynamiques pour orchestrer de nombreux sous-agents à la fois
