Documentation — Spybara

agent-sdk/claude-code-features.md +14 −12

Details

14 14

15## Contrôler les paramètres du système de fichiers avec settingSources15## Contrôler les paramètres du système de fichiers avec settingSources

16 16

17L'option des sources de paramètres ([`setting_sources`](/fr/agent-sdk/python#claude-agent-options) en Python, [`settingSources`](/fr/agent-sdk/typescript#setting-source) en TypeScript) contrôle quels paramètres basés sur le système de fichiers le SDK charge. Passez une liste explicite pour accepter des sources spécifiques, ou passez un tableau vide pour désactiver les paramètres utilisateur, projet et locaux.17L'option des sources de paramètres ([`setting_sources`](/fr/agent-sdk/python#claudeagentoptions) en Python, [`settingSources`](/fr/agent-sdk/typescript#settingsource) en TypeScript) contrôle quels paramètres basés sur le système de fichiers le SDK charge. Passez une liste explicite pour accepter des sources spécifiques, ou passez un tableau vide pour désactiver les paramètres utilisateur, projet et locaux.

18 18

19Cet exemple charge à la fois les paramètres au niveau utilisateur et au niveau projet en définissant `settingSources` sur `["user", "project"]` :19Cet exemple charge à la fois les paramètres au niveau utilisateur et au niveau projet en définissant `settingSources` sur `["user", "project"]` :

20 20

65 ```65 ```

66</CodeGroup>66</CodeGroup>

67 67

68Chaque source charge les paramètres à partir d'un emplacement spécifique, où `<cwd>` est le répertoire de travail que vous passez via l'option `cwd` (ou le répertoire courant du processus s'il n'est pas défini). Pour la définition de type complète, voir [`SettingSource`](/fr/agent-sdk/typescript#setting-source) (TypeScript) ou [`SettingSource`](/fr/agent-sdk/python#setting-source) (Python).68Chaque source charge les paramètres à partir d'un emplacement spécifique, où `<cwd>` est le répertoire de travail que vous passez via l'option `cwd`, ou le répertoire courant du processus s'il n'est pas défini. Pour la définition de type complète, voir [`SettingSource`](/fr/agent-sdk/typescript#settingsource) (TypeScript) ou [`SettingSource`](/fr/agent-sdk/python#settingsource) (Python).

69 69

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

119 119

120Les compétences sont des fichiers markdown qui donnent à votre agent des connaissances spécialisées et des flux de travail invocables. Contrairement à `CLAUDE.md` (qui se charge à chaque session), les compétences se chargent à la demande. L'agent reçoit les descriptions des compétences au démarrage et charge le contenu complet quand c'est pertinent.120Les compétences sont des fichiers markdown qui donnent à votre agent des connaissances spécialisées et des flux de travail invocables. Contrairement à `CLAUDE.md` (qui se charge à chaque session), les compétences se chargent à la demande. L'agent reçoit les descriptions des compétences au démarrage et charge le contenu complet quand c'est pertinent.

121 121

122Les compétences sont découvertes à partir du système de fichiers via `settingSources`. Avec les options par défaut, les compétences utilisateur et projet se chargent automatiquement. L'outil `Skill` est activé par défaut quand vous ne spécifiez pas `allowedTools`. Si vous utilisez une liste d'autorisation `allowedTools`, incluez `"Skill"` explicitement.122Les compétences sont découvertes à partir du système de fichiers via `settingSources`. Quand l'option `skills` sur `query()` est omise, les compétences utilisateur et projet découvertes sont activées et l'outil Skill est disponible, ce qui correspond au comportement de la CLI. Pour contrôler quelles compétences sont activées, passez `skills` comme `"all"`, une liste de noms de compétences, ou `[]` pour désactiver toutes les compétences. Le SDK active automatiquement l'outil Skill quand `skills` est défini, donc vous n'avez pas besoin de l'ajouter à `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") {

258Le SDK Agent vous donne accès à plusieurs façons d'étendre le comportement de votre agent. Si vous n'êtes pas sûr de celle à utiliser, ce tableau mappe les objectifs courants à la bonne approche.260Le SDK Agent vous donne accès à plusieurs façons d'étendre le comportement de votre agent. Si vous n'êtes pas sûr de celle à utiliser, ce tableau mappe les objectifs courants à la bonne approche.

259 261

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

264| Exécuter un flux de travail réutilisable (déployer, examiner, publier) | [Compétences invocables par l'utilisateur](/fr/agent-sdk/skills) | `settingSources` + `allowedTools: ["Skill"]` |266| Exécuter un flux de travail réutilisable (déployer, examiner, publier) | [User-invocable skills](/fr/agent-sdk/skills) | `settingSources` + option `skills` |

266| Coordonner plusieurs instances de Claude Code avec des listes de tâches partagées et la messagerie directe inter-agents | [Équipes d'agents](/fr/agent-teams) | Non configuré directement via les options SDK. Les équipes d'agents sont une fonctionnalité CLI où une session agit comme le chef d'équipe, coordonnant le travail entre les coéquipiers indépendants |268| Coordonner plusieurs instances de Claude Code avec des listes de tâches partagées et la messagerie directe inter-agents | [Agent teams](/fr/agent-teams) | Non configuré directement via les options SDK. Les équipes d'agents sont une fonctionnalité CLI où une session agit comme le chef d'équipe, coordonnant le travail entre les coéquipiers indépendants |

267| Exécuter une logique déterministe sur les appels d'outils (audit, blocage, transformation) | [Hooks](/fr/agent-sdk/hooks) | Paramètre `hooks` avec rappels, ou scripts shell chargés via `settingSources` |269| Exécuter une logique déterministe sur les appels d'outils (audit, blocage, transformation) | [Hooks](/fr/agent-sdk/hooks) | Paramètre `hooks` avec rappels, ou scripts shell chargés via `settingSources` |

269 271

270<Tip>272<Tip>

271 **Sous-agents versus équipes d'agents :** Les sous-agents sont éphémères et isolés : conversation fraîche, une tâche, résumé retourné au parent. Les équipes d'agents coordonnent plusieurs instances indépendantes de Claude Code qui partagent une liste de tâches et se envoient des messages directement. Les équipes d'agents sont une fonctionnalité CLI. Voir [Ce que les sous-agents héritent](/fr/agent-sdk/subagents#what-subagents-inherit) et la [comparaison des équipes d'agents](/fr/agent-teams#compare-with-subagents) pour les détails.273 **Subagents versus agent teams :** Les subagents sont éphémères et isolés : conversation fraîche, une tâche, résumé retourné au parent. Les agent teams coordonnent plusieurs instances indépendantes de Claude Code qui partagent une liste de tâches et se envoient des messages directement. Les agent teams sont une fonctionnalité CLI. Voir [What subagents inherit](/fr/agent-sdk/subagents#what-subagents-inherit) et la [agent teams comparison](/fr/agent-teams#compare-with-subagents) pour les détails.

272</Tip>274</Tip>

273 275

274Chaque fonctionnalité que vous activez ajoute à la fenêtre de contexte de votre agent. Pour les coûts par fonctionnalité et comment ces fonctionnalités se superposent, voir [Étendre Claude Code](/fr/features-overview#understand-context-costs).276Chaque fonctionnalité que vous activez ajoute à la fenêtre de contexte de votre agent. Pour les coûts par fonctionnalité et comment ces fonctionnalités se superposent, voir [Extend Claude Code](/fr/features-overview#understand-context-costs).

275 277

276## Ressources connexes278## Ressources connexes

277 279

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# Connecter à des outils externes avec MCP

7> Configurez les serveurs MCP pour étendre votre agent avec des outils externes. Couvre les types de transport, la recherche d'outils pour les grands ensembles d'outils, l'authentification et la gestion des erreurs.

9Le [Model Context Protocol (MCP)](https://modelcontextprotocol.io/docs/getting-started/intro) est une norme ouverte pour connecter les agents IA aux outils externes et aux sources de données. Avec MCP, votre agent peut interroger des bases de données, s'intégrer à des API comme Slack et GitHub, et se connecter à d'autres services sans écrire d'implémentations d'outils personnalisés.

11Les serveurs MCP peuvent s'exécuter en tant que processus locaux, se connecter via HTTP ou s'exécuter directement dans votre application SDK.

13<Note>

14 Cette page couvre la configuration de MCP pour l'Agent SDK. Pour ajouter des serveurs MCP à l'interface de ligne de commande Claude Code afin qu'ils se chargent dans chaque projet, consultez [Portées d'installation MCP](/fr/mcp#mcp-installation-scopes).

15</Note>

17## Démarrage rapide

19Cet exemple se connecte au serveur MCP de [documentation Claude Code](https://code.claude.com/docs) en utilisant le [transport HTTP](#httpsse-servers) et utilise [`allowedTools`](#allow-mcp-tools) avec un caractère générique pour autoriser tous les outils du serveur.

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'agent se connecte au serveur de documentation, recherche des informations sur les hooks et retourne les résultats.

73## Ajouter un serveur MCP

75Vous pouvez configurer les serveurs MCP dans le code lors de l'appel de `query()`, ou dans un fichier `.mcp.json` chargé via [`settingSources`](#from-a-config-file).

77### Dans le code

79Transmettez les serveurs MCP directement dans l'option `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### À partir d'un fichier de configuration

133

134Créez un fichier `.mcp.json` à la racine de votre projet. Le fichier est récupéré lorsque la source de paramètre `project` est activée, ce qui est le cas pour les options `query()` par défaut. Si vous définissez `settingSources` explicitement, incluez `"project"` pour que ce fichier se charge :

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## Autoriser les outils MCP

148

149Les outils MCP nécessitent une autorisation explicite avant que Claude puisse les utiliser. Sans autorisation, Claude verra que les outils sont disponibles mais ne pourra pas les appeler.

150

151### Convention de nommage des outils

152

153Les outils MCP suivent le modèle de nommage `mcp__<server-name>__<tool-name>`. Par exemple, un serveur GitHub nommé `"github"` avec un outil `list_issues` devient `mcp__github__list_issues`.

154

155### Accorder l'accès avec allowedTools

156

157Utilisez `allowedTools` pour spécifier quels outils MCP Claude peut utiliser :

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

174Les caractères génériques (`*`) vous permettent d'autoriser tous les outils d'un serveur sans lister chacun individuellement.

175

176<Note>

177 **Préférez `allowedTools` aux modes de permission pour l'accès MCP.** `permissionMode: "acceptEdits"` n'approuve pas automatiquement les outils MCP (uniquement les modifications de fichiers et les commandes Bash du système de fichiers). `permissionMode: "bypassPermissions"` approuve automatiquement les outils MCP mais désactive également tous les autres messages de sécurité, ce qui est plus large que nécessaire. Un caractère générique dans `allowedTools` accorde exactement le serveur MCP que vous souhaitez et rien de plus. Consultez [Modes de permission](/fr/agent-sdk/permissions#permission-modes) pour une comparaison complète.

178</Note>

179

180### Découvrir les outils disponibles

181

182Pour voir quels outils un serveur MCP fournit, consultez la documentation du serveur ou connectez-vous au serveur et inspectez le message d'initialisation `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## Types de transport

193

194Les serveurs MCP communiquent avec votre agent en utilisant différents protocoles de transport. Consultez la documentation du serveur pour voir quel transport il supporte :

195

196* Si la documentation vous donne une **commande à exécuter** (comme `npx @modelcontextprotocol/server-github`), utilisez stdio

197* Si la documentation vous donne une **URL**, utilisez HTTP ou SSE

198* Si vous construisez vos propres outils dans le code, utilisez un serveur MCP SDK

199

200### Serveurs stdio

201

202Les processus locaux qui communiquent via stdin/stdout. Utilisez ceci pour les serveurs MCP que vous exécutez sur la même machine :

203

204<Tabs>

205 <Tab title="Dans le code">

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### Serveurs HTTP/SSE

257

258Utilisez HTTP ou SSE pour les serveurs MCP hébergés dans le cloud et les API distantes :

259

260<Tabs>

261 <Tab title="Dans le code">

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

312Pour HTTP (non-streaming), utilisez `"type": "http"` à la place.

313

314### Serveurs MCP SDK

315

316Définissez des outils personnalisés directement dans le code de votre application au lieu d'exécuter un processus serveur séparé. Consultez le [guide des outils personnalisés](/fr/agent-sdk/custom-tools) pour les détails d'implémentation.

317

318## Recherche d'outils MCP

319

320Lorsque vous avez de nombreux outils MCP configurés, les définitions d'outils peuvent consommer une partie importante de votre fenêtre de contexte. La recherche d'outils résout ce problème en retenant les définitions d'outils du contexte et en chargeant uniquement ceux dont Claude a besoin pour chaque tour.

321

322La recherche d'outils est activée par défaut. Consultez [Recherche d'outils](/fr/agent-sdk/tool-search) pour les options de configuration et les détails.

323

324Pour plus de détails, y compris les meilleures pratiques et l'utilisation de la recherche d'outils avec les outils SDK personnalisés, consultez le [guide de recherche d'outils](/fr/agent-sdk/tool-search).

325

326## Authentification

327

328La plupart des serveurs MCP nécessitent une authentification pour accéder aux services externes. Transmettez les identifiants via des variables d'environnement dans la configuration du serveur.

329

330### Transmettre les identifiants via des variables d'environnement

331

332Utilisez le champ `env` pour transmettre les clés API, les jetons et autres identifiants au serveur MCP :

333

334<Tabs>

335 <Tab title="Dans le code">

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 syntaxe `${GITHUB_TOKEN}` développe les variables d'environnement au moment de l'exécution.

385 </Tab>

386</Tabs>

387

388Consultez [Lister les problèmes d'un référentiel](#list-issues-from-a-repository) pour un exemple complet fonctionnant avec la journalisation de débogage.

389

390### En-têtes HTTP pour les serveurs distants

391

392Pour les serveurs HTTP et SSE, transmettez les en-têtes d'authentification directement dans la configuration du serveur :

393

394<Tabs>

395 <Tab title="Dans le code">

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 syntaxe `${API_TOKEN}` développe les variables d'environnement au moment de l'exécution.

445 </Tab>

446</Tabs>

447

448### Authentification OAuth2

449

450La [spécification MCP supporte OAuth 2.1](https://modelcontextprotocol.io/specification/2025-03-26/basic/authorization) pour l'autorisation. Le SDK ne gère pas les flux OAuth automatiquement, mais vous pouvez transmettre les jetons d'accès via les en-têtes après avoir complété le flux OAuth dans votre application :

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## Exemples

489

490### Lister les problèmes d'un référentiel

491

492Cet exemple se connecte au [serveur GitHub MCP](https://github.com/modelcontextprotocol/servers/tree/main/src/github) pour lister les problèmes récents. L'exemple inclut la journalisation de débogage pour vérifier la connexion MCP et les appels d'outils.

493

494Avant d'exécuter, créez un [jeton d'accès personnel GitHub](https://github.com/settings/tokens) avec la portée `repo` et définissez-le comme variable d'environnement :

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### Interroger une base de données

588

589Cet exemple utilise le [serveur Postgres MCP](https://github.com/modelcontextprotocol/servers/tree/main/src/postgres) pour interroger une base de données. La chaîne de connexion est transmise comme argument au serveur. L'agent découvre automatiquement le schéma de la base de données, écrit la requête SQL et retourne les résultats :

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## Gestion des erreurs

659

660Les serveurs MCP peuvent échouer à se connecter pour diverses raisons : le processus serveur peut ne pas être installé, les identifiants peuvent être invalides, ou un serveur distant peut être inaccessible.

661

662Le SDK émet un message `system` avec le sous-type `init` au début de chaque requête. Ce message inclut l'état de la connexion pour chaque serveur MCP. Vérifiez le champ `status` pour détecter les défaillances de connexion avant que l'agent ne commence à travailler :

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## Dépannage

721

722### Le serveur affiche le statut « failed »

723

724Vérifiez le message `init` pour voir quels serveurs n'ont pas pu se connecter :

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

736Causes courantes :

737

738* **Variables d'environnement manquantes** : Assurez-vous que les jetons et identifiants requis sont définis. Pour les serveurs stdio, vérifiez que le champ `env` correspond à ce que le serveur attend.

739* **Serveur non installé** : Pour les commandes `npx`, vérifiez que le package existe et que Node.js est dans votre PATH.

740* **Chaîne de connexion invalide** : Pour les serveurs de base de données, vérifiez le format de la chaîne de connexion et que la base de données est accessible.

741* **Problèmes réseau** : Pour les serveurs HTTP/SSE distants, vérifiez que l'URL est accessible et que les pare-feu autorisent la connexion.

742

743### Les outils ne sont pas appelés

744

745Si Claude voit les outils mais ne les utilise pas, vérifiez que vous avez accordé la permission avec `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### Délais d'expiration de la connexion

759

760Le SDK MCP a un délai d'expiration par défaut de 60 secondes pour les connexions serveur. Si votre serveur prend plus de temps pour démarrer, la connexion échouera. Pour les serveurs qui ont besoin de plus de temps de démarrage, envisagez :

761

762* Utiliser un serveur plus léger si disponible

763* Préchauffer le serveur avant de démarrer votre agent

764* Vérifier les journaux du serveur pour les causes de lenteur d'initialisation

765

766## Ressources connexes

767

768* **[Guide des outils personnalisés](/fr/agent-sdk/custom-tools)** : Créez votre propre serveur MCP qui s'exécute en processus avec votre application SDK

769* **[Permissions](/fr/agent-sdk/permissions)** : Contrôlez quels outils MCP votre agent peut utiliser avec `allowedTools` et `disallowedTools`

770* **[Référence SDK TypeScript](/fr/agent-sdk/typescript)** : Référence API complète incluant les options de configuration MCP

771* **[Référence SDK Python](/fr/agent-sdk/python)** : Référence API complète incluant les options de configuration MCP

772* **[Répertoire des serveurs MCP](https://github.com/modelcontextprotocol/servers)** : Parcourez les serveurs MCP disponibles pour les bases de données, les API et bien d'autres

agent-sdk/python.md +2 −1

Details

836| `setting_sources` | `list[SettingSource] \| None` | `None` (CLI defaults: all sources) | Contrôlez quels paramètres du système de fichiers charger. Passez `[]` pour désactiver les paramètres utilisateur, projet et locaux. Les paramètres de politique gérée se chargent indépendamment. Voir [Utiliser les fonctionnalités de Claude Code](/fr/agent-sdk/claude-code-features#what-settingsources-does-not-control) |836| `setting_sources` | `list[SettingSource] \| None` | `None` (CLI defaults: all sources) | Contrôlez quels paramètres du système de fichiers charger. Passez `[]` pour désactiver les paramètres utilisateur, projet et locaux. Les paramètres de politique gérée se chargent indépendamment. Voir [Utiliser les fonctionnalités de Claude Code](/fr/agent-sdk/claude-code-features#what-settingsources-does-not-control) |

837| `skills` | `list[str] \| Literal["all"] \| None` | `None` | Compétences disponibles pour la session. Passez `"all"` pour activer chaque compétence découverte, ou une liste de noms de compétences. Quand défini, le SDK active l'outil Skill automatiquement sans le lister dans `allowed_tools`. Voir [Compétences](/fr/agent-sdk/skills) |

1049| `tools` | Non | Tableau des noms d'outils autorisés. Si omis, hérite de tous les outils |1050| `tools` | Non | Tableau des noms d'outils autorisés. Si omis, hérite de tous les outils |

1050| `disallowedTools` | Non | Tableau des noms d'outils à supprimer de l'ensemble d'outils de l'agent |1051| `disallowedTools` | Non | Tableau des noms d'outils à supprimer de l'ensemble d'outils de l'agent |

1051| `model` | Non | Remplacement de modèle pour cet agent. Accepte un alias tel que `"sonnet"`, `"opus"`, `"haiku"`, ou `"inherit"`, ou un ID de modèle complet. Si omis, utilise le modèle principal |1052| `model` | Non | Remplacement de modèle pour cet agent. Accepte un alias tel que `"sonnet"`, `"opus"`, `"haiku"`, ou `"inherit"`, ou un ID de modèle complet. Si omis, utilise le modèle principal |

1052| `skills` | Non | Liste des noms de compétences disponibles pour cet agent |1053| `skills` | Non | Liste des noms de compétences à précharger dans le contexte de l'agent au démarrage. Les compétences non listées restent invocables via l'outil Skill |

1053| `memory` | Non | Source de mémoire pour cet agent : `"user"`, `"project"`, ou `"local"` |1054| `memory` | Non | Source de mémoire pour cet agent : `"user"`, `"project"`, ou `"local"` |

1054| `mcpServers` | Non | Serveurs MCP disponibles pour cet agent. Chaque entrée est un nom de serveur ou un dict `{name: config}` en ligne |1055| `mcpServers` | Non | Serveurs MCP disponibles pour cet agent. Chaque entrée est un nom de serveur ou un dict `{name: config}` en ligne |

1055| `initialPrompt` | Non | Auto-soumis comme le premier tour utilisateur quand cet agent s'exécute comme l'agent du fil principal |1056| `initialPrompt` | Non | Auto-soumis comme le premier tour utilisateur quand cet agent s'exécute comme l'agent du fil principal |

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# Travailler avec les sessions

7> Comment les sessions conservent l'historique des conversations de l'agent, et quand utiliser continue, resume et fork pour revenir à une exécution antérieure.

9Une session est l'historique des conversations que le SDK accumule pendant que votre agent travaille. Elle contient votre prompt, chaque appel d'outil que l'agent a effectué, chaque résultat d'outil et chaque réponse. Le SDK l'écrit automatiquement sur le disque pour que vous puissiez y revenir plus tard.

11Revenir à une session signifie que l'agent a le contexte complet d'avant : les fichiers qu'il a déjà lus, l'analyse qu'il a déjà effectuée, les décisions qu'il a déjà prises. Vous pouvez poser une question de suivi, récupérer après une interruption ou vous brancher pour essayer une approche différente.

13<Note>

14 Les sessions conservent la **conversation**, pas le système de fichiers. Pour créer un instantané et annuler les modifications de fichiers que l'agent a apportées, utilisez [file checkpointing](/fr/agent-sdk/file-checkpointing).

15</Note>

17Ce guide couvre comment choisir la bonne approche pour votre application, les interfaces du SDK qui suivent automatiquement les sessions, comment capturer les ID de session et utiliser `resume` et `fork` manuellement, et ce qu'il faut savoir sur la reprise des sessions sur plusieurs hôtes.

19## Choisir une approche

21La quantité de gestion de session dont vous avez besoin dépend de la forme de votre application. La gestion des sessions entre en jeu lorsque vous envoyez plusieurs prompts qui doivent partager le contexte. Dans un seul appel `query()`, l'agent prend déjà autant de tours qu'il en a besoin, et les prompts de permission et `AskUserQuestion` sont [gérés en boucle](/fr/agent-sdk/user-input) (ils ne terminent pas l'appel).

23| Ce que vous construisez | Ce qu'il faut utiliser |

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

25| Tâche unique : prompt unique, pas de suivi | Rien d'extra. Un seul appel `query()` le gère. |

26| Chat multi-tours dans un seul processus | [`ClaudeSDKClient` (Python) ou `continue: true` (TypeScript)](#automatic-session-management). Le SDK suit la session pour vous sans gestion d'ID. |

27| Reprendre là où vous vous êtes arrêté après un redémarrage de processus | `continue_conversation=True` (Python) / `continue: true` (TypeScript). Reprend la session la plus récente du répertoire, aucun ID nécessaire. |

28| Reprendre une session passée spécifique (pas la plus récente) | Capturez l'ID de session et passez-le à `resume`. |

29| Essayer une approche alternative sans perdre l'original | Bifurquez la session. |

30| Tâche sans état, ne voulez rien écrire sur le disque (TypeScript uniquement) | Définissez [`persistSession: false`](/fr/agent-sdk/typescript#options). La session existe uniquement en mémoire pendant la durée de l'appel. Python persiste toujours sur le disque. |

32### Continue, resume et fork

34Continue, resume et fork sont des champs d'options que vous définissez sur `query()` ([`ClaudeAgentOptions`](/fr/agent-sdk/python#claudeagentoptions) en Python, [`Options`](/fr/agent-sdk/typescript#options) en TypeScript).

36**Continue** et **resume** reprennent tous les deux une session existante et l'ajoutent. La différence est la façon dont ils trouvent cette session :

38* **Continue** trouve la session la plus récente dans le répertoire courant. Vous ne suivez rien. Fonctionne bien lorsque votre application exécute une conversation à la fois.

39* **Resume** prend un ID de session spécifique. Vous suivez l'ID. Requis lorsque vous avez plusieurs sessions (par exemple, une par utilisateur dans une application multi-utilisateurs) ou que vous voulez revenir à une qui n'est pas la plus récente.

41**Fork** est différent : il crée une nouvelle session qui commence par une copie de l'historique de l'original. L'original reste inchangé. Utilisez fork pour essayer une direction différente tout en gardant la possibilité de revenir en arrière.

43## Gestion automatique des sessions

45Les deux SDK offrent une interface qui suit l'état de la session pour vous entre les appels, vous n'avez donc pas besoin de passer les ID manuellement. Utilisez-les pour les conversations multi-tours dans un seul processus.

47### Python : `ClaudeSDKClient`

49[`ClaudeSDKClient`](/fr/agent-sdk/python#claudesdkclient) gère les ID de session en interne. Chaque appel à `client.query()` continue automatiquement la même session. Appelez [`client.receive_response()`](/fr/agent-sdk/python#claudesdkclient) pour itérer sur les messages de la requête actuelle. Le client doit être utilisé comme gestionnaire de contexte asynchrone.

51Cet exemple exécute deux requêtes contre le même `client`. La première demande à l'agent d'analyser un module ; la seconde lui demande de refactoriser ce module. Parce que les deux appels passent par la même instance de client, la deuxième requête a le contexte complet de la première sans aucun `resume` ou ID de session explicite :

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```

99Consultez la [référence du SDK Python](/fr/agent-sdk/python#choosing-between-query-and-claudesdkclient) pour plus de détails sur quand utiliser `ClaudeSDKClient` par rapport à la fonction `query()` autonome.

100

101### TypeScript : `continue: true`

102

103Le SDK TypeScript stable (la fonction `query()` utilisée dans tous ces documents, parfois appelée V1) n'a pas d'objet client tenant une session comme le `ClaudeSDKClient` de Python. À la place, passez `continue: true` sur chaque appel `query()` suivant et le SDK reprend la session la plus récente dans le répertoire courant. Aucun suivi d'ID requis.

104

105Cet exemple effectue deux appels `query()` séparés. Le premier crée une session nouvelle ; le second définit `continue: true`, ce qui indique au SDK de trouver et reprendre la session la plus récente sur le disque. L'agent a le contexte complet du premier appel :

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 de session V2 expérimentale]\(/fr/agent-sdk/typescript-v2-preview), qui fournissait `createSession()` avec un modèle `send` / `stream`, est dépréciée. Utilisez la fonction V1 `query()` et les options de session décrites sur cette page à la place.

136</Note>

137

138## Utiliser les options de session avec `query()`

139

140### Capturer l'ID de session

141

142Resume et fork nécessitent un ID de session. Lisez-le à partir du champ `session_id` sur le message de résultat ([`ResultMessage`](/fr/agent-sdk/python#resultmessage) en Python, [`SDKResultMessage`](/fr/agent-sdk/typescript#sdkresultmessage) en TypeScript), qui est présent sur chaque résultat indépendamment du succès ou de l'erreur. En TypeScript, l'ID est également disponible plus tôt en tant que champ direct sur le `SystemMessage` d'initialisation ; en Python, il est imbriqué dans `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### Reprendre par ID

193

194Passez un ID de session à `resume` pour revenir à cette session spécifique. L'agent reprend avec le contexte complet d'où la session s'est arrêtée. Les raisons courantes de reprendre :

195

196* **Faire un suivi sur une tâche terminée.** L'agent a déjà analysé quelque chose ; maintenant vous voulez qu'il agisse sur cette analyse sans relire les fichiers.

197* **Récupérer d'une limite.** La première exécution s'est terminée avec `error_max_turns` ou `error_max_budget_usd` (voir [Handle the result](/fr/agent-sdk/agent-loop#handle-the-result)) ; reprenez avec une limite plus élevée.

198* **Redémarrer votre processus.** Vous avez capturé l'ID avant l'arrêt et voulez restaurer la conversation.

199

200Cet exemple reprend la session de [Capturer l'ID de session](#capture-the-session-id) avec un prompt de suivi. Parce que vous reprenez, l'agent a déjà l'analyse antérieure en contexte :

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 Si un appel `resume` retourne une session nouvelle au lieu de l'historique attendu, la cause la plus courante est un `cwd` non correspondant. Les sessions sont stockées sous `~/.claude/projects/<encoded-cwd>/*.jsonl`, où `<encoded-cwd>` est le répertoire de travail absolu avec chaque caractère non alphanumérique remplacé par `-` (donc `/Users/me/proj` devient `-Users-me-proj`). Si votre appel resume s'exécute à partir d'un répertoire différent, le SDK cherche au mauvais endroit. Le fichier de session doit également exister sur la machine actuelle.

234</Tip>

235

236Pour reprendre les sessions sur plusieurs machines ou dans des environnements sans serveur, mettez en miroir les transcriptions vers un stockage partagé avec un adaptateur [`SessionStore`](/fr/agent-sdk/session-storage).

237

238### Bifurquer pour explorer les alternatives

239

240La bifurcation crée une nouvelle session qui commence par une copie de l'historique de l'original mais diverge à partir de ce point. La bifurcation obtient son propre ID de session ; l'ID et l'historique de l'original restent inchangés. Vous vous retrouvez avec deux sessions indépendantes que vous pouvez reprendre séparément.

241

242<Note>

243 La bifurcation branche l'historique de la conversation, pas le système de fichiers. Si un agent bifurqué modifie des fichiers, ces modifications sont réelles et visibles pour toute session travaillant dans le même répertoire. Pour brancher et annuler les modifications de fichiers, utilisez [file checkpointing](/fr/agent-sdk/file-checkpointing).

244</Note>

245

246Cet exemple s'appuie sur [Capturer l'ID de session](#capture-the-session-id) : vous avez déjà analysé un module d'authentification dans `session_id` et voulez explorer OAuth2 sans perdre le fil axé sur JWT. Le premier bloc bifurque la session et capture l'ID de la bifurcation (`forked_id`) ; le deuxième bloc reprend le `session_id` original pour continuer sur le chemin JWT. Vous avez maintenant deux ID de session pointant vers deux historiques séparés :

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## Reprendre sur plusieurs hôtes

309

310Les fichiers de session sont locaux à la machine qui les a créés. Pour reprendre une session sur un hôte différent (travailleurs CI, conteneurs éphémères, sans serveur), vous avez deux options :

311

312* **Déplacer le fichier de session.** Persistez `~/.claude/projects/<encoded-cwd>/<session-id>.jsonl` de la première exécution et restaurez-le au même chemin sur le nouvel hôte avant d'appeler `resume`. Le `cwd` doit correspondre.

313* **Ne pas compter sur la reprise de session.** Capturez les résultats dont vous avez besoin (sortie d'analyse, décisions, diffs de fichiers) en tant qu'état d'application et passez-les dans le prompt d'une session nouvelle. C'est souvent plus robuste que d'expédier des fichiers de transcription.

314

315Les deux SDK exposent des fonctions pour énumérer les sessions sur le disque et lire leurs messages : [`listSessions()`](/fr/agent-sdk/typescript#listsessions) et [`getSessionMessages()`](/fr/agent-sdk/typescript#getsessionmessages) en TypeScript, [`list_sessions()`](/fr/agent-sdk/python#list_sessions) et [`get_session_messages()`](/fr/agent-sdk/python#get_session_messages) en Python. Utilisez-les pour construire des sélecteurs de session personnalisés, une logique de nettoyage ou des visionneuses de transcription.

316

317Les deux SDK exposent également des fonctions pour rechercher et muter des sessions individuelles : [`get_session_info()`](/fr/agent-sdk/python#get_session_info), [`rename_session()`](/fr/agent-sdk/python#rename_session) et [`tag_session()`](/fr/agent-sdk/python#tag_session) en Python, et [`getSessionInfo()`](/fr/agent-sdk/typescript#getsessioninfo), [`renameSession()`](/fr/agent-sdk/typescript#renamesession) et [`tagSession()`](/fr/agent-sdk/typescript#tagsession) en TypeScript. Utilisez-les pour organiser les sessions par tag ou leur donner des titres lisibles par l'homme.

318

319## Ressources connexes

320

321* [How the agent loop works](/fr/agent-sdk/agent-loop) : Comprendre les tours, les messages et l'accumulation de contexte dans une session

322* [File checkpointing](/fr/agent-sdk/file-checkpointing) : Suivre et annuler les modifications de fichiers entre les sessions

323* [Python `ClaudeAgentOptions`](/fr/agent-sdk/python#claudeagentoptions) : Référence complète des options de session pour Python

324* [TypeScript `Options`](/fr/agent-sdk/typescript#options) : Référence complète des options de session pour 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 dans le SDK

7> Étendez Claude avec des capacités spécialisées en utilisant Agent Skills dans le Claude Agent SDK

9## Aperçu

11Agent Skills étendent Claude avec des capacités spécialisées que Claude invoque de manière autonome lorsque c'est pertinent. Les Skills sont empaquetés sous forme de fichiers `SKILL.md` contenant des instructions, des descriptions et des ressources de support optionnelles.

13Pour des informations complètes sur les Skills, y compris les avantages, l'architecture et les directives de création, consultez l'[aperçu d'Agent Skills](https://platform.claude.com/docs/fr/agents-and-tools/agent-skills/overview).

15## Comment les Skills fonctionnent avec le SDK

17Lors de l'utilisation du Claude Agent SDK, les Skills sont :

191. **Définis comme des artefacts du système de fichiers** : Créés sous forme de fichiers `SKILL.md` dans des répertoires spécifiques (`.claude/skills/`)

202. **Chargés à partir du système de fichiers** : Les Skills sont chargés à partir des emplacements du système de fichiers régis par `settingSources` (TypeScript) ou `setting_sources` (Python)

213. **Découverts automatiquement** : Une fois que les paramètres du système de fichiers sont chargés, les métadonnées des Skills sont découvertes au démarrage à partir des répertoires utilisateur et projet ; le contenu complet est chargé lorsqu'il est déclenché

224. **Invoqués par le modèle** : Claude choisit de manière autonome quand les utiliser en fonction du contexte

235. **Filtrés via l'option `skills`** : Les Skills découverts sont activés par défaut. Passez une liste de noms de Skills, `"all"`, ou `[]` pour contrôler lesquels sont disponibles dans la session

25Contrairement aux sous-agents (qui peuvent être définis par programmation), les Skills doivent être créés comme des artefacts du système de fichiers. Le SDK ne fournit pas d'API programmatique pour enregistrer les Skills.

27<Note>

28 Les Skills sont découverts via les sources de paramètres du système de fichiers. Avec les options `query()` par défaut, le SDK charge les sources utilisateur et projet, donc les skills dans `~/.claude/skills/` et `<cwd>/.claude/skills/` sont disponibles. Si vous définissez `settingSources` explicitement, incluez `'user'` ou `'project'` pour maintenir la découverte des skills, ou utilisez l'[option `plugins`](/fr/agent-sdk/plugins) pour charger les skills à partir d'un chemin spécifique.

29</Note>

31## Utilisation des Skills avec le SDK

33Définissez l'option `skills` sur `query()` pour contrôler quels Skills sont disponibles pour la session. Lorsqu'elle est omise, les Skills découverts sont activés et l'outil Skill est disponible, ce qui correspond au comportement de la CLI. Passez `"all"` pour activer chaque Skill découvert, une liste de noms de Skills pour activer uniquement ceux-ci, ou `[]` pour désactiver tous les Skills. Lorsque vous définissez `skills`, le SDK active automatiquement l'outil Skill, vous n'avez donc pas besoin de le lister dans `allowedTools`.

35Une fois configuré, Claude découvre automatiquement les Skills à partir du système de fichiers et les invoque lorsque c'est pertinent pour la demande de l'utilisateur.

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>

77Pour activer uniquement des Skills spécifiques, passez leurs noms. Les noms correspondent au champ `name` dans `SKILL.md` ou au nom du répertoire du Skill. Utilisez `plugin:skill` pour les Skills fournis par les plugins.

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'option `skills` est un filtre de contexte, pas un bac à sable. Les Skills non listés sont masqués au modèle et rejetés par l'outil Skill, mais leurs fichiers restent sur le disque et sont accessibles via Read et Bash.

91## Emplacements des Skills

93Les Skills sont chargés à partir des répertoires du système de fichiers en fonction de votre configuration `settingSources`/`setting_sources` :

95* **Project Skills** (`.claude/skills/`) : Partagés avec votre équipe via git - chargés lorsque `setting_sources` inclut `"project"`

96* **User Skills** (`~/.claude/skills/`) : Skills personnels dans tous les projets - chargés lorsque `setting_sources` inclut `"user"`

97* **Plugin Skills** : Fournis avec les plugins Claude Code installés

99## Création de Skills

100

101Les Skills sont définis comme des répertoires contenant un fichier `SKILL.md` avec un frontmatter YAML et du contenu Markdown. Le champ `description` détermine quand Claude invoque votre Skill.

102

103**Exemple de structure de répertoire** :

104

105```bash theme={null}

106.claude/skills/processing-pdfs/

107└── SKILL.md

108```

109

110Pour des conseils complets sur la création de Skills, y compris la structure SKILL.md, les Skills multi-fichiers et les exemples, consultez :

111

112* [Agent Skills dans Claude Code](/fr/skills) : Guide complet avec des exemples

113* [Agent Skills Best Practices](https://platform.claude.com/docs/fr/agents-and-tools/agent-skills/best-practices) : Directives de création et conventions de nommage

114

115## Restrictions d'outils

116

117<Note>

118 Le champ frontmatter `allowed-tools` dans SKILL.md n'est pris en charge que lors de l'utilisation directe de la CLI Claude Code. **Il ne s'applique pas lors de l'utilisation de Skills via le SDK**.

119

120 Lors de l'utilisation du SDK, contrôlez l'accès aux outils via l'option principale `allowedTools` dans votre configuration de requête.

121</Note>

122

123Pour contrôler l'accès aux outils pour les Skills dans les applications SDK, utilisez `allowedTools` pour pré-approuver des outils spécifiques. Sans un rappel `canUseTool`, tout ce qui ne figure pas dans la liste est refusé :

124

125<Note>

126 Les déclarations d'importation du premier exemple sont supposées dans les extraits de code suivants.

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## Découverte des Skills disponibles

157

158Pour voir quels Skills sont disponibles dans votre application SDK, demandez simplement à 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 listera les Skills disponibles en fonction de votre répertoire de travail actuel et des plugins installés.

185

186## Test des Skills

187

188Testez les Skills en posant des questions qui correspondent à leurs descriptions :

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 invoque automatiquement le Skill pertinent si la description correspond à votre demande.

219

220## Dépannage

221

222### Skills non trouvés

223

224**Vérifiez la configuration settingSources** : Les Skills sont découverts via les sources de paramètres `user` et `project`. Si vous définissez `settingSources`/`setting_sources` explicitement et omettez ces sources, les skills ne sont pas chargés :

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

253Pour plus de détails sur `settingSources`/`setting_sources`, consultez la [référence du SDK TypeScript](/fr/agent-sdk/typescript#settingsource) ou la [référence du SDK Python](/fr/agent-sdk/python#settingsource).

254

255**Vérifiez le répertoire de travail** : Le SDK charge les Skills par rapport à l'option `cwd`. Assurez-vous qu'elle pointe vers un répertoire contenant `.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

277Consultez la section « Utilisation des Skills avec le SDK » ci-dessus pour le modèle complet.

278

279**Vérifiez l'emplacement du système de fichiers** :

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 utilisé

290

291**Vérifiez l'option `skills`** : Si vous avez passé une liste `skills`, confirmez que le nom du skill est inclus. Passer `[]` désactive tous les skills.

292

293**Vérifiez la description** : Assurez-vous qu'elle est spécifique et inclut les mots-clés pertinents. Consultez [Agent Skills Best Practices](https://platform.claude.com/docs/fr/agents-and-tools/agent-skills/best-practices#writing-effective-descriptions) pour des conseils sur la rédaction de descriptions efficaces.

294

295### Dépannage supplémentaire

296

297Pour le dépannage général des Skills (syntaxe YAML, débogage, etc.), consultez la [section dépannage des Skills de Claude Code](/fr/skills#troubleshooting).

298

299## Documentation connexe

300

301### Guides des Skills

302

303* [Agent Skills dans Claude Code](/fr/skills) : Guide complet des Skills avec création, exemples et dépannage

304* [Agent Skills Overview](https://platform.claude.com/docs/fr/agents-and-tools/agent-skills/overview) : Aperçu conceptuel, avantages et architecture

305* [Agent Skills Best Practices](https://platform.claude.com/docs/fr/agents-and-tools/agent-skills/best-practices) : Directives de création pour des Skills efficaces

306* [Agent Skills Cookbook](https://platform.claude.com/cookbook/skills-notebooks-01-skills-introduction) : Exemples de Skills et modèles

307

308### Ressources du SDK

309

310* [Subagents dans le SDK](/fr/agent-sdk/subagents) : Agents similaires basés sur le système de fichiers avec options programmatiques

311* [Slash Commands dans le SDK](/fr/agent-sdk/slash-commands) : Commandes invoquées par l'utilisateur

312* [Aperçu du SDK](/fr/agent-sdk/overview) : Concepts généraux du SDK

313* [Référence du SDK TypeScript](/fr/agent-sdk/typescript) : Documentation complète de l'API

314* [Référence du SDK Python](/fr/agent-sdk/python) : Documentation complète de l'API

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# Sous-agents dans le SDK

7> Définissez et invoquez des sous-agents pour isoler le contexte, exécuter des tâches en parallèle et appliquer des instructions spécialisées dans vos applications Claude Agent SDK.

9Les sous-agents sont des instances d'agent distinctes que votre agent principal peut créer pour gérer des sous-tâches ciblées.

10Utilisez les sous-agents pour isoler le contexte des sous-tâches ciblées, exécuter plusieurs analyses en parallèle et appliquer des instructions spécialisées sans surcharger l'invite du principal agent.

12Ce guide explique comment définir et utiliser les sous-agents dans le SDK en utilisant le paramètre `agents`.

14## Aperçu

16Vous pouvez créer des sous-agents de trois façons :

18* **Par programmation** : utilisez le paramètre `agents` dans vos options `query()` ([TypeScript](/fr/agent-sdk/typescript#agentdefinition), [Python](/fr/agent-sdk/python#agentdefinition))

19* **Basé sur le système de fichiers** : définissez les agents comme des fichiers markdown dans les répertoires `.claude/agents/` (voir [définir les sous-agents comme fichiers](/fr/sub-agents))

20* **Général intégré** : Claude peut invoquer le sous-agent `general-purpose` intégré à tout moment via l'outil Agent sans que vous ayez besoin de rien définir

22Ce guide se concentre sur l'approche programmatique, qui est recommandée pour les applications SDK.

24Lorsque vous définissez des sous-agents, Claude détermine s'il faut les invoquer en fonction du champ `description` de chaque sous-agent. Écrivez des descriptions claires qui expliquent quand le sous-agent doit être utilisé, et Claude délèguera automatiquement les tâches appropriées. Vous pouvez également demander explicitement un sous-agent par son nom dans votre invite (par exemple, « Utilisez l'agent code-reviewer pour... »).

26## Avantages de l'utilisation des sous-agents

28### Isolation du contexte

30Chaque sous-agent s'exécute dans sa propre conversation nouvelle. Les appels d'outils intermédiaires et les résultats restent à l'intérieur du sous-agent ; seul son message final revient au parent. Voir [Ce que les sous-agents héritent](#what-subagents-inherit) pour savoir exactement ce qui se trouve dans le contexte du sous-agent.

32**Exemple :** un sous-agent `research-assistant` peut explorer des dizaines de fichiers sans que le contenu de ces fichiers s'accumule dans la conversation principale. Le parent reçoit un résumé concis, pas chaque fichier que le sous-agent a lu.

34### Parallélisation

36Plusieurs sous-agents peuvent s'exécuter simultanément, accélérant considérablement les flux de travail complexes.

38**Exemple :** lors d'une révision de code, vous pouvez exécuter les sous-agents `style-checker`, `security-scanner` et `test-coverage` simultanément, réduisant le temps de révision de minutes à secondes.

40### Instructions et connaissances spécialisées

42Chaque sous-agent peut avoir des invites système adaptées avec une expertise spécifique, des meilleures pratiques et des contraintes.

44**Exemple :** un sous-agent `database-migration` peut avoir des connaissances détaillées sur les meilleures pratiques SQL, les stratégies de restauration et les vérifications d'intégrité des données qui seraient du bruit inutile dans les instructions du principal agent.

46### Restrictions d'outils

48Les sous-agents peuvent être limités à des outils spécifiques, réduisant le risque d'actions involontaires.

50**Exemple :** un sous-agent `doc-reviewer` pourrait n'avoir accès qu'aux outils Read et Grep, garantissant qu'il peut analyser mais ne peut jamais modifier accidentellement vos fichiers de documentation.

52## Création de sous-agents

54### Définition programmatique (recommandée)

56Définissez les sous-agents directement dans votre code en utilisant le paramètre `agents`. Cet exemple crée deux sous-agents : un examinateur de code avec accès en lecture seule et un exécuteur de tests qui peut exécuter des commandes. L'outil `Agent` doit être inclus dans `allowedTools` puisque Claude invoque les sous-agents via l'outil 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### Configuration AgentDefinition

161

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

168| `model` | `string` | Non | Remplacement du modèle pour cet agent. Accepte un alias tel que `'sonnet'`, `'opus'`, `'haiku'`, `'inherit'`, ou un ID de modèle complet. Par défaut le modèle principal s'il est omis |

176

177Dans le SDK Python, ces noms de champs utilisent camelCase pour correspondre au format de transmission. Voir la référence [`AgentDefinition`](/fr/agent-sdk/python#agentdefinition) pour plus de détails.

178

179<Note>

180 Les sous-agents ne peuvent pas créer leurs propres sous-agents. N'incluez pas `Agent` dans le tableau `tools` d'un sous-agent.

181</Note>

182

183### Définition basée sur le système de fichiers (alternative)

184

185Vous pouvez également définir les sous-agents comme des fichiers markdown dans les répertoires `.claude/agents/`. Voir la [documentation des sous-agents Claude Code](/fr/sub-agents) pour plus de détails sur cette approche. Les agents définis par programmation ont la priorité sur les agents basés sur le système de fichiers portant le même nom.

186

187<Note>

188 Même sans définir de sous-agents personnalisés, Claude peut créer le sous-agent `general-purpose` intégré lorsque `Agent` se trouve dans votre `allowedTools`. Ceci est utile pour déléguer des tâches de recherche ou d'exploration sans créer d'agents spécialisés.

189</Note>

190

191## Ce que les sous-agents héritent

192

193La fenêtre de contexte d'un sous-agent commence fraîche (pas de conversation parent) mais n'est pas vide. Le seul canal du parent au sous-agent est la chaîne d'invite de l'outil Agent, donc incluez tous les chemins de fichiers, messages d'erreur ou décisions dont le sous-agent a besoin directement dans cette invite.

194

195| Le sous-agent reçoit | Le sous-agent ne reçoit pas |

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

197| Sa propre invite système (`AgentDefinition.prompt`) et l'invite de l'outil Agent | L'historique de conversation du parent ou les résultats des outils |

198| Le CLAUDE.md du projet (chargé via `settingSources`) | Le contenu des compétences préchargées, sauf s'il est listé dans `AgentDefinition.skills` |

199| Les définitions d'outils (héritées du parent, ou le sous-ensemble dans `tools`) | L'invite système du parent |

200

201<Note>

202 Le parent reçoit le message final du sous-agent tel quel comme résultat de l'outil Agent, mais peut le résumer dans sa propre réponse. Pour préserver la sortie du sous-agent tel quel dans la réponse visible par l'utilisateur, incluez une instruction pour le faire dans l'invite ou l'option `systemPrompt` que vous transmettez à l'appel `query()` **principal**.

203</Note>

204

205## Invocation des sous-agents

206

207### Invocation automatique

208

209Claude décide automatiquement quand invoquer les sous-agents en fonction de la tâche et de la `description` de chaque sous-agent. Par exemple, si vous définissez un sous-agent `performance-optimizer` avec la description « Spécialiste de l'optimisation des performances pour l'optimisation des requêtes », Claude l'invoquera lorsque votre invite mentionne l'optimisation des requêtes.

210

211Écrivez des descriptions claires et spécifiques pour que Claude puisse faire correspondre les tâches au bon sous-agent.

212

213### Invocation explicite

214

215Pour garantir que Claude utilise un sous-agent spécifique, mentionnez-le par son nom dans votre invite :

216

217```text theme={null}

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

219```

220

221Cela contourne la correspondance automatique et invoque directement le sous-agent nommé.

222

223### Configuration d'agent dynamique

224

225Vous pouvez créer des définitions d'agent dynamiquement en fonction des conditions d'exécution. Cet exemple crée un examinateur de sécurité avec différents niveaux de rigueur, en utilisant un modèle plus puissant pour les révisions strictes.

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## Détection de l'invocation de sous-agents

300

301Les sous-agents sont invoqués via l'outil Agent. Pour détecter quand un sous-agent est invoqué, vérifiez les blocs `tool_use` où `name` est `"Agent"`. Les messages provenant du contexte d'un sous-agent incluent un champ `parent_tool_use_id`.

302

303<Note>

304 Le nom de l'outil a été renommé de `"Task"` à `"Agent"` dans Claude Code v2.1.63. Les versions actuelles du SDK émettent `"Agent"` dans les blocs `tool_use` mais utilisent toujours `"Task"` dans la liste des outils `system:init` et dans `result.permission_denials[].tool_name`. Vérifier les deux valeurs dans `block.name` assure la compatibilité entre les versions du SDK.

305</Note>

306

307Cet exemple itère à travers les messages en continu, enregistrant quand un sous-agent est invoqué et quand les messages suivants proviennent du contexte d'exécution de ce sous-agent.

308

309<Note>

310 La structure du message diffère entre les SDK. En Python, les blocs de contenu sont accessibles directement via `message.content`. En TypeScript, `SDKAssistantMessage` enveloppe le message de l'API Claude, donc le contenu est accessible via `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## Reprise des sous-agents

393

394Les sous-agents peuvent être repris pour continuer là où ils se sont arrêtés. Les sous-agents repris conservent leur historique de conversation complet, y compris tous les appels d'outils précédents, les résultats et le raisonnement. Le sous-agent reprend exactement là où il s'est arrêté plutôt que de recommencer à zéro.

395

396Lorsqu'un sous-agent se termine, Claude reçoit son ID d'agent dans le résultat de l'outil Agent. Pour reprendre un sous-agent par programmation :

397

3981. **Capturez l'ID de session** : Extrayez `session_id` des messages lors de la première requête

3992. **Extrayez l'ID d'agent** : Analysez `agentId` du contenu du message

4003. **Reprenez la session** : Passez `resume: sessionId` dans les options de la deuxième requête, et incluez l'ID d'agent dans votre invite

401

402<Note>

403 Vous devez reprendre la même session pour accéder à la transcription du sous-agent. Chaque appel `query()` démarre une nouvelle session par défaut, donc passez `resume: sessionId` pour continuer dans la même session.

404

405 Si vous utilisez un agent personnalisé (pas un agent intégré), vous devez également transmettre la même définition d'agent dans le paramètre `agents` pour les deux requêtes.

406</Note>

407

408L'exemple ci-dessous démontre ce flux : la première requête exécute un sous-agent et capture l'ID de session et l'ID d'agent, puis la deuxième requête reprend la session pour poser une question de suivi qui nécessite le contexte de la première analyse.

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

504Les transcriptions des sous-agents persistent indépendamment de la conversation principale :

505

506* **Compaction de la conversation principale** : Lorsque la conversation principale se compacte, les transcriptions des sous-agents ne sont pas affectées. Elles sont stockées dans des fichiers séparés.

507* **Persistance de la session** : Les transcriptions des sous-agents persistent au sein de leur session. Vous pouvez reprendre un sous-agent après avoir redémarré Claude Code en reprenant la même session.

508* **Nettoyage automatique** : Les transcriptions sont nettoyées en fonction du paramètre `cleanupPeriodDays` (par défaut : 30 jours).

509

510## Restrictions d'outils

511

512Les sous-agents peuvent avoir un accès aux outils restreint via le champ `tools` :

513

514* **Omettez le champ** : l'agent hérite de tous les outils disponibles (par défaut)

515* **Spécifiez les outils** : l'agent ne peut utiliser que les outils listés

516

517Cet exemple crée un agent d'analyse en lecture seule qui peut examiner le code mais ne peut pas modifier les fichiers ou exécuter des commandes.

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### Combinaisons d'outils courantes

572

573| Cas d'usage | Outils | Description |

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

575| Analyse en lecture seule | `Read`, `Grep`, `Glob` | Peut examiner le code mais pas modifier ou exécuter |

576| Exécution de tests | `Bash`, `Read`, `Grep` | Peut exécuter des commandes et analyser la sortie |

577| Modification de code | `Read`, `Edit`, `Write`, `Grep`, `Glob` | Accès complet en lecture/écriture sans exécution de commandes |

578| Accès complet | Tous les outils | Hérite de tous les outils du parent (omettez le champ `tools`) |

579

580## Dépannage

581

582### Claude ne délègue pas aux sous-agents

583

584Si Claude complète les tâches directement au lieu de déléguer à votre sous-agent :

585

5861. **Incluez l'outil Agent** : les sous-agents sont invoqués via l'outil Agent, donc il doit être dans `allowedTools`

5872. **Utilisez des invites explicites** : mentionnez le sous-agent par son nom dans votre invite (par exemple, « Utilisez l'agent code-reviewer pour... »)

5883. **Écrivez une description claire** : expliquez exactement quand le sous-agent doit être utilisé pour que Claude puisse faire correspondre les tâches de manière appropriée

589

590### Les agents basés sur le système de fichiers ne se chargent pas

591

592Les agents définis dans `.claude/agents/` sont chargés au démarrage uniquement. Si vous créez un nouveau fichier d'agent pendant que Claude Code s'exécute, redémarrez la session pour le charger.

593

594### Windows : échecs d'invite longue

595

596Sur Windows, les sous-agents avec des invites très longues peuvent échouer en raison des limites de longueur de ligne de commande (8191 caractères). Gardez les invites concises ou utilisez des agents basés sur le système de fichiers pour les instructions complexes.

597

598## Documentation connexe

599

600* [Sous-agents Claude Code](/fr/sub-agents) : documentation complète des sous-agents incluant les définitions basées sur le système de fichiers

601* [Aperçu du SDK](/fr/agent-sdk/overview) : prise en main du Claude Agent SDK

agent-sdk/typescript.md +4 −2

Details

358| `sessionStore` | [`SessionStore`](/fr/agent-sdk/session-storage#the-sessionstore-interface) | `undefined` | Refléter les transcriptions de session vers un backend externe pour que n'importe quel hôte puisse les reprendre. Voir [Persister les sessions vers un stockage externe](/fr/agent-sdk/session-storage) |358| `sessionStore` | [`SessionStore`](/fr/agent-sdk/session-storage#the-sessionstore-interface) | `undefined` | Refléter les transcriptions de session vers un backend externe pour que n'importe quel hôte puisse les reprendre. Voir [Persister les sessions vers un stockage externe](/fr/agent-sdk/session-storage) |

359| `settings` | `string \| Settings` | `undefined` | Objet [paramètres](/fr/settings) en ligne ou chemin vers un fichier de paramètres. Remplit la couche de paramètres d'indicateur dans l'[ordre de précédence](/fr/settings#settings-precedence). Modifiez à l'exécution avec [`applyFlagSettings()`](#applyflagsettings) |359| `settings` | `string \| Settings` | `undefined` | Objet [paramètres](/fr/settings) en ligne ou chemin vers un fichier de paramètres. Remplit la couche de paramètres d'indicateur dans l'[ordre de précédence](/fr/settings#settings-precedence). Modifiez à l'exécution avec [`applyFlagSettings()`](#applyflagsettings) |

360| `settingSources` | [`SettingSource`](#settingsource)`[]` | Paramètres par défaut de CLI (toutes les sources) | Contrôler les paramètres du système de fichiers à charger. Passez `[]` pour désactiver les paramètres utilisateur, projet et locaux. Les paramètres de politique gérée se chargent indépendamment. Voir [Utiliser les fonctionnalités Claude Code](/fr/agent-sdk/claude-code-features#what-settingsources-does-not-control) |360| `settingSources` | [`SettingSource`](#settingsource)`[]` | Paramètres par défaut de CLI (toutes les sources) | Contrôler les paramètres du système de fichiers à charger. Passez `[]` pour désactiver les paramètres utilisateur, projet et locaux. Les paramètres de politique gérée se chargent indépendamment. Voir [Utiliser les fonctionnalités Claude Code](/fr/agent-sdk/claude-code-features#what-settingsources-does-not-control) |

361| `skills` | `string[] \| 'all'` | `undefined` | Compétences disponibles pour la session. Passez `'all'` pour activer chaque compétence découverte, ou une liste de noms de compétences. Quand défini, le SDK active l'outil Skill automatiquement sans le lister dans `allowedTools`. Voir [Compétences](/fr/agent-sdk/skills) |

361| `spawnClaudeCodeProcess` | `(options: SpawnOptions) => SpawnedProcess` | `undefined` | Fonction personnalisée pour générer le processus Claude Code. Utilisez pour exécuter Claude Code dans des VM, des conteneurs ou des environnements distants |362| `spawnClaudeCodeProcess` | `(options: SpawnOptions) => SpawnedProcess` | `undefined` | Fonction personnalisée pour générer le processus Claude Code. Utilisez pour exécuter Claude Code dans des VM, des conteneurs ou des environnements distants |

528```529```

529 530

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

532| `description` | Oui | Description en langage naturel de quand utiliser cet agent |533| `description` | Oui | Description en langage naturel de quand utiliser cet agent |

533| `tools` | Non | Tableau de noms d'outils autorisés. S'il est omis, hérite tous les outils du parent |534| `tools` | Non | Tableau de noms d'outils autorisés. S'il est omis, hérite tous les outils du parent. Pour précharger les compétences dans le contexte de l'agent, utilisez le champ `skills` plutôt que de lister `'Skill'` ici |

534| `disallowedTools` | Non | Tableau de noms d'outils à explicitement interdire pour cet agent |535| `disallowedTools` | Non | Tableau de noms d'outils à explicitement interdire pour cet agent |

535| `prompt` | Oui | L'invite système de l'agent |536| `prompt` | Oui | L'invite système de l'agent |

536| `model` | Non | Remplacement de modèle pour cet agent. Accepte un alias tel que `'sonnet'`, `'opus'`, `'haiku'`, `'inherit'`, ou un ID de modèle complet. S'il est omis ou `'inherit'`, utilise le modèle principal |537| `model` | Non | Remplacement de modèle pour cet agent. Accepte un alias tel que `'sonnet'`, `'opus'`, `'haiku'`, `'inherit'`, ou un ID de modèle complet. S'il est omis ou `'inherit'`, utilise le modèle principal |

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# Interface TypeScript SDK V2 (aperçu)~~5# API de session TypeScript SDK V2 (dépréciée)

6 6

~~7> Aperçu du SDK Agent TypeScript V2 simplifié, avec des modèles send/stream basés sur les sessions pour les conversations multi-tours.~~7> Référence pour l'API de session dépréciée V2 du SDK Agent TypeScript, avec des modèles send/stream basés sur les sessions pour les conversations multi-tours.

8 8

9<Warning>9<Warning>

10 L'interface V2 est un **aperçu instable**. Les API peuvent changer en fonction des commentaires avant de devenir stables. Certaines fonctionnalités comme le forking de session ne sont disponibles que dans le [SDK V1](/fr/agent-sdk/typescript).10 Les fonctions de l'API de session V2 `unstable_v2_createSession`, `unstable_v2_resumeSession` et `unstable_v2_prompt` sont dépréciées et seront supprimées dans une version future. Utilisez plutôt l'[API V1 `query()`](/fr/agent-sdk/typescript).

11</Warning>11</Warning>

12 12

13Le SDK Agent TypeScript V2 de Claude supprime le besoin de générateurs asynchrones et de coordination de rendement. Cela rend les conversations multi-tours plus simples, au lieu de gérer l'état du générateur entre les tours, chaque tour est un cycle `send()`/`stream()` séparé. La surface de l'API se réduit à trois concepts :13V2 était une API de session expérimentale qui supprimait le besoin de générateurs asynchrones et de coordination de rendement. Au lieu de gérer l'état du générateur entre les tours, chaque tour était un cycle `send()`/`stream()` séparé. La surface de l'API se réduisait à trois concepts :

14 14

15* `createSession()` / `resumeSession()` : Démarrer ou continuer une conversation15* `createSession()` / `resumeSession()` : Démarrer ou continuer une conversation

16* `session.send()` : Envoyer un message16* `session.send()` : Envoyer un message

380 380

381## Disponibilité des fonctionnalités381## Disponibilité des fonctionnalités

382 382

383Toutes les fonctionnalités V1 ne sont pas encore disponibles en V2. Les éléments suivants nécessitent l'utilisation du [SDK V1](/fr/agent-sdk/typescript) :383L'API de session V2 ne supporte pas toutes les fonctionnalités V1. Les éléments suivants nécessitent l'utilisation du [SDK V1](/fr/agent-sdk/typescript) :

384 384

385* Forking de session (option `forkSession`)385* Forking de session (option `forkSession`)

386* Certains modèles de flux d'entrée avancés386* Certains modèles de flux d'entrée avancés

387 387

388## Commentaires

~~389~~

390Partagez vos commentaires sur l'interface V2 avant qu'elle ne devienne stable. Signalez les problèmes et les suggestions via [GitHub Issues](https://github.com/anthropics/claude-code/issues).

~~391~~

392## Voir aussi388## Voir aussi

393 389

394* [Référence SDK TypeScript (V1)](/fr/agent-sdk/typescript) - Documentation complète du SDK V1390* [Référence SDK TypeScript (V1)](/fr/agent-sdk/typescript) - Documentation complète du SDK V1

agent-teams.md +3 −3

Details

402 402

403Les équipes d'agents sont expérimentales. Les limitations actuelles à connaître :403Les équipes d'agents sont expérimentales. Les limitations actuelles à connaître :

404 404

405* **Pas de reprise de session avec les coéquipiers in-process** : `/resume` et `/rewind` ne restaurent pas les coéquipiers in-process. Après la reprise d'une session, le chef peut tenter de envoyer un message aux coéquipiers qui n'existent plus. Si cela se produit, dites au chef de générer de nouveaux coéquipiers.405* **Pas de reprise de session avec les coéquipiers in-process** : `/resume` et `/rewind` ne restaurent pas les coéquipiers in-process. Après la reprise d'une session, le chef peut tenter d'envoyer un message aux coéquipiers qui n'existent plus. Si cela se produit, dites au chef de générer de nouveaux coéquipiers.

406* **L'état des tâches peut être en retard** : les coéquipiers échouent parfois à marquer les tâches comme complètes, ce qui bloque les tâches dépendantes. Si une tâche semble bloquée, vérifiez si le travail est réellement terminé et mettez à jour l'état de la tâche manuellement ou dites au chef de pousser le coéquipier.406* **L'état des tâches peut être en retard** : les coéquipiers échouent parfois à marquer les tâches comme complètes, ce qui bloque les tâches dépendantes. Si une tâche semble bloquée, vérifiez si le travail est réellement terminé et mettez à jour l'état de la tâche manuellement ou dites au chef de pousser le coéquipier.

407* **L'arrêt peut être lent** : les coéquipiers terminent leur demande actuelle ou appel d'outil avant de s'arrêter, ce qui peut prendre du temps.407* **L'arrêt peut être lent** : les coéquipiers terminent leur demande actuelle ou appel d'outil avant de s'arrêter, ce qui peut prendre du temps.

408* **Une équipe par session** : un chef ne peut gérer qu'une seule équipe à la fois. Nettoyez l'équipe actuelle avant de démarrer une nouvelle.408* **Une équipe à la fois** : un chef ne peut gérer qu'une seule équipe. Nettoyez l'équipe actuelle avant de créer une nouvelle.

409* **Pas d'équipes imbriquées** : les coéquipiers ne peuvent pas générer leurs propres équipes ou coéquipiers. Seul le chef peut gérer l'équipe.409* **Pas d'équipes imbriquées** : les coéquipiers ne peuvent pas générer leurs propres équipes ou coéquipiers. Seul le chef peut gérer l'équipe.

410* **Le chef est fixe** : la session qui crée l'équipe est le chef pour sa durée de vie. Vous ne pouvez pas promouvoir un coéquipier en chef ou transférer le leadership.410* **Le chef est fixe** : la session qui crée l'équipe est le chef pour sa durée de vie. Vous ne pouvez pas promouvoir un coéquipier en chef ou transférer le leadership.

411* **Permissions définies au moment de la génération** : tous les coéquipiers commencent avec le mode de permission du chef. Vous pouvez modifier les modes de coéquipiers individuels après la génération, mais vous ne pouvez pas définir les modes par coéquipier au moment de la génération.411* **Permissions définies au moment de la génération** : tous les coéquipiers commencent avec le mode de permission du chef. Vous pouvez modifier les modes de coéquipiers individuels après la génération, mais vous ne pouvez pas définir les modes par coéquipier au moment de la génération.

420Explorez les approches connexes pour le travail parallèle et la délégation :420Explorez les approches connexes pour le travail parallèle et la délégation :

421 421

422* **Délégation légère** : les [subagents](/fr/sub-agents) génèrent des agents auxiliaires pour la recherche ou la vérification au sein de votre session, mieux pour les tâches qui n'ont pas besoin de coordination inter-agents422* **Délégation légère** : les [subagents](/fr/sub-agents) génèrent des agents auxiliaires pour la recherche ou la vérification au sein de votre session, mieux pour les tâches qui n'ont pas besoin de coordination inter-agents

423* **Sessions parallèles manuelles** : les [Git worktrees](/fr/common-workflows#run-parallel-claude-code-sessions-with-git-worktrees) vous permettent d'exécuter plusieurs sessions Claude Code vous-même sans coordination d'équipe automatisée423* **Sessions parallèles manuelles** : les [Git worktrees](/fr/worktrees) vous permettent d'exécuter plusieurs sessions Claude Code vous-même sans coordination d'équipe automatisée

424* **Comparer les approches** : consultez la comparaison [subagent vs équipe d'agents](/fr/features-overview#compare-similar-features) pour une répartition côte à côte424* **Comparer les approches** : consultez la comparaison [subagent vs équipe d'agents](/fr/features-overview#compare-similar-features) pour une répartition côte à côte

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## Prérequis81## Prérequis

192 82

cli-reference.md +2 −2

Details

84| `--permission-mode` | Commencer dans un [mode de permission](/fr/permission-modes) spécifié. Accepte `default`, `acceptEdits`, `plan`, `auto`, `dontAsk`, ou `bypassPermissions`. Remplace `defaultMode` des fichiers de paramètres | `claude --permission-mode plan` |84| `--permission-mode` | Commencer dans un [mode de permission](/fr/permission-modes) spécifié. Accepte `default`, `acceptEdits`, `plan`, `auto`, `dontAsk`, ou `bypassPermissions`. Remplace `defaultMode` des fichiers de paramètres | `claude --permission-mode plan` |

85| `--permission-prompt-tool` | Spécifier un outil MCP pour gérer les invites de permission en mode non interactif | `claude -p --permission-prompt-tool mcp_auth_tool "query"` |85| `--permission-prompt-tool` | Spécifier un outil MCP pour gérer les invites de permission en mode non interactif | `claude -p --permission-prompt-tool mcp_auth_tool "query"` |

86| `--plugin-dir` | Charger un plugin à partir d'un répertoire ou d'une archive `.zip` pour cette session uniquement. Chaque drapeau prend un chemin. Répétez le drapeau pour plusieurs plugins : `--plugin-dir A --plugin-dir B.zip` | `claude --plugin-dir ./my-plugin` |86| `--plugin-dir` | Charger un plugin à partir d'un répertoire ou d'une archive `.zip` pour cette session uniquement. Chaque drapeau prend un chemin. Répétez le drapeau pour plusieurs plugins : `--plugin-dir A --plugin-dir B.zip` | `claude --plugin-dir ./my-plugin` |

87| `--plugin-url` | Récupérer une archive `.zip` de plugin à partir d'une URL pour cette session uniquement. Chaque drapeau prend une URL. Répétez le drapeau pour plusieurs plugins | `claude --plugin-url https://example.com/plugin.zip` |87| `--plugin-url` | Récupérer une archive `.zip` de plugin à partir d'une URL pour cette session uniquement. Répétez le drapeau pour plusieurs plugins, ou passez des URL séparées par des espaces dans une seule valeur entre guillemets | `claude --plugin-url https://example.com/plugin.zip` |

88| `--print`, `-p` | Imprimer la réponse sans mode interactif (voir la [documentation du SDK Agent](/fr/agent-sdk/overview) pour les détails d'utilisation programmatique) | `claude -p "query"` |88| `--print`, `-p` | Imprimer la réponse sans mode interactif (voir la [documentation du SDK Agent](/fr/agent-sdk/overview) pour les détails d'utilisation programmatique) | `claude -p "query"` |

90| `--remote-control`, `--rc` | Démarrer une session interactive avec [Remote Control](/fr/remote-control#start-a-remote-control-session) activé afin que vous puissiez également le contrôler depuis claude.ai ou l'application Claude. Optionnellement, passez un nom pour la session | `claude --remote-control "My Project"` |90| `--remote-control`, `--rc` | Démarrer une session interactive avec [Remote Control](/fr/remote-control#start-a-remote-control-session) activé afin que vous puissiez également le contrôler depuis claude.ai ou l'application Claude. Optionnellement, passez un nom pour la session | `claude --remote-control "My Project"` |

103| `--tools` | Restreindre les outils intégrés que Claude peut utiliser. Utilisez `""` pour désactiver tous, `"default"` pour tous, ou des noms d'outils comme `"Bash,Edit,Read"` | `claude --tools "Bash,Edit,Read"` |103| `--tools` | Restreindre les outils intégrés que Claude peut utiliser. Utilisez `""` pour désactiver tous, `"default"` pour tous, ou des noms d'outils comme `"Bash,Edit,Read"` | `claude --tools "Bash,Edit,Read"` |

104| `--verbose` | Activer la journalisation détaillée, affiche la sortie complète tour par tour. Remplace le paramètre [`viewMode`](/fr/settings#available-settings) pour cette session | `claude --verbose` |104| `--verbose` | Activer la journalisation détaillée, affiche la sortie complète tour par tour. Remplace le paramètre [`viewMode`](/fr/settings#available-settings) pour cette session | `claude --verbose` |

106| `--worktree`, `-w` | Démarrer Claude dans un [git worktree](/fr/worktrees) isolé à `<repo>/.claude/worktrees/<name>`. Si aucun nom n'est donné, un est généré automatiquement | `claude -w feature-auth` |106| `--worktree`, `-w` | Démarrer Claude dans un [git worktree](/fr/worktrees) isolé à `<repo>/.claude/worktrees/<name>`. Si aucun nom n'est donné, un est généré automatiquement. Passez `#<number>` ou une URL de demande de tirage GitHub pour récupérer cette PR de `origin` et créer une branche du worktree à partir de celle-ci | `claude -w feature-auth` |

107 107

108### Drapeaux d'invite système108### Drapeaux d'invite système

109 109

commands.md +21 −3

Details

12 12

13Une commande n'est reconnue qu'au début de votre message. Le texte qui suit le nom de la commande lui est transmis en tant qu'arguments.13Une commande n'est reconnue qu'au début de votre message. Le texte qui suit le nom de la commande lui est transmis en tant qu'arguments.

14 14

15Le tableau ci-dessous répertorie toutes les commandes incluses dans Claude Code. Les entrées marquées **[Skill](/fr/skills#bundled-skills)** sont des skills fournis. Ils utilisent le même mécanisme que les skills que vous écrivez vous-même : une invite remise à Claude, que Claude peut également invoquer automatiquement si pertinent. Tout le reste est une commande intégrée dont le comportement est codé dans le CLI. Pour ajouter vos propres commandes, consultez [skills](/fr/skills).15## Commandes au cours d'un workflow typique

17La plupart des commandes sont utiles à un moment spécifique d'une session, de la configuration d'un projet à la livraison d'une modification.

19**Première session dans un référentiel.** Exécutez `/init` pour générer un `CLAUDE.md` de démarrage, puis `/memory` pour l'affiner. Utilisez `/mcp` et `/agents` pour configurer les serveurs ou sous-agents dont le projet a besoin, et `/permissions` pour définir les règles d'approbation que vous souhaitez.

21**Pendant une tâche.** `/plan` bascule en mode plan avant une modification importante. `/model` et `/effort` ajustent le temps de réflexion que vous dépensez. Lorsque la conversation devient longue, `/context` montre où la fenêtre va et `/compact` la résume ; utilisez `/btw` pour une question rapide qui ne devrait pas gonfler l'historique.

23**Avant de livrer.** `/diff` montre ce qui a changé, `/simplify` examine les fichiers récents et applique des corrections de qualité et d'efficacité, et `/review` ou `/security-review` donnent une lecture plus approfondie en lecture seule.

16 24

17Toutes les commandes ne s'affichent pas pour tous les utilisateurs. La disponibilité dépend de votre plateforme, de votre plan et de votre environnement. Par exemple, `/desktop` ne s'affiche que sur macOS et Windows, et `/upgrade` ne s'affiche que sur les plans Pro et Max.25**Entre les sessions.** `/clear` démarre une nouvelle tâche tout en conservant la mémoire du projet. `/resume` et `/branch` vous permettent de revenir à ou de forker une conversation antérieure. `/teleport` extrait une session web dans ce terminal, et `/remote-control` vous permet de continuer cette session locale depuis un autre appareil.

27**Quand quelque chose ne va pas.** `/rewind` ramène le code et la conversation à un point de contrôle. `/doctor` et `/debug` diagnostiquent les problèmes d'installation et d'exécution, et `/feedback` signale un bug avec le contexte de la session joint.

29## Toutes les commandes

31Le tableau ci-dessous répertorie toutes les commandes incluses dans Claude Code. Les entrées marquées **[Skill](/fr/skills#bundled-skills)** sont des skills fournis. Ils utilisent le même mécanisme que les skills que vous écrivez vous-même : une invite remise à Claude, que Claude peut également invoquer automatiquement si pertinent. Tout le reste est une commande intégrée dont le comportement est codé dans le CLI. Pour ajouter vos propres commandes, consultez [skills](/fr/skills).

18 32

19Dans le tableau ci-dessous, `<arg>` indique un argument obligatoire et `[arg]` indique un argument facultatif.33Dans le tableau ci-dessous, `<arg>` indique un argument obligatoire et `[arg]` indique un argument facultatif.

20 34

35<Note>

36 Toutes les commandes ne s'affichent pas pour tous les utilisateurs. La disponibilité dépend de votre plateforme, de votre plan et de votre environnement. Par exemple, `/desktop` ne s'affiche que sur macOS et Windows, et `/upgrade` ne s'affiche que sur les plans Pro et Max.

37</Note>

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

23| `/add-dir <path>` | Ajouter un répertoire de travail pour l'accès aux fichiers pendant la session actuelle. La plupart de la configuration `.claude/` [n'est pas découverte](/fr/permissions#additional-directories-grant-file-access-not-configuration) à partir du répertoire ajouté. Vous pouvez ensuite reprendre la session à partir du répertoire ajouté avec `--continue` ou `--resume` |41| `/add-dir <path>` | Ajouter un répertoire de travail pour l'accès aux fichiers pendant la session actuelle. La plupart de la configuration `.claude/` [n'est pas découverte](/fr/permissions#additional-directories-grant-file-access-not-configuration) à partir du répertoire ajouté. Vous pouvez ensuite reprendre la session à partir du répertoire ajouté avec `--continue` ou `--resume` |

80| `/review [PR]` | Examiner une demande de tirage localement dans votre session actuelle. Pour un examen plus approfondi basé sur le cloud, consultez [`/ultrareview`](/fr/ultrareview) |98| `/review [PR]` | Examiner une demande de tirage localement dans votre session actuelle. Pour un examen plus approfondi basé sur le cloud, consultez [`/ultrareview`](/fr/ultrareview) |

81| `/rewind` | Rembobiner la conversation et/ou le code à un point antérieur, ou résumer à partir d'un message sélectionné. Consultez [checkpointing](/fr/checkpointing). Alias : `/checkpoint`, `/undo` |99| `/rewind` | Rembobiner la conversation et/ou le code à un point antérieur, ou résumer à partir d'un message sélectionné. Consultez [checkpointing](/fr/checkpointing). Alias : `/checkpoint`, `/undo` |

83| `/schedule [description]` | Créer, mettre à jour, lister ou exécuter des [routines](/fr/routines). Claude vous guide à travers la configuration de manière conversationnelle. Alias : `/routines` |101| `/schedule [description]` | Créer, mettre à jour, lister ou exécuter des [routines](/fr/routines), qui s'exécutent sur l'infrastructure cloud gérée par Anthropic. Claude vous guide à travers la configuration de manière conversationnelle. Alias : `/routines` |

84| `/security-review` | Analyser les modifications en attente sur la branche actuelle pour les vulnérabilités de sécurité. Examine le diff git et identifie les risques comme l'injection, les problèmes d'authentification et l'exposition de données |102| `/security-review` | Analyser les modifications en attente sur la branche actuelle pour les vulnérabilités de sécurité. Examine le diff git et identifie les risques comme l'injection, les problèmes d'authentification et l'exposition de données |

85| `/setup-bedrock` | Configurer l'authentification [Amazon Bedrock](/fr/amazon-bedrock), la région et les épingles de modèle via un assistant interactif. Visible uniquement lorsque `CLAUDE_CODE_USE_BEDROCK=1` est défini. Les utilisateurs de Bedrock pour la première fois peuvent également accéder à cet assistant à partir de l'écran de connexion |103| `/setup-bedrock` | Configurer l'authentification [Amazon Bedrock](/fr/amazon-bedrock), la région et les épingles de modèle via un assistant interactif. Visible uniquement lorsque `CLAUDE_CODE_USE_BEDROCK=1` est défini. Les utilisateurs de Bedrock pour la première fois peuvent également accéder à cet assistant à partir de l'écran de connexion |

86| `/setup-vertex` | Configurer l'authentification [Google Vertex AI](/fr/google-vertex-ai), le projet, la région et les épingles de modèle via un assistant interactif. Visible uniquement lorsque `CLAUDE_CODE_USE_VERTEX=1` est défini. Les utilisateurs de Vertex AI pour la première fois peuvent également accéder à cet assistant à partir de l'écran de connexion |104| `/setup-vertex` | Configurer l'authentification [Google Vertex AI](/fr/google-vertex-ai), le projet, la région et les épingles de modèle via un assistant interactif. Visible uniquement lorsque `CLAUDE_CODE_USE_VERTEX=1` est défini. Les utilisateurs de Vertex AI pour la première fois peuvent également accéder à cet assistant à partir de l'écran de connexion |

desktop.md +18 −1

Details

564 564

565Chaque entrée nécessite `id`, `name` et `sshHost`. Les champs `sshPort`, `sshIdentityFile` et `startDirectory` sont optionnels. Les utilisateurs peuvent également ajouter `sshConfigs` à leur propre `~/.claude/settings.json`, qui est l'endroit où les connexions ajoutées via la boîte de dialogue sont stockées.565Chaque entrée nécessite `id`, `name` et `sshHost`. Les champs `sshPort`, `sshIdentityFile` et `startDirectory` sont optionnels. Les utilisateurs peuvent également ajouter `sshConfigs` à leur propre `~/.claude/settings.json`, qui est l'endroit où les connexions ajoutées via la boîte de dialogue sont stockées.

566 566

567#### Restreindre les hôtes SSH auxquels les utilisateurs peuvent se connecter

568

569Les administrateurs peuvent limiter les sessions SSH de Desktop à un ensemble approuvé d'hôtes en ajoutant `sshHostAllowlist` à un fichier de [paramètres gérés](/fr/settings#settings-precedence). Lorsqu'il est défini, les utilisateurs ne peuvent se connecter qu'à des hôtes dont le nom d'hôte résolu correspond à l'un des modèles. Définissez-le sur un tableau vide pour désactiver complètement les sessions SSH.

570

571L'exemple suivant autorise les connexions à n'importe quel hôte sous `devboxes.example.com` et à un seul hôte bastion nommé :

572

573```json theme={null}

574{

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

576}

577```

578

579Les modèles sont insensibles à la casse. `*` correspond à n'importe quel hôte, et `*.example.com` correspond à `example.com` et à n'importe quel sous-domaine. Tout le reste est une correspondance exacte. La vérification s'exécute sur le nom d'hôte après la résolution `~/.ssh/config` via `ssh -G`, de sorte que les alias `Host` et les entrées `ProxyCommand`/`ProxyJump` sont autorisés tant que le `HostName` résolu correspond.

580

581`sshHostAllowlist` est lu uniquement à partir des paramètres gérés ; les valeurs dans les paramètres utilisateur ou projet sont ignorées. Seule l'application Claude Desktop honore ce paramètre ; la CLI Claude Code et les extensions IDE ne le lisent pas, et il ne restreint pas les commandes `ssh` exécutées via l'outil Bash. Il gouverne les hôtes auxquels l'application Desktop se connecte, pas la sortie réseau, donc associez-le aux contrôles réseau ou zero-trust de votre organisation si vous avez besoin d'une limite stricte.

582

567## Configuration d'entreprise583## Configuration d'entreprise

568 584

569Les organisations sur les plans Team ou Enterprise peuvent gérer le comportement de l'application de bureau via les contrôles de la console d'administration, les fichiers de paramètres gérés et les politiques de gestion des appareils.585Les organisations sur les plans Team ou Enterprise peuvent gérer le comportement de l'application de bureau via les contrôles de la console d'administration, les fichiers de paramètres gérés et les politiques de gestion des appareils.

582Les paramètres gérés remplacent les paramètres du projet et de l'utilisateur et s'appliquent quand Desktop génère des sessions CLI. Vous pouvez définir ces clés dans le fichier [paramètres gérés](/fr/settings#settings-precedence) de votre organisation ou les pousser à distance via la console d'administration.598Les paramètres gérés remplacent les paramètres du projet et de l'utilisateur et s'appliquent quand Desktop génère des sessions CLI. Vous pouvez définir ces clés dans le fichier [paramètres gérés](/fr/settings#settings-precedence) de votre organisation ou les pousser à distance via la console d'administration.

583 599

584| Clé | Description |600| Clé | Description |

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

586| `permissions.disableBypassPermissionsMode` | définissez sur `"disable"` pour empêcher les utilisateurs d'activer le mode de contournement des permissions. |602| `permissions.disableBypassPermissionsMode` | définissez sur `"disable"` pour empêcher les utilisateurs d'activer le mode de contournement des permissions. |

587| `disableAutoMode` | définissez sur `"disable"` pour empêcher les utilisateurs d'activer le mode [Auto](/fr/permission-modes#eliminate-prompts-with-auto-mode). Supprime Auto du sélecteur de mode. Également accepté sous `permissions`. |603| `disableAutoMode` | définissez sur `"disable"` pour empêcher les utilisateurs d'activer le mode [Auto](/fr/permission-modes#eliminate-prompts-with-auto-mode). Supprime Auto du sélecteur de mode. Également accepté sous `permissions`. |

588| `autoMode` | personnalisez ce que le classificateur du mode auto fait confiance et bloque dans votre organisation. Voir [Configurer le mode auto](/fr/auto-mode-config). |604| `autoMode` | personnalisez ce que le classificateur du mode auto fait confiance et bloque dans votre organisation. Voir [Configurer le mode auto](/fr/auto-mode-config). |

589| `sshConfigs` | pré-configurez les [connexions SSH](#pre-configure-ssh-connections-for-your-team) qui apparaissent dans la liste déroulante de l'environnement. Les utilisateurs ne peuvent pas modifier ou supprimer les connexions gérées. |605| `sshConfigs` | pré-configurez les [connexions SSH](#pre-configure-ssh-connections-for-your-team) qui apparaissent dans la liste déroulante de l'environnement. Les utilisateurs ne peuvent pas modifier ou supprimer les connexions gérées. |

606| `sshHostAllowlist` | restreignez les [sessions SSH](#restrict-which-ssh-hosts-users-can-connect-to) aux hôtes dont le nom d'hôte résolu correspond à l'un de ces modèles. Un tableau vide désactive les sessions SSH. Lecture à partir des paramètres gérés uniquement. |

590 607

591Un fichier de paramètres gérés déployé sur le disque de chaque machine s'applique aux sessions Desktop. Les paramètres gérés poussés à distance via la console d'administration atteignent actuellement uniquement les sessions CLI et IDE, donc pour les déploiements Desktop, distribuez le fichier via MDM ou utilisez les [contrôles de la console d'administration](#admin-console-controls) ci-dessus.608Un fichier de paramètres gérés déployé sur le disque de chaque machine s'applique aux sessions Desktop. Les paramètres gérés poussés à distance via la console d'administration atteignent actuellement uniquement les sessions CLI et IDE, donc pour les déploiements Desktop, distribuez le fichier via MDM ou utilisez les [contrôles de la console d'administration](#admin-console-controls) ci-dessus.

592 609

env-vars.md +3 −1

Details

92| `CLAUDE_CODE_EFFORT_LEVEL` | Définissez le niveau d'effort pour les modèles pris en charge. Valeurs : `low`, `medium`, `high`, `xhigh`, `max` ou `auto` pour utiliser le niveau par défaut du modèle. Les niveaux disponibles dépendent du modèle. Prend la priorité sur `/effort` et le paramètre `effortLevel`. Voir [Ajuster le niveau d'effort](/fr/model-config#adjust-effort-level) |92| `CLAUDE_CODE_EFFORT_LEVEL` | Définissez le niveau d'effort pour les modèles pris en charge. Valeurs : `low`, `medium`, `high`, `xhigh`, `max` ou `auto` pour utiliser le niveau par défaut du modèle. Les niveaux disponibles dépendent du modèle. Prend la priorité sur `/effort` et le paramètre `effortLevel`. Voir [Ajuster le niveau d'effort](/fr/model-config#adjust-effort-level) |

93| `CLAUDE_CODE_ENABLE_AWAY_SUMMARY` | Remplacer la disponibilité du [récapitulatif de session](/fr/interactive-mode#session-recap). Définissez sur `0` pour forcer les récapitulatifs désactivés indépendamment du bouton bascule `/config`. Définissez sur `1` pour forcer les récapitulatifs activés lorsque [`awaySummaryEnabled`](/fr/settings#available-settings) est `false`. Prend la priorité sur le paramètre et le bouton bascule `/config` |93| `CLAUDE_CODE_ENABLE_AWAY_SUMMARY` | Remplacer la disponibilité du [récapitulatif de session](/fr/interactive-mode#session-recap). Définissez sur `0` pour forcer les récapitulatifs désactivés indépendamment du bouton bascule `/config`. Définissez sur `1` pour forcer les récapitulatifs activés lorsque [`awaySummaryEnabled`](/fr/settings#available-settings) est `false`. Prend la priorité sur le paramètre et le bouton bascule `/config` |

94| `CLAUDE_CODE_ENABLE_BACKGROUND_PLUGIN_REFRESH` | Définissez sur `1` pour actualiser l'état du plugin aux limites de tour en [mode non interactif](/fr/headless) après la fin d'une installation en arrière-plan. Désactivé par défaut car l'actualisation modifie l'invite système en milieu de session, ce qui invalide la [mise en cache des invites](https://platform.claude.com/docs/en/build-with-claude/prompt-caching) pour ce tour |94| `CLAUDE_CODE_ENABLE_BACKGROUND_PLUGIN_REFRESH` | Définissez sur `1` pour actualiser l'état du plugin aux limites de tour en [mode non interactif](/fr/headless) après la fin d'une installation en arrière-plan. Désactivé par défaut car l'actualisation modifie l'invite système en milieu de session, ce qui invalide la [mise en cache des invites](https://platform.claude.com/docs/en/build-with-claude/prompt-caching) pour ce tour |

95| `CLAUDE_CODE_ENABLE_FINE_GRAINED_TOOL_STREAMING` | Contrôle si les entrées d'appel d'outil se transmettent en continu depuis l'API au fur et à mesure que Claude les génère. Avec ceci désactivé, une grande entrée d'outil telle qu'une longue écriture de fichier n'arrive qu'après que Claude ait terminé de la générer, ce qui peut sembler qu'il se bloque. Activé par défaut pour les connexions API Anthropic directes. Définissez sur `0` pour refuser. Définissez sur `1` pour forcer l'activation même lorsque la valeur par défaut côté serveur est désactivée. N'a aucun effet sur les connexions Bedrock, Vertex, Foundry ou [gateway](/fr/llm-gateway) |95| `CLAUDE_CODE_ENABLE_FINE_GRAINED_TOOL_STREAMING` | Contrôle si les entrées d'appel d'outil se transmettent en continu depuis l'API au fur et à mesure que Claude les génère. Avec ceci désactivé, une grande entrée d'outil telle qu'une longue écriture de fichier n'arrive qu'après que Claude ait terminé de la générer, ce qui peut sembler qu'il se bloque. Activé par défaut sur l'API Anthropic. Sur Bedrock et Vertex, activé par modèle où le conteneur déployé le prend en charge. Définissez sur `0` pour refuser. Définissez sur `1` pour forcer l'activation lors du routage via un proxy via `ANTHROPIC_BASE_URL`, `ANTHROPIC_VERTEX_BASE_URL` ou `ANTHROPIC_BEDROCK_BASE_URL`. Désactivé par défaut sur Foundry et les connexions [gateway](/fr/llm-gateway) |

96| `CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY` | Définissez sur `1` pour remplir le sélecteur `/model` à partir du point de terminaison `/v1/models` de votre passerelle lorsque `ANTHROPIC_BASE_URL` pointe vers une passerelle compatible Anthropic telle que LiteLLM, Kong ou un proxy interne. Désactivé par défaut car les passerelles soutenues par une clé API partagée afficheraient autrement à chaque utilisateur chaque modèle auquel la clé peut accéder. Les modèles découverts sont toujours filtrés par la liste d'autorisation [`availableModels`](/fr/settings#available-settings) |96| `CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY` | Définissez sur `1` pour remplir le sélecteur `/model` à partir du point de terminaison `/v1/models` de votre passerelle lorsque `ANTHROPIC_BASE_URL` pointe vers une passerelle compatible Anthropic telle que LiteLLM, Kong ou un proxy interne. Désactivé par défaut car les passerelles soutenues par une clé API partagée afficheraient autrement à chaque utilisateur chaque modèle auquel la clé peut accéder. Les modèles découverts sont toujours filtrés par la liste d'autorisation [`availableModels`](/fr/settings#available-settings) |

97| `CLAUDE_CODE_ENABLE_PROMPT_SUGGESTION` | Définissez sur `false` pour désactiver les suggestions d'invite (le bouton bascule « Suggestions d'invite » dans `/config`). Ce sont les prédictions grisées qui apparaissent dans votre entrée d'invite après que Claude répond. Voir [Suggestions d'invite](/fr/interactive-mode#prompt-suggestions) |97| `CLAUDE_CODE_ENABLE_PROMPT_SUGGESTION` | Définissez sur `false` pour désactiver les suggestions d'invite (le bouton bascule « Suggestions d'invite » dans `/config`). Ce sont les prédictions grisées qui apparaissent dans votre entrée d'invite après que Claude répond. Voir [Suggestions d'invite](/fr/interactive-mode#prompt-suggestions) |

98| `CLAUDE_CODE_ENABLE_TASKS` | Définissez sur `1` pour activer le système de suivi des tâches en mode non interactif (l'indicateur `-p`). Les tâches sont activées par défaut en mode interactif. Voir [Liste des tâches](/fr/interactive-mode#task-list) |98| `CLAUDE_CODE_ENABLE_TASKS` | Définissez sur `1` pour activer le système de suivi des tâches en mode non interactif (l'indicateur `-p`). Les tâches sont activées par défaut en mode interactif. Voir [Liste des tâches](/fr/interactive-mode#task-list) |

164| `CLAUDE_CODE_USE_POWERSHELL_TOOL` | Contrôle l'outil PowerShell. Sur Windows sans Git Bash, l'outil est activé automatiquement ; définissez sur `0` pour le désactiver. Sur Windows avec Git Bash installé, l'outil se déploie progressivement : définissez sur `1` pour participer ou `0` pour refuser. Sur Linux, macOS et WSL, définissez sur `1` pour l'activer, ce qui nécessite `pwsh` sur votre `PATH`. Lorsqu'il est activé sur Windows, Claude peut exécuter les commandes PowerShell en mode natif au lieu de les acheminer via Git Bash. Voir [Outil PowerShell](/fr/tools-reference#powershell-tool) |164| `CLAUDE_CODE_USE_POWERSHELL_TOOL` | Contrôle l'outil PowerShell. Sur Windows sans Git Bash, l'outil est activé automatiquement ; définissez sur `0` pour le désactiver. Sur Windows avec Git Bash installé, l'outil se déploie progressivement : définissez sur `1` pour participer ou `0` pour refuser. Sur Linux, macOS et WSL, définissez sur `1` pour l'activer, ce qui nécessite `pwsh` sur votre `PATH`. Lorsqu'il est activé sur Windows, Claude peut exécuter les commandes PowerShell en mode natif au lieu de les acheminer via Git Bash. Voir [Outil PowerShell](/fr/tools-reference#powershell-tool) |

166| `CLAUDE_CONFIG_DIR` | Remplacer le répertoire de configuration (par défaut : `~/.claude`). Tous les paramètres, identifiants, historique de session et plugins sont stockés sous ce chemin. Utile pour exécuter plusieurs comptes côte à côte : par exemple, `alias claude-work='CLAUDE_CONFIG_DIR=~/.claude-work claude'` |166| `CLAUDE_CONFIG_DIR` | Remplacer le répertoire de configuration (par défaut : `~/.claude`). Tous les paramètres, identifiants, historique de session et plugins sont stockés sous ce chemin. Utile pour exécuter plusieurs comptes côte à côte : par exemple, `alias claude-work='CLAUDE_CONFIG_DIR=~/.claude-work claude'` |

167| `CLAUDE_EFFORT` | Défini automatiquement dans les sous-processus des outils Bash et les commandes hook au [niveau d'effort](/fr/model-config#adjust-effort-level) actif pour le tour : `low`, `medium`, `high`, `xhigh` ou `max`. Correspond au champ `effort.level` passé aux [hooks](/fr/hooks). Défini uniquement lorsque le modèle actuel prend en charge le paramètre d'effort |

167| `CLAUDE_ENABLE_BYTE_WATCHDOG` | Définissez sur `1` pour forcer l'activation du chien de garde d'inactivité au niveau des octets, ou définissez sur `0` pour forcer la désactivation. Lorsqu'il n'est pas défini, le chien de garde est activé par défaut pour les connexions API Anthropic. Le chien de garde d'octets abandonne une connexion lorsqu'aucun octet n'arrive sur le fil pendant la durée définie par `CLAUDE_STREAM_IDLE_TIMEOUT_MS`, avec un minimum de 5 minutes, indépendamment du chien de garde au niveau des événements |168| `CLAUDE_ENABLE_BYTE_WATCHDOG` | Définissez sur `1` pour forcer l'activation du chien de garde d'inactivité au niveau des octets, ou définissez sur `0` pour forcer la désactivation. Lorsqu'il n'est pas défini, le chien de garde est activé par défaut pour les connexions API Anthropic. Le chien de garde d'octets abandonne une connexion lorsqu'aucun octet n'arrive sur le fil pendant la durée définie par `CLAUDE_STREAM_IDLE_TIMEOUT_MS`, avec un minimum de 5 minutes, indépendamment du chien de garde au niveau des événements |

168| `CLAUDE_ENABLE_STREAM_WATCHDOG` | Définissez sur `1` pour activer le chien de garde d'inactivité de streaming au niveau des événements. Désactivé par défaut. Pour Bedrock, Vertex et Foundry, c'est le seul chien de garde d'inactivité disponible. Configurez le délai d'expiration avec `CLAUDE_STREAM_IDLE_TIMEOUT_MS` |169| `CLAUDE_ENABLE_STREAM_WATCHDOG` | Définissez sur `1` pour activer le chien de garde d'inactivité de streaming au niveau des événements. Désactivé par défaut. Pour Bedrock, Vertex et Foundry, c'est le seul chien de garde d'inactivité disponible. Configurez le délai d'expiration avec `CLAUDE_STREAM_IDLE_TIMEOUT_MS` |

169| `CLAUDE_ENV_FILE` | Chemin d'accès à un script shell dont le contenu Claude Code exécute avant chaque commande Bash dans le même processus shell, de sorte que les exports du fichier sont visibles pour la commande. À utiliser pour persister l'activation de virtualenv ou conda entre les commandes. Également rempli dynamiquement par les hooks [SessionStart](/fr/hooks#persist-environment-variables), [Setup](/fr/hooks#setup), [CwdChanged](/fr/hooks#cwdchanged) et [FileChanged](/fr/hooks#filechanged) |170| `CLAUDE_ENV_FILE` | Chemin d'accès à un script shell dont le contenu Claude Code exécute avant chaque commande Bash dans le même processus shell, de sorte que les exports du fichier sont visibles pour la commande. À utiliser pour persister l'activation de virtualenv ou conda entre les commandes. Également rempli dynamiquement par les hooks [SessionStart](/fr/hooks#persist-environment-variables), [Setup](/fr/hooks#setup), [CwdChanged](/fr/hooks#cwdchanged) et [FileChanged](/fr/hooks#filechanged) |

205| `MAX_THINKING_TOKENS` | Remplacer le budget de tokens de [réflexion étendue](https://platform.claude.com/docs/en/build-with-claude/extended-thinking). Le plafond est le [max output tokens](https://platform.claude.com/docs/en/about-claude/models/overview#latest-models-comparison) du modèle moins un. Définissez sur `0` pour désactiver complètement la réflexion. Sur les modèles avec [raisonnement adaptatif](/fr/model-config#adjust-effort-level), le budget est ignoré sauf si le raisonnement adaptatif est désactivé via `CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING` |206| `MAX_THINKING_TOKENS` | Remplacer le budget de tokens de [réflexion étendue](https://platform.claude.com/docs/en/build-with-claude/extended-thinking). Le plafond est le [max output tokens](https://platform.claude.com/docs/en/about-claude/models/overview#latest-models-comparison) du modèle moins un. Définissez sur `0` pour désactiver complètement la réflexion. Sur les modèles avec [raisonnement adaptatif](/fr/model-config#adjust-effort-level), le budget est ignoré sauf si le raisonnement adaptatif est désactivé via `CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING` |

206| `MCP_CLIENT_SECRET` | Secret client OAuth pour les serveurs MCP qui nécessitent des [identifiants préconfigurés](/fr/mcp#use-pre-configured-oauth-credentials). Évite l'invite interactive lors de l'ajout d'un serveur avec `--client-secret` |207| `MCP_CLIENT_SECRET` | Secret client OAuth pour les serveurs MCP qui nécessitent des [identifiants préconfigurés](/fr/mcp#use-pre-configured-oauth-credentials). Évite l'invite interactive lors de l'ajout d'un serveur avec `--client-secret` |

207| `MCP_CONNECTION_NONBLOCKING` | Définissez sur `true` en mode non interactif (`-p`) pour ignorer complètement l'attente de connexion MCP. Utile pour les pipelines scriptés où les outils MCP ne sont pas nécessaires. Sans cette variable, la première requête attend jusqu'à 5 secondes pour les connexions du serveur `--mcp-config`. Les serveurs configurés avec [`alwaysLoad: true`](/fr/mcp#exempt-a-server-from-deferral) bloquent toujours le démarrage indépendamment de cette variable, car leurs outils doivent être présents lorsque la première invite est construite |208| `MCP_CONNECTION_NONBLOCKING` | Définissez sur `true` en mode non interactif (`-p`) pour ignorer complètement l'attente de connexion MCP. Utile pour les pipelines scriptés où les outils MCP ne sont pas nécessaires. Sans cette variable, la première requête attend jusqu'à 5 secondes pour les connexions du serveur `--mcp-config`. Les serveurs configurés avec [`alwaysLoad: true`](/fr/mcp#exempt-a-server-from-deferral) bloquent toujours le démarrage indépendamment de cette variable, car leurs outils doivent être présents lorsque la première invite est construite |

209| `MCP_CONNECT_TIMEOUT_MS` | Combien de temps la première requête attend, en millisecondes, pour le lot de connexion MCP avant de prendre un instantané de la liste d'outils (par défaut : 5 000). Les serveurs toujours en attente à la date limite continuent à se connecter en arrière-plan mais n'apparaîtront pas jusqu'à la requête suivante. Distinct de `MCP_TIMEOUT`, qui limite la tentative de connexion d'un serveur individuel. Plus pertinent pour les sessions non interactives qui émettent une seule requête et ont besoin que les serveurs à connexion lente soient visibles |

208| `MCP_OAUTH_CALLBACK_PORT` | Port fixe pour le rappel de redirection OAuth, comme alternative à `--callback-port` lors de l'ajout d'un serveur MCP avec des [identifiants préconfigurés](/fr/mcp#use-pre-configured-oauth-credentials) |210| `MCP_OAUTH_CALLBACK_PORT` | Port fixe pour le rappel de redirection OAuth, comme alternative à `--callback-port` lors de l'ajout d'un serveur MCP avec des [identifiants préconfigurés](/fr/mcp#use-pre-configured-oauth-credentials) |

209| `MCP_REMOTE_SERVER_CONNECTION_BATCH_SIZE` | Nombre maximal de serveurs MCP distants (HTTP/SSE) à connecter en parallèle au démarrage (par défaut : 20) |211| `MCP_REMOTE_SERVER_CONNECTION_BATCH_SIZE` | Nombre maximal de serveurs MCP distants (HTTP/SSE) à connecter en parallèle au démarrage (par défaut : 20) |

210| `MCP_SERVER_CONNECTION_BATCH_SIZE` | Nombre maximal de serveurs MCP locaux (stdio) à connecter en parallèle au démarrage (par défaut : 3) |212| `MCP_SERVER_CONNECTION_BATCH_SIZE` | Nombre maximal de serveurs MCP locaux (stdio) à connecter en parallèle au démarrage (par défaut : 3) |

features-overview.md +1 −1

Details

249 249

250 **Coût du contexte :** Faible jusqu'à utilisation. Les skills utilisateur uniquement ont un coût zéro jusqu'à invocation.250 **Coût du contexte :** Faible jusqu'à utilisation. Les skills utilisateur uniquement ont un coût zéro jusqu'à invocation.

251 251

252 **Dans les subagents :** Les skills fonctionnent différemment dans les subagents. Au lieu du chargement à la demande, les skills passées à un subagent sont entièrement préchargées dans son contexte au lancement. Les subagents n'héritent pas des skills de la session principale ; vous devez les spécifier explicitement.252 **Dans les subagents :** Les skills fonctionnent différemment dans les subagents. Au lieu du chargement à la demande, les skills listées dans le champ `skills` du subagent sont entièrement préchargées dans son contexte au lancement. Les subagents peuvent toujours découvrir et invoquer les skills de projet, utilisateur et plugin non listées via l'outil Skill.

253 253

254 <Tip>Utilisez `disable-model-invocation: true` pour les skills avec des effets secondaires. Cela économise du contexte et garantit que seul vous les déclenchez.</Tip>254 <Tip>Utilisez `disable-model-invocation: true` pour les skills avec des effets secondaires. Cela économise du contexte et garantit que seul vous les déclenchez.</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## Conditions préalables81## Conditions préalables

192 82

hooks.md +5 −4

Details

518Les événements de hook reçoivent ces champs en JSON, en plus des champs spécifiques à l'événement documentés dans chaque section [événement de hook](#hook-events). Pour les hooks de commande, ce JSON arrive via stdin. Pour les hooks HTTP, il arrive dans le corps de la requête POST.518Les événements de hook reçoivent ces champs en JSON, en plus des champs spécifiques à l'événement documentés dans chaque section [événement de hook](#hook-events). Pour les hooks de commande, ce JSON arrive via stdin. Pour les hooks HTTP, il arrive dans le corps de la requête POST.

519 519

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

524| `cwd` | Répertoire de travail courant lorsque le hook est invoqué |524| `cwd` | Répertoire de travail courant lorsque le hook est invoqué |

525| `permission_mode` | [Mode de permission](/fr/permissions#permission-modes) actuel : `"default"`, `"plan"`, `"acceptEdits"`, `"auto"`, `"dontAsk"` ou `"bypassPermissions"`. Tous les événements ne reçoivent pas ce champ : consultez l'exemple JSON de chaque événement ci-dessous pour vérifier |525| `permission_mode` | [Mode de permission](/fr/permissions#permission-modes) actuel : `"default"`, `"plan"`, `"acceptEdits"`, `"auto"`, `"dontAsk"` ou `"bypassPermissions"`. Tous les événements ne reçoivent pas ce champ : consultez l'exemple JSON de chaque événement ci-dessous pour vérifier |

526| `effort` | Objet avec un champ `level` contenant le [niveau d'effort](/fr/model-config#adjust-effort-level) actif pour le tour : `"low"`, `"medium"`, `"high"`, `"xhigh"` ou `"max"`. Si l'effort demandé dépasse ce que le modèle actuel supporte, c'est le niveau réduit que le modèle a réellement utilisé, pas le niveau que vous avez demandé. L'objet correspond au champ `effort` de la [ligne de statut](/fr/statusline#available-data). Présent pour les événements qui se déclenchent dans un contexte d'utilisation d'outil, tels que `PreToolUse`, `PostToolUse`, `Stop` et `SubagentStop`, lorsque le modèle actuel supporte le paramètre d'effort. Le niveau est également disponible pour les commandes de hook et l'outil Bash en tant que variable d'environnement `$CLAUDE_EFFORT`. |

527 528

528Lors de l'exécution avec `--agent` ou à l'intérieur d'un subagent, deux champs supplémentaires sont inclus :529Lors de l'exécution avec `--agent` ou à l'intérieur d'un subagent, deux champs supplémentaires sont inclus :

1225 1226

1226Si l'outil différé n'est plus disponible lorsque vous reprenez, le processus quitte avec `stop_reason: "tool_deferred_unavailable"` et `is_error: true` avant que le hook ne se déclenche. Cela se produit lorsqu'un serveur MCP qui a fourni l'outil n'est pas connecté pour la session reprise. La charge utile `deferred_tool_use` est toujours incluse afin que vous puissiez identifier quel outil a disparu.1227Si l'outil différé n'est plus disponible lorsque vous reprenez, le processus quitte avec `stop_reason: "tool_deferred_unavailable"` et `is_error: true` avant que le hook ne se déclenche. Cela se produit lorsqu'un serveur MCP qui a fourni l'outil n'est pas connecté pour la session reprise. La charge utile `deferred_tool_use` est toujours incluse afin que vous puissiez identifier quel outil a disparu.

1227 1228

1228<Warning>1229<Note>

1229 `--resume` ne restaure pas le mode de permission de la session antérieure. Passez le même drapeau `--permission-mode` lors de la reprise qui était actif lorsque l'outil a été différé. Claude Code enregistre un avertissement si les modes diffèrent.1230 `--resume` restaure le mode de permission qui était actif lorsque l'outil a été différé, donc vous n'avez pas besoin de passer `--permission-mode` à nouveau. Les exceptions sont `plan` et `bypassPermissions`, qui ne sont jamais reportés. Passer `--permission-mode` explicitement lors de la reprise remplace la valeur restaurée.

1230</Warning>1231</Note>

1231 1232

1232### PermissionRequest1233### PermissionRequest

1233 1234

memory.md +10 −0

Details

132Utilisez le mode plan pour les modifications sous `src/billing/`.132Utilisez le mode plan pour les modifications sous `src/billing/`.

133```133```

134 134

135Un lien symbolique fonctionne également si vous n'avez pas besoin d'ajouter du contenu spécifique à Claude Code :

136

137```bash theme={null}

138ln -s AGENTS.md CLAUDE.md

139```

140

141Sur Windows, créer un lien symbolique nécessite les privilèges d'administrateur ou le mode développeur, donc utilisez plutôt l'import `@AGENTS.md`.

142

143L'exécution de [`/init`](/fr/commands) dans un référentiel qui a déjà un `AGENTS.md` le lit et incorpore les parties pertinentes dans le `CLAUDE.md` généré. Il lit également d'autres configurations d'outils comme `.cursorrules` et `.windsurfrules`.

144

135### Comment les fichiers CLAUDE.md se chargent145### Comment les fichiers CLAUDE.md se chargent

136 146

137Claude Code lit les fichiers CLAUDE.md en remontant l'arborescence des répertoires à partir de votre répertoire de travail actuel, en vérifiant chaque répertoire en chemin pour les fichiers `CLAUDE.md` et `CLAUDE.local.md`. Cela signifie que si vous exécutez Claude Code dans `foo/bar/`, il charge les instructions de `foo/bar/CLAUDE.md`, `foo/CLAUDE.md` et tous les fichiers `CLAUDE.local.md` à côté d'eux.147Claude Code lit les fichiers CLAUDE.md en remontant l'arborescence des répertoires à partir de votre répertoire de travail actuel, en vérifiant chaque répertoire en chemin pour les fichiers `CLAUDE.md` et `CLAUDE.local.md`. Cela signifie que si vous exécutez Claude Code dans `foo/bar/`, il charge les instructions de `foo/bar/CLAUDE.md`, `foo/CLAUDE.md` et tous les fichiers `CLAUDE.local.md` à côté d'eux.

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## Conditions préalables81## Conditions préalables

192 82

model-config.md +4 −0

Details

17 * Foundry : un nom de déploiement17 * Foundry : un nom de déploiement

18 * Vertex : un nom de version18 * Vertex : un nom de version

19 19

20<Note>

21 `ANTHROPIC_BASE_URL` change l'endroit où les demandes sont envoyées, et non le modèle qui y répond. Pour acheminer Claude via une passerelle LLM, consultez la [configuration de la passerelle LLM](/fr/llm-gateway).

22</Note>

20### Alias de modèle24### Alias de modèle

21 25

22Les alias de modèle offrent un moyen pratique de sélectionner les paramètres du modèle sans avoir à mémoriser les numéros de version exacts :26Les alias de modèle offrent un moyen pratique de sélectionner les paramètres du modèle sans avoir à mémoriser les numéros de version exacts :

overview.md +1 −635

Details

6 6

7> Claude Code est un outil de codage agentique qui lit votre base de code, modifie les fichiers, exécute des commandes et s'intègre à vos outils de développement. Disponible dans votre terminal, IDE, application de bureau et navigateur.7> Claude Code est un outil de codage agentique qui lit votre base de code, modifie les fichiers, exécute des commandes et s'intègre à vos outils de développement. Disponible dans votre terminal, IDE, application de bureau et navigateur.

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 est un assistant de codage alimenté par l'IA qui vous aide à créer des fonctionnalités, corriger des bogues et automatiser les tâches de développement. Il comprend l'ensemble de votre base de code et peut travailler sur plusieurs fichiers et outils pour accomplir les tâches.9Claude Code est un assistant de codage alimenté par l'IA qui vous aide à créer des fonctionnalités, corriger des bogues et automatiser les tâches de développement. Il comprend l'ensemble de votre base de code et peut travailler sur plusieurs fichiers et outils pour accomplir les tâches.

640 10

641<div data-gb-slot="overview-install-configurator">

642 <Experiment flag="overview-install-configurator" treatment={<InstallConfigurator />} />

643</div>

~~644~~

645## Commencer11## Commencer

646 12

647Choisissez votre environnement pour commencer. La plupart des surfaces nécessitent un [abonnement Claude](https://claude.com/pricing?utm_source=claude_code\&utm_medium=docs\&utm_content=overview_pricing) ou un compte [Anthropic Console](https://console.anthropic.com/). Le CLI Terminal et VS Code prennent également en charge les [fournisseurs tiers](/fr/third-party-integrations).13Choisissez votre environnement pour commencer. La plupart des surfaces nécessitent un [abonnement Claude](https://claude.com/pricing?utm_source=claude_code\&utm_medium=docs\&utm_content=overview_pricing) ou un compte [Anthropic Console](https://console.anthropic.com/). Le CLI Terminal et VS Code prennent également en charge les [fournisseurs tiers](/fr/third-party-integrations).

798 <Accordion title="Personnaliser avec des instructions, des skills et des hooks" icon="sliders">164 <Accordion title="Personnaliser avec des instructions, des skills et des hooks" icon="sliders">

799 [`CLAUDE.md`](/fr/memory) est un fichier markdown que vous ajoutez à la racine de votre projet que Claude Code lit au début de chaque session. Utilisez-le pour définir les normes de codage, les décisions architecturales, les bibliothèques préférées et les listes de contrôle d'examen. Claude construit également une [mémoire automatique](/fr/memory#auto-memory) au fur et à mesure qu'il travaille, en sauvegardant les apprentissages comme les commandes de construction et les informations de débogage entre les sessions sans que vous ayez à écrire quoi que ce soit.165 [`CLAUDE.md`](/fr/memory) est un fichier markdown que vous ajoutez à la racine de votre projet que Claude Code lit au début de chaque session. Utilisez-le pour définir les normes de codage, les décisions architecturales, les bibliothèques préférées et les listes de contrôle d'examen. Claude construit également une [mémoire automatique](/fr/memory#auto-memory) au fur et à mesure qu'il travaille, en sauvegardant les apprentissages comme les commandes de construction et les informations de débogage entre les sessions sans que vous ayez à écrire quoi que ce soit.

800 166

801 Créez des [commandes personnalisées](/fr/skills) pour empaqueter les flux de travail répétables que votre équipe peut partager, comme `/review-pr` ou `/deploy-staging`.167 Créez des [skills](/fr/skills) pour empaqueter les flux de travail répétables que votre équipe peut partager, comme `/review-pr` ou `/deploy-staging`.

802 168

803 Les [hooks](/fr/hooks) vous permettent d'exécuter des commandes shell avant ou après les actions de Claude Code, comme le formatage automatique après chaque modification de fichier ou l'exécution de lint avant un commit.169 Les [hooks](/fr/hooks) vous permettent d'exécuter des commandes shell avant ou après les actions de Claude Code, comme le formatage automatique après chaque modification de fichier ou l'exécution de lint avant un commit.

804 </Accordion>170 </Accordion>

plugins.md +9 −1

Details

317 317

318Pour tester un plugin qui est déjà empaqueté en tant qu'archive `.zip` et hébergé à une URL, comme un artefact de build CI, utilisez `--plugin-url` à la place. Claude Code récupère l'archive au démarrage et la charge pour cette session uniquement. Si la récupération échoue ou que l'archive est invalide, Claude Code signale une erreur de chargement de plugin et démarre sans elle. Les mêmes [considérations de confiance](/fr/discover-plugins#security) s'appliquent que pour toute source de plugin : pointez uniquement ce drapeau vers des archives que vous contrôlez ou en lesquelles vous avez confiance.318Pour tester un plugin qui est déjà empaqueté en tant qu'archive `.zip` et hébergé à une URL, comme un artefact de build CI, utilisez `--plugin-url` à la place. Claude Code récupère l'archive au démarrage et la charge pour cette session uniquement. Si la récupération échoue ou que l'archive est invalide, Claude Code signale une erreur de chargement de plugin et démarre sans elle. Les mêmes [considérations de confiance](/fr/discover-plugins#security) s'appliquent que pour toute source de plugin : pointez uniquement ce drapeau vers des archives que vous contrôlez ou en lesquelles vous avez confiance.

319 319

320Pour charger plusieurs plugins, répétez le drapeau pour chaque URL :

321

322```bash theme={null}

323claude --plugin-url https://example.com/my-plugin.zip --plugin-url https://example.com/other.zip

324```

325

326Ou passez des URL séparées par des espaces en tant qu'un seul argument entre guillemets :

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### Déboguez les problèmes de plugin332### Déboguez les problèmes de plugin

quickstart.md +4 −637

Details

6 6

7> Bienvenue dans Claude Code !7> Bienvenue dans 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~~

639Ce guide de démarrage rapide vous permettra d'utiliser l'assistance au codage alimentée par l'IA en quelques minutes. À la fin, vous comprendrez comment utiliser Claude Code pour les tâches de développement courantes.9Ce guide de démarrage rapide vous permettra d'utiliser l'assistance au codage alimentée par l'IA en quelques minutes. À la fin, vous comprendrez comment utiliser Claude Code pour les tâches de développement courantes.

640 10

641<Experiment flag="quickstart-install-configurator" treatment={<InstallConfigurator />} />

~~642~~

643## Avant de commencer11## Avant de commencer

644 12

645Assurez-vous que vous avez :13Assurez-vous que vous avez :

647* Un terminal ou une invite de commande ouvert15* Un terminal ou une invite de commande ouvert

648 * Si vous n'avez jamais utilisé le terminal auparavant, consultez le [guide du terminal](/fr/terminal-guide)16 * Si vous n'avez jamais utilisé le terminal auparavant, consultez le [guide du terminal](/fr/terminal-guide)

649* Un projet de code avec lequel travailler17* Un projet de code avec lequel travailler

650* Un [abonnement Claude](https://claude.com/pricing?utm_source=claude_code\&utm_medium=docs\&utm_content=quickstart_prereq) (Pro, Max, Teams ou Enterprise), un compte [Claude Console](https://console.anthropic.com/), ou un accès via un [fournisseur cloud pris en charge](/fr/third-party-integrations)18* Un [abonnement Claude](https://claude.com/pricing?utm_source=claude_code\&utm_medium=docs\&utm_content=quickstart_prereq) (Pro, Max, Team ou Enterprise), un compte [Claude Console](https://console.anthropic.com/), ou un accès via un [fournisseur cloud pris en charge](/fr/third-party-integrations)

651 19

652<Note>20<Note>

653 Ce guide couvre le CLI du terminal. Claude Code est également disponible sur le [web](https://claude.ai/code), en tant qu'[application de bureau](/fr/desktop), dans [VS Code](/fr/vs-code) et [les IDE JetBrains](/fr/jetbrains), dans [Slack](/fr/slack), et en CI/CD avec [GitHub Actions](/fr/github-actions) et [GitLab](/fr/gitlab-ci-cd). Voir [toutes les interfaces](/fr/overview#use-claude-code-everywhere).21 Ce guide couvre le CLI du terminal. Claude Code est également disponible sur le [web](https://claude.ai/code), en tant qu'[application de bureau](/fr/desktop), dans [VS Code](/fr/vs-code) et [les IDE JetBrains](/fr/jetbrains), dans [Slack](/fr/slack), et en CI/CD avec [GitHub Actions](/fr/github-actions) et [GitLab](/fr/gitlab-ci-cd). Voir [toutes les interfaces](/fr/overview#use-claude-code-everywhere).

727 95

728Vous pouvez vous connecter en utilisant l'un de ces types de compte :96Vous pouvez vous connecter en utilisant l'un de ces types de compte :

729 97

730* [Claude Pro, Max, Teams ou Enterprise](https://claude.com/pricing?utm_source=claude_code\&utm_medium=docs\&utm_content=quickstart_login) (recommandé)98* [Claude Pro, Max, Team ou Enterprise](https://claude.com/pricing?utm_source=claude_code\&utm_medium=docs\&utm_content=quickstart_login) (recommandé)

731* [Claude Console](https://console.anthropic.com/) (accès API avec crédits prépayés). Lors de la première connexion, un espace de travail « Claude Code » est automatiquement créé dans la Console pour un suivi centralisé des coûts.99* [Claude Console](https://console.anthropic.com/) (accès API avec crédits prépayés). Lors de la première connexion, un espace de travail « Claude Code » est automatiquement créé dans la Console pour un suivi centralisé des coûts.

732* [Amazon Bedrock, Google Vertex AI ou Microsoft Foundry](/fr/third-party-integrations) (fournisseurs cloud d'entreprise)100* [Amazon Bedrock, Google Vertex AI ou Microsoft Foundry](/fr/third-party-integrations) (fournisseurs cloud d'entreprise)

733 101

902| `claude commit` | Créer un commit Git | `claude commit` |

906 273

907Voir la [référence CLI](/fr/cli-reference) pour une liste complète des commandes.274Voir la [référence CLI](/fr/cli-reference) pour une liste complète des commandes.

908 275

971 338

972## Obtenir de l'aide339## Obtenir de l'aide

973 340

974* **Dans Claude Code** : Tapez `/help` ou demandez « how do I... »341* **Dans Claude Code** : Tapez `/help` ou demandez « comment faire... »

975* **Documentation** : Vous êtes ici ! Parcourez les autres guides342* **Documentation** : Vous êtes ici ! Parcourez les autres guides

976* **Communauté** : Rejoignez notre [Discord](https://www.anthropic.com/discord) pour des conseils et du support343* **Communauté** : Rejoignez notre [Discord](https://www.anthropic.com/discord) pour des conseils et du support

settings.md +7 −3

Details

156`settings.json` supporte un certain nombre d'options :156`settings.json` supporte un certain nombre d'options :

157 157

158| Clé | Description | Exemple |158| Clé | Description | Exemple |

159| :-------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | :----------------------------------------------------------------------------------------------------------------------------- |159| :-------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------- |

160| `agent` | Exécuter le thread principal en tant que subagent nommé. Applique l'invite système, les restrictions d'outils et le modèle de ce subagent. Voir [Invoquer les subagents explicitement](/fr/sub-agents#invoke-subagents-explicitly) | `"code-reviewer"` |160| `agent` | Exécuter le thread principal en tant que subagent nommé. Applique l'invite système, les restrictions d'outils et le modèle de ce subagent. Voir [Invoquer les subagents explicitement](/fr/sub-agents#invoke-subagents-explicitly) | `"code-reviewer"` |

161| `allowedChannelPlugins` | (Paramètres gérés uniquement) Liste blanche des plugins de channel qui peuvent envoyer des messages. Remplace la liste blanche Anthropic par défaut quand défini. Non défini = revenir à la valeur par défaut, tableau vide = bloquer tous les plugins de channel. Nécessite `channelsEnabled: true`. Voir [Restreindre quels plugins de channel peuvent s'exécuter](/fr/channels#restrict-which-channel-plugins-can-run) | `[{ "marketplace": "claude-plugins-official", "plugin": "telegram" }]` |161| `allowedChannelPlugins` | (Paramètres gérés uniquement) Liste blanche des plugins de channel qui peuvent envoyer des messages. Remplace la liste blanche Anthropic par défaut quand défini. Non défini = revenir à la valeur par défaut, tableau vide = bloquer tous les plugins de channel. Nécessite `channelsEnabled: true`. Voir [Restreindre quels plugins de channel peuvent s'exécuter](/fr/channels#restrict-which-channel-plugins-can-run) | `[{ "marketplace": "claude-plugins-official", "plugin": "telegram" }]` |

162| `allowedHttpHookUrls` | Liste blanche des modèles d'URL que les hooks HTTP peuvent cibler. Supporte `*` comme caractère générique. Quand défini, les hooks avec des URL non correspondantes sont bloqués. Non défini = pas de restriction, tableau vide = bloquer tous les hooks HTTP. Les tableaux fusionnent entre les sources de paramètres. Voir [Configuration des hooks](#hook-configuration) | `["https://hooks.example.com/*"]` |162| `allowedHttpHookUrls` | Liste blanche des modèles d'URL que les hooks HTTP peuvent cibler. Supporte `*` comme caractère générique. Quand défini, les hooks avec des URL non correspondantes sont bloqués. Non défini = pas de restriction, tableau vide = bloquer tous les hooks HTTP. Les tableaux fusionnent entre les sources de paramètres. Voir [Configuration des hooks](#hook-configuration) | `["https://hooks.example.com/*"]` |

211| `modelOverrides` | Mapper les ID de modèle Anthropic aux ID de modèle spécifiques au fournisseur tels que les ARN de profil d'inférence Bedrock. Chaque entrée du sélecteur de modèle utilise sa valeur mappée lors de l'appel de l'API du fournisseur. Voir [Remplacer les ID de modèle par version](/fr/model-config#override-model-ids-per-version) | `{"claude-opus-4-6": "arn:aws:bedrock:..."}` |211| `modelOverrides` | Mapper les ID de modèle Anthropic aux ID de modèle spécifiques au fournisseur tels que les ARN de profil d'inférence Bedrock. Chaque entrée du sélecteur de modèle utilise sa valeur mappée lors de l'appel de l'API du fournisseur. Voir [Remplacer les ID de modèle par version](/fr/model-config#override-model-ids-per-version) | `{"claude-opus-4-6": "arn:aws:bedrock:..."}` |

212| `otelHeadersHelper` | Script pour générer des en-têtes OpenTelemetry dynamiques. S'exécute au démarrage et périodiquement. Définissez l'intervalle d'actualisation avec [`CLAUDE_CODE_OTEL_HEADERS_HELPER_DEBOUNCE_MS`](/fr/env-vars). Voir [En-têtes dynamiques](/fr/monitoring-usage#dynamic-headers) | `/bin/generate_otel_headers.sh` |212| `otelHeadersHelper` | Script pour générer des en-têtes OpenTelemetry dynamiques. S'exécute au démarrage et périodiquement. Définissez l'intervalle d'actualisation avec [`CLAUDE_CODE_OTEL_HEADERS_HELPER_DEBOUNCE_MS`](/fr/env-vars). Voir [En-têtes dynamiques](/fr/monitoring-usage#dynamic-headers) | `/bin/generate_otel_headers.sh` |

214| `parentSettingsBehavior` | {/* min-version: 2.1.133 */}(Paramètres gérés uniquement) Contrôle si les paramètres gérés fournis programmatiquement par un processus hôte d'intégration, tel que l'Agent SDK ou une extension IDE, s'appliquent quand un niveau géré déployé par l'administrateur est également présent. `"first-wins"` : les paramètres fournis par le parent sont supprimés et seul le niveau administrateur s'applique. `"merge"` : les paramètres fournis par le parent s'appliquent sous le niveau administrateur, filtrés pour qu'ils puissent resserrer la politique mais pas l'assouplir. N'a aucun effet quand aucun niveau administrateur n'est déployé. Par défaut : `"first-wins"`. Nécessite Claude Code v2.1.133 ou ultérieur | `"merge"` |

216| `pluginTrustMessage` | (Paramètres gérés uniquement) Message personnalisé ajouté à l'avertissement de confiance du plugin affiché avant l'installation. Utilisez ceci pour ajouter du contexte spécifique à l'organisation, par exemple pour confirmer que les plugins de votre marketplace interne sont vérifiés. | `"All plugins from our marketplace are approved by IT"` |217| `pluginTrustMessage` | (Paramètres gérés uniquement) Message personnalisé ajouté à l'avertissement de confiance du plugin affiché avant l'installation. Utilisez ceci pour ajouter du contexte spécifique à l'organisation, par exemple pour confirmer que les plugins de votre marketplace interne sont vérifiés. | `"All plugins from our marketplace are approved by IT"` |

255 256

256### Paramètres de worktree257### Paramètres de worktree

257 258

258Configurez comment `--worktree` crée et gère les git worktrees. Utilisez ces paramètres pour réduire l'utilisation du disque et le temps de démarrage dans les grands monorepos.259Configurez comment `--worktree` crée et gère les git worktrees.

259 260

260| Clé | Description | Exemple |261| Clé | Description | Exemple |

261| :---------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------ |262| :---------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------ |

263| `worktree.baseRef` | Quelle ref les nouveaux worktrees branchent. `"fresh"` (par défaut) branche à partir de `origin/<default-branch>` pour un arbre propre correspondant au distant. `"head"` branche à partir de votre `HEAD` local actuel, donc les commits non poussés et l'état de la branche de fonctionnalité sont présents dans le worktree. S'applique à `--worktree`, l'outil `EnterWorktree`, et l'isolation du subagent | `"head"` |

262| `worktree.symlinkDirectories` | Répertoires à créer en lien symbolique à partir du référentiel principal dans chaque worktree pour éviter de dupliquer les grands répertoires sur le disque. Aucun répertoire n'est créé en lien symbolique par défaut | `["node_modules", ".cache"]` |264| `worktree.symlinkDirectories` | Répertoires à créer en lien symbolique à partir du référentiel principal dans chaque worktree pour éviter de dupliquer les grands répertoires sur le disque. Aucun répertoire n'est créé en lien symbolique par défaut | `["node_modules", ".cache"]` |

263| `worktree.sparsePaths` | Répertoires à extraire dans chaque worktree via git sparse-checkout (mode cone). Seuls les chemins listés sont écrits sur le disque, ce qui est plus rapide dans les grands monorepos | `["packages/my-app", "shared/utils"]` |265| `worktree.sparsePaths` | Répertoires à extraire dans chaque worktree via git sparse-checkout (mode cone). Seuls les chemins listés sont écrits sur le disque, ce qui est plus rapide dans les grands monorepos | `["packages/my-app", "shared/utils"]` |

264 266

318| `network.socksProxyPort` | Port du proxy SOCKS5 utilisé si vous souhaitez apporter votre propre proxy. S'il n'est pas spécifié, Claude exécutera son propre proxy. | `8081` |320| `network.socksProxyPort` | Port du proxy SOCKS5 utilisé si vous souhaitez apporter votre propre proxy. S'il n'est pas spécifié, Claude exécutera son propre proxy. | `8081` |

319| `enableWeakerNestedSandbox` | Activer un sandbox plus faible pour les environnements Docker non privilégiés (Linux et WSL2 uniquement). **Réduit la sécurité.** Par défaut : false | `true` |321| `enableWeakerNestedSandbox` | Activer un sandbox plus faible pour les environnements Docker non privilégiés (Linux et WSL2 uniquement). **Réduit la sécurité.** Par défaut : false | `true` |

320| `enableWeakerNetworkIsolation` | (macOS uniquement) Autoriser l'accès au service de confiance TLS du système (`com.apple.trustd.agent`) dans le sandbox. Requis pour que les outils basés sur Go comme `gh`, `gcloud`, et `terraform` vérifient les certificats TLS lors de l'utilisation de `httpProxyPort` avec un proxy MITM et une CA personnalisée. **Réduit la sécurité** en ouvrant un chemin potentiel d'exfiltration de données. Par défaut : false | `true` |322| `enableWeakerNetworkIsolation` | (macOS uniquement) Autoriser l'accès au service de confiance TLS du système (`com.apple.trustd.agent`) dans le sandbox. Requis pour que les outils basés sur Go comme `gh`, `gcloud`, et `terraform` vérifient les certificats TLS lors de l'utilisation de `httpProxyPort` avec un proxy MITM et une CA personnalisée. **Réduit la sécurité** en ouvrant un chemin potentiel d'exfiltration de données. Par défaut : false | `true` |

323| `bwrapPath` | (Paramètres gérés uniquement, Linux/WSL2) Chemin absolu vers le binaire bubblewrap (`bwrap`). Remplace la détection automatique via `PATH`. Honoré uniquement à partir des [paramètres gérés](/fr/settings#settings-precedence), pas à partir des paramètres utilisateur ou projet. Utile quand `bwrap` est installé à un emplacement non standard dans les environnements gérés. | `/opt/admin/bwrap` |

324| `socatPath` | (Paramètres gérés uniquement, Linux/WSL2) Chemin absolu vers le binaire `socat` utilisé pour le proxy réseau du sandbox. Remplace la détection automatique via `PATH`. Honoré uniquement à partir des paramètres gérés. | `/opt/admin/socat` |

321 325

322#### Préfixes de chemin sandbox326#### Préfixes de chemin sandbox

323 327

setup.md +2 −0

Details

398 398

399Les plateformes d'installation npm supportées sont `darwin-arm64`, `darwin-x64`, `linux-x64`, `linux-arm64`, `linux-x64-musl`, `linux-arm64-musl`, `win32-x64` et `win32-arm64`. Votre gestionnaire de paquets doit autoriser les dépendances optionnelles. Consultez le [dépannage](/fr/troubleshoot-install#native-binary-not-found-after-npm-install) si le binaire est manquant après l'installation.399Les plateformes d'installation npm supportées sont `darwin-arm64`, `darwin-x64`, `linux-x64`, `linux-arm64`, `linux-x64-musl`, `linux-arm64-musl`, `win32-x64` et `win32-arm64`. Votre gestionnaire de paquets doit autoriser les dépendances optionnelles. Consultez le [dépannage](/fr/troubleshoot-install#native-binary-not-found-after-npm-install) si le binaire est manquant après l'installation.

400 400

401Pour mettre à niveau une installation npm, exécutez `npm install -g @anthropic-ai/claude-code@latest`. Évitez `npm update -g`, qui respecte la plage semver de l'installation d'origine et peut ne pas vous amener à la version la plus récente.

402

401<Warning>403<Warning>

402 N'utilisez PAS `sudo npm install -g` car cela peut entraîner des problèmes de permissions et des risques de sécurité. Si vous rencontrez des erreurs de permissions, consultez le [dépannage des erreurs de permissions](/fr/troubleshoot-install#permission-errors-during-installation).404 N'utilisez PAS `sudo npm install -g` car cela peut entraîner des problèmes de permissions et des risques de sécurité. Si vous rencontrez des erreurs de permissions, consultez le [dépannage des erreurs de permissions](/fr/troubleshoot-install#permission-errors-during-installation).

403</Warning>405</Warning>

sub-agents.md +3 −3

Details

262| :---------------- | :---------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |262| :---------------- | :---------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

263| `name` | Oui | Identifiant unique utilisant des lettres minuscules et des tirets |263| `name` | Oui | Identifiant unique utilisant des lettres minuscules et des tirets |

264| `description` | Oui | Quand Claude doit déléguer à ce sous-agent |264| `description` | Oui | Quand Claude doit déléguer à ce sous-agent |

265| `tools` | Non | [Outils](#available-tools) que le sous-agent peut utiliser. Hérite de tous les outils s'il est omis |265| `tools` | Non | [Outils](#available-tools) que le sous-agent peut utiliser. Hérite de tous les outils s'il est omis. Pour précharger les Skills dans le contexte, utilisez le champ `skills` plutôt que de lister `Skill` ici |

266| `disallowedTools` | Non | Outils à refuser, supprimés de la liste héritée ou spécifiée |266| `disallowedTools` | Non | Outils à refuser, supprimés de la liste héritée ou spécifiée |

267| `model` | Non | [Modèle](#choose-a-model) à utiliser : `sonnet`, `opus`, `haiku`, un ID de modèle complet (par exemple, `claude-opus-4-7`), ou `inherit`. Par défaut `inherit` |267| `model` | Non | [Modèle](#choose-a-model) à utiliser : `sonnet`, `opus`, `haiku`, un ID de modèle complet (par exemple, `claude-opus-4-7`), ou `inherit`. Par défaut `inherit` |

268| `permissionMode` | Non | [Mode de permission](#permission-modes) : `default`, `acceptEdits`, `auto`, `dontAsk`, `bypassPermissions` ou `plan`. Ignoré pour les [sous-agents de plugin](#choose-the-subagent-scope) |268| `permissionMode` | Non | [Mode de permission](#permission-modes) : `default`, `acceptEdits`, `auto`, `dontAsk`, `bypassPermissions` ou `plan`. Ignoré pour les [sous-agents de plugin](#choose-the-subagent-scope) |

269| `maxTurns` | Non | Nombre maximum de tours d'agent avant que le sous-agent s'arrête |269| `maxTurns` | Non | Nombre maximum de tours d'agent avant que le sous-agent s'arrête |

270| `skills` | Non | [Skills](/fr/skills) à charger dans le contexte du sous-agent au démarrage. Le contenu complet de la skill est injecté, pas seulement mis à disposition pour l'invocation. Les sous-agents n'héritent pas des skills de la conversation parent |270| `skills` | Non | [Skills](/fr/skills) à précharger dans le contexte du sous-agent au démarrage. Le contenu complet de la skill est injecté, pas seulement la description. Les sous-agents peuvent toujours invoquer les skills de projet, utilisateur et plugin non listées via l'outil Skill |

271| `mcpServers` | Non | [Serveurs MCP](/fr/mcp) disponibles pour ce sous-agent. Chaque entrée est soit un nom de serveur référençant un serveur déjà configuré (par exemple, `"slack"`) soit une définition en ligne avec le nom du serveur comme clé et une [configuration de serveur MCP](/fr/mcp#installing-mcp-servers) complète comme valeur. Ignoré pour les [sous-agents de plugin](#choose-the-subagent-scope) |271| `mcpServers` | Non | [Serveurs MCP](/fr/mcp) disponibles pour ce sous-agent. Chaque entrée est soit un nom de serveur référençant un serveur déjà configuré (par exemple, `"slack"`) soit une définition en ligne avec le nom du serveur comme clé et une [configuration de serveur MCP](/fr/mcp#installing-mcp-servers) complète comme valeur. Ignoré pour les [sous-agents de plugin](#choose-the-subagent-scope) |

272| `hooks` | Non | [Hooks de cycle de vie](#define-hooks-for-subagents) limités à ce sous-agent. Ignoré pour les [sous-agents de plugin](#choose-the-subagent-scope) |272| `hooks` | Non | [Hooks de cycle de vie](#define-hooks-for-subagents) limités à ce sous-agent. Ignoré pour les [sous-agents de plugin](#choose-the-subagent-scope) |

273| `memory` | Non | [Portée de la mémoire persistante](#enable-persistent-memory) : `user`, `project` ou `local`. Active l'apprentissage entre sessions |273| `memory` | Non | [Portée de la mémoire persistante](#enable-persistent-memory) : `user`, `project` ou `local`. Active l'apprentissage entre sessions |

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

421Le contenu complet de chaque skill est injecté dans le contexte du sous-agent, pas seulement mis à disposition pour l'invocation. Les sous-agents n'héritent pas des skills de la conversation parent ; vous devez les lister explicitement.421Le contenu complet de chaque skill listée est injecté dans le contexte du sous-agent au démarrage. Ce champ contrôle quelles skills sont préchargées, pas quelles skills le sous-agent peut accéder : sans lui, le sous-agent peut toujours découvrir et invoquer les skills de projet, utilisateur et plugin via l'outil Skill pendant l'exécution. Pour empêcher un sous-agent d'invoquer les skills entièrement, omettez `Skill` de la liste [`tools`](#available-tools) ou ajoutez-le à `disallowedTools`.

422 422

423Vous ne pouvez pas précharger les skills qui définissent [`disable-model-invocation: true`](/fr/skills#control-who-invokes-a-skill), car le préchargement provient du même ensemble de skills que Claude peut invoquer. Si une skill listée est manquante ou désactivée, Claude Code la saute et enregistre un avertissement dans le journal de débogage.423Vous ne pouvez pas précharger les skills qui définissent [`disable-model-invocation: true`](/fr/skills#control-who-invokes-a-skill), car le préchargement provient du même ensemble de skills que Claude peut invoquer. Si une skill listée est manquante ou désactivée, Claude Code la saute et enregistre un avertissement dans le journal de débogage.

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 ligne `allow-passthrough` permet aux notifications et aux mises à jour de progression d'atteindre iTerm2, Ghostty ou Kitty au lieu d'être avalées par tmux. Les lignes `extended-keys` permettent à tmux de distinguer Maj+Entrée de la simple Entrée afin que le raccourci de saut de ligne fonctionne.110La ligne `allow-passthrough` permet aux notifications et aux mises à jour de progression d'atteindre le terminal externe au lieu d'être avalées par tmux. Les lignes `extended-keys` permettent à tmux de distinguer Maj+Entrée de la simple Entrée afin que le raccourci de saut de ligne fonctionne.

111 111

112## Adapter le thème de couleur112## Adapter le thème de couleur

113 113

third-party-integrations.md +73 −1

Details

6 6

7> Découvrez comment Claude Code peut s'intégrer à divers services tiers et infrastructures pour répondre aux exigences de déploiement en entreprise.7> Découvrez comment Claude Code peut s'intégrer à divers services tiers et infrastructures pour répondre aux exigences de déploiement en entreprise.

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};

9Les organisations peuvent déployer Claude Code directement via Anthropic ou via un fournisseur de cloud. Cette page vous aide à choisir la bonne configuration.79Les organisations peuvent déployer Claude Code directement via Anthropic ou via un fournisseur de cloud. Cette page vous aide à choisir la bonne configuration.

10 80

81<ContactSalesCard surface="third_party_overview" />

11## Comparer les options de déploiement83## Comparer les options de déploiement

12 84

13Pour la plupart des organisations, Claude for Teams ou Claude for Enterprise offre la meilleure expérience. Les membres de l'équipe ont accès à la fois à Claude Code et à Claude sur le web avec un seul abonnement, une facturation centralisée et aucune configuration d'infrastructure requise.85Pour la plupart des organisations, Claude for Teams ou Claude for Enterprise offre la meilleure expérience. Les membres de l'équipe ont accès à la fois à Claude Code et à Claude sur le web avec un seul abonnement, une facturation centralisée et aucune configuration d'infrastructure requise.

241 313

242### Épingler les versions de modèle pour les fournisseurs de cloud314### Épingler les versions de modèle pour les fournisseurs de cloud

243 315

244Si vous déployez via [Bedrock](/fr/amazon-bedrock), [Vertex AI](/fr/google-vertex-ai) ou [Foundry](/fr/microsoft-foundry), épinglez les versions de modèle spécifiques en utilisant `ANTHROPIC_DEFAULT_OPUS_MODEL`, `ANTHROPIC_DEFAULT_SONNET_MODEL` et `ANTHROPIC_DEFAULT_HAIKU_MODEL`. Sans épinglage, les alias Claude Code se résolvent à la dernière version, ce qui peut casser les utilisateurs lorsqu'Anthropic publie un nouveau modèle qui n'est pas encore activé dans votre compte. Voir [Configuration du modèle](/fr/model-config#pin-models-for-third-party-deployments) pour plus de détails.316Si vous déployez via [Bedrock](/fr/amazon-bedrock), [Vertex AI](/fr/google-vertex-ai) ou [Foundry](/fr/microsoft-foundry), épinglez les versions de modèle spécifiques en utilisant `ANTHROPIC_DEFAULT_OPUS_MODEL`, `ANTHROPIC_DEFAULT_SONNET_MODEL` et `ANTHROPIC_DEFAULT_HAIKU_MODEL`. Sans épinglage, les alias de modèle se résolvent à la dernière version, ce qui peut ne pas encore être activé dans votre compte lorsqu'Anthropic publie une mise à jour. L'épinglage vous permet de contrôler quand vos utilisateurs passent à un nouveau modèle. Voir [Configuration du modèle](/fr/model-config#pin-models-for-third-party-deployments) pour ce que chaque fournisseur fait lorsque la dernière version n'est pas disponible.

245 317

246### Configurer les politiques de sécurité318### Configurer les politiques de sécurité

247 319

vs-code.md +3 −1

Details

32 32

33Ou dans VS Code, appuyez sur `Cmd+Shift+X` (Mac) ou `Ctrl+Shift+X` (Windows/Linux) pour ouvrir la vue Extensions, recherchez « Claude Code » et cliquez sur **Installer**.33Ou dans VS Code, appuyez sur `Cmd+Shift+X` (Mac) ou `Ctrl+Shift+X` (Windows/Linux) pour ouvrir la vue Extensions, recherchez « Claude Code » et cliquez sur **Installer**.

34 34

35L'extension s'installe également dans d'autres forks de VS Code comme Windsurf ou Kiro. Recherchez « Claude Code » dans la vue Extensions de l'éditeur, ou installez à partir du [registre Open VSX](https://open-vsx.org/extension/Anthropic/claude-code). Si votre éditeur ne peut pas installer l'extension, exécutez `claude` dans son terminal intégré à la place. L'[interface CLI](/fr/quickstart) fonctionne dans n'importe quel terminal.

35<Note>Si l'extension n'apparaît pas après l'installation, redémarrez VS Code ou exécutez « Developer: Reload Window » à partir de la Palette de commandes.</Note>37<Note>Si l'extension n'apparaît pas après l'installation, redémarrez VS Code ou exécutez « Developer: Reload Window » à partir de la Palette de commandes.</Note>

36 38

37## Commencer39## Commencer

318| `environmentVariables` | `[]` | Définir les variables d'environnement pour le processus Claude. Utilisez plutôt les paramètres Claude Code pour la configuration partagée. |320| `environmentVariables` | `[]` | Définir les variables d'environnement pour le processus Claude. Utilisez plutôt les paramètres Claude Code pour la configuration partagée. |

320| `allowDangerouslySkipPermissions` | `false` | Ajoute [Auto mode](/fr/permission-modes#eliminate-prompts-with-auto-mode) et Bypass permissions au sélecteur de mode. Auto mode a [plan, admin, model, and provider requirements](/fr/permission-modes#eliminate-prompts-with-auto-mode), donc il peut rester indisponible même avec ce basculement activé. Utilisez Bypass permissions uniquement dans les sandboxes sans accès à Internet. |322| `allowDangerouslySkipPermissions` | `false` | Ajoute [Auto mode](/fr/permission-modes#eliminate-prompts-with-auto-mode) et Bypass permissions au sélecteur de mode. Auto mode a [plan, admin, model, and provider requirements](/fr/permission-modes#eliminate-prompts-with-auto-mode), donc il peut rester indisponible même avec ce basculement activé. Utilisez Bypass permissions uniquement dans les sandboxes sans accès à Internet. |

321| `claudeProcessWrapper` | - | Chemin exécutable utilisé pour lancer le processus Claude |323| `claudeProcessWrapper` | - | Exécutable utilisé pour lancer le processus Claude. Le chemin du binaire fourni est transmis en tant qu'argument si présent. Définissez ceci sur un binaire `claude` installé séparément si la version de l'extension n'en inclut pas un pour votre plateforme. |

322 324

323## Extension VS Code vs. CLI Claude Code325## Extension VS Code vs. CLI Claude Code

324 326

Documentation 2026-05-07 22:59 UTC to 2026-05-08 22:00 UTC