Documentation — Spybara

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

Details

14 14

15## Controlar la configuración del sistema de archivos con settingSources15## Controlar la configuración del sistema de archivos con settingSources

16 16

17La opción de fuentes de configuración ([`setting_sources`](/es/agent-sdk/python#claude-agent-options) en Python, [`settingSources`](/es/agent-sdk/typescript#setting-source) en TypeScript) controla qué configuración basada en el sistema de archivos carga el SDK. Pase una lista explícita para optar por fuentes específicas, o pase una matriz vacía para deshabilitar la configuración de usuario, proyecto y local.17La opción de fuentes de configuración ([`setting_sources`](/es/agent-sdk/python#claudeagentoptions) en Python, [`settingSources`](/es/agent-sdk/typescript#settingsource) en TypeScript) controla qué configuración basada en el sistema de archivos carga el SDK. Pase una lista explícita para optar por fuentes específicas, o pase una matriz vacía para deshabilitar la configuración de usuario, proyecto y local.

18 18

19Este ejemplo carga tanto la configuración a nivel de usuario como a nivel de proyecto estableciendo `settingSources` en `["user", "project"]`:19Este ejemplo carga tanto la configuración a nivel de usuario como a nivel de proyecto estableciendo `settingSources` en `["user", "project"]`:

20 20

65 ```65 ```

66</CodeGroup>66</CodeGroup>

67 67

68Cada fuente carga la configuración desde una ubicación específica, donde `<cwd>` es el directorio de trabajo que pasa a través de la opción `cwd` (o el directorio actual del proceso si no está establecido). Para la definición de tipo completa, consulte [`SettingSource`](/es/agent-sdk/typescript#setting-source) (TypeScript) o [`SettingSource`](/es/agent-sdk/python#setting-source) (Python).68Cada fuente carga la configuración desde una ubicación específica, donde `<cwd>` es el directorio de trabajo que pasa a través de la opción `cwd`, o el directorio actual del proceso si no está establecido. Para la definición de tipo completa, consulte [`SettingSource`](/es/agent-sdk/typescript#settingsource) (TypeScript) o [`SettingSource`](/es/agent-sdk/python#settingsource) (Python).

69 69

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

119 119

120Los skills son archivos markdown que proporcionan a su agente conocimiento especializado y flujos de trabajo invocables. A diferencia de `CLAUDE.md` (que se carga cada sesión), los skills se cargan bajo demanda. El agente recibe descripciones de skills al inicio y carga el contenido completo cuando es relevante.120Los skills son archivos markdown que proporcionan a su agente conocimiento especializado y flujos de trabajo invocables. A diferencia de `CLAUDE.md` (que se carga cada sesión), los skills se cargan bajo demanda. El agente recibe descripciones de skills al inicio y carga el contenido completo cuando es relevante.

121 121

122Los skills se descubren desde el sistema de archivos a través de `settingSources`. Con opciones predeterminadas, los skills de usuario y proyecto se cargan automáticamente. La herramienta `Skill` está habilitada de forma predeterminada cuando no especifica `allowedTools`. Si está usando una lista de permitidos `allowedTools`, incluya `"Skill"` explícitamente.122Los skills se descubren desde el sistema de archivos a través de `settingSources`. Cuando la opción `skills` en `query()` se omite, los skills de usuario y proyecto descubiertos se habilitan y la herramienta Skill está disponible, coincidiendo con el comportamiento de CLI. Para controlar qué skills están habilitados, pase `skills` como `"all"`, una lista de nombres de skills, o `[]` para deshabilitar todos. El SDK habilita la herramienta Skill automáticamente cuando `skills` está configurado, por lo que no necesita agregarla a `allowedTools`.

123 123

124<CodeGroup>124<CodeGroup>

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

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

132 options=ClaudeAgentOptions(132 options=ClaudeAgentOptions(

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

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

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

135 ),136 ),

136 ):137 ):

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

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

148 options: {149 options: {

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

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

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

151 }153 }

152 })) {154 })) {

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

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

264| Ejecutar un flujo de trabajo reutilizable (desplegar, revisar, lanzar) | [Skills invocables por el usuario](/es/agent-sdk/skills) | `settingSources` + `allowedTools: ["Skill"]` |266| Ejecutar un flujo de trabajo reutilizable (desplegar, revisar, lanzar) | [Skills invocables por el usuario](/es/agent-sdk/skills) | opción `settingSources` + `skills` |

265| Delegar una subtarea aislada a un contexto nuevo (investigación, revisión) | [Subagentos](/es/agent-sdk/subagents) | parámetro `agents` + `allowedTools: ["Agent"]` |267| Delegar una subtarea aislada a un contexto nuevo (investigación, revisión) | [Subagentos](/es/agent-sdk/subagents) | parámetro `agents` + `allowedTools: ["Agent"]` |

266| Coordinar múltiples instancias de Claude Code con listas de tareas compartidas y mensajería directa entre agentes | [Equipos de agentes](/es/agent-teams) | No se configura directamente a través de opciones del SDK. Los equipos de agentes son una característica CLI donde una sesión actúa como el líder del equipo, coordinando el trabajo entre compañeros independientes |268| Coordinar múltiples instancias de Claude Code con listas de tareas compartidas y mensajería directa entre agentes | [Equipos de agentes](/es/agent-teams) | No se configura directamente a través de opciones del SDK. Los equipos de agentes son una característica CLI donde una sesión actúa como el líder del equipo, coordinando el trabajo entre compañeros independientes |

267| Ejecutar lógica determinista en llamadas de herramientas (auditoría, bloqueo, transformación) | [Hooks](/es/agent-sdk/hooks) | parámetro `hooks` con devoluciones de llamada, o scripts de shell cargados a través de `settingSources` |269| Ejecutar lógica determinista en llamadas de herramientas (auditoría, bloqueo, transformación) | [Hooks](/es/agent-sdk/hooks) | parámetro `hooks` con devoluciones de llamada, o scripts de shell cargados a través de `settingSources` |

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

Details

1> ## Documentation Index

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

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

5# Conectar con herramientas externas usando MCP

7> Configure servidores MCP para extender su agente con herramientas externas. Cubre tipos de transporte, búsqueda de herramientas para conjuntos grandes de herramientas, autenticación y manejo de errores.

9El [Protocolo de Contexto de Modelo (MCP)](https://modelcontextprotocol.io/docs/getting-started/intro) es un estándar abierto para conectar agentes de IA a herramientas externas y fuentes de datos. Con MCP, su agente puede consultar bases de datos, integrarse con APIs como Slack y GitHub, y conectarse a otros servicios sin escribir implementaciones de herramientas personalizadas.

11Los servidores MCP pueden ejecutarse como procesos locales, conectarse a través de HTTP o ejecutarse directamente dentro de su aplicación SDK.

13<Note>

14 Esta página cubre la configuración de MCP para el Agent SDK. Para agregar servidores MCP a la CLI de Claude Code de modo que se carguen en cada proyecto, consulte [Alcances de instalación de MCP](/es/mcp#mcp-installation-scopes).

15</Note>

17## Inicio rápido

19Este ejemplo se conecta al servidor MCP de [documentación de Claude Code](https://code.claude.com/docs) usando [transporte HTTP](#httpsse-servers) y utiliza [`allowedTools`](#allow-mcp-tools) con un comodín para permitir todas las herramientas del servidor.

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>

71El agente se conecta al servidor de documentación, busca información sobre hooks y devuelve los resultados.

73## Agregar un servidor MCP

75Puede configurar servidores MCP en código al llamar a `query()`, o en un archivo `.mcp.json` cargado a través de [`settingSources`](#from-a-config-file).

77### En código

79Pase servidores MCP directamente en la opción `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### Desde un archivo de configuración

133

134Cree un archivo `.mcp.json` en la raíz de su proyecto. El archivo se recoge cuando la fuente de configuración `project` está habilitada, que lo está para las opciones predeterminadas de `query()`. Si establece `settingSources` explícitamente, incluya `"project"` para que este archivo se cargue:

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## Permitir herramientas MCP

148

149Las herramientas MCP requieren permiso explícito antes de que Claude pueda usarlas. Sin permiso, Claude verá que las herramientas están disponibles pero no podrá llamarlas.

150

151### Convención de nomenclatura de herramientas

152

153Las herramientas MCP siguen el patrón de nomenclatura `mcp__<server-name>__<tool-name>`. Por ejemplo, un servidor GitHub llamado `"github"` con una herramienta `list_issues` se convierte en `mcp__github__list_issues`.

154

155### Otorgar acceso con allowedTools

156

157Use `allowedTools` para especificar qué herramientas MCP puede usar Claude:

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

174Los comodines (`*`) le permiten permitir todas las herramientas de un servidor sin enumerar cada una individualmente.

175

176<Note>

177 **Prefiera `allowedTools` sobre modos de permiso para acceso a MCP.** `permissionMode: "acceptEdits"` no aprueba automáticamente herramientas MCP (solo ediciones de archivos y comandos Bash del sistema de archivos). `permissionMode: "bypassPermissions"` sí aprueba automáticamente herramientas MCP pero también desactiva todos los demás avisos de seguridad, lo que es más amplio de lo necesario. Un comodín en `allowedTools` otorga exactamente el servidor MCP que desea y nada más. Consulte [Modos de permiso](/es/agent-sdk/permissions#permission-modes) para una comparación completa.

178</Note>

179

180### Descubrir herramientas disponibles

181

182Para ver qué herramientas proporciona un servidor MCP, consulte la documentación del servidor o conéctese al servidor e inspeccione el mensaje de inicialización `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## Tipos de transporte

193

194Los servidores MCP se comunican con su agente utilizando diferentes protocolos de transporte. Consulte la documentación del servidor para ver qué transporte admite:

195

196* Si los documentos le dan un **comando para ejecutar** (como `npx @modelcontextprotocol/server-github`), use stdio

197* Si los documentos le dan una **URL**, use HTTP o SSE

198* Si está construyendo sus propias herramientas en código, use un servidor MCP SDK

199

200### Servidores stdio

201

202Procesos locales que se comunican a través de stdin/stdout. Use esto para servidores MCP que ejecuta en la misma máquina:

203

204<Tabs>

205 <Tab title="En código">

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

257

258Use HTTP o SSE para servidores MCP alojados en la nube y APIs remotas:

259

260<Tabs>

261 <Tab title="En código">

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

312Para HTTP (sin transmisión), use `"type": "http"` en su lugar.

313

314### Servidores MCP SDK

315

316Defina herramientas personalizadas directamente en el código de su aplicación en lugar de ejecutar un proceso de servidor separado. Consulte la [guía de herramientas personalizadas](/es/agent-sdk/custom-tools) para detalles de implementación.

317

318## Búsqueda de herramientas MCP

319

320Cuando tiene muchas herramientas MCP configuradas, las definiciones de herramientas pueden consumir una parte significativa de su ventana de contexto. La búsqueda de herramientas resuelve esto al retener las definiciones de herramientas del contexto y cargar solo las que Claude necesita para cada turno.

321

322La búsqueda de herramientas está habilitada de forma predeterminada. Consulte [Búsqueda de herramientas](/es/agent-sdk/tool-search) para opciones de configuración y detalles.

323

324Para más detalles, incluidas las mejores prácticas y el uso de búsqueda de herramientas con herramientas SDK personalizadas, consulte la [guía de búsqueda de herramientas](/es/agent-sdk/tool-search).

325

326## Autenticación

327

328La mayoría de los servidores MCP requieren autenticación para acceder a servicios externos. Pase credenciales a través de variables de entorno en la configuración del servidor.

329

330### Pasar credenciales a través de variables de entorno

331

332Use el campo `env` para pasar claves API, tokens y otras credenciales al servidor MCP:

333

334<Tabs>

335 <Tab title="En código">

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 sintaxis `${GITHUB_TOKEN}` expande variables de entorno en tiempo de ejecución.

385 </Tab>

386</Tabs>

387

388Consulte [Listar problemas de un repositorio](#list-issues-from-a-repository) para un ejemplo completo y funcional con registro de depuración.

389

390### Encabezados HTTP para servidores remotos

391

392Para servidores HTTP y SSE, pase encabezados de autenticación directamente en la configuración del servidor:

393

394<Tabs>

395 <Tab title="En código">

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 sintaxis `${API_TOKEN}` expande variables de entorno en tiempo de ejecución.

445 </Tab>

446</Tabs>

447

448### Autenticación OAuth2

449

450La [especificación MCP admite OAuth 2.1](https://modelcontextprotocol.io/specification/2025-03-26/basic/authorization) para autorización. El SDK no maneja flujos OAuth automáticamente, pero puede pasar tokens de acceso a través de encabezados después de completar el flujo OAuth en su aplicación:

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

489

490### Listar problemas de un repositorio

491

492Este ejemplo se conecta al [servidor GitHub MCP](https://github.com/modelcontextprotocol/servers/tree/main/src/github) para enumerar problemas recientes. El ejemplo incluye registro de depuración para verificar la conexión MCP y las llamadas de herramientas.

493

494Antes de ejecutar, cree un [token de acceso personal de GitHub](https://github.com/settings/tokens) con alcance `repo` y establézcalo como variable de entorno:

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### Consultar una base de datos

588

589Este ejemplo utiliza el [servidor Postgres MCP](https://github.com/modelcontextprotocol/servers/tree/main/src/postgres) para consultar una base de datos. La cadena de conexión se pasa como argumento al servidor. El agente descubre automáticamente el esquema de la base de datos, escribe la consulta SQL y devuelve los resultados:

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## Manejo de errores

659

660Los servidores MCP pueden fallar al conectarse por varias razones: el proceso del servidor podría no estar instalado, las credenciales podrían ser inválidas, o un servidor remoto podría ser inaccesible.

661

662El SDK emite un mensaje `system` con subtipo `init` al inicio de cada consulta. Este mensaje incluye el estado de conexión para cada servidor MCP. Verifique el campo `status` para detectar fallos de conexión antes de que el agente comience a trabajar:

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## Solución de problemas

721

722### El servidor muestra estado "failed"

723

724Verifique el mensaje `init` para ver qué servidores no se conectaron:

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

736Causas comunes:

737

738* **Variables de entorno faltantes**: Asegúrese de que los tokens y credenciales requeridos estén configurados. Para servidores stdio, verifique que el campo `env` coincida con lo que espera el servidor.

739* **Servidor no instalado**: Para comandos `npx`, verifique que el paquete exista y que Node.js esté en su PATH.

740* **Cadena de conexión inválida**: Para servidores de base de datos, verifique el formato de la cadena de conexión y que la base de datos sea accesible.

741* **Problemas de red**: Para servidores HTTP/SSE remotos, verifique que la URL sea accesible y que los firewalls permitan la conexión.

742

743### Las herramientas no se están llamando

744

745Si Claude ve herramientas pero no las usa, verifique que haya otorgado permiso con `allowedTools`:

746

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

748const _ = {

749 options: {

750 mcpServers: {

751 // your servers

752 },

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

754 }

755};

756```

757

758### Tiempos de espera de conexión

759

760El SDK de MCP tiene un tiempo de espera predeterminado de 60 segundos para conexiones de servidor. Si su servidor tarda más en iniciarse, la conexión fallará. Para servidores que necesitan más tiempo de inicio, considere:

761

762* Usar un servidor más ligero si está disponible

763* Precalentar el servidor antes de iniciar su agente

764* Verificar los registros del servidor para causas de inicialización lenta

765

766## Recursos relacionados

767

768* **[Guía de herramientas personalizadas](/es/agent-sdk/custom-tools)**: Construya su propio servidor MCP que se ejecute en proceso con su aplicación SDK

769* **[Permisos](/es/agent-sdk/permissions)**: Controle qué herramientas MCP puede usar su agente con `allowedTools` y `disallowedTools`

770* **[Referencia del SDK de TypeScript](/es/agent-sdk/typescript)**: Referencia completa de la API incluyendo opciones de configuración de MCP

771* **[Referencia del SDK de Python](/es/agent-sdk/python)**: Referencia completa de la API incluyendo opciones de configuración de MCP

772* **[Directorio de servidores MCP](https://github.com/modelcontextprotocol/servers)**: Explore servidores MCP disponibles para bases de datos, APIs y más

agent-sdk/python.md +1 −0

Details

836| `setting_sources` | `list[SettingSource] \| None` | `None` (CLI defaults: all sources) | Controlar qué configuración del sistema de archivos cargar. Pase `[]` para deshabilitar la configuración de usuario, proyecto y local. La configuración de política administrada se carga independientemente. Ver [Use Claude Code features](/es/agent-sdk/claude-code-features#what-settingsources-does-not-control) |836| `setting_sources` | `list[SettingSource] \| None` | `None` (CLI defaults: all sources) | Controlar qué configuración del sistema de archivos cargar. Pase `[]` para deshabilitar la configuración de usuario, proyecto y local. La configuración de política administrada se carga independientemente. Ver [Use Claude Code features](/es/agent-sdk/claude-code-features#what-settingsources-does-not-control) |

837| `skills` | `list[str] \| Literal["all"] \| None` | `None` | Skills disponibles para la sesión. Pase `"all"` para habilitar cada skill descubierto, o una lista de nombres de skills. Cuando se establece, el SDK habilita la herramienta Skill automáticamente sin listarla en `allowed_tools`. Ver [Skills](/es/agent-sdk/skills) |

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# Trabajar con sesiones

7> Cómo las sesiones persisten el historial de conversación del agente, y cuándo usar continue, resume y fork para volver a una ejecución anterior.

9Una sesión es el historial de conversación que el SDK acumula mientras su agente trabaja. Contiene su prompt, cada llamada a herramienta que hizo el agente, cada resultado de herramienta y cada respuesta. El SDK la escribe en disco automáticamente para que pueda volver a ella más tarde.

11Volver a una sesión significa que el agente tiene contexto completo de antes: archivos que ya leyó, análisis que ya realizó, decisiones que ya tomó. Puede hacer una pregunta de seguimiento, recuperarse de una interrupción o ramificarse para probar un enfoque diferente.

13<Note>

14 Las sesiones persisten la **conversación**, no el sistema de archivos. Para capturar y revertir cambios de archivos que hizo el agente, use [file checkpointing](/es/agent-sdk/file-checkpointing).

15</Note>

17Esta guía cubre cómo elegir el enfoque correcto para su aplicación, las interfaces del SDK que rastrean sesiones automáticamente, cómo capturar IDs de sesión y usar `resume` y `fork` manualmente, y qué debe saber sobre reanudar sesiones entre hosts.

19## Elegir un enfoque

21Cuánto manejo de sesiones necesita depende de la forma de su aplicación. La gestión de sesiones entra en juego cuando envía múltiples prompts que deben compartir contexto. Dentro de una única llamada `query()`, el agente ya toma tantos turnos como necesita, y los prompts de permiso y `AskUserQuestion` se [manejan en bucle](/es/agent-sdk/user-input) (no terminan la llamada).

23| Lo que está construyendo | Qué usar |

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

25| Tarea de una sola vez: prompt único, sin seguimiento | Nada extra. Una llamada `query()` lo maneja. |

26| Chat multi-turno en un proceso | [`ClaudeSDKClient` (Python) o `continue: true` (TypeScript)](#automatic-session-management). El SDK rastrea la sesión para usted sin manejo de ID. |

27| Continuar donde lo dejó después de un reinicio de proceso | `continue_conversation=True` (Python) / `continue: true` (TypeScript). Reanuda la sesión más reciente en el directorio, sin ID necesario. |

28| Reanudar una sesión pasada específica (no la más reciente) | Capture el ID de sesión y páselo a `resume`. |

29| Probar un enfoque alternativo sin perder el original | Bifurque la sesión. |

30| Tarea sin estado, no quiere nada escrito en disco (solo TypeScript) | Establezca [`persistSession: false`](/es/agent-sdk/typescript#options). La sesión existe solo en memoria durante la duración de la llamada. Python siempre persiste en disco. |

32### Continue, resume y fork

34Continue, resume y fork son campos de opción que establece en `query()` ([`ClaudeAgentOptions`](/es/agent-sdk/python#claudeagentoptions) en Python, [`Options`](/es/agent-sdk/typescript#options) en TypeScript).

36**Continue** y **resume** ambos retoman una sesión existente y la amplían. La diferencia es cómo encuentran esa sesión:

38* **Continue** encuentra la sesión más reciente en el directorio actual. No rastrea nada. Funciona bien cuando su aplicación ejecuta una conversación a la vez.

39* **Resume** toma un ID de sesión específico. Rastrea el ID. Requerido cuando tiene múltiples sesiones (por ejemplo, una por usuario en una aplicación multiusuario) o desea volver a una que no sea la más reciente.

41**Fork** es diferente: crea una nueva sesión que comienza con una copia del historial del original. El original permanece sin cambios. Use fork para probar una dirección diferente mientras mantiene la opción de volver atrás.

43## Gestión automática de sesiones

45Ambos SDKs ofrecen una interfaz que rastrea el estado de la sesión para usted entre llamadas, por lo que no pasa IDs alrededor manualmente. Use estos para conversaciones multi-turno dentro de un único proceso.

47### Python: `ClaudeSDKClient`

49[`ClaudeSDKClient`](/es/agent-sdk/python#claudesdkclient) maneja IDs de sesión internamente. Cada llamada a `client.query()` continúa automáticamente la misma sesión. Llame a [`client.receive_response()`](/es/agent-sdk/python#claudesdkclient) para iterar sobre los mensajes de la consulta actual. El cliente debe usarse como un gestor de contexto asincrónico.

51Este ejemplo ejecuta dos consultas contra el mismo `client`. La primera le pide al agente que analice un módulo; la segunda le pide que refactorice ese módulo. Debido a que ambas llamadas van a través de la misma instancia de cliente, la segunda consulta tiene contexto completo de la primera sin ningún `resume` explícito o ID de sesión:

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

99Vea la [referencia del SDK de Python](/es/agent-sdk/python#choosing-between-query-and-claudesdkclient) para detalles sobre cuándo usar `ClaudeSDKClient` versus la función `query()` independiente.

100

101### TypeScript: `continue: true`

102

103El SDK de TypeScript estable (la función `query()` utilizada en toda esta documentación, a veces llamada V1) no tiene un objeto cliente que mantenga sesión como el `ClaudeSDKClient` de Python. En su lugar, pase `continue: true` en cada llamada `query()` posterior y el SDK retoma la sesión más reciente en el directorio actual. No se requiere seguimiento de ID.

104

105Este ejemplo hace dos llamadas `query()` separadas. La primera crea una sesión nueva; la segunda establece `continue: true`, que le dice al SDK que encuentre y reanude la sesión más reciente en disco. El agente tiene contexto completo de la primera llamada:

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 La [API de sesión V2](/es/agent-sdk/typescript-v2-preview) experimental, que proporcionaba `createSession()` con un patrón `send` / `stream`, está deprecada. Use la función V1 `query()` y las opciones de sesión descritas en esta página en su lugar.

136</Note>

137

138## Usar opciones de sesión con `query()`

139

140### Capturar el ID de sesión

141

142Resume y fork requieren un ID de sesión. Léalo del campo `session_id` en el mensaje de resultado ([`ResultMessage`](/es/agent-sdk/python#resultmessage) en Python, [`SDKResultMessage`](/es/agent-sdk/typescript#sdkresultmessage) en TypeScript), que está presente en cada resultado independientemente del éxito o error. En TypeScript, el ID también está disponible antes como un campo directo en el `SystemMessage` de inicio; en Python está anidado dentro de `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### Reanudar por ID

193

194Pase un ID de sesión a `resume` para volver a esa sesión específica. El agente retoma con contexto completo de donde la sesión se quedó. Las razones comunes para reanudar son:

195

196* **Seguimiento en una tarea completada.** El agente ya analizó algo; ahora quiere que actúe sobre ese análisis sin releer archivos.

197* **Recuperarse de un límite.** La primera ejecución terminó con `error_max_turns` o `error_max_budget_usd` (vea [Manejar el resultado](/es/agent-sdk/agent-loop#handle-the-result)); reanude con un límite más alto.

198* **Reiniciar su proceso.** Capturó el ID antes del apagado y desea restaurar la conversación.

199

200Este ejemplo reanuda la sesión de [Capturar el ID de sesión](#capture-the-session-id) con un prompt de seguimiento. Debido a que está reanudando, el agente ya tiene el análisis anterior en contexto:

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 una llamada `resume` devuelve una sesión nueva en lugar del historial esperado, la causa más común es un `cwd` no coincidente. Las sesiones se almacenan bajo `~/.claude/projects/<encoded-cwd>/*.jsonl`, donde `<encoded-cwd>` es el directorio de trabajo absoluto con cada carácter no alfanumérico reemplazado por `-` (entonces `/Users/me/proj` se convierte en `-Users-me-proj`). Si su llamada resume se ejecuta desde un directorio diferente, el SDK busca en el lugar incorrecto. El archivo de sesión también necesita existir en la máquina actual.

234</Tip>

235

236Para reanudar sesiones entre máquinas o en entornos sin servidor, refleje transcripciones en almacenamiento compartido con un adaptador [`SessionStore`](/es/agent-sdk/session-storage).

237

238### Bifurcar para explorar alternativas

239

240Bifurcar crea una nueva sesión que comienza con una copia del historial del original pero diverge desde ese punto. La bifurcación obtiene su propio ID de sesión; el ID y el historial del original permanecen sin cambios. Termina con dos sesiones independientes que puede reanudar por separado.

241

242<Note>

243 Bifurcar ramifica el historial de conversación, no el sistema de archivos. Si un agente bifurcado edita archivos, esos cambios son reales y visibles para cualquier sesión que trabaje en el mismo directorio. Para ramificar y revertir cambios de archivos, use [file checkpointing](/es/agent-sdk/file-checkpointing).

244</Note>

245

246Este ejemplo se basa en [Capturar el ID de sesión](#capture-the-session-id): ya ha analizado un módulo de autenticación en `session_id` y desea explorar OAuth2 sin perder el hilo enfocado en JWT. El primer bloque bifurca la sesión y captura el ID de la bifurcación (`forked_id`); el segundo bloque reanuda el `session_id` original para continuar por el camino JWT. Ahora tiene dos IDs de sesión apuntando a dos historiales separados:

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## Reanudar entre hosts

309

310Los archivos de sesión son locales a la máquina que los creó. Para reanudar una sesión en un host diferente (trabajadores de CI, contenedores efímeros, sin servidor), tiene dos opciones:

311

312* **Mover el archivo de sesión.** Persista `~/.claude/projects/<encoded-cwd>/<session-id>.jsonl` de la primera ejecución y restáurelo a la misma ruta en el nuevo host antes de llamar a `resume`. El `cwd` debe coincidir.

313* **No confíe en la reanudación de sesión.** Capture los resultados que necesita (salida de análisis, decisiones, diffs de archivos) como estado de aplicación y páselos al prompt de una sesión nueva. Esto a menudo es más robusto que enviar archivos de transcripción.

314

315Ambos SDKs exponen funciones para enumerar sesiones en disco y leer sus mensajes: [`listSessions()`](/es/agent-sdk/typescript#listsessions) y [`getSessionMessages()`](/es/agent-sdk/typescript#getsessionmessages) en TypeScript, [`list_sessions()`](/es/agent-sdk/python#list_sessions) y [`get_session_messages()`](/es/agent-sdk/python#get_session_messages) en Python. Úselos para construir selectores de sesión personalizados, lógica de limpieza o visores de transcripción.

316

317Ambos SDKs también exponen funciones para buscar y mutar sesiones individuales: [`get_session_info()`](/es/agent-sdk/python#get_session_info), [`rename_session()`](/es/agent-sdk/python#rename_session) y [`tag_session()`](/es/agent-sdk/python#tag_session) en Python, y [`getSessionInfo()`](/es/agent-sdk/typescript#getsessioninfo), [`renameSession()`](/es/agent-sdk/typescript#renamesession) y [`tagSession()`](/es/agent-sdk/typescript#tagsession) en TypeScript. Úselos para organizar sesiones por etiqueta o darles títulos legibles por humanos.

318

319## Recursos relacionados

320

321* [Cómo funciona el bucle del agente](/es/agent-sdk/agent-loop): Comprenda turnos, mensajes y acumulación de contexto dentro de una sesión

322* [File checkpointing](/es/agent-sdk/file-checkpointing): Rastrear y revertir cambios de archivos entre sesiones

323* [Python `ClaudeAgentOptions`](/es/agent-sdk/python#claudeagentoptions): Referencia completa de opciones de sesión para Python

324* [TypeScript `Options`](/es/agent-sdk/typescript#options): Referencia completa de opciones de sesión para 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 en el SDK

7> Extienda Claude con capacidades especializadas utilizando Agent Skills en el Claude Agent SDK

9## Descripción general

11Agent Skills extienden Claude con capacidades especializadas que Claude invoca autónomamente cuando es relevante. Las Skills se empaquetan como archivos `SKILL.md` que contienen instrucciones, descripciones y recursos de apoyo opcionales.

13Para obtener información completa sobre Skills, incluidos beneficios, arquitectura y directrices de autoría, consulte la [descripción general de Agent Skills](https://platform.claude.com/docs/es/agents-and-tools/agent-skills/overview).

15## Cómo funcionan las Skills con el SDK

17Cuando se utiliza el Claude Agent SDK, las Skills son:

191. **Definidas como artefactos del sistema de archivos**: Creadas como archivos `SKILL.md` en directorios específicos (`.claude/skills/`)

202. **Cargadas desde el sistema de archivos**: Las Skills se cargan desde ubicaciones del sistema de archivos gobernadas por `settingSources` (TypeScript) o `setting_sources` (Python)

213. **Descubiertas automáticamente**: Una vez que se cargan las configuraciones del sistema de archivos, los metadatos de Skill se descubren al inicio desde directorios de usuario y proyecto; el contenido completo se carga cuando se activa

224. **Invocadas por el modelo**: Claude elige autónomamente cuándo usarlas según el contexto

235. **Filtradas a través de la opción `skills`**: Las Skills descubiertas están habilitadas de forma predeterminada. Pase una lista de nombres de Skills, `"all"`, o `[]` para controlar cuáles están disponibles en la sesión

25A diferencia de los subagentes (que se pueden definir mediante programación), las Skills deben crearse como artefactos del sistema de archivos. El SDK no proporciona una API programática para registrar Skills.

27<Note>

28 Las Skills se descubren a través de las fuentes de configuración del sistema de archivos. Con las opciones predeterminadas de `query()`, el SDK carga fuentes de usuario y proyecto, por lo que las Skills en `~/.claude/skills/` y `<cwd>/.claude/skills/` están disponibles. Si establece `settingSources` explícitamente, incluya `'user'` o `'project'` para mantener el descubrimiento de Skills, o use la [opción `plugins`](/es/agent-sdk/plugins) para cargar Skills desde una ruta específica.

29</Note>

31## Uso de Skills con el SDK

33Establezca la opción `skills` en `query()` para controlar qué Skills están disponibles para la sesión. Cuando se omite, las Skills descubiertas están habilitadas y la herramienta Skill está disponible, coincidiendo con el comportamiento de CLI. Pase `"all"` para habilitar cada Skill descubierta, una lista de nombres de Skill para habilitar solo esos, o `[]` para deshabilitar todos. Cuando establece `skills`, el SDK habilita la herramienta Skill automáticamente, por lo que no necesita incluirla en `allowedTools`.

35Una vez configurado, Claude descubre automáticamente Skills desde el sistema de archivos e las invoca cuando es relevante para la solicitud del usuario.

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>

77Para habilitar solo Skills específicas, pase sus nombres. Los nombres coinciden con el campo `name` en `SKILL.md` o el nombre del directorio de la Skill. Use `plugin:skill` para Skills proporcionadas por 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>

89La opción `skills` es un filtro de contexto, no un sandbox. Las Skills no listadas se ocultan del modelo y se rechazan por la herramienta Skill, pero sus archivos permanecen en el disco y son accesibles a través de Read y Bash.

91## Ubicaciones de Skills

93Las Skills se cargan desde directorios del sistema de archivos según su configuración `settingSources`/`setting_sources`:

95* **Project Skills** (`.claude/skills/`): Compartidas con su equipo a través de git - cargadas cuando `setting_sources` incluye `"project"`

96* **User Skills** (`~/.claude/skills/`): Skills personales en todos los proyectos - cargadas cuando `setting_sources` incluye `"user"`

97* **Plugin Skills**: Incluidas con plugins de Claude Code instalados

99## Creación de Skills

100

101Las Skills se definen como directorios que contienen un archivo `SKILL.md` con frontmatter YAML y contenido Markdown. El campo `description` determina cuándo Claude invoca su Skill.

102

103**Estructura de directorio de ejemplo**:

104

105```bash theme={null}

106.claude/skills/processing-pdfs/

107└── SKILL.md

108```

109

110Para obtener orientación completa sobre la creación de Skills, incluida la estructura de SKILL.md, Skills de múltiples archivos y ejemplos, consulte:

111

112* [Agent Skills en Claude Code](/es/skills): Guía completa con ejemplos

113* [Agent Skills Best Practices](https://platform.claude.com/docs/es/agents-and-tools/agent-skills/best-practices): Directrices de autoría y convenciones de nomenclatura

114

115## Restricciones de herramientas

116

117<Note>

118 El campo frontmatter `allowed-tools` en SKILL.md solo se admite cuando se utiliza directamente la CLI de Claude Code. **No se aplica cuando se utilizan Skills a través del SDK**.

119

120 Cuando se utiliza el SDK, controle el acceso a herramientas a través de la opción principal `allowedTools` en su configuración de consulta.

121</Note>

122

123Para controlar el acceso a herramientas para Skills en aplicaciones SDK, use `allowedTools` para preautorizar herramientas específicas. Sin una devolución de llamada `canUseTool`, se deniega cualquier cosa que no esté en la lista:

124

125<Note>

126 Se asume que las declaraciones de importación del primer ejemplo están en los siguientes fragmentos de código.

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## Descubrimiento de Skills disponibles

157

158Para ver qué Skills están disponibles en su aplicación SDK, simplemente pregunte a Claude:

159

160<CodeGroup>

161 ```python Python theme={null}

162 options = ClaudeAgentOptions(

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

164 skills="all",

165 )

166

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

168 print(message)

169 ```

170

171 ```typescript TypeScript theme={null}

172 for await (const message of query({

173 prompt: "What Skills are available?",

174 options: {

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

176 skills: "all"

177 }

178 })) {

179 console.log(message);

180 }

181 ```

182</CodeGroup>

183

184Claude listará las Skills disponibles según su directorio de trabajo actual y plugins instalados.

185

186## Prueba de Skills

187

188Pruebe Skills haciendo preguntas que coincidan con sus descripciones:

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 invoca automáticamente la Skill relevante si la descripción coincide con su solicitud.

219

220## Solución de problemas

221

222### Skills no encontradas

223

224**Verifique la configuración de settingSources**: Las Skills se descubren a través de las fuentes de configuración `user` y `project`. Si establece `settingSources`/`setting_sources` explícitamente y omite esas fuentes, las Skills no se cargan:

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

253Para más detalles sobre `settingSources`/`setting_sources`, consulte la [referencia del SDK de TypeScript](/es/agent-sdk/typescript#settingsource) o la [referencia del SDK de Python](/es/agent-sdk/python#settingsource).

254

255**Verifique el directorio de trabajo**: El SDK carga Skills relativas a la opción `cwd`. Asegúrese de que apunte a un directorio que contenga `.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

277Consulte la sección "Uso de Skills con el SDK" anterior para el patrón completo.

278

279**Verifique la ubicación del sistema de archivos**:

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 no se está utilizando

290

291**Verifique la opción `skills`**: Si pasó una lista de `skills`, confirme que el nombre de la Skill está incluido. Pasar `[]` deshabilita todas las Skills.

292

293**Verifique la descripción**: Asegúrese de que sea específica e incluya palabras clave relevantes. Consulte [Agent Skills Best Practices](https://platform.claude.com/docs/es/agents-and-tools/agent-skills/best-practices#writing-effective-descriptions) para obtener orientación sobre cómo escribir descripciones efectivas.

294

295### Solución de problemas adicional

296

297Para la solución de problemas general de Skills (sintaxis YAML, depuración, etc.), consulte la [sección de solución de problemas de Skills de Claude Code](/es/skills#troubleshooting).

298

299## Documentación relacionada

300

301### Guías de Skills

302

303* [Agent Skills en Claude Code](/es/skills): Guía completa de Skills con creación, ejemplos y solución de problemas

304* [Agent Skills Overview](https://platform.claude.com/docs/es/agents-and-tools/agent-skills/overview): Descripción general conceptual, beneficios y arquitectura

305* [Agent Skills Best Practices](https://platform.claude.com/docs/es/agents-and-tools/agent-skills/best-practices): Directrices de autoría para Skills efectivas

306* [Agent Skills Cookbook](https://platform.claude.com/cookbook/skills-notebooks-01-skills-introduction): Skills de ejemplo y plantillas

307

308### Recursos del SDK

309

310* [Subagents en el SDK](/es/agent-sdk/subagents): Agentes similares basados en el sistema de archivos con opciones programáticas

311* [Slash Commands en el SDK](/es/agent-sdk/slash-commands): Comandos invocados por el usuario

312* [Descripción general del SDK](/es/agent-sdk/overview): Conceptos generales del SDK

313* [Referencia del SDK de TypeScript](/es/agent-sdk/typescript): Documentación completa de la API

314* [Referencia del SDK de Python](/es/agent-sdk/python): Documentación completa de la 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# Subagentes en el SDK

7> Define e invoque subagentes para aislar contexto, ejecutar tareas en paralelo y aplicar instrucciones especializadas en sus aplicaciones Claude Agent SDK.

9Los subagentes son instancias de agente separadas que su agente principal puede generar para manejar subtareas enfocadas.

10Utilice subagentes para aislar contexto para subtareas enfocadas, ejecutar múltiples análisis en paralelo y aplicar instrucciones especializadas sin sobrecargar el prompt del agente principal.

12Esta guía explica cómo definir y usar subagentes en el SDK utilizando el parámetro `agents`.

14## Descripción general

16Puede crear subagentes de tres formas:

18* **Programáticamente**: use el parámetro `agents` en sus opciones `query()` ([TypeScript](/es/agent-sdk/typescript#agentdefinition), [Python](/es/agent-sdk/python#agentdefinition))

19* **Basado en sistema de archivos**: defina agentes como archivos markdown en directorios `.claude/agents/` (consulte [definición de subagentes como archivos](/es/sub-agents))

20* **Propósito general integrado**: Claude puede invocar el subagente integrado `general-purpose` en cualquier momento a través de la herramienta Agent sin que usted defina nada

22Esta guía se enfoca en el enfoque programático, que se recomienda para aplicaciones SDK.

24Cuando define subagentes, Claude determina si invocarlos en función del campo `description` de cada subagente. Escriba descripciones claras que expliquen cuándo se debe usar el subagente, y Claude delegará automáticamente las tareas apropiadas. También puede solicitar explícitamente un subagente por nombre en su prompt (por ejemplo, "Usa el agente code-reviewer para...").

26## Beneficios de usar subagentes

28### Aislamiento de contexto

30Cada subagente se ejecuta en su propia conversación nueva. Las llamadas a herramientas intermedias y los resultados permanecen dentro del subagente; solo su mensaje final regresa al padre. Consulte [Qué heredan los subagentes](#what-subagents-inherit) para ver exactamente qué hay en el contexto del subagente.

32**Ejemplo:** un subagente `research-assistant` puede explorar docenas de archivos sin que ninguno de ese contenido se acumule en la conversación principal. El padre recibe un resumen conciso, no cada archivo que leyó el subagente.

34### Paralelización

36Múltiples subagentes pueden ejecutarse simultáneamente, acelerando dramáticamente flujos de trabajo complejos.

38**Ejemplo:** durante una revisión de código, puede ejecutar los subagentes `style-checker`, `security-scanner` y `test-coverage` simultáneamente, reduciendo el tiempo de revisión de minutos a segundos.

40### Instrucciones y conocimiento especializados

42Cada subagente puede tener prompts de sistema personalizados con experiencia específica, mejores prácticas y restricciones.

44**Ejemplo:** un subagente `database-migration` puede tener conocimiento detallado sobre mejores prácticas de SQL, estrategias de reversión y verificaciones de integridad de datos que serían ruido innecesario en las instrucciones del agente principal.

46### Restricciones de herramientas

48Los subagentes pueden limitarse a herramientas específicas, reduciendo el riesgo de acciones no intencionadas.

50**Ejemplo:** un subagente `doc-reviewer` podría tener acceso solo a las herramientas Read y Grep, asegurando que pueda analizar pero nunca modifique accidentalmente sus archivos de documentación.

52## Creación de subagentes

54### Definición programática (recomendada)

56Defina subagentes directamente en su código utilizando el parámetro `agents`. Este ejemplo crea dos subagentes: un revisor de código con acceso de solo lectura y un ejecutor de pruebas que puede ejecutar comandos. La herramienta `Agent` debe incluirse en `allowedTools` ya que Claude invoca subagentes a través de la herramienta 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### Configuración de AgentDefinition

161

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

176

177En el SDK de Python, estos nombres de campo usan camelCase para coincidir con el formato de cable. Consulte la referencia [`AgentDefinition`](/es/agent-sdk/python#agentdefinition) para obtener detalles.

178

179<Note>

180 Los subagentes no pueden generar sus propios subagentes. No incluya `Agent` en la matriz `tools` de un subagente.

181</Note>

182

183### Definición basada en sistema de archivos (alternativa)

184

185También puede definir subagentes como archivos markdown en directorios `.claude/agents/`. Consulte la [documentación de subagentes de Claude Code](/es/sub-agents) para obtener detalles sobre este enfoque. Los agentes definidos programáticamente tienen prioridad sobre los agentes basados en sistema de archivos con el mismo nombre.

186

187<Note>

188 Incluso sin definir subagentes personalizados, Claude puede generar el subagente integrado `general-purpose` cuando `Agent` está en su `allowedTools`. Esto es útil para delegar tareas de investigación o exploración sin crear agentes especializados.

189</Note>

190

191## Qué heredan los subagentes

192

193La ventana de contexto de un subagente comienza nueva (sin conversación padre) pero no está vacía. El único canal del padre al subagente es la cadena de prompt de la herramienta Agent, así que incluya cualquier ruta de archivo, mensaje de error o decisión que el subagente necesite directamente en ese prompt.

194

195| El subagente recibe | El subagente no recibe |

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

197| Su propio prompt del sistema (`AgentDefinition.prompt`) y el prompt de la herramienta Agent | El historial de conversación del padre o resultados de herramientas |

198| CLAUDE.md del proyecto (cargado a través de `settingSources`) | Contenido de skill precargado, a menos que esté listado en `AgentDefinition.skills` |

199| Definiciones de herramientas (heredadas del padre, o el subconjunto en `tools`) | El prompt del sistema del padre |

200

201<Note>

202 El padre recibe el mensaje final del subagente textualmente como el resultado de la herramienta Agent, pero puede resumirlo en su propia respuesta. Para preservar la salida del subagente textualmente en la respuesta visible para el usuario, incluya una instrucción para hacerlo en el prompt u opción `systemPrompt` que pase a la llamada `query()` **principal**.

203</Note>

204

205## Invocación de subagentes

206

207### Invocación automática

208

209Claude decide automáticamente cuándo invocar subagentes en función de la tarea y la `description` de cada subagente. Por ejemplo, si define un subagente `performance-optimizer` con la descripción "Especialista en optimización de rendimiento para ajuste de consultas", Claude lo invocará cuando su prompt mencione optimizar consultas.

210

211Escriba descripciones claras y específicas para que Claude pueda hacer coincidir tareas con el subagente correcto.

212

213### Invocación explícita

214

215Para garantizar que Claude use un subagente específico, mencione su nombre en su prompt:

216

217```text theme={null}

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

219```

220

221Esto omite la coincidencia automática e invoca directamente el subagente nombrado.

222

223### Configuración dinámica de agentes

224

225Puede crear definiciones de agentes dinámicamente en función de condiciones en tiempo de ejecución. Este ejemplo crea un revisor de seguridad con diferentes niveles de rigor, utilizando un modelo más potente para revisiones estrictas.

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## Detección de invocación de subagentes

300

301Los subagentes se invocan a través de la herramienta Agent. Para detectar cuándo se invoca un subagente, busque bloques `tool_use` donde `name` sea `"Agent"`. Los mensajes desde dentro del contexto de un subagente incluyen un campo `parent_tool_use_id`.

302

303<Note>

304 El nombre de la herramienta se cambió de `"Task"` a `"Agent"` en Claude Code v2.1.63. Los lanzamientos actuales del SDK emiten `"Agent"` en bloques `tool_use` pero aún usan `"Task"` en la lista de herramientas `system:init` y en `result.permission_denials[].tool_name`. Verificar ambos valores en `block.name` asegura compatibilidad entre versiones del SDK.

305</Note>

306

307Este ejemplo itera a través de mensajes transmitidos, registrando cuándo se invoca un subagente y cuándo los mensajes posteriores se originan dentro del contexto de ejecución de ese subagente.

308

309<Note>

310 La estructura del mensaje difiere entre SDKs. En Python, los bloques de contenido se acceden directamente a través de `message.content`. En TypeScript, `SDKAssistantMessage` envuelve el mensaje de la API de Claude, por lo que el contenido se accede a través de `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## Reanudación de subagentes

393

394Los subagentes pueden reanudarse para continuar donde se detuvieron. Los subagentes reanudados retienen su historial de conversación completo, incluidas todas las llamadas a herramientas anteriores, resultados y razonamiento. El subagente continúa exactamente donde se detuvo en lugar de comenzar de nuevo.

395

396Cuando un subagente se completa, Claude recibe su ID de agente en el resultado de la herramienta Agent. Para reanudar un subagente programáticamente:

397

3981. **Capture el ID de sesión**: Extraiga `session_id` de los mensajes durante la primera consulta

3992. **Extraiga el ID del agente**: Analice `agentId` del contenido del mensaje

4003. **Reanude la sesión**: Pase `resume: sessionId` en las opciones de la segunda consulta e incluya el ID del agente en su prompt

401

402<Note>

403 Debe reanudar la misma sesión para acceder a la transcripción del subagente. Cada llamada `query()` inicia una nueva sesión por defecto, así que pase `resume: sessionId` para continuar en la misma sesión.

404

405 Si está usando un agente personalizado (no uno integrado), también necesita pasar la misma definición de agente en el parámetro `agents` para ambas consultas.

406</Note>

407

408El ejemplo a continuación demuestra este flujo: la primera consulta ejecuta un subagente y captura el ID de sesión e ID de agente, luego la segunda consulta reanuda la sesión para hacer una pregunta de seguimiento que requiere contexto del primer análisis.

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

504Las transcripciones de subagentes persisten independientemente de la conversación principal:

505

506* **Compactación de conversación principal**: Cuando la conversación principal se compacta, las transcripciones de subagentes no se ven afectadas. Se almacenan en archivos separados.

507* **Persistencia de sesión**: Las transcripciones de subagentes persisten dentro de su sesión. Puede reanudar un subagente después de reiniciar Claude Code reanudando la misma sesión.

508* **Limpieza automática**: Las transcripciones se limpian en función de la configuración `cleanupPeriodDays` (predeterminado: 30 días).

509

510## Restricciones de herramientas

511

512Los subagentes pueden tener acceso restringido a herramientas a través del campo `tools`:

513

514* **Omitir el campo**: el agente hereda todas las herramientas disponibles (predeterminado)

515* **Especificar herramientas**: el agente solo puede usar las herramientas listadas

516

517Este ejemplo crea un agente de análisis de solo lectura que puede examinar código pero no puede modificar archivos ni ejecutar comandos.

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### Combinaciones comunes de herramientas

572

573| Caso de uso | Herramientas | Descripción |

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

575| Análisis de solo lectura | `Read`, `Grep`, `Glob` | Puede examinar código pero no modificar ni ejecutar |

576| Ejecución de pruebas | `Bash`, `Read`, `Grep` | Puede ejecutar comandos y analizar salida |

577| Modificación de código | `Read`, `Edit`, `Write`, `Grep`, `Glob` | Acceso completo de lectura/escritura sin ejecución de comandos |

578| Acceso completo | Todas las herramientas | Hereda todas las herramientas del padre (omita el campo `tools`) |

579

580## Solución de problemas

581

582### Claude no delega a subagentes

583

584Si Claude completa tareas directamente en lugar de delegar a su subagente:

585

5861. **Incluya la herramienta Agent**: los subagentes se invocan a través de la herramienta Agent, por lo que debe estar en `allowedTools`

5872. **Use prompting explícito**: mencione el subagente por nombre en su prompt (por ejemplo, "Usa el agente code-reviewer para...")

5883. **Escriba una descripción clara**: explique exactamente cuándo se debe usar el subagente para que Claude pueda hacer coincidir las tareas apropiadamente

589

590### Agentes basados en sistema de archivos no se cargan

591

592Los agentes definidos en `.claude/agents/` se cargan solo al inicio. Si crea un nuevo archivo de agente mientras Claude Code está en ejecución, reinicie la sesión para cargarlo.

593

594### Windows: fallos de prompt largo

595

596En Windows, los subagentes con prompts muy largos pueden fallar debido a límites de longitud de línea de comandos (8191 caracteres). Mantenga los prompts concisos o use agentes basados en sistema de archivos para instrucciones complejas.

597

598## Documentación relacionada

599

600* [Subagentes de Claude Code](/es/sub-agents): documentación completa de subagentes incluyendo definiciones basadas en sistema de archivos

601* [Descripción general del SDK](/es/agent-sdk/overview): introducción al Claude Agent SDK

agent-sdk/typescript.md +5 −3

Details

358| `sessionStore` | [`SessionStore`](/es/agent-sdk/session-storage#the-sessionstore-interface) | `undefined` | Refleje transcripciones de sesión en un backend externo para que cualquier host pueda reanudarlas. Vea [Persistir sesiones en almacenamiento externo](/es/agent-sdk/session-storage) |358| `sessionStore` | [`SessionStore`](/es/agent-sdk/session-storage#the-sessionstore-interface) | `undefined` | Refleje transcripciones de sesión en un backend externo para que cualquier host pueda reanudarlas. Vea [Persistir sesiones en almacenamiento externo](/es/agent-sdk/session-storage) |

359| `settings` | `string \| Settings` | `undefined` | Objeto de [configuración](/es/settings) en línea o ruta a un archivo de configuración. Completa la capa de configuración de marca en el [orden de precedencia](/es/settings#settings-precedence). Cambie en tiempo de ejecución con [`applyFlagSettings()`](#applyflagsettings) |359| `settings` | `string \| Settings` | `undefined` | Objeto de [configuración](/es/settings) en línea o ruta a un archivo de configuración. Completa la capa de configuración de marca en el [orden de precedencia](/es/settings#settings-precedence). Cambie en tiempo de ejecución con [`applyFlagSettings()`](#applyflagsettings) |

360| `settingSources` | [`SettingSource`](#settingsource)`[]` | Valores predeterminados de CLI (todas las fuentes) | Controle qué configuración del sistema de archivos cargar. Pase `[]` para deshabilitar la configuración de usuario, proyecto y local. La configuración de política administrada se carga independientemente. Vea [Usar características de Claude Code](/es/agent-sdk/claude-code-features#what-settingsources-does-not-control) |360| `settingSources` | [`SettingSource`](#settingsource)`[]` | Valores predeterminados de CLI (todas las fuentes) | Controle qué configuración del sistema de archivos cargar. Pase `[]` para deshabilitar la configuración de usuario, proyecto y local. La configuración de política administrada se carga independientemente. Vea [Usar características de Claude Code](/es/agent-sdk/claude-code-features#what-settingsources-does-not-control) |

361| `skills` | `string[] \| 'all'` | `undefined` | Skills disponibles para la sesión. Pase `'all'` para habilitar cada skill descubierto, o una lista de nombres de skills. Cuando se establece, el SDK habilita la herramienta Skill automáticamente sin enumerarla en `allowedTools`. Vea [Skills](/es/agent-sdk/skills) |

361| `spawnClaudeCodeProcess` | `(options: SpawnOptions) => SpawnedProcess` | `undefined` | Función personalizada para generar el proceso de Claude Code. Use para ejecutar Claude Code en máquinas virtuales, contenedores o entornos remotos |362| `spawnClaudeCodeProcess` | `(options: SpawnOptions) => SpawnedProcess` | `undefined` | Función personalizada para generar el proceso de Claude Code. Use para ejecutar Claude Code en máquinas virtuales, contenedores o entornos remotos |

528```529```

529 530

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

532| `description` | Sí | Descripción en lenguaje natural de cuándo usar este agente |533| `description` | Sí | Descripción en lenguaje natural de cuándo usar este agente |

533| `tools` | No | Matriz de nombres de herramientas permitidas. Si se omite, hereda todas las herramientas del padre |534| `tools` | No | Matriz de nombres de herramientas permitidas. Si se omite, hereda todas las herramientas del padre. Para precargar Skills en el contexto del agente, use el campo `skills` en lugar de enumerar `'Skill'` aquí |

534| `disallowedTools` | No | Matriz de nombres de herramientas a desautorizar explícitamente para este agente |535| `disallowedTools` | No | Matriz de nombres de herramientas a desautorizar explícitamente para este agente |

535| `prompt` | Sí | El mensaje del sistema del agente |536| `prompt` | Sí | El mensaje del sistema del agente |

536| `model` | No | Anulación de modelo para este agente. Acepta un alias como `'sonnet'`, `'opus'`, `'haiku'`, `'inherit'`, o un ID de modelo completo. Si se omite o es `'inherit'`, usa el modelo principal |537| `model` | No | Anulación de modelo para este agente. Acepta un alias como `'sonnet'`, `'opus'`, `'haiku'`, `'inherit'`, o un ID de modelo completo. Si se omite o es `'inherit'`, usa el modelo principal |

537| `mcpServers` | No | Especificaciones de servidor MCP para este agente |538| `mcpServers` | No | Especificaciones de servidor MCP para este agente |

538| `skills` | No | Matriz de nombres de habilidades a precargar en el contexto del agente |539| `skills` | No | Matriz de nombres de skills a precargar en el contexto del agente |

539| `initialPrompt` | No | Auto-enviado como el primer turno de usuario cuando este agente se ejecuta como el agente del hilo principal |540| `initialPrompt` | No | Auto-enviado como el primer turno de usuario cuando este agente se ejecuta como el agente del hilo principal |

540| `maxTurns` | No | Número máximo de turnos agentes (viajes de ronda de API) antes de detener |541| `maxTurns` | No | Número máximo de turnos agentes (viajes de ronda de API) antes de detener |

541| `background` | No | Ejecute este agente como una tarea de fondo no bloqueante cuando se invoque |542| `background` | No | Ejecute este agente como una tarea de fondo no bloqueante cuando se invoque |

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# Interfaz TypeScript SDK V2 (vista previa)~~5# API de sesión de TypeScript SDK V2 (obsoleta)

6 6

~~7> Vista previa del SDK del Agente TypeScript V2 simplificado, con patrones de envío/transmisión basados en sesiones para conversaciones de múltiples turnos.~~7> Referencia para la API de sesión obsoleta V2 del SDK del Agente TypeScript, con patrones de envío/transmisión basados en sesiones para conversaciones de múltiples turnos.

8 8

9<Warning>9<Warning>

10 La interfaz V2 es una **vista previa inestable**. Las API pueden cambiar según los comentarios antes de volverse estables. Algunas características como la bifurcación de sesiones solo están disponibles en el [SDK V1](/es/agent-sdk/typescript).10 Las funciones de la API de sesión V2 `unstable_v2_createSession`, `unstable_v2_resumeSession` y `unstable_v2_prompt` están obsoletas y se eliminarán en una versión futura. Use la [API V1 `query()`](/es/agent-sdk/typescript) en su lugar.

11</Warning>11</Warning>

12 12

13El SDK del Agente TypeScript V2 de Claude elimina la necesidad de generadores asincronos y coordinación de rendimiento. Esto hace que las conversaciones de múltiples turnos sean más simples; en lugar de gestionar el estado del generador entre turnos, cada turno es un ciclo `send()`/`stream()` separado. La superficie de la API se reduce a tres conceptos:13V2 fue una API de sesión experimental que eliminó la necesidad de generadores asincronos y coordinación de rendimiento. En lugar de gestionar el estado del generador entre turnos, cada turno era un ciclo `send()`/`stream()` separado. La superficie de la API se redujo a tres conceptos:

14 14

15* `createSession()` / `resumeSession()`: Iniciar o continuar una conversación15* `createSession()` / `resumeSession()`: Iniciar o continuar una conversación

16* `session.send()`: Enviar un mensaje16* `session.send()`: Enviar un mensaje

380 380

381## Disponibilidad de características381## Disponibilidad de características

382 382

383No todas las características de V1 están disponibles en V2 aún. Lo siguiente requiere usar el [SDK V1](/es/agent-sdk/typescript):383La API de sesión V2 no admite todas las características de V1. Lo siguiente requiere el [SDK V1](/es/agent-sdk/typescript):

384 384

385* Bifurcación de sesiones (opción `forkSession`)385* Bifurcación de sesiones (opción `forkSession`)

386* Algunos patrones avanzados de entrada de transmisión386* Algunos patrones avanzados de entrada de transmisión

387 387

388## Comentarios

~~389~~

390Comparta sus comentarios sobre la interfaz V2 antes de que se vuelva estable. Informe de problemas y sugerencias a través de [GitHub Issues](https://github.com/anthropics/claude-code/issues).

~~391~~

392## Véase también388## Véase también

393 389

394* [Referencia del SDK TypeScript (V1)](/es/agent-sdk/typescript) - Documentación completa del SDK V1390* [Referencia del SDK TypeScript (V1)](/es/agent-sdk/typescript) - Documentación completa del SDK V1

agent-teams.md +1 −1

Details

423Explore enfoques relacionados para trabajo paralelo y delegación:423Explore enfoques relacionados para trabajo paralelo y delegación:

424 424

425* **Delegación ligera**: [subagents](/es/sub-agents) generan agentes auxiliares para investigación o verificación dentro de su sesión, mejor para tareas que no necesitan coordinación entre agentes425* **Delegación ligera**: [subagents](/es/sub-agents) generan agentes auxiliares para investigación o verificación dentro de su sesión, mejor para tareas que no necesitan coordinación entre agentes

426* **Sesiones paralelas manuales**: [Git worktrees](/es/common-workflows#run-parallel-claude-code-sessions-with-git-worktrees) le permiten ejecutar múltiples sesiones de Claude Code usted mismo sin coordinación de equipo automatizada426* **Sesiones paralelas manuales**: [Git worktrees](/es/worktrees) le permiten ejecutar múltiples sesiones de Claude Code usted mismo sin coordinación de equipo automatizada

427* **Comparar enfoques**: vea la comparación [subagent vs agent team](/es/features-overview#compare-similar-features) para un desglose lado a lado427* **Comparar enfoques**: vea la comparación [subagent vs agent team](/es/features-overview#compare-similar-features) para un desglose lado a lado

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## Requisitos previos81## Requisitos previos

192 82

cli-reference.md +2 −2

Details

84| `--permission-mode` | Comenzar en un [modo de permiso](/es/permission-modes) especificado. Acepta `default`, `acceptEdits`, `plan`, `auto`, `dontAsk` o `bypassPermissions`. Anula `defaultMode` de archivos de configuración | `claude --permission-mode plan` |84| `--permission-mode` | Comenzar en un [modo de permiso](/es/permission-modes) especificado. Acepta `default`, `acceptEdits`, `plan`, `auto`, `dontAsk` o `bypassPermissions`. Anula `defaultMode` de archivos de configuración | `claude --permission-mode plan` |

85| `--permission-prompt-tool` | Especificar una herramienta MCP para manejar indicadores de permiso en modo no interactivo | `claude -p --permission-prompt-tool mcp_auth_tool "query"` |85| `--permission-prompt-tool` | Especificar una herramienta MCP para manejar indicadores de permiso en modo no interactivo | `claude -p --permission-prompt-tool mcp_auth_tool "query"` |

86| `--plugin-dir` | Cargar un plugin desde un directorio o archivo `.zip` solo para esta sesión. Cada bandera toma una ruta. Repita la bandera para múltiples plugins: `--plugin-dir A --plugin-dir B.zip` | `claude --plugin-dir ./my-plugin` |86| `--plugin-dir` | Cargar un plugin desde un directorio o archivo `.zip` solo para esta sesión. Cada bandera toma una ruta. Repita la bandera para múltiples plugins: `--plugin-dir A --plugin-dir B.zip` | `claude --plugin-dir ./my-plugin` |

87| `--plugin-url` | Obtener un archivo `.zip` de plugin desde una URL solo para esta sesión. Cada bandera toma una URL. Repita la bandera para múltiples plugins | `claude --plugin-url https://example.com/plugin.zip` |87| `--plugin-url` | Obtener un archivo `.zip` de plugin desde una URL solo para esta sesión. Repita la bandera para múltiples plugins, o pase URLs separadas por espacios en un valor único entre comillas | `claude --plugin-url https://example.com/plugin.zip` |

88| `--print`, `-p` | Imprimir respuesta sin modo interactivo (consulte [documentación de Agent SDK](/es/agent-sdk/overview) para detalles de uso programático) | `claude -p "query"` |88| `--print`, `-p` | Imprimir respuesta sin modo interactivo (consulte [documentación de Agent SDK](/es/agent-sdk/overview) para detalles de uso programático) | `claude -p "query"` |

90| `--remote-control`, `--rc` | Iniciar una sesión interactiva con [Remote Control](/es/remote-control#start-a-remote-control-session) habilitado para que también pueda controlarlo desde claude.ai o la aplicación Claude. Opcionalmente pase un nombre para la sesión | `claude --remote-control "My Project"` |90| `--remote-control`, `--rc` | Iniciar una sesión interactiva con [Remote Control](/es/remote-control#start-a-remote-control-session) habilitado para que también pueda controlarlo desde claude.ai o la aplicación Claude. Opcionalmente pase un nombre para la sesión | `claude --remote-control "My Project"` |

103| `--tools` | Restringir qué herramientas integradas puede usar Claude. Use `""` para deshabilitar todas, `"default"` para todas, o nombres de herramientas como `"Bash,Edit,Read"` | `claude --tools "Bash,Edit,Read"` |103| `--tools` | Restringir qué herramientas integradas puede usar Claude. Use `""` para deshabilitar todas, `"default"` para todas, o nombres de herramientas como `"Bash,Edit,Read"` | `claude --tools "Bash,Edit,Read"` |

104| `--verbose` | Habilitar registro detallado, muestra salida completa turno por turno. Anula la configuración [`viewMode`](/es/settings#available-settings) para esta sesión | `claude --verbose` |104| `--verbose` | Habilitar registro detallado, muestra salida completa turno por turno. Anula la configuración [`viewMode`](/es/settings#available-settings) para esta sesión | `claude --verbose` |

106| `--worktree`, `-w` | Iniciar Claude en un [git worktree](/es/worktrees) aislado en `<repo>/.claude/worktrees/<name>`. Si no se proporciona un nombre, se genera automáticamente | `claude -w feature-auth` |106| `--worktree`, `-w` | Iniciar Claude en un [git worktree](/es/worktrees) aislado en `<repo>/.claude/worktrees/<name>`. Si no se proporciona un nombre, se genera automáticamente. Pase `#<number>` o una URL de solicitud de extracción de GitHub para obtener ese PR de `origin` y ramificar el worktree desde él | `claude -w feature-auth` |

107 107

108### Banderas de indicación del sistema108### Banderas de indicación del sistema

109 109

commands.md +21 −3

Details

12 12

13Un comando solo se reconoce al inicio de su mensaje. El texto que sigue al nombre del comando se le pasa como argumentos.13Un comando solo se reconoce al inicio de su mensaje. El texto que sigue al nombre del comando se le pasa como argumentos.

14 14

15La tabla siguiente enumera todos los comandos incluidos en Claude Code. Las entradas marcadas como **[Skill](/es/skills#bundled-skills)** son skills agrupados. Utilizan el mismo mecanismo que los skills que escribe usted mismo: un prompt entregado a Claude, que Claude también puede invocar automáticamente cuando sea relevante. Todo lo demás es un comando integrado cuyo comportamiento está codificado en la CLI. Para agregar sus propios comandos, consulte [skills](/es/skills).15## Comandos en un flujo de trabajo típico

17La mayoría de los comandos son útiles en un punto específico de una sesión, desde la configuración de un proyecto hasta el envío de un cambio.

19**Primera sesión en un repositorio.** Ejecute `/init` para generar un `CLAUDE.md` inicial, luego `/memory` para refinarlo. Use `/mcp` y `/agents` para configurar cualquier servidor o subagente que el proyecto necesite, y `/permissions` para establecer las reglas de aprobación que desee.

21**Durante una tarea.** `/plan` cambia a Plan Mode antes de un cambio grande. `/model` y `/effort` ajustan cuánto razonamiento está gastando. Cuando la conversación se alarga, `/context` muestra hacia dónde va la ventana y `/compact` la resume; use `/btw` para una pregunta rápida que no debería inflar el historial.

23**Antes de enviar.** `/diff` muestra qué cambió, `/simplify` revisa archivos recientes y aplica correcciones de calidad y eficiencia, y `/review` o `/security-review` dan una lectura más profunda de solo lectura.

16 24

17No todos los comandos aparecen para todos los usuarios. La disponibilidad depende de su plataforma, plan y entorno. Por ejemplo, `/desktop` solo aparece en macOS y Windows, y `/upgrade` solo aparece en planes Pro y Max.25**Entre sesiones.** `/clear` comienza de nuevo en una nueva tarea mientras mantiene la memoria del proyecto. `/resume` y `/branch` le permiten volver a una conversación anterior o bifurcarla. `/teleport` extrae una sesión web en esta terminal, y `/remote-control` le permite continuar esta sesión local desde otro dispositivo.

27**Cuando algo está mal.** `/rewind` revierte el código y la conversación a un checkpoint. `/doctor` y `/debug` diagnostican problemas de instalación y tiempo de ejecución, y `/feedback` reporta un error con contexto de sesión adjunto.

29## Todos los comandos

31La tabla siguiente enumera todos los comandos incluidos en Claude Code. Las entradas marcadas como **[Skill](/es/skills#bundled-skills)** son skills agrupados. Utilizan el mismo mecanismo que los skills que escribe usted mismo: un prompt entregado a Claude, que Claude también puede invocar automáticamente cuando sea relevante. Todo lo demás es un comando integrado cuyo comportamiento está codificado en la CLI. Para agregar sus propios comandos, consulte [skills](/es/skills).

18 32

19En la tabla siguiente, `<arg>` indica un argumento requerido y `[arg]` indica uno opcional.33En la tabla siguiente, `<arg>` indica un argumento requerido y `[arg]` indica uno opcional.

20 34

35<Note>

36 No todos los comandos aparecen para todos los usuarios. La disponibilidad depende de su plataforma, plan y entorno. Por ejemplo, `/desktop` solo aparece en macOS y Windows, y `/upgrade` solo aparece en planes Pro y Max.

37</Note>

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

23| `/add-dir <path>` | Agregar un directorio de trabajo para acceso a archivos durante la sesión actual. La mayoría de la configuración de `.claude/` [no se descubre](/es/permissions#additional-directories-grant-file-access-not-configuration) desde el directorio agregado. Puede reanudar la sesión más tarde desde el directorio agregado con `--continue` o `--resume` |41| `/add-dir <path>` | Agregar un directorio de trabajo para acceso a archivos durante la sesión actual. La mayoría de la configuración de `.claude/` [no se descubre](/es/permissions#additional-directories-grant-file-access-not-configuration) desde el directorio agregado. Puede reanudar la sesión más tarde desde el directorio agregado con `--continue` o `--resume` |

80| `/review [PR]` | Revisar una solicitud de extracción localmente en su sesión actual. Para una revisión más profunda basada en la nube, consulte [`/ultrareview`](/es/ultrareview) |98| `/review [PR]` | Revisar una solicitud de extracción localmente en su sesión actual. Para una revisión más profunda basada en la nube, consulte [`/ultrareview`](/es/ultrareview) |

81| `/rewind` | Rebobinar la conversación y/o código a un punto anterior, o resumir desde un mensaje seleccionado. Consulte [checkpointing](/es/checkpointing). Alias: `/checkpoint`, `/undo` |99| `/rewind` | Rebobinar la conversación y/o código a un punto anterior, o resumir desde un mensaje seleccionado. Consulte [checkpointing](/es/checkpointing). Alias: `/checkpoint`, `/undo` |

83| `/schedule [description]` | Crear, actualizar, listar o ejecutar [routines](/es/routines). Claude lo guía a través de la configuración de manera conversacional. Alias: `/routines` |101| `/schedule [description]` | Crear, actualizar, listar o ejecutar [routines](/es/routines), que se ejecutan en infraestructura en la nube administrada por Anthropic. Claude lo guía a través de la configuración de manera conversacional. Alias: `/routines` |

84| `/security-review` | Analizar cambios pendientes en la rama actual para detectar vulnerabilidades de seguridad. Revisa el diff de git e identifica riesgos como inyección, problemas de autenticación y exposición de datos |102| `/security-review` | Analizar cambios pendientes en la rama actual para detectar vulnerabilidades de seguridad. Revisa el diff de git e identifica riesgos como inyección, problemas de autenticación y exposición de datos |

85| `/setup-bedrock` | Configurar autenticación de [Amazon Bedrock](/es/amazon-bedrock), región y fijaciones de modelo a través de un asistente interactivo. Solo visible cuando se establece `CLAUDE_CODE_USE_BEDROCK=1`. Los usuarios de Bedrock por primera vez también pueden acceder a este asistente desde la pantalla de inicio de sesión |103| `/setup-bedrock` | Configurar autenticación de [Amazon Bedrock](/es/amazon-bedrock), región y fijaciones de modelo a través de un asistente interactivo. Solo visible cuando se establece `CLAUDE_CODE_USE_BEDROCK=1`. Los usuarios de Bedrock por primera vez también pueden acceder a este asistente desde la pantalla de inicio de sesión |

86| `/setup-vertex` | Configurar autenticación de [Google Vertex AI](/es/google-vertex-ai), proyecto, región y fijaciones de modelo a través de un asistente interactivo. Solo visible cuando se establece `CLAUDE_CODE_USE_VERTEX=1`. Los usuarios de Vertex AI por primera vez también pueden acceder a este asistente desde la pantalla de inicio de sesión |104| `/setup-vertex` | Configurar autenticación de [Google Vertex AI](/es/google-vertex-ai), proyecto, región y fijaciones de modelo a través de un asistente interactivo. Solo visible cuando se establece `CLAUDE_CODE_USE_VERTEX=1`. Los usuarios de Vertex AI por primera vez también pueden acceder a este asistente desde la pantalla de inicio de sesión |

desktop.md +18 −1

Details

564 564

565Cada entrada requiere `id`, `name` y `sshHost`. Los campos `sshPort`, `sshIdentityFile` y `startDirectory` son opcionales. Los usuarios también pueden agregar `sshConfigs` a su propio `~/.claude/settings.json`, que es donde se almacenan las conexiones agregadas a través del diálogo.565Cada entrada requiere `id`, `name` y `sshHost`. Los campos `sshPort`, `sshIdentityFile` y `startDirectory` son opcionales. Los usuarios también pueden agregar `sshConfigs` a su propio `~/.claude/settings.json`, que es donde se almacenan las conexiones agregadas a través del diálogo.

566 566

567#### Restringir a qué hosts SSH pueden conectarse los usuarios

568

569Los administradores pueden limitar las sesiones SSH de Desktop a un conjunto aprobado de hosts agregando `sshHostAllowlist` a un archivo de [configuración administrada](/es/settings#settings-precedence). Cuando se establece, los usuarios solo pueden conectarse a hosts cuyo nombre de host resuelto coincida con uno de los patrones. Establézcalo en una matriz vacía para deshabilitar completamente las sesiones SSH.

570

571El siguiente ejemplo permite conexiones a cualquier host bajo `devboxes.example.com` y a un único host bastión nombrado:

572

573```json theme={null}

574{

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

576}

577```

578

579Los patrones no distinguen entre mayúsculas y minúsculas. `*` coincide con cualquier host, y `*.example.com` coincide con `example.com` y cualquier subdominio. Cualquier otra cosa es una coincidencia exacta. La verificación se ejecuta contra el nombre de host después de la resolución de `~/.ssh/config` a través de `ssh -G`, por lo que se permiten entradas de alias `Host` y `ProxyCommand`/`ProxyJump` siempre que el `HostName` resuelto coincida.

580

581`sshHostAllowlist` se lee solo desde la configuración administrada; los valores en la configuración de usuario o proyecto se ignoran. Solo la aplicación Claude Desktop honra esta configuración; la CLI de Claude Code y las extensiones IDE no la leen, y no restringe los comandos `ssh` ejecutados a través de la herramienta Bash. Rige a qué hosts se conecta la aplicación Desktop, no la salida de red, por lo que emparéjelo con los controles de red de su organización o de confianza cero si necesita un límite duro.

582

567## Configuración empresarial583## Configuración empresarial

568 584

569Las organizaciones en planes Team o Enterprise pueden gestionar el comportamiento de la aplicación de escritorio a través de controles de consola de administración, archivos de configuración administrados y políticas de gestión de dispositivos.585Las organizaciones en planes Team o Enterprise pueden gestionar el comportamiento de la aplicación de escritorio a través de controles de consola de administración, archivos de configuración administrados y políticas de gestión de dispositivos.

582La configuración administrada anula la configuración del proyecto y usuario y se aplica cuando Desktop genera sesiones de CLI. Puede establecer estas claves en el archivo de [configuración administrada](/es/settings#settings-precedence) de su organización o enviarlas de forma remota a través de la consola de administración.598La configuración administrada anula la configuración del proyecto y usuario y se aplica cuando Desktop genera sesiones de CLI. Puede establecer estas claves en el archivo de [configuración administrada](/es/settings#settings-precedence) de su organización o enviarlas de forma remota a través de la consola de administración.

583 599

584| Clave | Descripción |600| Clave | Descripción |

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

586| `permissions.disableBypassPermissionsMode` | establezca en `"disable"` para evitar que los usuarios habiliten el modo bypass permissions. |602| `permissions.disableBypassPermissionsMode` | establezca en `"disable"` para evitar que los usuarios habiliten el modo bypass permissions. |

587| `disableAutoMode` | establezca en `"disable"` para evitar que los usuarios habiliten el modo [Auto](/es/permission-modes#eliminate-prompts-with-auto-mode). Elimina Auto del selector de modo. También aceptado bajo `permissions`. |603| `disableAutoMode` | establezca en `"disable"` para evitar que los usuarios habiliten el modo [Auto](/es/permission-modes#eliminate-prompts-with-auto-mode). Elimina Auto del selector de modo. También aceptado bajo `permissions`. |

588| `autoMode` | personalice lo que el clasificador de modo auto confía y bloquea en toda su organización. Consulte [Configurar el modo auto](/es/auto-mode-config). |604| `autoMode` | personalice lo que el clasificador de modo auto confía y bloquea en toda su organización. Consulte [Configurar el modo auto](/es/auto-mode-config). |

589| `sshConfigs` | pre-configure [conexiones SSH](#pre-configure-ssh-connections-for-your-team) que aparecen en el menú desplegable de entorno. Los usuarios no pueden editar ni eliminar conexiones administradas. |605| `sshConfigs` | pre-configure [conexiones SSH](#pre-configure-ssh-connections-for-your-team) que aparecen en el menú desplegable de entorno. Los usuarios no pueden editar ni eliminar conexiones administradas. |

606| `sshHostAllowlist` | restrinja [sesiones SSH](#restrict-which-ssh-hosts-users-can-connect-to) a hosts cuyo nombre de host resuelto coincida con uno de estos patrones. Una matriz vacía deshabilita las sesiones SSH. Se lee solo desde configuración administrada. |

590 607

591Un archivo de configuración administrada implementado en disco en cada máquina se aplica a sesiones de Desktop. La configuración administrada enviada de forma remota a través de la consola de administración actualmente solo llega a sesiones de CLI e IDE, por lo que para implementaciones de Desktop distribuya el archivo a través de MDM o use los [controles de consola de administración](#admin-console-controls) anteriores.608Un archivo de configuración administrada implementado en disco en cada máquina se aplica a sesiones de Desktop. La configuración administrada enviada de forma remota a través de la consola de administración actualmente solo llega a sesiones de CLI e IDE, por lo que para implementaciones de Desktop distribuya el archivo a través de MDM o use los [controles de consola de administración](#admin-console-controls) anteriores.

592 609

env-vars.md +4 −2

Details

9Claude Code admite las siguientes variables de entorno para controlar su comportamiento. Establézcalas en su shell antes de lanzar `claude`, o configúrelas en [`settings.json`](/es/settings#available-settings) bajo la clave `env` para aplicarlas a cada sesión o implementarlas en su equipo.9Claude Code admite las siguientes variables de entorno para controlar su comportamiento. Establézcalas en su shell antes de lanzar `claude`, o configúrelas en [`settings.json`](/es/settings#available-settings) bajo la clave `env` para aplicarlas a cada sesión o implementarlas en su equipo.

10 10

12| :------------------------------------------------------ | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |12| :------------------------------------------------------ | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

13| `ANTHROPIC_API_KEY` | Clave de API enviada como encabezado `X-Api-Key`. Cuando se establece, esta clave se utiliza en lugar de su suscripción de Claude Pro, Max, Team o Enterprise incluso si ha iniciado sesión. En modo no interactivo (`-p`), la clave siempre se utiliza cuando está presente. En modo interactivo, se le solicita que apruebe la clave una vez antes de que anule su suscripción. Para utilizar su suscripción en su lugar, ejecute `unset ANTHROPIC_API_KEY` |13| `ANTHROPIC_API_KEY` | Clave de API enviada como encabezado `X-Api-Key`. Cuando se establece, esta clave se utiliza en lugar de su suscripción de Claude Pro, Max, Team o Enterprise incluso si ha iniciado sesión. En modo no interactivo (`-p`), la clave siempre se utiliza cuando está presente. En modo interactivo, se le solicita que apruebe la clave una vez antes de que anule su suscripción. Para utilizar su suscripción en su lugar, ejecute `unset ANTHROPIC_API_KEY` |

14| `ANTHROPIC_AUTH_TOKEN` | Valor personalizado para el encabezado `Authorization` (el valor que establezca aquí tendrá el prefijo `Bearer `) |14| `ANTHROPIC_AUTH_TOKEN` | Valor personalizado para el encabezado `Authorization` (el valor que establezca aquí tendrá el prefijo `Bearer `) |

15| `ANTHROPIC_BASE_URL` | Anule el endpoint de API para enrutar solicitudes a través de un proxy o puerta de enlace. Cuando se establece en un host que no es de primera parte, [búsqueda de herramientas MCP](/es/mcp#scale-with-mcp-tool-search) está deshabilitada de forma predeterminada. Establezca `ENABLE_TOOL_SEARCH=true` si su proxy reenvía bloques `tool_reference` |15| `ANTHROPIC_BASE_URL` | Anule el endpoint de API para enrutar solicitudes a través de un proxy o puerta de enlace. Cuando se establece en un host que no es de primera parte, [búsqueda de herramientas MCP](/es/mcp#scale-with-mcp-tool-search) está deshabilitada de forma predeterminada. Establezca `ENABLE_TOOL_SEARCH=true` si su proxy reenvía bloques `tool_reference` |

92| `CLAUDE_CODE_EFFORT_LEVEL` | Establezca el nivel de esfuerzo para modelos compatibles. Valores: `low`, `medium`, `high`, `xhigh`, `max` o `auto` para usar el valor predeterminado del modelo. Los niveles disponibles dependen del modelo. Tiene precedencia sobre `/effort` y la configuración `effortLevel`. Consulte [Ajustar nivel de esfuerzo](/es/model-config#adjust-effort-level) |92| `CLAUDE_CODE_EFFORT_LEVEL` | Establezca el nivel de esfuerzo para modelos compatibles. Valores: `low`, `medium`, `high`, `xhigh`, `max` o `auto` para usar el valor predeterminado del modelo. Los niveles disponibles dependen del modelo. Tiene precedencia sobre `/effort` y la configuración `effortLevel`. Consulte [Ajustar nivel de esfuerzo](/es/model-config#adjust-effort-level) |

93| `CLAUDE_CODE_ENABLE_AWAY_SUMMARY` | Anule la disponibilidad de [resumen de sesión](/es/interactive-mode#session-recap). Establezca en `0` para forzar los resúmenes desactivados independientemente del toggle `/config`. Establezca en `1` para forzar los resúmenes activados cuando [`awaySummaryEnabled`](/es/settings#available-settings) es `false`. Tiene precedencia sobre la configuración y el toggle `/config` |93| `CLAUDE_CODE_ENABLE_AWAY_SUMMARY` | Anule la disponibilidad de [resumen de sesión](/es/interactive-mode#session-recap). Establezca en `0` para forzar los resúmenes desactivados independientemente del toggle `/config`. Establezca en `1` para forzar los resúmenes activados cuando [`awaySummaryEnabled`](/es/settings#available-settings) es `false`. Tiene precedencia sobre la configuración y el toggle `/config` |

94| `CLAUDE_CODE_ENABLE_BACKGROUND_PLUGIN_REFRESH` | Establezca en `1` para actualizar el estado del plugin en los límites de turno en [modo no interactivo](/es/headless) después de que se complete una instalación en segundo plano. Desactivado de forma predeterminada porque la actualización cambia el indicador del sistema a mitad de sesión, lo que invalida el [almacenamiento en caché de indicadores](https://platform.claude.com/docs/en/build-with-claude/prompt-caching) para ese turno |94| `CLAUDE_CODE_ENABLE_BACKGROUND_PLUGIN_REFRESH` | Establezca en `1` para actualizar el estado del plugin en los límites de turno en [modo no interactivo](/es/headless) después de que se complete una instalación en segundo plano. Desactivado de forma predeterminada porque la actualización cambia el indicador del sistema a mitad de sesión, lo que invalida el [almacenamiento en caché de indicadores](https://platform.claude.com/docs/en/build-with-claude/prompt-caching) para ese turno |

95| `CLAUDE_CODE_ENABLE_FINE_GRAINED_TOOL_STREAMING` | Controla si las entradas de llamadas de herramientas se transmiten desde la API mientras Claude las genera. Con esto desactivado, una entrada de herramienta grande como una escritura de archivo larga llega solo después de que Claude termina de generarla, lo que puede parecer que se está colgando. Habilitado de forma predeterminada para conexiones directas de API de Anthropic. Establezca en `0` para optar por no participar. Establezca en `1` para forzar la habilitación incluso cuando el valor predeterminado del lado del servidor está desactivado. No tiene efecto en Bedrock, Vertex, Foundry o conexiones de [puerta de enlace](/es/llm-gateway) |95| `CLAUDE_CODE_ENABLE_FINE_GRAINED_TOOL_STREAMING` | Controla si las entradas de llamadas de herramientas se transmiten desde la API mientras Claude las genera. Con esto desactivado, una entrada de herramienta grande como una escritura de archivo larga llega solo después de que Claude termina de generarla, lo que puede parecer que se está colgando. Habilitado de forma predeterminada en la API de Anthropic. En Bedrock y Vertex, habilitado por modelo donde el contenedor implementado lo admite. Establezca en `0` para optar por no participar. Establezca en `1` para forzar la habilitación cuando se enruta a través de un proxy a través de `ANTHROPIC_BASE_URL`, `ANTHROPIC_VERTEX_BASE_URL` o `ANTHROPIC_BEDROCK_BASE_URL`. Desactivado de forma predeterminada en Foundry y conexiones de [puerta de enlace](/es/llm-gateway) |

96| `CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY` | Establezca en `1` para rellenar el selector `/model` desde el endpoint `/v1/models` de su puerta de enlace cuando `ANTHROPIC_BASE_URL` apunta a una puerta de enlace compatible con Anthropic como LiteLLM, Kong o un proxy interno. Desactivado de forma predeterminada porque las puertas de enlace respaldadas por una clave de API compartida de otra manera mostrarían a cada usuario cada modelo que la clave puede acceder. Los modelos descubiertos aún se filtran por la lista de permitidos [`availableModels`](/es/settings#available-settings) |96| `CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY` | Establezca en `1` para rellenar el selector `/model` desde el endpoint `/v1/models` de su puerta de enlace cuando `ANTHROPIC_BASE_URL` apunta a una puerta de enlace compatible con Anthropic como LiteLLM, Kong o un proxy interno. Desactivado de forma predeterminada porque las puertas de enlace respaldadas por una clave de API compartida de otra manera mostrarían a cada usuario cada modelo que la clave puede acceder. Los modelos descubiertos aún se filtran por la lista de permitidos [`availableModels`](/es/settings#available-settings) |

97| `CLAUDE_CODE_ENABLE_PROMPT_SUGGESTION` | Establezca en `false` para deshabilitar sugerencias de indicador (el toggle "Prompt suggestions" en `/config`). Estas son las predicciones atenuadas que aparecen en su entrada de indicador después de que Claude responda. Consulte [Sugerencias de indicador](/es/interactive-mode#prompt-suggestions) |97| `CLAUDE_CODE_ENABLE_PROMPT_SUGGESTION` | Establezca en `false` para deshabilitar sugerencias de indicador (el toggle "Prompt suggestions" en `/config`). Estas son las predicciones atenuadas que aparecen en su entrada de indicador después de que Claude responda. Consulte [Sugerencias de indicador](/es/interactive-mode#prompt-suggestions) |

98| `CLAUDE_CODE_ENABLE_TASKS` | Establezca en `1` para habilitar el sistema de seguimiento de tareas en modo no interactivo (la bandera `-p`). Las tareas están activadas de forma predeterminada en modo interactivo. Consulte [Lista de tareas](/es/interactive-mode#task-list) |98| `CLAUDE_CODE_ENABLE_TASKS` | Establezca en `1` para habilitar el sistema de seguimiento de tareas en modo no interactivo (la bandera `-p`). Las tareas están activadas de forma predeterminada en modo interactivo. Consulte [Lista de tareas](/es/interactive-mode#task-list) |

164| `CLAUDE_CODE_USE_POWERSHELL_TOOL` | Controla la herramienta PowerShell. En Windows sin Git Bash, la herramienta se habilita automáticamente; establezca en `0` para deshabilitarla. En Windows con Git Bash instalado, la herramienta se está implementando progresivamente: establezca en `1` para optar por participar o `0` para optar por no participar. En Linux, macOS y WSL, establezca en `1` para habilitarla, lo que requiere `pwsh` en su `PATH`. Cuando se habilita en Windows, Claude puede ejecutar comandos de PowerShell de forma nativa en lugar de enrutarlos a través de Git Bash. Consulte [Herramienta PowerShell](/es/tools-reference#powershell-tool) |164| `CLAUDE_CODE_USE_POWERSHELL_TOOL` | Controla la herramienta PowerShell. En Windows sin Git Bash, la herramienta se habilita automáticamente; establezca en `0` para deshabilitarla. En Windows con Git Bash instalado, la herramienta se está implementando progresivamente: establezca en `1` para optar por participar o `0` para optar por no participar. En Linux, macOS y WSL, establezca en `1` para habilitarla, lo que requiere `pwsh` en su `PATH`. Cuando se habilita en Windows, Claude puede ejecutar comandos de PowerShell de forma nativa en lugar de enrutarlos a través de Git Bash. Consulte [Herramienta PowerShell](/es/tools-reference#powershell-tool) |

166| `CLAUDE_CONFIG_DIR` | Anule el directorio de configuración (predeterminado: `~/.claude`). Todos los ajustes, credenciales, historial de sesiones y plugins se almacenan bajo esta ruta. Útil para ejecutar múltiples cuentas lado a lado: por ejemplo, `alias claude-work='CLAUDE_CONFIG_DIR=~/.claude-work claude'` |166| `CLAUDE_CONFIG_DIR` | Anule el directorio de configuración (predeterminado: `~/.claude`). Todos los ajustes, credenciales, historial de sesiones y plugins se almacenan bajo esta ruta. Útil para ejecutar múltiples cuentas lado a lado: por ejemplo, `alias claude-work='CLAUDE_CONFIG_DIR=~/.claude-work claude'` |

167| `CLAUDE_EFFORT` | Se establece automáticamente en subprocesos de herramientas Bash y comandos hook en el [nivel de esfuerzo](/es/model-config#adjust-effort-level) activo para el turno: `low`, `medium`, `high`, `xhigh` o `max`. Coincide con el campo `effort.level` pasado a [hooks](/es/hooks). Solo se establece cuando el modelo actual admite el parámetro de esfuerzo |

167| `CLAUDE_ENABLE_BYTE_WATCHDOG` | Establezca en `1` para forzar la habilitación del perro guardián de inactividad de transmisión a nivel de byte, o establezca en `0` para forzar su deshabilitación. Cuando no se establece, el perro guardián se habilita de forma predeterminada para conexiones de API de Anthropic. El perro guardián de byte aborta una conexión cuando no llegan bytes en el cable durante la duración establecida por `CLAUDE_STREAM_IDLE_TIMEOUT_MS`, con un mínimo de 5 minutos, independientemente del perro guardián a nivel de evento |168| `CLAUDE_ENABLE_BYTE_WATCHDOG` | Establezca en `1` para forzar la habilitación del perro guardián de inactividad de transmisión a nivel de byte, o establezca en `0` para forzar su deshabilitación. Cuando no se establece, el perro guardián se habilita de forma predeterminada para conexiones de API de Anthropic. El perro guardián de byte aborta una conexión cuando no llegan bytes en el cable durante la duración establecida por `CLAUDE_STREAM_IDLE_TIMEOUT_MS`, con un mínimo de 5 minutos, independientemente del perro guardián a nivel de evento |

168| `CLAUDE_ENABLE_STREAM_WATCHDOG` | Establezca en `1` para habilitar el perro guardián de inactividad de transmisión a nivel de evento. Desactivado de forma predeterminada. Para Bedrock, Vertex y Foundry, este es el único perro guardián de inactividad disponible. Configure el tiempo de espera con `CLAUDE_STREAM_IDLE_TIMEOUT_MS` |169| `CLAUDE_ENABLE_STREAM_WATCHDOG` | Establezca en `1` para habilitar el perro guardián de inactividad de transmisión a nivel de evento. Desactivado de forma predeterminada. Para Bedrock, Vertex y Foundry, este es el único perro guardián de inactividad disponible. Configure el tiempo de espera con `CLAUDE_STREAM_IDLE_TIMEOUT_MS` |

169| `CLAUDE_ENV_FILE` | Ruta a un script de shell cuyo contenido Claude Code ejecuta antes de cada comando Bash en el mismo proceso de shell, por lo que las exportaciones en el archivo son visibles para el comando. Utilice para persistir la activación de virtualenv o conda entre comandos. También se completa dinámicamente por hooks [SessionStart](/es/hooks#persist-environment-variables), [Setup](/es/hooks#setup), [CwdChanged](/es/hooks#cwdchanged) y [FileChanged](/es/hooks#filechanged) |170| `CLAUDE_ENV_FILE` | Ruta a un script de shell cuyo contenido Claude Code ejecuta antes de cada comando Bash en el mismo proceso de shell, por lo que las exportaciones en el archivo son visibles para el comando. Utilice para persistir la activación de virtualenv o conda entre comandos. También se completa dinámicamente por hooks [SessionStart](/es/hooks#persist-environment-variables), [Setup](/es/hooks#setup), [CwdChanged](/es/hooks#cwdchanged) y [FileChanged](/es/hooks#filechanged) |

205| `MAX_THINKING_TOKENS` | Anule el presupuesto de tokens de [pensamiento extendido](https://platform.claude.com/docs/en/build-with-claude/extended-thinking). El techo es el [máximo de tokens de salida](https://platform.claude.com/docs/en/about-claude/models/overview#latest-models-comparison) del modelo menos uno. Establezca en `0` para deshabilitar el pensamiento completamente. En modelos con [razonamiento adaptativo](/es/model-config#adjust-effort-level), el presupuesto se ignora a menos que el razonamiento adaptativo esté deshabilitado a través de `CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING` |206| `MAX_THINKING_TOKENS` | Anule el presupuesto de tokens de [pensamiento extendido](https://platform.claude.com/docs/en/build-with-claude/extended-thinking). El techo es el [máximo de tokens de salida](https://platform.claude.com/docs/en/about-claude/models/overview#latest-models-comparison) del modelo menos uno. Establezca en `0` para deshabilitar el pensamiento completamente. En modelos con [razonamiento adaptativo](/es/model-config#adjust-effort-level), el presupuesto se ignora a menos que el razonamiento adaptativo esté deshabilitado a través de `CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING` |

206| `MCP_CLIENT_SECRET` | Secreto de cliente OAuth para servidores MCP que requieren [credenciales preconfiguradas](/es/mcp#use-pre-configured-oauth-credentials). Evita el indicador interactivo al agregar un servidor con `--client-secret` |207| `MCP_CLIENT_SECRET` | Secreto de cliente OAuth para servidores MCP que requieren [credenciales preconfiguradas](/es/mcp#use-pre-configured-oauth-credentials). Evita el indicador interactivo al agregar un servidor con `--client-secret` |

207| `MCP_CONNECTION_NONBLOCKING` | Establezca en `true` en modo no interactivo (`-p`) para omitir completamente la espera de conexión MCP. Útil para canalizaciones con scripts donde las herramientas MCP no son necesarias. Sin esta variable, la primera consulta espera hasta 5 segundos para que se conecten los servidores `--mcp-config`. Los servidores configurados con [`alwaysLoad: true`](/es/mcp#exempt-a-server-from-deferral) siempre bloquean el inicio independientemente de esta variable, ya que sus herramientas deben estar presentes cuando se construye el primer indicador |208| `MCP_CONNECTION_NONBLOCKING` | Establezca en `true` en modo no interactivo (`-p`) para omitir completamente la espera de conexión MCP. Útil para canalizaciones con scripts donde las herramientas MCP no son necesarias. Sin esta variable, la primera consulta espera hasta 5 segundos para que se conecten los servidores `--mcp-config`. Los servidores configurados con [`alwaysLoad: true`](/es/mcp#exempt-a-server-from-deferral) siempre bloquean el inicio independientemente de esta variable, ya que sus herramientas deben estar presentes cuando se construye el primer indicador |

209| `MCP_CONNECT_TIMEOUT_MS` | Cuánto tiempo espera la primera consulta, en milisegundos, para que se complete el lote de conexión MCP antes de tomar una instantánea de la lista de herramientas (predeterminado: 5000). Los servidores aún pendientes en la fecha límite continúan conectándose en segundo plano pero no aparecerán hasta la siguiente consulta. Distinto de `MCP_TIMEOUT`, que limita el intento de conexión de un servidor individual. Más relevante para sesiones no interactivas que emiten una única consulta y necesitan que servidores de conexión lenta sean visibles |

208| `MCP_OAUTH_CALLBACK_PORT` | Puerto fijo para la devolución de llamada de redirección de OAuth, como alternativa a `--callback-port` al agregar un servidor MCP con [credenciales preconfiguradas](/es/mcp#use-pre-configured-oauth-credentials) |210| `MCP_OAUTH_CALLBACK_PORT` | Puerto fijo para la devolución de llamada de redirección de OAuth, como alternativa a `--callback-port` al agregar un servidor MCP con [credenciales preconfiguradas](/es/mcp#use-pre-configured-oauth-credentials) |

209| `MCP_REMOTE_SERVER_CONNECTION_BATCH_SIZE` | Número máximo de servidores MCP remotos (HTTP/SSE) para conectar en paralelo durante el inicio (predeterminado: 20) |211| `MCP_REMOTE_SERVER_CONNECTION_BATCH_SIZE` | Número máximo de servidores MCP remotos (HTTP/SSE) para conectar en paralelo durante el inicio (predeterminado: 20) |

210| `MCP_SERVER_CONNECTION_BATCH_SIZE` | Número máximo de servidores MCP locales (stdio) para conectar en paralelo durante el inicio (predeterminado: 3) |212| `MCP_SERVER_CONNECTION_BATCH_SIZE` | Número máximo de servidores MCP locales (stdio) para conectar en paralelo durante el inicio (predeterminado: 3) |

features-overview.md +1 −1

Details

249 249

250 **Costo de contexto:** Bajo hasta que se use. Las skills solo de usuario tienen costo cero hasta que se invoquen.250 **Costo de contexto:** Bajo hasta que se use. Las skills solo de usuario tienen costo cero hasta que se invoquen.

251 251

252 **En subagents:** Las skills funcionan de manera diferente en subagents. En lugar de carga bajo demanda, las skills pasadas a un subagent se precarga completamente en su contexto al iniciar. Los subagents no heredan skills de la sesión principal; debe especificarlas explícitamente.252 **En subagents:** Las skills funcionan de manera diferente en subagents. En lugar de carga bajo demanda, las skills listadas en el campo `skills:` del subagent se precarga completamente en su contexto al iniciar. Los subagents aún pueden descubrir e invocar skills de proyecto, usuario y plugin no listadas a través de la herramienta Skill.

253 253

254 <Tip>Use `disable-model-invocation: true` para skills con efectos secundarios. Esto ahorra contexto y asegura que solo usted las desencadene.</Tip>254 <Tip>Use `disable-model-invocation: true` para skills con efectos secundarios. Esto ahorra contexto y asegura que solo usted las desencadene.</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## Requisitos previos81## Requisitos previos

192 82

hooks.md +6 −5

Details

518Los eventos de hook reciben estos campos como JSON, además de campos específicos del evento documentados en cada sección [hook event](#hook-events). Para hooks de comando, este JSON llega a través de stdin. Para hooks HTTP, llega como el cuerpo de la solicitud POST.518Los eventos de hook reciben estos campos como JSON, además de campos específicos del evento documentados en cada sección [hook event](#hook-events). Para hooks de comando, este JSON llega a través de stdin. Para hooks HTTP, llega como el cuerpo de la solicitud POST.

519 519

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

524| `cwd` | Directorio de trabajo actual cuando se invoca el hook |524| `cwd` | Directorio de trabajo actual cuando se invoca el hook |

525| `permission_mode` | [Modo de permiso](/es/permissions#permission-modes) actual: `"default"`, `"plan"`, `"acceptEdits"`, `"auto"`, `"dontAsk"` o `"bypassPermissions"`. No todos los eventos reciben este campo: consulte cada ejemplo JSON de evento a continuación para verificar |525| `permission_mode` | [Modo de permiso](/es/permissions#permission-modes) actual: `"default"`, `"plan"`, `"acceptEdits"`, `"auto"`, `"dontAsk"` o `"bypassPermissions"`. No todos los eventos reciben este campo: consulte cada ejemplo JSON de evento a continuación para verificar |

526| `effort` | Objeto con un campo `level` que contiene el [nivel de esfuerzo](/es/model-config#adjust-effort-level) activo para el turno: `"low"`, `"medium"`, `"high"`, `"xhigh"` o `"max"`. Si el esfuerzo solicitado excede lo que el modelo actual admite, este es el nivel degradado que el modelo realmente utilizó, no el nivel que solicitó. El objeto coincide con el campo `effort` de la [línea de estado](/es/statusline#available-data). Presente para eventos que se activan dentro de un contexto de uso de herramienta, como `PreToolUse`, `PostToolUse`, `Stop` y `SubagentStop`, cuando el modelo actual admite el parámetro de esfuerzo. El nivel también está disponible para comandos de hook y la herramienta Bash como la variable de entorno `$CLAUDE_EFFORT`. |

527 528

528Cuando se ejecuta con `--agent` o dentro de un subagente, se incluyen dos campos adicionales:529Cuando se ejecuta con `--agent` o dentro de un subagente, se incluyen dos campos adicionales:

1225 1226

1226Si la herramienta diferida ya no está disponible cuando reanuda, el proceso sale con `stop_reason: "tool_deferred_unavailable"` e `is_error: true` antes de que se active el hook. Esto sucede cuando un servidor MCP que proporcionó la herramienta no está conectado para la sesión reanudada. El payload `deferred_tool_use` aún se incluye para que pueda identificar qué herramienta desapareció.1227Si la herramienta diferida ya no está disponible cuando reanuda, el proceso sale con `stop_reason: "tool_deferred_unavailable"` e `is_error: true` antes de que se active el hook. Esto sucede cuando un servidor MCP que proporcionó la herramienta no está conectado para la sesión reanudada. El payload `deferred_tool_use` aún se incluye para que pueda identificar qué herramienta desapareció.

1227 1228

1228<Warning>1229<Note>

1229 `--resume` no restaura el modo de permiso de la sesión anterior. Pase la misma bandera `--permission-mode` en reanudar que estaba activa cuando se diferió la herramienta. Claude Code registra una advertencia si los modos difieren.1230 `--resume` restaura el modo de permiso que estaba activo cuando se diferió la herramienta, por lo que no necesita pasar `--permission-mode` nuevamente. Las excepciones son `plan` y `bypassPermissions`, que nunca se llevan. Pasar `--permission-mode` explícitamente en reanudar anula el valor restaurado.

1230</Warning>1231</Note>

1231 1232

1232### PermissionRequest1233### PermissionRequest

1233 1234

1358 1359

1359| Campo | Descripción |1360| Campo | Descripción |

1360| :--------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------- |1361| :--------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------- |

1361| `decision` | `"block"` solicita a Claude con la `reason`. Omita para permitir que la acción continúe |1362| `decision` | `"block"` agrega la `reason` junto al resultado de la herramienta. Claude aún ve la salida original; para reemplazarla, use `updatedToolOutput` |

1363| `additionalContext` | Cadena agregada al contexto de Claude junto con el resultado de la herramienta. Consulte [Agregar contexto para Claude](#add-context-for-claude) |1364| `additionalContext` | Cadena agregada al contexto de Claude junto con el resultado de la herramienta. Consulte [Agregar contexto para Claude](#add-context-for-claude) |

1364| `updatedToolOutput` | Reemplaza la salida de la herramienta con el valor proporcionado antes de que se envíe a Claude. El valor debe coincidir con la forma de salida de la herramienta |1365| `updatedToolOutput` | Reemplaza la salida de la herramienta con el valor proporcionado antes de que se envíe a Claude. El valor debe coincidir con la forma de salida de la herramienta |

memory.md +10 −0

Details

132Use plan mode para cambios bajo `src/billing/`.132Use plan mode para cambios bajo `src/billing/`.

133```133```

134 134

135Un enlace simbólico también funciona si no necesita agregar contenido específico de Claude Code:

136

137```bash theme={null}

138ln -s AGENTS.md CLAUDE.md

139```

140

141En Windows, crear un enlace simbólico requiere privilegios de administrador o modo de desarrollador, así que use la importación `@AGENTS.md` en su lugar.

142

143Ejecutar [`/init`](/es/commands) en un repositorio que ya tiene un `AGENTS.md` lo lee e incorpora las partes relevantes en el `CLAUDE.md` generado. También lee otras configuraciones de herramientas como `.cursorrules` y `.windsurfrules`.

144

135### Cómo se cargan los archivos CLAUDE.md145### Cómo se cargan los archivos CLAUDE.md

136 146

137Claude Code lee los archivos CLAUDE.md caminando hacia arriba en el árbol de directorios desde su directorio de trabajo actual, verificando cada directorio en el camino para archivos `CLAUDE.md` y `CLAUDE.local.md`. Esto significa que si ejecuta Claude Code en `foo/bar/`, carga instrucciones desde `foo/bar/CLAUDE.md`, `foo/CLAUDE.md` y cualquier archivo `CLAUDE.local.md` junto a ellos.147Claude Code lee los archivos CLAUDE.md caminando hacia arriba en el árbol de directorios desde su directorio de trabajo actual, verificando cada directorio en el camino para archivos `CLAUDE.md` y `CLAUDE.local.md`. Esto significa que si ejecuta Claude Code en `foo/bar/`, carga instrucciones desde `foo/bar/CLAUDE.md`, `foo/CLAUDE.md` y cualquier archivo `CLAUDE.local.md` junto a ellos.

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## Requisitos previos81## Requisitos previos

192 82

model-config.md +4 −0

Details

17 * Foundry: un nombre de implementación17 * Foundry: un nombre de implementación

18 * Vertex: un nombre de versión18 * Vertex: un nombre de versión

19 19

20<Note>

21 `ANTHROPIC_BASE_URL` cambia dónde se envían las solicitudes, no qué modelo las responde. Para enrutar Claude a través de una puerta de enlace LLM, consulte [configuración de puerta de enlace LLM](/es/llm-gateway).

22</Note>

20### Alias de modelo24### Alias de modelo

21 25

22Los alias de modelo proporcionan una forma conveniente de seleccionar configuraciones de modelo sin necesidad de recordar números de versión exactos:26Los alias de modelo proporcionan una forma conveniente de seleccionar configuraciones de modelo sin necesidad de recordar números de versión exactos:

overview.md +1 −635

Details

6 6

7> Claude Code es una herramienta de codificación agencial que lee tu base de código, edita archivos, ejecuta comandos e integra con tus herramientas de desarrollo. Disponible en tu terminal, IDE, aplicación de escritorio y navegador.7> Claude Code es una herramienta de codificación agencial que lee tu base de código, edita archivos, ejecuta comandos e integra con tus herramientas de desarrollo. Disponible en tu terminal, IDE, aplicación de escritorio y navegador.

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 es un asistente de codificación impulsado por IA que te ayuda a construir características, corregir errores y automatizar tareas de desarrollo. Entiende tu base de código completa y puede trabajar en múltiples archivos y herramientas para lograr las cosas.9Claude Code es un asistente de codificación impulsado por IA que te ayuda a construir características, corregir errores y automatizar tareas de desarrollo. Entiende tu base de código completa y puede trabajar en múltiples archivos y herramientas para lograr las cosas.

640 10

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

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

643</div>

~~644~~

645## Comenzar11## Comenzar

646 12

647Elige tu entorno para comenzar. La mayoría de las superficies requieren una [suscripción a Claude](https://claude.com/pricing?utm_source=claude_code\&utm_medium=docs\&utm_content=overview_pricing) o una cuenta de [Anthropic Console](https://console.anthropic.com/). La CLI de Terminal y VS Code también admiten [proveedores de terceros](/es/third-party-integrations).13Elige tu entorno para comenzar. La mayoría de las superficies requieren una [suscripción a Claude](https://claude.com/pricing?utm_source=claude_code\&utm_medium=docs\&utm_content=overview_pricing) o una cuenta de [Anthropic Console](https://console.anthropic.com/). La CLI de Terminal y VS Code también admiten [proveedores de terceros](/es/third-party-integrations).

798 <Accordion title="Personaliza con instrucciones, skills y hooks" icon="sliders">164 <Accordion title="Personaliza con instrucciones, skills y hooks" icon="sliders">

799 [`CLAUDE.md`](/es/memory) es un archivo markdown que añades a la raíz de tu proyecto que Claude Code lee al inicio de cada sesión. Úsalo para establecer estándares de codificación, decisiones de arquitectura, librerías preferidas y listas de verificación de revisión. Claude también construye [memoria automática](/es/memory#auto-memory) mientras trabaja, guardando aprendizajes como comandos de compilación e insights de depuración en sesiones sin que escribas nada.165 [`CLAUDE.md`](/es/memory) es un archivo markdown que añades a la raíz de tu proyecto que Claude Code lee al inicio de cada sesión. Úsalo para establecer estándares de codificación, decisiones de arquitectura, librerías preferidas y listas de verificación de revisión. Claude también construye [memoria automática](/es/memory#auto-memory) mientras trabaja, guardando aprendizajes como comandos de compilación e insights de depuración en sesiones sin que escribas nada.

800 166

801 Crea [comandos personalizados](/es/skills) para empaquetar flujos de trabajo repetibles que tu equipo pueda compartir, como `/review-pr` o `/deploy-staging`.167 Crea [skills](/es/skills) para empaquetar flujos de trabajo repetibles que tu equipo pueda compartir, como `/review-pr` o `/deploy-staging`.

802 168

803 [Hooks](/es/hooks) te permiten ejecutar comandos de shell antes o después de acciones de Claude Code, como formateo automático después de cada edición de archivo o ejecución de lint antes de un commit.169 [Hooks](/es/hooks) te permiten ejecutar comandos de shell antes o después de acciones de Claude Code, como formateo automático después de cada edición de archivo o ejecución de lint antes de un commit.

804 </Accordion>170 </Accordion>

plugins.md +9 −1

Details

317 317

318Para probar un plugin que ya está empaquetado como un archivo `.zip` y alojado en una URL, como un artefacto de compilación de CI, use `--plugin-url` en su lugar. Claude Code obtiene el archivo al inicio y lo carga solo para esa sesión. Si la obtención falla o el archivo no es válido, Claude Code reporta un error de carga de plugin e inicia sin él. Las mismas [consideraciones de confianza](/es/discover-plugins#security) se aplican como para cualquier fuente de plugin: solo apunte esta bandera a archivos que controle o en los que confíe.318Para probar un plugin que ya está empaquetado como un archivo `.zip` y alojado en una URL, como un artefacto de compilación de CI, use `--plugin-url` en su lugar. Claude Code obtiene el archivo al inicio y lo carga solo para esa sesión. Si la obtención falla o el archivo no es válido, Claude Code reporta un error de carga de plugin e inicia sin él. Las mismas [consideraciones de confianza](/es/discover-plugins#security) se aplican como para cualquier fuente de plugin: solo apunte esta bandera a archivos que controle o en los que confíe.

319 319

320Para cargar múltiples plugins, repita la bandera para cada URL:

321

322```bash theme={null}

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

324```

325

326O pase URLs separadas por espacios como un argumento entrecomillado:

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### Depure problemas del plugin332### Depure problemas del plugin

quickstart.md +3 −636

Details

6 6

7> ¡Bienvenido a Claude Code!7> ¡Bienvenido a 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~~

639Esta guía de inicio rápido le permitirá usar asistencia de codificación impulsada por IA en pocos minutos. Al final, comprenderá cómo usar Claude Code para tareas comunes de desarrollo.9Esta guía de inicio rápido le permitirá usar asistencia de codificación impulsada por IA en pocos minutos. Al final, comprenderá cómo usar Claude Code para tareas comunes de desarrollo.

640 10

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

~~642~~

643## Antes de comenzar11## Antes de comenzar

644 12

645Asegúrese de tener:13Asegúrese de tener:

647* Una terminal o símbolo del sistema abiertos15* Una terminal o símbolo del sistema abiertos

648 * Si nunca ha usado la terminal antes, consulte la [guía de terminal](/es/terminal-guide)16 * Si nunca ha usado la terminal antes, consulte la [guía de terminal](/es/terminal-guide)

649* Un proyecto de código con el que trabajar17* Un proyecto de código con el que trabajar

650* Una [suscripción a Claude](https://claude.com/pricing?utm_source=claude_code\&utm_medium=docs\&utm_content=quickstart_prereq) (Pro, Max, Teams o Enterprise), una cuenta de [Claude Console](https://console.anthropic.com/), o acceso a través de un [proveedor de nube compatible](/es/third-party-integrations)18* Una [suscripción a Claude](https://claude.com/pricing?utm_source=claude_code\&utm_medium=docs\&utm_content=quickstart_prereq) (Pro, Max, Team o Enterprise), una cuenta de [Claude Console](https://console.anthropic.com/), o acceso a través de un [proveedor de nube compatible](/es/third-party-integrations)

651 19

652<Note>20<Note>

653 Esta guía cubre la CLI de terminal. Claude Code también está disponible en la [web](https://claude.ai/code), como una [aplicación de escritorio](/es/desktop), en [VS Code](/es/vs-code) e [IDEs de JetBrains](/es/jetbrains), en [Slack](/es/slack), y en CI/CD con [GitHub Actions](/es/github-actions) y [GitLab](/es/gitlab-ci-cd). Consulte [todas las interfaces](/es/overview#use-claude-code-everywhere).21 Esta guía cubre la CLI de terminal. Claude Code también está disponible en la [web](https://claude.ai/code), como una [aplicación de escritorio](/es/desktop), en [VS Code](/es/vs-code) e [IDEs de JetBrains](/es/jetbrains), en [Slack](/es/slack), y en CI/CD con [GitHub Actions](/es/github-actions) y [GitLab](/es/gitlab-ci-cd). Consulte [todas las interfaces](/es/overview#use-claude-code-everywhere).

727 95

728Puede iniciar sesión usando cualquiera de estos tipos de cuenta:96Puede iniciar sesión usando cualquiera de estos tipos de cuenta:

729 97

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

731* [Claude Console](https://console.anthropic.com/) (acceso a API con créditos prepagados). En el primer inicio de sesión, se crea automáticamente un espacio de trabajo "Claude Code" en la Console para el seguimiento centralizado de costos.99* [Claude Console](https://console.anthropic.com/) (acceso a API con créditos prepagados). En el primer inicio de sesión, se crea automáticamente un espacio de trabajo "Claude Code" en la Console para el seguimiento centralizado de costos.

732* [Amazon Bedrock, Google Vertex AI o Microsoft Foundry](/es/third-party-integrations) (proveedores de nube empresariales)100* [Amazon Bedrock, Google Vertex AI o Microsoft Foundry](/es/third-party-integrations) (proveedores de nube empresariales)

733 101

902| `claude commit` | Crea un commit de Git | `claude commit` |

906 273

907Consulte la [referencia de CLI](/es/cli-reference) para obtener una lista completa de comandos.274Consulte la [referencia de CLI](/es/cli-reference) para obtener una lista completa de comandos.

908 275

settings.md +7 −3

Details

156`settings.json` admite varias opciones:156`settings.json` admite varias opciones:

157 157

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

160| `agent` | Ejecutar el hilo principal como un subagent nombrado. Aplica el indicador del sistema del subagent, restricciones de herramientas y modelo. Consulte [Invocar subagents explícitamente](/es/sub-agents#invoke-subagents-explicitly) | `"code-reviewer"` |160| `agent` | Ejecutar el hilo principal como un subagent nombrado. Aplica el indicador del sistema del subagent, restricciones de herramientas y modelo. Consulte [Invocar subagents explícitamente](/es/sub-agents#invoke-subagents-explicitly) | `"code-reviewer"` |

161| `allowedChannelPlugins` | (Solo configuraciones administradas) Lista blanca de plugins de canal que pueden enviar mensajes. Reemplaza la lista blanca predeterminada de Anthropic cuando se establece. Sin definir = recurrir a la predeterminada, matriz vacía = bloquear todos los plugins de canal. Requiere `channelsEnabled: true`. Consulte [Restringir qué plugins de canal pueden ejecutarse](/es/channels#restrict-which-channel-plugins-can-run) | `[{ "marketplace": "claude-plugins-official", "plugin": "telegram" }]` |161| `allowedChannelPlugins` | (Solo configuraciones administradas) Lista blanca de plugins de canal que pueden enviar mensajes. Reemplaza la lista blanca predeterminada de Anthropic cuando se establece. Sin definir = recurrir a la predeterminada, matriz vacía = bloquear todos los plugins de canal. Requiere `channelsEnabled: true`. Consulte [Restringir qué plugins de canal pueden ejecutarse](/es/channels#restrict-which-channel-plugins-can-run) | `[{ "marketplace": "claude-plugins-official", "plugin": "telegram" }]` |

162| `allowedHttpHookUrls` | Lista blanca de patrones de URL que los hooks HTTP pueden dirigirse. Admite `*` como comodín. Cuando se establece, los hooks con URLs que no coinciden se bloquean. Sin definir = sin restricción, matriz vacía = bloquear todos los hooks HTTP. Las matrices se fusionan entre fuentes de configuración. Consulte [Configuración de hooks](#hook-configuration) | `["https://hooks.example.com/*"]` |162| `allowedHttpHookUrls` | Lista blanca de patrones de URL que los hooks HTTP pueden dirigirse. Admite `*` como comodín. Cuando se establece, los hooks con URLs que no coinciden se bloquean. Sin definir = sin restricción, matriz vacía = bloquear todos los hooks HTTP. Las matrices se fusionan entre fuentes de configuración. Consulte [Configuración de hooks](#hook-configuration) | `["https://hooks.example.com/*"]` |

211| `modelOverrides` | Asignar IDs de modelo de Anthropic a IDs de modelo específicos del proveedor como ARNs de perfil de inferencia de Bedrock. Cada entrada del selector de modelo usa su valor asignado al llamar a la API del proveedor. Consulte [Anular IDs de modelo por versión](/es/model-config#override-model-ids-per-version) | `{"claude-opus-4-6": "arn:aws:bedrock:..."}` |211| `modelOverrides` | Asignar IDs de modelo de Anthropic a IDs de modelo específicos del proveedor como ARNs de perfil de inferencia de Bedrock. Cada entrada del selector de modelo usa su valor asignado al llamar a la API del proveedor. Consulte [Anular IDs de modelo por versión](/es/model-config#override-model-ids-per-version) | `{"claude-opus-4-6": "arn:aws:bedrock:..."}` |

212| `otelHeadersHelper` | Script para generar encabezados dinámicos de OpenTelemetry. Se ejecuta al inicio y periódicamente. Establezca el intervalo de actualización con [`CLAUDE_CODE_OTEL_HEADERS_HELPER_DEBOUNCE_MS`](/es/env-vars). Consulte [Encabezados dinámicos](/es/monitoring-usage#dynamic-headers) | `/bin/generate_otel_headers.sh` |212| `otelHeadersHelper` | Script para generar encabezados dinámicos de OpenTelemetry. Se ejecuta al inicio y periódicamente. Establezca el intervalo de actualización con [`CLAUDE_CODE_OTEL_HEADERS_HELPER_DEBOUNCE_MS`](/es/env-vars). Consulte [Encabezados dinámicos](/es/monitoring-usage#dynamic-headers) | `/bin/generate_otel_headers.sh` |

213| `outputStyle` | Configurar un estilo de salida para ajustar el indicador del sistema. Consulte [documentación de estilos de salida](/es/output-styles) | `"Explanatory"` |213| `outputStyle` | Configurar un estilo de salida para ajustar el indicador del sistema. Consulte [documentación de estilos de salida](/es/output-styles) | `"Explanatory"` |

214| `parentSettingsBehavior` | {/* min-version: 2.1.133 */}(Solo configuraciones administradas) Controla si las configuraciones administradas suministradas programáticamente por un proceso host de incrustación, como el Agent SDK o una extensión IDE, se aplican cuando también está presente un nivel administrado implementado por administrador. `"first-wins"`: las configuraciones suministradas por el padre se descartan y solo se aplica el nivel administrado. `"merge"`: las configuraciones suministradas por el padre se aplican bajo el nivel administrado, filtradas para que puedan restringir la política pero no flexibilizarla. No tiene efecto cuando no se implementa ningún nivel administrado. Predeterminado: `"first-wins"`. Requiere Claude Code v2.1.133 o posterior | `"merge"` |

215| `plansDirectory` | Personalizar dónde se almacenan los archivos de plan. La ruta es relativa a la raíz del proyecto. Predeterminado: `~/.claude/plans` | `"./plans"` |216| `plansDirectory` | Personalizar dónde se almacenan los archivos de plan. La ruta es relativa a la raíz del proyecto. Predeterminado: `~/.claude/plans` | `"./plans"` |

216| `pluginTrustMessage` | (Solo configuraciones administradas) Mensaje personalizado agregado a la advertencia de confianza de plugin mostrada antes de la instalación. Use esto para agregar contexto específico de la organización, por ejemplo para confirmar que los plugins de su marketplace interno están verificados. | `"All plugins from our marketplace are approved by IT"` |217| `pluginTrustMessage` | (Solo configuraciones administradas) Mensaje personalizado agregado a la advertencia de confianza de plugin mostrada antes de la instalación. Use esto para agregar contexto específico de la organización, por ejemplo para confirmar que los plugins de su marketplace interno están verificados. | `"All plugins from our marketplace are approved by IT"` |

255 256

256### Configuración de worktrees257### Configuración de worktrees

257 258

258Configure cómo `--worktree` crea y gestiona git worktrees. Use estas configuraciones para reducir el uso de disco y el tiempo de inicio en monorepos grandes.259Configure cómo `--worktree` crea y gestiona git worktrees.

259 260

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

263| `worktree.baseRef` | Qué ref ramifican los nuevos worktrees. `"fresh"` (predeterminado) ramifica desde `origin/<default-branch>` para un árbol limpio que coincida con el remoto. `"head"` ramifica desde su `HEAD` local actual, por lo que los commits no enviados y el estado de rama de características están presentes en el worktree. Se aplica a `--worktree`, la herramienta `EnterWorktree` y el aislamiento de subagent | `"head"` |

262| `worktree.symlinkDirectories` | Directorios a enlazar simbólicamente desde el repositorio principal en cada worktree para evitar duplicar directorios grandes en disco. No se enlazan directorios de forma predeterminada | `["node_modules", ".cache"]` |264| `worktree.symlinkDirectories` | Directorios a enlazar simbólicamente desde el repositorio principal en cada worktree para evitar duplicar directorios grandes en disco. No se enlazan directorios de forma predeterminada | `["node_modules", ".cache"]` |

263| `worktree.sparsePaths` | Directorios a verificar en cada worktree a través de git sparse-checkout (modo cone). Solo las rutas listadas se escriben en disco, lo que es más rápido en monorepos grandes | `["packages/my-app", "shared/utils"]` |265| `worktree.sparsePaths` | Directorios a verificar en cada worktree a través de git sparse-checkout (modo cone). Solo las rutas listadas se escriben en disco, lo que es más rápido en monorepos grandes | `["packages/my-app", "shared/utils"]` |

264 266

318| `network.socksProxyPort` | Puerto de proxy SOCKS5 usado si desea traer su propio proxy. Si no se especifica, Claude ejecutará su propio proxy. | `8081` |320| `network.socksProxyPort` | Puerto de proxy SOCKS5 usado si desea traer su propio proxy. Si no se especifica, Claude ejecutará su propio proxy. | `8081` |

319| `enableWeakerNestedSandbox` | Habilitar sandbox más débil para entornos Docker sin privilegios (solo Linux y WSL2). **Reduce la seguridad.** Predeterminado: false | `true` |321| `enableWeakerNestedSandbox` | Habilitar sandbox más débil para entornos Docker sin privilegios (solo Linux y WSL2). **Reduce la seguridad.** Predeterminado: false | `true` |

320| `enableWeakerNetworkIsolation` | (Solo macOS) Permitir acceso al servicio de confianza TLS del sistema (`com.apple.trustd.agent`) en el sandbox. Requerido para herramientas basadas en Go como `gh`, `gcloud` y `terraform` para verificar certificados TLS cuando se usa `httpProxyPort` con un proxy MITM y CA personalizada. **Reduce la seguridad** al abrir una posible ruta de exfiltración de datos. Predeterminado: false | `true` |322| `enableWeakerNetworkIsolation` | (Solo macOS) Permitir acceso al servicio de confianza TLS del sistema (`com.apple.trustd.agent`) en el sandbox. Requerido para herramientas basadas en Go como `gh`, `gcloud` y `terraform` para verificar certificados TLS cuando se usa `httpProxyPort` con un proxy MITM y CA personalizada. **Reduce la seguridad** al abrir una posible ruta de exfiltración de datos. Predeterminado: false | `true` |

323| `bwrapPath` | (Solo configuraciones administradas, Linux/WSL2) Ruta absoluta al binario bubblewrap (`bwrap`). Anula la detección automática a través de `PATH`. Solo se honra desde [configuraciones administradas](/es/settings#settings-files), no desde configuraciones de usuario o proyecto. Útil cuando `bwrap` se instala en una ubicación no estándar en entornos administrados. | `/opt/admin/bwrap` |

324| `socatPath` | (Solo configuraciones administradas, Linux/WSL2) Ruta absoluta al binario `socat` usado para el proxy de red del sandbox. Anula la detección automática a través de `PATH`. Solo se honra desde configuraciones administradas. | `/opt/admin/socat` |

321 325

322#### Prefijos de ruta de sandbox326#### Prefijos de ruta de sandbox

323 327

setup.md +2 −0

Details

398 398

399Las plataformas de instalación npm compatibles son `darwin-arm64`, `darwin-x64`, `linux-x64`, `linux-arm64`, `linux-x64-musl`, `linux-arm64-musl`, `win32-x64` y `win32-arm64`. Su gestor de paquetes debe permitir dependencias opcionales. Consulte [solución de problemas](/es/troubleshoot-install#native-binary-not-found-after-npm-install) si falta el binario después de la instalación.399Las plataformas de instalación npm compatibles son `darwin-arm64`, `darwin-x64`, `linux-x64`, `linux-arm64`, `linux-x64-musl`, `linux-arm64-musl`, `win32-x64` y `win32-arm64`. Su gestor de paquetes debe permitir dependencias opcionales. Consulte [solución de problemas](/es/troubleshoot-install#native-binary-not-found-after-npm-install) si falta el binario después de la instalación.

400 400

401Para actualizar una instalación de npm, ejecute `npm install -g @anthropic-ai/claude-code@latest`. Evite `npm update -g`, que respeta el rango semver de la instalación original y puede no llevarlo a la versión más reciente.

402

401<Warning>403<Warning>

402 NO use `sudo npm install -g` ya que esto puede causar problemas de permisos y riesgos de seguridad. Si encuentra errores de permisos, consulte [solución de problemas de errores de permisos](/es/troubleshoot-install#permission-errors-during-installation).404 NO use `sudo npm install -g` ya que esto puede causar problemas de permisos y riesgos de seguridad. Si encuentra errores de permisos, consulte [solución de problemas de errores de permisos](/es/troubleshoot-install#permission-errors-during-installation).

403</Warning>405</Warning>

sub-agents.md +3 −3

Details

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

263| `name` | Sí | Identificador único usando letras minúsculas y guiones |263| `name` | Sí | Identificador único usando letras minúsculas y guiones |

264| `description` | Sí | Cuándo Claude debe delegar en este subagente |264| `description` | Sí | Cuándo Claude debe delegar en este subagente |

265| `tools` | No | [Herramientas](#available-tools) que el subagente puede usar. Hereda todas las herramientas si se omite |265| `tools` | No | [Herramientas](#available-tools) que el subagente puede usar. Hereda todas las herramientas si se omite. Para precargar Skills en el contexto, use el campo `skills` en lugar de listar `Skill` aquí |

266| `disallowedTools` | No | Herramientas a denegar, eliminadas de la lista heredada o especificada |266| `disallowedTools` | No | Herramientas a denegar, eliminadas de la lista heredada o especificada |

267| `model` | No | [Modelo](#choose-a-model) a usar: `sonnet`, `opus`, `haiku`, un ID de modelo completo (por ejemplo, `claude-opus-4-7`), o `inherit`. Por defecto es `inherit` |267| `model` | No | [Modelo](#choose-a-model) a usar: `sonnet`, `opus`, `haiku`, un ID de modelo completo (por ejemplo, `claude-opus-4-7`), o `inherit`. Por defecto es `inherit` |

268| `permissionMode` | No | [Modo de permiso](#permission-modes): `default`, `acceptEdits`, `auto`, `dontAsk`, `bypassPermissions`, o `plan`. Se ignora para [subagentes de plugin](#choose-the-subagent-scope) |268| `permissionMode` | No | [Modo de permiso](#permission-modes): `default`, `acceptEdits`, `auto`, `dontAsk`, `bypassPermissions`, o `plan`. Se ignora para [subagentes de plugin](#choose-the-subagent-scope) |

269| `maxTurns` | No | Número máximo de turnos de agente antes de que el subagente se detenga |269| `maxTurns` | No | Número máximo de turnos de agente antes de que el subagente se detenga |

270| `skills` | No | [Skills](/es/skills) a cargar en el contexto del subagente al inicio. El contenido completo de la skill se inyecta, no solo se pone disponible para invocación. Los subagentes no heredan skills de la conversación principal |270| `skills` | No | [Skills](/es/skills) a precargar en el contexto del subagente al inicio. El contenido completo de la skill se inyecta, no solo la descripción. Los subagentes aún pueden invocar skills de proyecto, usuario y plugin no listadas a través de la herramienta Skill |

271| `mcpServers` | No | [Servidores MCP](/es/mcp) disponibles para este subagente. Cada entrada es un nombre de servidor que hace referencia a un servidor ya configurado (por ejemplo, `"slack"`) o una definición en línea con el nombre del servidor como clave y una [configuración completa del servidor MCP](/es/mcp#installing-mcp-servers) como valor. Se ignora para [subagentes de plugin](#choose-the-subagent-scope) |271| `mcpServers` | No | [Servidores MCP](/es/mcp) disponibles para este subagente. Cada entrada es un nombre de servidor que hace referencia a un servidor ya configurado (por ejemplo, `"slack"`) o una definición en línea con el nombre del servidor como clave y una [configuración completa del servidor MCP](/es/mcp#installing-mcp-servers) como valor. Se ignora para [subagentes de plugin](#choose-the-subagent-scope) |

272| `hooks` | No | [Hooks de ciclo de vida](#define-hooks-for-subagents) limitados a este subagente. Se ignora para [subagentes de plugin](#choose-the-subagent-scope) |272| `hooks` | No | [Hooks de ciclo de vida](#define-hooks-for-subagents) limitados a este subagente. Se ignora para [subagentes de plugin](#choose-the-subagent-scope) |

273| `memory` | No | [Alcance de memoria persistente](#enable-persistent-memory): `user`, `project`, o `local`. Habilita aprendizaje entre sesiones |273| `memory` | No | [Alcance de memoria persistente](#enable-persistent-memory): `user`, `project`, o `local`. Habilita aprendizaje entre sesiones |

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

421El contenido completo de cada skill se inyecta en el contexto del subagente, no solo se pone disponible para invocación. Los subagentes no heredan skills de la conversación principal; debe enumerarlas explícitamente.421El contenido completo de cada skill listada se inyecta en el contexto del subagente al inicio. Este campo controla qué skills se precargan, no qué skills el subagente puede acceder: sin él, el subagente aún puede descubrir e invocar skills de proyecto, usuario y plugin a través de la herramienta Skill durante la ejecución. Para evitar que un subagente invoque skills en absoluto, omita `Skill` de la lista [`tools`](#available-tools) o agréguelo a `disallowedTools`.

422 422

423No puede precargar skills que establezcan [`disable-model-invocation: true`](/es/skills#control-who-invokes-a-skill), ya que la precarga se extrae del mismo conjunto de skills que Claude puede invocar. Si una skill listada falta o está deshabilitada, Claude Code la omite y registra una advertencia en el registro de depuración.423No puede precargar skills que establezcan [`disable-model-invocation: true`](/es/skills#control-who-invokes-a-skill), ya que la precarga se extrae del mismo conjunto de skills que Claude puede invocar. Si una skill listada falta o está deshabilitada, Claude Code la omite y registra una advertencia en el registro de depuración.

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 línea `allow-passthrough` permite que las notificaciones y actualizaciones de progreso lleguen a iTerm2, Ghostty o Kitty en lugar de ser tragadas por tmux. Las líneas `extended-keys` permiten que tmux distinga Shift+Enter de Enter simple para que el atajo de salto de línea funcione.110La línea `allow-passthrough` permite que las notificaciones y actualizaciones de progreso lleguen a la terminal externa en lugar de ser tragadas por tmux. Las líneas `extended-keys` permiten que tmux distinga Shift+Enter de Enter simple para que el atajo de salto de línea funcione.

111 111

112## Haz coincidir el tema de color112## Haz coincidir el tema de color

113 113

third-party-integrations.md +73 −1

Details

6 6

7> Aprenda cómo Claude Code puede integrarse con varios servicios de terceros e infraestructura para cumplir con los requisitos de implementación empresarial.7> Aprenda cómo Claude Code puede integrarse con varios servicios de terceros e infraestructura para cumplir con los requisitos de implementación empresarial.

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

9Las organizaciones pueden implementar Claude Code directamente a través de Anthropic o a través de un proveedor de nube. Esta página le ayuda a elegir la configuración correcta.79Las organizaciones pueden implementar Claude Code directamente a través de Anthropic o a través de un proveedor de nube. Esta página le ayuda a elegir la configuración correcta.

10 80

81<ContactSalesCard surface="third_party_overview" />

11## Comparar opciones de implementación83## Comparar opciones de implementación

12 84

13Para la mayoría de las organizaciones, Claude for Teams o Claude for Enterprise proporciona la mejor experiencia. Los miembros del equipo obtienen acceso tanto a Claude Code como a Claude en la web con una única suscripción, facturación centralizada y sin necesidad de configuración de infraestructura.85Para la mayoría de las organizaciones, Claude for Teams o Claude for Enterprise proporciona la mejor experiencia. Los miembros del equipo obtienen acceso tanto a Claude Code como a Claude en la web con una única suscripción, facturación centralizada y sin necesidad de configuración de infraestructura.

241 313

242### Fijar versiones de modelo para proveedores de nube314### Fijar versiones de modelo para proveedores de nube

243 315

244Si implementa a través de [Bedrock](/es/amazon-bedrock), [Vertex AI](/es/google-vertex-ai), o [Foundry](/es/microsoft-foundry), fije versiones de modelo específicas usando `ANTHROPIC_DEFAULT_OPUS_MODEL`, `ANTHROPIC_DEFAULT_SONNET_MODEL`, y `ANTHROPIC_DEFAULT_HAIKU_MODEL`. Sin fijar, los alias de Claude Code se resuelven a la versión más reciente, lo que puede romper a los usuarios cuando Anthropic lanza un nuevo modelo que aún no está habilitado en su cuenta. Consulte [Configuración de modelo](/es/model-config#pin-models-for-third-party-deployments) para obtener detalles.316Si implementa a través de [Bedrock](/es/amazon-bedrock), [Vertex AI](/es/google-vertex-ai), o [Foundry](/es/microsoft-foundry), fije versiones de modelo específicas usando `ANTHROPIC_DEFAULT_OPUS_MODEL`, `ANTHROPIC_DEFAULT_SONNET_MODEL`, y `ANTHROPIC_DEFAULT_HAIKU_MODEL`. Sin fijar, los alias de modelo se resuelven a la versión más reciente, lo que puede no estar habilitado en su cuenta cuando Anthropic lanza una actualización. Fijar le permite controlar cuándo sus usuarios se mueven a un nuevo modelo. Consulte [Configuración de modelo](/es/model-config#pin-models-for-third-party-deployments) para ver qué hace cada proveedor cuando la versión más reciente no está disponible.

245 317

246### Configurar políticas de seguridad318### Configurar políticas de seguridad

247 319

vs-code.md +7 −5

Details

8 8

9<img src="https://mintcdn.com/claude-code/-YhHHmtSxwr7W8gy/images/vs-code-extension-interface.jpg?fit=max&auto=format&n=-YhHHmtSxwr7W8gy&q=85&s=300652d5678c63905e6b0ea9e50835f8" alt="Editor de VS Code con el panel de extensión Claude Code abierto en el lado derecho, mostrando una conversación con Claude" width="2500" height="1155" data-path="images/vs-code-extension-interface.jpg" />9<img src="https://mintcdn.com/claude-code/-YhHHmtSxwr7W8gy/images/vs-code-extension-interface.jpg?fit=max&auto=format&n=-YhHHmtSxwr7W8gy&q=85&s=300652d5678c63905e6b0ea9e50835f8" alt="Editor de VS Code con el panel de extensión Claude Code abierto en el lado derecho, mostrando una conversación con Claude" width="2500" height="1155" data-path="images/vs-code-extension-interface.jpg" />

10 10

~~11La extensión de VS Code proporciona una interfaz gráfica nativa para Claude Code, integrada directamente en tu IDE. Esta es la forma recomendada de usar Claude Code en VS Code.~~11La extensión de VS Code proporciona una interfaz gráfica nativa para Claude Code, integrada directamente en su IDE. Esta es la forma recomendada de usar Claude Code en VS Code.

12 12

13Con la extensión, puedes revisar y editar los planes de Claude antes de aceptarlos, aceptar automáticamente ediciones a medida que se realizan, mencionar archivos con rangos de líneas específicas de tu selección, acceder al historial de conversaciones y abrir múltiples conversaciones en pestañas o ventanas separadas.13Con la extensión, puede revisar y editar los planes de Claude antes de aceptarlos, aceptar automáticamente ediciones a medida que se realizan, mencionar archivos con rangos de líneas específicas de su selección, acceder al historial de conversaciones y abrir múltiples conversaciones en pestañas o ventanas separadas.

14 14

15## Requisitos previos15## Requisitos previos

16 16

32 32

33O en VS Code, presiona `Cmd+Shift+X` (Mac) o `Ctrl+Shift+X` (Windows/Linux) para abrir la vista Extensiones, busca "Claude Code" y haz clic en **Instalar**.33O en VS Code, presiona `Cmd+Shift+X` (Mac) o `Ctrl+Shift+X` (Windows/Linux) para abrir la vista Extensiones, busca "Claude Code" y haz clic en **Instalar**.

34 34

35La extensión también se instala en otros forks de VS Code como Windsurf o Kiro. Busca "Claude Code" en la vista Extensiones del editor, o instala desde el [registro Open VSX](https://open-vsx.org/extension/Anthropic/claude-code). Si tu editor no puede instalar la extensión, ejecuta `claude` en su terminal integrada en su lugar. La [CLI](/es/quickstart) funciona en cualquier terminal.

35<Note>Si la extensión no aparece después de la instalación, reinicia VS Code o ejecuta "Developer: Reload Window" desde la Paleta de comandos.</Note>37<Note>Si la extensión no aparece después de la instalación, reinicia VS Code o ejecuta "Developer: Reload Window" desde la Paleta de comandos.</Note>

36 38

37## Comenzar39## Comenzar

305### Configuración de extensión307### Configuración de extensión

306 308

308| --------------------------------- | -------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |310| --------------------------------- | -------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

310| `initialPermissionMode` | `default` | Controla mensajes de aprobación para nuevas conversaciones: `default`, `plan`, `acceptEdits`, o `bypassPermissions`. Consulta [modos de permiso](/es/permission-modes). |312| `initialPermissionMode` | `default` | Controla mensajes de aprobación para nuevas conversaciones: `default`, `plan`, `acceptEdits`, o `bypassPermissions`. Consulta [modos de permiso](/es/permission-modes). |

318| `environmentVariables` | `[]` | Establecer variables de entorno para el proceso de Claude. Usa la configuración de Claude Code en su lugar para configuración compartida. |320| `environmentVariables` | `[]` | Establecer variables de entorno para el proceso de Claude. Usa la configuración de Claude Code en su lugar para configuración compartida. |

320| `allowDangerouslySkipPermissions` | `false` | Agrega [Modo Auto](/es/permission-modes#eliminate-prompts-with-auto-mode) y Bypass permissions a la selector de modo. Auto mode tiene [requisitos de plan, admin, modelo y proveedor](/es/permission-modes#eliminate-prompts-with-auto-mode), por lo que puede permanecer no disponible incluso con este toggle activado. Usa Bypass permissions solo en sandboxes sin acceso a Internet. |322| `allowDangerouslySkipPermissions` | `false` | Agrega [Modo Auto](/es/permission-modes#eliminate-prompts-with-auto-mode) y Bypass permissions al selector de modo. Auto mode tiene [requisitos de plan, admin, modelo y proveedor](/es/permission-modes#eliminate-prompts-with-auto-mode), por lo que puede permanecer no disponible incluso con este toggle activado. Usa Bypass permissions solo en sandboxes sin acceso a Internet. |

321| `claudeProcessWrapper` | - | Ruta ejecutable utilizada para lanzar el proceso de Claude |323| `claudeProcessWrapper` | - | Ejecutable utilizado para lanzar el proceso de Claude. La ruta del binario incluido se pasa como argumento cuando está presente. Establece esto en un binario `claude` instalado por separado si la compilación de la extensión no incluye uno para tu plataforma. |

322 324

323## Extensión de VS Code frente a CLI de Claude Code325## Extensión de VS Code frente a CLI de Claude Code

324 326

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