Documentation — Spybara

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

Details

14 14

15## Dateisystemeinstellungen mit settingSources kontrollieren15## Dateisystemeinstellungen mit settingSources kontrollieren

16 16

17Die Einstellungsquellen-Option ([`setting_sources`](/de/agent-sdk/python#claude-agent-options) in Python, [`settingSources`](/de/agent-sdk/typescript#setting-source) in TypeScript) kontrolliert, welche dateisystemgestützten Einstellungen das SDK lädt. Übergeben Sie eine explizite Liste, um sich für bestimmte Quellen anzumelden, oder übergeben Sie ein leeres Array, um Benutzer-, Projekt- und lokale Einstellungen zu deaktivieren.17Die Einstellungsquellen-Option ([`setting_sources`](/de/agent-sdk/python#claudeagentoptions) in Python, [`settingSources`](/de/agent-sdk/typescript#settingsource) in TypeScript) kontrolliert, welche dateisystemgestützten Einstellungen das SDK lädt. Übergeben Sie eine explizite Liste, um sich für bestimmte Quellen anzumelden, oder übergeben Sie ein leeres Array, um Benutzer-, Projekt- und lokale Einstellungen zu deaktivieren.

18 18

19Dieses Beispiel lädt sowohl Benutzer- als auch Projektebenen-Einstellungen, indem `settingSources` auf `["user", "project"]` gesetzt wird:19Dieses Beispiel lädt sowohl Benutzer- als auch Projektebenen-Einstellungen, indem `settingSources` auf `["user", "project"]` gesetzt wird:

20 20

65 ```65 ```

66</CodeGroup>66</CodeGroup>

67 67

68Jede Quelle lädt Einstellungen von einem bestimmten Ort, wobei `<cwd>` das Arbeitsverzeichnis ist, das Sie über die `cwd`-Option übergeben (oder das aktuelle Verzeichnis des Prozesses, falls nicht gesetzt). Für die vollständige Typdefinition siehe [`SettingSource`](/de/agent-sdk/typescript#setting-source) (TypeScript) oder [`SettingSource`](/de/agent-sdk/python#setting-source) (Python).68Jede Quelle lädt Einstellungen von einem bestimmten Ort, wobei `<cwd>` das Arbeitsverzeichnis ist, das Sie über die `cwd`-Option übergeben, oder das aktuelle Verzeichnis des Prozesses, falls nicht gesetzt. Für die vollständige Typdefinition siehe [`SettingSource`](/de/agent-sdk/typescript#settingsource) (TypeScript) oder [`SettingSource`](/de/agent-sdk/python#settingsource) (Python).

69 69

70| Quelle | Was wird geladen | Ort |70| Quelle | Was wird geladen | Ort |

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

119 119

120Skills sind Markdown-Dateien, die Ihrem Agenten spezialisiertes Wissen und aufrufbare Workflows geben. Im Gegensatz zu `CLAUDE.md` (das jede Sitzung geladen wird) werden Skills bei Bedarf geladen. Der Agent erhält Skill-Beschreibungen beim Start und lädt den vollständigen Inhalt, wenn relevant.120Skills sind Markdown-Dateien, die Ihrem Agenten spezialisiertes Wissen und aufrufbare Workflows geben. Im Gegensatz zu `CLAUDE.md` (das jede Sitzung geladen wird) werden Skills bei Bedarf geladen. Der Agent erhält Skill-Beschreibungen beim Start und lädt den vollständigen Inhalt, wenn relevant.

121 121

122Skills werden durch `settingSources` vom Dateisystem entdeckt. Mit Standardoptionen werden Benutzer- und Projekt-Skills automatisch geladen. Das `Skill`-Tool ist standardmäßig aktiviert, wenn Sie `allowedTools` nicht angeben. Wenn Sie eine `allowedTools`-Zulassungsliste verwenden, schließen Sie `"Skill"` explizit ein.122Skills werden durch `settingSources` vom Dateisystem entdeckt. Wenn die `skills`-Option bei `query()` weggelassen wird, werden entdeckte Benutzer- und Projekt-Skills aktiviert und das Skill-Tool ist verfügbar, was dem CLI-Verhalten entspricht. Um zu steuern, welche Skills aktiviert sind, übergeben Sie `skills` als `"all"`, eine Liste von Skill-Namen oder `[]`, um alle zu deaktivieren. Das SDK aktiviert das Skill-Tool automatisch, wenn `skills` gesetzt ist, daher müssen Sie es nicht zu `allowedTools` hinzufügen.

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| Einen wiederverwendbaren Workflow ausführen (bereitstellen, überprüfen, freigeben) | [Benutzer-aufrufbare Skills](/de/agent-sdk/skills) | `settingSources` + `allowedTools: ["Skill"]` |266| Einen wiederverwendbaren Workflow ausführen (bereitstellen, überprüfen, freigeben) | [Benutzer-aufrufbare Skills](/de/agent-sdk/skills) | `settingSources` + `skills`-Option |

265| Eine isolierte Teilaufgabe an einen frischen Kontext delegieren (Recherche, Überprüfung) | [Subagenten](/de/agent-sdk/subagents) | `agents`-Parameter + `allowedTools: ["Agent"]` |267| Eine isolierte Teilaufgabe an einen frischen Kontext delegieren (Recherche, Überprüfung) | [Subagenten](/de/agent-sdk/subagents) | `agents`-Parameter + `allowedTools: ["Agent"]` |

266| Mehrere Claude Code-Instanzen mit gemeinsamen Aufgabenlisten und direkter Inter-Agent-Messaging koordinieren | [Agent-Teams](/de/agent-teams) | Nicht direkt über SDK-Optionen konfiguriert. Agent-Teams sind eine CLI-Funktion, bei der eine Sitzung als Team-Lead fungiert und die Arbeit über unabhängige Teammates koordiniert |268| Mehrere Claude Code-Instanzen mit gemeinsamen Aufgabenlisten und direkter Inter-Agent-Messaging koordinieren | [Agent-Teams](/de/agent-teams) | Nicht direkt über SDK-Optionen konfiguriert. Agent-Teams sind eine CLI-Funktion, bei der eine Sitzung als Team-Lead fungiert und die Arbeit über unabhängige Teammates koordiniert |

267| Deterministische Logik auf Tool-Aufrufe ausführen (Audit, Block, Transform) | [Hooks](/de/agent-sdk/hooks) | `hooks`-Parameter mit Callbacks oder Shell-Skripte, die über `settingSources` geladen werden |269| Deterministische Logik auf Tool-Aufrufe ausführen (Audit, Block, Transform) | [Hooks](/de/agent-sdk/hooks) | `hooks`-Parameter mit Callbacks oder Shell-Skripte, die über `settingSources` geladen werden |

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# Mit MCP zu externen Tools verbinden

7> Konfigurieren Sie MCP-Server, um Ihren Agenten mit externen Tools zu erweitern. Behandelt Transporttypen, Tool-Suche für große Tool-Sets, Authentifizierung und Fehlerbehandlung.

9Das [Model Context Protocol (MCP)](https://modelcontextprotocol.io/docs/getting-started/intro) ist ein offener Standard für die Verbindung von KI-Agenten mit externen Tools und Datenquellen. Mit MCP kann Ihr Agent Datenbanken abfragen, sich mit APIs wie Slack und GitHub integrieren und sich mit anderen Diensten verbinden, ohne benutzerdefinierte Tool-Implementierungen zu schreiben.

11MCP-Server können als lokale Prozesse ausgeführt werden, sich über HTTP verbinden oder direkt in Ihrer SDK-Anwendung ausgeführt werden.

13<Note>

14 Diese Seite behandelt die MCP-Konfiguration für das Agent SDK. Um MCP-Server zur Claude Code CLI hinzuzufügen, damit sie in jedem Projekt geladen werden, siehe [MCP-Installationsbereiche](/de/mcp#mcp-installation-scopes).

15</Note>

17## Schnellstart

19Dieses Beispiel verbindet sich mit dem [Claude Code-Dokumentations](https://code.claude.com/docs)-MCP-Server unter Verwendung von [HTTP-Transport](#httpsse-servers) und verwendet [`allowedTools`](#allow-mcp-tools) mit einem Platzhalter, um alle Tools vom Server zuzulassen.

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>

71Der Agent verbindet sich mit dem Dokumentationsserver, sucht nach Informationen über hooks und gibt die Ergebnisse zurück.

73## Einen MCP-Server hinzufügen

75Sie können MCP-Server im Code beim Aufrufen von `query()` konfigurieren oder in einer `.mcp.json`-Datei, die über [`settingSources`](#from-a-config-file) geladen wird.

77### Im Code

79Übergeben Sie MCP-Server direkt in der `mcpServers`-Option:

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### Aus einer Konfigurationsdatei

133

134Erstellen Sie eine `.mcp.json`-Datei im Stammverzeichnis Ihres Projekts. Die Datei wird aufgegriffen, wenn die `project`-Einstellungsquelle aktiviert ist, was sie für Standard-`query()`-Optionen ist. Wenn Sie `settingSources` explizit festlegen, fügen Sie `"project"` ein, damit diese Datei geladen wird:

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## MCP-Tools zulassen

148

149MCP-Tools erfordern explizite Genehmigung, bevor Claude sie verwenden kann. Ohne Genehmigung sieht Claude, dass Tools verfügbar sind, kann sie aber nicht aufrufen.

150

151### Tool-Benennungskonvention

152

153MCP-Tools folgen dem Benennungsmuster `mcp__<server-name>__<tool-name>`. Beispielsweise wird ein GitHub-Server mit dem Namen `"github"` mit einem `list_issues`-Tool zu `mcp__github__list_issues`.

154

155### Zugriff mit allowedTools gewähren

156

157Verwenden Sie `allowedTools`, um anzugeben, welche MCP-Tools Claude verwenden kann:

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

174Platzhalter (`*`) ermöglichen es Ihnen, alle Tools von einem Server zuzulassen, ohne jedes einzeln aufzulisten.

175

176<Note>

177 **Bevorzugen Sie `allowedTools` gegenüber Berechtigungsmodi für MCP-Zugriff.** `permissionMode: "acceptEdits"` genehmigt MCP-Tools nicht automatisch (nur Dateibearbeitungen und Filesystem-Bash-Befehle). `permissionMode: "bypassPermissions"` genehmigt MCP-Tools automatisch, deaktiviert aber auch alle anderen Sicherheitsaufforderungen, was breiter ist als nötig. Ein Platzhalter in `allowedTools` gewährt genau den MCP-Server, den Sie möchten, und nichts mehr. Siehe [Berechtigungsmodi](/de/agent-sdk/permissions#permission-modes) für einen vollständigen Vergleich.

178</Note>

179

180### Verfügbare Tools entdecken

181

182Um zu sehen, welche Tools ein MCP-Server bereitstellt, überprüfen Sie die Dokumentation des Servers oder verbinden Sie sich mit dem Server und inspizieren Sie die `system`-Init-Nachricht:

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

193

194MCP-Server kommunizieren mit Ihrem Agenten über verschiedene Transportprotokolle. Überprüfen Sie die Dokumentation des Servers, um zu sehen, welchen Transport er unterstützt:

195

196* Wenn die Dokumentation Ihnen einen **Befehl zum Ausführen** gibt (wie `npx @modelcontextprotocol/server-github`), verwenden Sie stdio

197* Wenn die Dokumentation Ihnen eine **URL** gibt, verwenden Sie HTTP oder SSE

198* Wenn Sie Ihre eigenen Tools im Code erstellen, verwenden Sie einen SDK MCP-Server

199

200### stdio-Server

201

202Lokale Prozesse, die über stdin/stdout kommunizieren. Verwenden Sie dies für MCP-Server, die Sie auf demselben Computer ausführen:

203

204<Tabs>

205 <Tab title="Im Code">

206 <CodeGroup>

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

208 const _ = {

209 options: {

210 mcpServers: {

211 github: {

212 command: "npx",

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

214 env: {

215 GITHUB_TOKEN: process.env.GITHUB_TOKEN

216 }

217 }

218 },

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

220 }

221 };

222 ```

223

224 ```python Python theme={null}

225 options = ClaudeAgentOptions(

226 mcp_servers={

227 "github": {

228 "command": "npx",

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

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

231 }

232 },

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

234 )

235 ```

236 </CodeGroup>

237 </Tab>

238

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

240 ```json theme={null}

241 {

242 "mcpServers": {

243 "github": {

244 "command": "npx",

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

246 "env": {

247 "GITHUB_TOKEN": "${GITHUB_TOKEN}"

248 }

249 }

250 }

251 }

252 ```

253 </Tab>

254</Tabs>

255

256### HTTP/SSE-Server

257

258Verwenden Sie HTTP oder SSE für Cloud-gehostete MCP-Server und Remote-APIs:

259

260<Tabs>

261 <Tab title="Im Code">

262 <CodeGroup>

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

264 const _ = {

265 options: {

266 mcpServers: {

267 "remote-api": {

268 type: "sse",

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

270 headers: {

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

272 }

273 }

274 },

275 allowedTools: ["mcp__remote-api__*"]

276 }

277 };

278 ```

279

280 ```python Python theme={null}

281 options = ClaudeAgentOptions(

282 mcp_servers={

283 "remote-api": {

284 "type": "sse",

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

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

287 }

288 },

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

290 )

291 ```

292 </CodeGroup>

293 </Tab>

294

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

296 ```json theme={null}

297 {

298 "mcpServers": {

299 "remote-api": {

300 "type": "sse",

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

302 "headers": {

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

304 }

305 }

306 }

307 }

308 ```

309 </Tab>

310</Tabs>

311

312Verwenden Sie für HTTP (nicht-Streaming) stattdessen `"type": "http"`.

313

314### SDK MCP-Server

315

316Definieren Sie benutzerdefinierte Tools direkt in Ihrem Anwendungscode, anstatt einen separaten Serverprozess auszuführen. Siehe das [Leitfaden für benutzerdefinierte Tools](/de/agent-sdk/custom-tools) für Implementierungsdetails.

317

318## MCP-Tool-Suche

319

320Wenn Sie viele MCP-Tools konfiguriert haben, können Tool-Definitionen einen erheblichen Teil Ihres Kontextfensters verbrauchen. Die Tool-Suche löst dies, indem Tool-Definitionen aus dem Kontext zurückgehalten und nur die Tools geladen werden, die Claude für jeden Durchgang benötigt.

321

322Die Tool-Suche ist standardmäßig aktiviert. Siehe [Tool-Suche](/de/agent-sdk/tool-search) für Konfigurationsoptionen und Details.

323

324Für weitere Details, einschließlich Best Practices und Verwendung der Tool-Suche mit benutzerdefinierten SDK-Tools, siehe das [Tool-Suche-Leitfaden](/de/agent-sdk/tool-search).

325

326## Authentifizierung

327

328Die meisten MCP-Server erfordern Authentifizierung, um auf externe Dienste zuzugreifen. Übergeben Sie Anmeldedaten über Umgebungsvariablen in der Serverkonfiguration.

329

330### Anmeldedaten über Umgebungsvariablen übergeben

331

332Verwenden Sie das `env`-Feld, um API-Schlüssel, Token und andere Anmeldedaten an den MCP-Server zu übergeben:

333

334<Tabs>

335 <Tab title="Im Code">

336 <CodeGroup>

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

338 const _ = {

339 options: {

340 mcpServers: {

341 github: {

342 command: "npx",

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

344 env: {

345 GITHUB_TOKEN: process.env.GITHUB_TOKEN

346 }

347 }

348 },

349 allowedTools: ["mcp__github__list_issues"]

350 }

351 };

352 ```

353

354 ```python Python theme={null}

355 options = ClaudeAgentOptions(

356 mcp_servers={

357 "github": {

358 "command": "npx",

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

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

361 }

362 },

363 allowed_tools=["mcp__github__list_issues"],

364 )

365 ```

366 </CodeGroup>

367 </Tab>

368

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

370 ```json theme={null}

371 {

372 "mcpServers": {

373 "github": {

374 "command": "npx",

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

376 "env": {

377 "GITHUB_TOKEN": "${GITHUB_TOKEN}"

378 }

379 }

380 }

381 }

382 ```

383

384 Die `${GITHUB_TOKEN}`-Syntax erweitert Umgebungsvariablen zur Laufzeit.

385 </Tab>

386</Tabs>

387

388Siehe [Probleme aus einem Repository auflisten](#list-issues-from-a-repository) für ein vollständiges funktionierendes Beispiel mit Debug-Protokollierung.

389

390### HTTP-Header für Remote-Server

391

392Für HTTP- und SSE-Server übergeben Sie Authentifizierungs-Header direkt in der Serverkonfiguration:

393

394<Tabs>

395 <Tab title="Im Code">

396 <CodeGroup>

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

398 const _ = {

399 options: {

400 mcpServers: {

401 "secure-api": {

402 type: "http",

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

404 headers: {

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

406 }

407 }

408 },

409 allowedTools: ["mcp__secure-api__*"]

410 }

411 };

412 ```

413

414 ```python Python theme={null}

415 options = ClaudeAgentOptions(

416 mcp_servers={

417 "secure-api": {

418 "type": "http",

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

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

421 }

422 },

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

424 )

425 ```

426 </CodeGroup>

427 </Tab>

428

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

430 ```json theme={null}

431 {

432 "mcpServers": {

433 "secure-api": {

434 "type": "http",

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

436 "headers": {

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

438 }

439 }

440 }

441 }

442 ```

443

444 Die `${API_TOKEN}`-Syntax erweitert Umgebungsvariablen zur Laufzeit.

445 </Tab>

446</Tabs>

447

448### OAuth2-Authentifizierung

449

450Die [MCP-Spezifikation unterstützt OAuth 2.1](https://modelcontextprotocol.io/specification/2025-03-26/basic/authorization) für Autorisierung. Das SDK verarbeitet OAuth-Flows nicht automatisch, aber Sie können Zugriffs-Token über Header übergeben, nachdem Sie den OAuth-Flow in Ihrer Anwendung abgeschlossen haben:

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

489

490### Probleme aus einem Repository auflisten

491

492Dieses Beispiel verbindet sich mit dem [GitHub MCP-Server](https://github.com/modelcontextprotocol/servers/tree/main/src/github), um aktuelle Probleme aufzulisten. Das Beispiel enthält Debug-Protokollierung, um die MCP-Verbindung und Tool-Aufrufe zu überprüfen.

493

494Erstellen Sie vor dem Ausführen ein [GitHub-Persönliches Zugriffs-Token](https://github.com/settings/tokens) mit `repo`-Bereich und legen Sie es als Umgebungsvariable fest:

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### Eine Datenbank abfragen

588

589Dieses Beispiel verwendet den [Postgres MCP-Server](https://github.com/modelcontextprotocol/servers/tree/main/src/postgres), um eine Datenbank abzufragen. Die Verbindungszeichenfolge wird als Argument an den Server übergeben. Der Agent entdeckt automatisch das Datenbankschema, schreibt die SQL-Abfrage und gibt die Ergebnisse zurück:

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

659

660MCP-Server können aus verschiedenen Gründen keine Verbindung herstellen: Der Serverprozess ist möglicherweise nicht installiert, Anmeldedaten könnten ungültig sein, oder ein Remote-Server könnte unerreichbar sein.

661

662Das SDK sendet eine `system`-Nachricht mit dem Subtyp `init` am Anfang jeder Abfrage. Diese Nachricht enthält den Verbindungsstatus für jeden MCP-Server. Überprüfen Sie das `status`-Feld, um Verbindungsfehler zu erkennen, bevor der Agent mit der Arbeit beginnt:

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

721

722### Server zeigt Status „fehlgeschlagen"

723

724Überprüfen Sie die `init`-Nachricht, um zu sehen, welche Server keine Verbindung herstellen konnten:

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

736Häufige Ursachen:

737

738* **Fehlende Umgebungsvariablen**: Stellen Sie sicher, dass erforderliche Token und Anmeldedaten festgelegt sind. Überprüfen Sie für stdio-Server, dass das `env`-Feld dem entspricht, was der Server erwartet.

739* **Server nicht installiert**: Überprüfen Sie für `npx`-Befehle, dass das Paket vorhanden ist und Node.js in Ihrem PATH ist.

740* **Ungültige Verbindungszeichenfolge**: Überprüfen Sie für Datenbankserver das Format der Verbindungszeichenfolge und dass die Datenbank zugänglich ist.

741* **Netzwerkprobleme**: Überprüfen Sie für Remote-HTTP/SSE-Server, dass die URL erreichbar ist und Firewalls die Verbindung zulassen.

742

743### Tools werden nicht aufgerufen

744

745Wenn Claude Tools sieht, sie aber nicht verwendet, überprüfen Sie, dass Sie die Berechtigung mit `allowedTools` gewährt haben:

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### Verbindungs-Timeouts

759

760Das MCP SDK hat ein Standard-Timeout von 60 Sekunden für Serververbindungen. Wenn Ihr Server länger zum Starten benötigt, schlägt die Verbindung fehl. Für Server, die mehr Startzeit benötigen, erwägen Sie:

761

762* Verwendung eines leichteren Servers, falls verfügbar

763* Vorwärmung des Servers vor dem Starten Ihres Agenten

764* Überprüfung von Serverprotokollen auf langsame Initialisierungsursachen

765

766## Verwandte Ressourcen

767

768* **[Leitfaden für benutzerdefinierte Tools](/de/agent-sdk/custom-tools)**: Erstellen Sie Ihren eigenen MCP-Server, der in-process mit Ihrer SDK-Anwendung ausgeführt wird

769* **[Berechtigungen](/de/agent-sdk/permissions)**: Kontrollieren Sie, welche MCP-Tools Ihr Agent mit `allowedTools` und `disallowedTools` verwenden kann

770* **[TypeScript SDK-Referenz](/de/agent-sdk/typescript)**: Vollständige API-Referenz einschließlich MCP-Konfigurationsoptionen

771* **[Python SDK-Referenz](/de/agent-sdk/python)**: Vollständige API-Referenz einschließlich MCP-Konfigurationsoptionen

772* **[MCP-Server-Verzeichnis](https://github.com/modelcontextprotocol/servers)**: Durchsuchen Sie verfügbare MCP-Server für Datenbanken, APIs und mehr

agent-sdk/python.md +1 −0

Details

836| `setting_sources` | `list[SettingSource] \| None` | `None` (CLI-Standard: alle Quellen) | Kontrollieren Sie, welche Dateisystem-Einstellungen geladen werden. Übergeben Sie `[]`, um Benutzer-, Projekt- und lokale Einstellungen zu deaktivieren. Verwaltete Richtlinieneinstellungen werden unabhängig davon geladen. Siehe [Claude Code-Funktionen verwenden](/de/agent-sdk/claude-code-features#what-settingsources-does-not-control) |836| `setting_sources` | `list[SettingSource] \| None` | `None` (CLI-Standard: alle Quellen) | Kontrollieren Sie, welche Dateisystem-Einstellungen geladen werden. Übergeben Sie `[]`, um Benutzer-, Projekt- und lokale Einstellungen zu deaktivieren. Verwaltete Richtlinieneinstellungen werden unabhängig davon geladen. Siehe [Claude Code-Funktionen verwenden](/de/agent-sdk/claude-code-features#what-settingsources-does-not-control) |

837| `skills` | `list[str] \| Literal["all"] \| None` | `None` | Skills, die der Sitzung zur Verfügung stehen. Übergeben Sie `"all"`, um jeden erkannten Skill zu aktivieren, oder eine Liste von Skill-Namen. Wenn gesetzt, aktiviert das SDK das Skill-Tool automatisch, ohne es in `allowed_tools` aufzulisten. Siehe [Skills](/de/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# Mit Sitzungen arbeiten

7> Wie Sitzungen die Gesprächsverlauf des Agenten speichern, und wann Sie continue, resume und fork verwenden, um zu einem früheren Durchlauf zurückzukehren.

9Eine Sitzung ist der Gesprächsverlauf, den das SDK während der Arbeit Ihres Agenten sammelt. Sie enthält Ihren Prompt, jeden Werkzeugaufruf, den der Agent durchgeführt hat, jedes Werkzeugergebnis und jede Antwort. Das SDK schreibt sie automatisch auf die Festplatte, damit Sie später zu ihr zurückkehren können.

11Zu einer Sitzung zurückzukehren bedeutet, dass der Agent den vollständigen Kontext von zuvor hat: Dateien, die er bereits gelesen hat, Analysen, die er bereits durchgeführt hat, Entscheidungen, die er bereits getroffen hat. Sie können eine Anschlussfrage stellen, sich von einer Unterbrechung erholen oder einen anderen Ansatz ausprobieren.

13<Note>

14 Sitzungen speichern das **Gespräch**, nicht das Dateisystem. Um Dateiänderungen, die der Agent vorgenommen hat, zu erfassen und rückgängig zu machen, verwenden Sie [Datei-Checkpointing](/de/agent-sdk/file-checkpointing).

15</Note>

17Dieser Leitfaden behandelt, wie Sie den richtigen Ansatz für Ihre App wählen, die SDK-Schnittstellen, die Sitzungen automatisch verfolgen, wie Sie Sitzungs-IDs erfassen und `resume` und `fork` manuell verwenden, und was Sie über das Fortsetzen von Sitzungen über Hosts hinweg wissen müssen.

19## Wählen Sie einen Ansatz

21Wie viel Sitzungsverwaltung Sie benötigen, hängt von der Form Ihrer Anwendung ab. Die Sitzungsverwaltung kommt ins Spiel, wenn Sie mehrere Prompts senden, die Kontext teilen sollten. Innerhalb eines einzelnen `query()`-Aufrufs nimmt der Agent bereits so viele Durchläufe vor, wie nötig, und Berechtigungsprompts und `AskUserQuestion` werden [in-loop verarbeitet](/de/agent-sdk/user-input) (sie beenden den Aufruf nicht).

23| Was Sie erstellen | Was Sie verwenden |

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

25| Einmalige Aufgabe: einzelner Prompt, keine Anschlussfrage | Nichts Zusätzliches. Ein `query()`-Aufruf verarbeitet es. |

26| Multi-Turn-Chat in einem Prozess | [`ClaudeSDKClient` (Python) oder `continue: true` (TypeScript)](#automatic-session-management). Das SDK verfolgt die Sitzung für Sie ohne ID-Verwaltung. |

27| Dort weitermachen, wo Sie nach einem Prozessneustart aufgehört haben | `continue_conversation=True` (Python) / `continue: true` (TypeScript). Setzt die neueste Sitzung im Verzeichnis fort, keine ID erforderlich. |

28| Eine bestimmte frühere Sitzung fortsetzen (nicht die neueste) | Erfassen Sie die Sitzungs-ID und übergeben Sie sie an `resume`. |

29| Einen alternativen Ansatz ausprobieren, ohne das Original zu verlieren | Forken Sie die Sitzung. |

30| Zustandslose Aufgabe, möchten nichts auf die Festplatte geschrieben haben (nur TypeScript) | Setzen Sie [`persistSession: false`](/de/agent-sdk/typescript#options). Die Sitzung existiert nur im Speicher für die Dauer des Aufrufs. Python speichert immer auf der Festplatte. |

32### Continue, resume und fork

34Continue, resume und fork sind Optionsfelder, die Sie auf `query()` setzen ([`ClaudeAgentOptions`](/de/agent-sdk/python#claudeagentoptions) in Python, [`Options`](/de/agent-sdk/typescript#options) in TypeScript).

36**Continue** und **resume** holen beide eine vorhandene Sitzung ab und fügen sie hinzu. Der Unterschied liegt darin, wie sie diese Sitzung finden:

38* **Continue** findet die neueste Sitzung im aktuellen Verzeichnis. Sie müssen nichts verfolgen. Funktioniert gut, wenn Ihre App jeweils ein Gespräch führt.

39* **Resume** nimmt eine bestimmte Sitzungs-ID. Sie verfolgen die ID. Erforderlich, wenn Sie mehrere Sitzungen haben (z. B. eine pro Benutzer in einer Multi-User-App) oder zu einer zurückkehren möchten, die nicht die neueste ist.

41**Fork** ist anders: Es erstellt eine neue Sitzung, die mit einer Kopie des Verlaufs des Originals beginnt. Das Original bleibt unverändert. Verwenden Sie fork, um eine andere Richtung auszuprobieren und gleichzeitig die Möglichkeit zu behalten, zurückzugehen.

43## Automatische Sitzungsverwaltung

45Beide SDKs bieten eine Schnittstelle, die den Sitzungszustand für Sie über Aufrufe hinweg verfolgt, sodass Sie IDs nicht manuell weitergeben müssen. Verwenden Sie diese für Multi-Turn-Gespräche innerhalb eines einzelnen Prozesses.

47### Python: `ClaudeSDKClient`

49[`ClaudeSDKClient`](/de/agent-sdk/python#claudesdkclient) verwaltet Sitzungs-IDs intern. Jeder Aufruf von `client.query()` setzt automatisch die gleiche Sitzung fort. Rufen Sie [`client.receive_response()`](/de/agent-sdk/python#claudesdkclient) auf, um über die Nachrichten für die aktuelle Abfrage zu iterieren. Der Client muss als asynchroner Kontext-Manager verwendet werden.

51Dieses Beispiel führt zwei Abfragen gegen denselben `client` aus. Die erste fordert den Agent auf, ein Modul zu analysieren; die zweite fordert ihn auf, dieses Modul zu refaktorieren. Da beide Aufrufe durch die gleiche Client-Instanz gehen, hat die zweite Abfrage den vollständigen Kontext aus der ersten, ohne explizites `resume` oder Sitzungs-ID:

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

99Siehe die [Python SDK-Referenz](/de/agent-sdk/python#choosing-between-query-and-claudesdkclient) für Details, wann Sie `ClaudeSDKClient` gegenüber der eigenständigen `query()`-Funktion verwenden sollten.

100

101### TypeScript: `continue: true`

102

103Das stabile TypeScript SDK (die `query()`-Funktion, die in diesen Dokumenten verwendet wird, manchmal V1 genannt) hat kein Sitzungs-Halter-Client-Objekt wie Pythons `ClaudeSDKClient`. Übergeben Sie stattdessen `continue: true` bei jedem nachfolgenden `query()`-Aufruf und das SDK holt die neueste Sitzung im aktuellen Verzeichnis ab. Keine ID-Verfolgung erforderlich.

104

105Dieses Beispiel macht zwei separate `query()`-Aufrufe. Der erste erstellt eine neue Sitzung; der zweite setzt `continue: true`, was dem SDK mitteilt, die neueste Sitzung auf der Festplatte zu finden und fortzusetzen. Der Agent hat den vollständigen Kontext aus dem ersten Aufruf:

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 Die experimentelle [V2-Sitzungs-API](/de/agent-sdk/typescript-v2-preview), die `createSession()` mit einem `send` / `stream`-Muster bereitstellte, ist veraltet. Verwenden Sie stattdessen die V1 `query()`-Funktion und die auf dieser Seite beschriebenen Sitzungsoptionen.

136</Note>

137

138## Verwenden Sie Sitzungsoptionen mit `query()`

139

140### Erfassen Sie die Sitzungs-ID

141

142Resume und fork erfordern eine Sitzungs-ID. Lesen Sie sie aus dem `session_id`-Feld in der Ergebnismeldung ([`ResultMessage`](/de/agent-sdk/python#resultmessage) in Python, [`SDKResultMessage`](/de/agent-sdk/typescript#sdkresultmessage) in TypeScript), die bei jedem Ergebnis unabhängig von Erfolg oder Fehler vorhanden ist. In TypeScript ist die ID auch früher als direktes Feld in der Init-`SystemMessage` verfügbar; in Python ist sie in `SystemMessage.data` verschachtelt.

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### Fortsetzen nach ID

193

194Übergeben Sie eine Sitzungs-ID an `resume`, um zu dieser bestimmten Sitzung zurückzukehren. Der Agent setzt mit vollständigem Kontext von dort fort, wo die Sitzung endete. Häufige Gründe zum Fortsetzen:

195

196* **Folgen Sie einer abgeschlossenen Aufgabe.** Der Agent hat bereits etwas analysiert; jetzt möchten Sie, dass er auf dieser Analyse handelt, ohne Dateien erneut zu lesen.

197* **Erholen Sie sich von einem Limit.** Der erste Durchlauf endete mit `error_max_turns` oder `error_max_budget_usd` (siehe [Verarbeiten Sie das Ergebnis](/de/agent-sdk/agent-loop#handle-the-result)); setzen Sie mit einem höheren Limit fort.

198* **Starten Sie Ihren Prozess neu.** Sie haben die ID vor dem Herunterfahren erfasst und möchten das Gespräch wiederherstellen.

199

200Dieses Beispiel setzt die Sitzung aus [Erfassen Sie die Sitzungs-ID](#capture-the-session-id) mit einem Anschlussfrage fort. Da Sie fortsetzen, hat der Agent die vorherige Analyse bereits im Kontext:

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 Wenn ein `resume`-Aufruf eine neue Sitzung statt des erwarteten Verlaufs zurückgibt, ist die häufigste Ursache ein nicht übereinstimmendes `cwd`. Sitzungen werden unter `~/.claude/projects/<encoded-cwd>/*.jsonl` gespeichert, wobei `<encoded-cwd>` das absolute Arbeitsverzeichnis mit jedem nicht-alphanumerischen Zeichen ist, das durch `-` ersetzt wird (also `/Users/me/proj` wird zu `-Users-me-proj`). Wenn Ihr Resume-Aufruf aus einem anderen Verzeichnis ausgeführt wird, sucht das SDK am falschen Ort. Die Sitzungsdatei muss auch auf dem aktuellen Computer vorhanden sein.

234</Tip>

235

236Um Sitzungen über Maschinen hinweg oder in serverlosen Umgebungen fortzusetzen, spiegeln Sie Transkripte mit einem [`SessionStore`-Adapter](/de/agent-sdk/session-storage) zu gemeinsam genutztem Speicher.

237

238### Forken Sie, um Alternativen zu erkunden

239

240Das Forken erstellt eine neue Sitzung, die mit einer Kopie des Verlaufs des Originals beginnt, aber von diesem Punkt an abweicht. Der Fork erhält seine eigene Sitzungs-ID; die ID und der Verlauf des Originals bleiben unverändert. Sie erhalten zwei unabhängige Sitzungen, die Sie separat fortsetzen können.

241

242<Note>

243 Das Forken verzweigt den Gesprächsverlauf, nicht das Dateisystem. Wenn ein gegabelter Agent Dateien bearbeitet, sind diese Änderungen real und für jede Sitzung sichtbar, die im gleichen Verzeichnis arbeitet. Um zu verzweigen und Dateiänderungen rückgängig zu machen, verwenden Sie [Datei-Checkpointing](/de/agent-sdk/file-checkpointing).

244</Note>

245

246Dieses Beispiel baut auf [Erfassen Sie die Sitzungs-ID](#capture-the-session-id) auf: Sie haben bereits ein Auth-Modul in `session_id` analysiert und möchten OAuth2 erkunden, ohne den JWT-fokussierten Thread zu verlieren. Der erste Block forkt die Sitzung und erfasst die ID des Forks (`forked_id`); der zweite Block setzt die ursprüngliche `session_id` fort, um den JWT-Pfad fortzusetzen. Sie haben jetzt zwei Sitzungs-IDs, die auf zwei separate Verläufe verweisen:

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## Fortsetzen über Hosts hinweg

309

310Sitzungsdateien sind lokal auf dem Computer, der sie erstellt hat. Um eine Sitzung auf einem anderen Host fortzusetzen (CI-Worker, kurzlebige Container, serverlos), haben Sie zwei Optionen:

311

312* **Verschieben Sie die Sitzungsdatei.** Speichern Sie `~/.claude/projects/<encoded-cwd>/<session-id>.jsonl` aus dem ersten Durchlauf und stellen Sie es auf dem neuen Host auf dem gleichen Pfad wieder her, bevor Sie `resume` aufrufen. Das `cwd` muss übereinstimmen.

313* **Verlassen Sie sich nicht auf Sitzungsfortsetzen.** Erfassen Sie die Ergebnisse, die Sie benötigen (Analyseergebnis, Entscheidungen, Datei-Diffs) als Anwendungszustand und übergeben Sie sie in den Prompt einer neuen Sitzung. Dies ist oft robuster als das Verschiffen von Transkriptdateien.

314

315Beide SDKs stellen Funktionen zum Aufzählen von Sitzungen auf der Festplatte und zum Lesen ihrer Nachrichten bereit: [`listSessions()`](/de/agent-sdk/typescript#listsessions) und [`getSessionMessages()`](/de/agent-sdk/typescript#getsessionmessages) in TypeScript, [`list_sessions()`](/de/agent-sdk/python#list_sessions) und [`get_session_messages()`](/de/agent-sdk/python#get_session_messages) in Python. Verwenden Sie sie, um benutzerdefinierte Sitzungsauswähler, Bereinigungslogik oder Transkript-Viewer zu erstellen.

316

317Beide SDKs stellen auch Funktionen zum Nachschlagen und Mutieren einzelner Sitzungen bereit: [`get_session_info()`](/de/agent-sdk/python#get_session_info), [`rename_session()`](/de/agent-sdk/python#rename_session) und [`tag_session()`](/de/agent-sdk/python#tag_session) in Python, und [`getSessionInfo()`](/de/agent-sdk/typescript#getsessioninfo), [`renameSession()`](/de/agent-sdk/typescript#renamesession) und [`tagSession()`](/de/agent-sdk/typescript#tagsession) in TypeScript. Verwenden Sie sie, um Sitzungen nach Tag zu organisieren oder ihnen menschenlesbare Titel zu geben.

318

319## Verwandte Ressourcen

320

321* [Wie die Agent-Schleife funktioniert](/de/agent-sdk/agent-loop): Verstehen Sie Durchläufe, Nachrichten und Kontextakkumulation innerhalb einer Sitzung

322* [Datei-Checkpointing](/de/agent-sdk/file-checkpointing): Verfolgen und Rückgängigmachen von Dateiänderungen über Sitzungen hinweg

323* [Python `ClaudeAgentOptions`](/de/agent-sdk/python#claudeagentoptions): Vollständige Sitzungsoptionsreferenz für Python

324* [TypeScript `Options`](/de/agent-sdk/typescript#options): Vollständige Sitzungsoptionsreferenz für 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 im SDK

7> Erweitern Sie Claude mit spezialisierten Fähigkeiten mithilfe von Agent Skills im Claude Agent SDK

9## Übersicht

11Agent Skills erweitern Claude um spezialisierte Fähigkeiten, die Claude autonom aufruft, wenn relevant. Skills werden als `SKILL.md`-Dateien verpackt, die Anweisungen, Beschreibungen und optionale unterstützende Ressourcen enthalten.

13Umfassende Informationen zu Skills, einschließlich Vorteile, Architektur und Authoring-Richtlinien, finden Sie in der [Agent Skills-Übersicht](https://platform.claude.com/docs/en/agents-and-tools/agent-skills/overview).

15## Wie Skills mit dem SDK funktionieren

17Bei Verwendung des Claude Agent SDK sind Skills:

191. **Als Dateisystem-Artefakte definiert**: Erstellt als `SKILL.md`-Dateien in spezifischen Verzeichnissen (`.claude/skills/`)

202. **Aus dem Dateisystem geladen**: Skills werden aus Dateisystem-Speicherorten geladen, die von `settingSources` (TypeScript) oder `setting_sources` (Python) gesteuert werden

213. **Automatisch erkannt**: Sobald Dateisystem-Einstellungen geladen sind, werden Skill-Metadaten beim Start aus Benutzer- und Projektverzeichnissen erkannt; vollständiger Inhalt wird geladen, wenn ausgelöst

224. **Modell-aufgerufen**: Claude wählt autonom basierend auf dem Kontext, wann sie verwendet werden

235. **Gefiltert über die `skills`-Option**: Erkannte Skills sind standardmäßig aktiviert. Übergeben Sie eine Liste von Skill-Namen, `"all"` oder `[]`, um zu steuern, welche in der Sitzung verfügbar sind

25Im Gegensatz zu Subagenten (die programmatisch definiert werden können) müssen Skills als Dateisystem-Artefakte erstellt werden. Das SDK bietet keine programmatische API zum Registrieren von Skills.

27<Note>

28 Skills werden durch die Dateisystem-Einstellungsquellen erkannt. Mit Standard-`query()`-Optionen lädt das SDK Benutzer- und Projektquellen, sodass Skills in `~/.claude/skills/` und `<cwd>/.claude/skills/` verfügbar sind. Wenn Sie `settingSources` explizit festlegen, schließen Sie `'user'` oder `'project'` ein, um die Skill-Erkennung beizubehalten, oder verwenden Sie die [`plugins`-Option](/de/agent-sdk/plugins), um Skills aus einem bestimmten Pfad zu laden.

29</Note>

31## Verwendung von Skills mit dem SDK

33Legen Sie die `skills`-Option auf `query()` fest, um zu steuern, welche Skills der Sitzung zur Verfügung stehen. Wenn weggelassen, sind erkannte Skills aktiviert und das Skill-Tool ist verfügbar, was dem CLI-Verhalten entspricht. Übergeben Sie `"all"`, um jeden erkannten Skill zu aktivieren, eine Liste von Skill-Namen, um nur diese zu aktivieren, oder `[]`, um alle zu deaktivieren. Wenn Sie `skills` festlegen, aktiviert das SDK das Skill-Tool automatisch, sodass Sie es nicht in `allowedTools` auflisten müssen.

35Nach der Konfiguration erkennt Claude automatisch Skills aus dem Dateisystem und ruft sie auf, wenn sie für die Anfrage des Benutzers relevant sind.

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>

77Um nur bestimmte Skills zu aktivieren, übergeben Sie ihre Namen. Namen entsprechen dem `name`-Feld in `SKILL.md` oder dem Skill-Verzeichnisnamen. Verwenden Sie `plugin:skill` für von Plugins bereitgestellte Skills.

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>

89Die `skills`-Option ist ein Kontextfilter, kein Sandbox. Nicht aufgelistete Skills sind für das Modell verborgen und werden vom Skill-Tool abgelehnt, aber ihre Dateien bleiben auf der Festplatte und sind über Read und Bash erreichbar.

91## Skill-Speicherorte

93Skills werden aus Dateisystem-Verzeichnissen basierend auf Ihrer `settingSources`/`setting_sources`-Konfiguration geladen:

95* **Projekt-Skills** (`.claude/skills/`): Mit Ihrem Team über Git geteilt - geladen, wenn `setting_sources` `"project"` enthält

96* **Benutzer-Skills** (`~/.claude/skills/`): Persönliche Skills über alle Projekte hinweg - geladen, wenn `setting_sources` `"user"` enthält

97* **Plugin-Skills**: Mit installierten Claude Code-Plugins gebündelt

99## Erstellen von Skills

100

101Skills werden als Verzeichnisse definiert, die eine `SKILL.md`-Datei mit YAML-Frontmatter und Markdown-Inhalt enthalten. Das `description`-Feld bestimmt, wann Claude Ihren Skill aufruft.

102

103**Beispiel-Verzeichnisstruktur**:

104

105```bash theme={null}

106.claude/skills/processing-pdfs/

107└── SKILL.md

108```

109

110Vollständige Anleitung zum Erstellen von Skills, einschließlich SKILL.md-Struktur, mehrdatei-Skills und Beispiele, finden Sie unter:

111

112* [Agent Skills in Claude Code](/de/skills): Vollständige Anleitung mit Beispielen

113* [Agent Skills Best Practices](https://platform.claude.com/docs/en/agents-and-tools/agent-skills/best-practices): Authoring-Richtlinien und Namenskonventionen

114

115## Tool-Einschränkungen

116

117<Note>

118 Das `allowed-tools`-Frontmatter-Feld in SKILL.md wird nur unterstützt, wenn Sie Claude Code CLI direkt verwenden. **Es gilt nicht bei Verwendung von Skills über das SDK**.

119

120 Bei Verwendung des SDK steuern Sie den Tool-Zugriff über die Hauptoption `allowedTools` in Ihrer Query-Konfiguration.

121</Note>

122

123Um den Tool-Zugriff für Skills in SDK-Anwendungen zu steuern, verwenden Sie `allowedTools`, um bestimmte Tools vorab zu genehmigen. Ohne einen `canUseTool`-Callback wird alles, was nicht in der Liste enthalten ist, verweigert:

124

125<Note>

126 Import-Anweisungen aus dem ersten Beispiel werden in den folgenden Code-Snippets angenommen.

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## Verfügbare Skills entdecken

157

158Um zu sehen, welche Skills in Ihrer SDK-Anwendung verfügbar sind, fragen Sie einfach 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 listet die verfügbaren Skills basierend auf Ihrem aktuellen Arbeitsverzeichnis und installierten Plugins auf.

185

186## Testen von Skills

187

188Testen Sie Skills, indem Sie Fragen stellen, die ihren Beschreibungen entsprechen:

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 ruft automatisch den relevanten Skill auf, wenn die Beschreibung Ihrer Anfrage entspricht.

219

220## Fehlerbehebung

221

222### Skills nicht gefunden

223

224**Überprüfen Sie die settingSources-Konfiguration**: Skills werden durch die `user`- und `project`-Einstellungsquellen erkannt. Wenn Sie `settingSources`/`setting_sources` explizit festlegen und diese Quellen weglassen, werden Skills nicht geladen:

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

253Weitere Details zu `settingSources`/`setting_sources` finden Sie in der [TypeScript SDK-Referenz](/de/agent-sdk/typescript#settingsource) oder [Python SDK-Referenz](/de/agent-sdk/python#settingsource).

254

255**Überprüfen Sie das Arbeitsverzeichnis**: Das SDK lädt Skills relativ zur `cwd`-Option. Stellen Sie sicher, dass sie auf ein Verzeichnis verweist, das `.claude/skills/` enthält:

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

277Siehe den Abschnitt "Verwendung von Skills mit dem SDK" oben für das vollständige Muster.

278

279**Überprüfen Sie den Dateisystem-Speicherort**:

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 wird nicht verwendet

290

291**Überprüfen Sie die `skills`-Option**: Wenn Sie eine `skills`-Liste übergeben haben, bestätigen Sie, dass der Name des Skills enthalten ist. Das Übergeben von `[]` deaktiviert alle Skills.

292

293**Überprüfen Sie die Beschreibung**: Stellen Sie sicher, dass sie spezifisch ist und relevante Schlüsselwörter enthält. Siehe [Agent Skills Best Practices](https://platform.claude.com/docs/en/agents-and-tools/agent-skills/best-practices#writing-effective-descriptions) für Anleitung zum Schreiben effektiver Beschreibungen.

294

295### Zusätzliche Fehlerbehebung

296

297Für allgemeine Skills-Fehlerbehebung (YAML-Syntax, Debugging usw.) siehe den [Claude Code Skills-Fehlerbehebungsabschnitt](/de/skills#troubleshooting).

298

299## Zugehörige Dokumentation

300

301### Skills-Leitfäden

302

303* [Agent Skills in Claude Code](/de/skills): Vollständiger Skills-Leitfaden mit Erstellung, Beispielen und Fehlerbehebung

304* [Agent Skills Overview](https://platform.claude.com/docs/en/agents-and-tools/agent-skills/overview): Konzeptionelle Übersicht, Vorteile und Architektur

305* [Agent Skills Best Practices](https://platform.claude.com/docs/en/agents-and-tools/agent-skills/best-practices): Authoring-Richtlinien für effektive Skills

306* [Agent Skills Cookbook](https://platform.claude.com/cookbook/skills-notebooks-01-skills-introduction): Beispiel-Skills und Vorlagen

307

308### SDK-Ressourcen

309

310* [Subagents im SDK](/de/agent-sdk/subagents): Ähnliche dateisystem-basierte Agenten mit programmatischen Optionen

311* [Slash Commands im SDK](/de/agent-sdk/slash-commands): Benutzer-aufgerufene Befehle

312* [SDK-Übersicht](/de/agent-sdk/overview): Allgemeine SDK-Konzepte

313* [TypeScript SDK-Referenz](/de/agent-sdk/typescript): Vollständige API-Dokumentation

314* [Python SDK-Referenz](/de/agent-sdk/python): Vollständige API-Dokumentation

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# Subagenten im SDK

7> Definieren und rufen Sie Subagenten auf, um den Kontext zu isolieren, Aufgaben parallel auszuführen und spezialisierte Anweisungen in Ihren Claude Agent SDK-Anwendungen anzuwenden.

9Subagenten sind separate Agent-Instanzen, die Ihr Haupt-Agent spawnen kann, um fokussierte Teilaufgaben zu bewältigen.

10Verwenden Sie Subagenten, um den Kontext für fokussierte Teilaufgaben zu isolieren, mehrere Analysen parallel auszuführen und spezialisierte Anweisungen anzuwenden, ohne den Prompt des Haupt-Agenten zu überlasten.

12Dieser Leitfaden erklärt, wie Sie Subagenten im SDK mit dem Parameter `agents` definieren und verwenden.

14## Übersicht

16Sie können Subagenten auf drei Arten erstellen:

18* **Programmatisch**: Verwenden Sie den Parameter `agents` in Ihren `query()`-Optionen ([TypeScript](/de/agent-sdk/typescript#agentdefinition), [Python](/de/agent-sdk/python#agentdefinition))

19* **Dateisystem-basiert**: Definieren Sie Agenten als Markdown-Dateien in `.claude/agents/`-Verzeichnissen (siehe [Subagenten als Dateien definieren](/de/sub-agents))

20* **Integriert allgemein einsetzbar**: Claude kann den integrierten `general-purpose`-Subagenten jederzeit über das Agent-Tool aufrufen, ohne dass Sie etwas definieren müssen

22Dieser Leitfaden konzentriert sich auf den programmatischen Ansatz, der für SDK-Anwendungen empfohlen wird.

24Wenn Sie Subagenten definieren, bestimmt Claude basierend auf dem Feld `description` jedes Subagenten, ob dieser aufgerufen werden soll. Schreiben Sie klare Beschreibungen, die erklären, wann der Subagent verwendet werden sollte, und Claude wird automatisch geeignete Aufgaben delegieren. Sie können einen Subagenten auch explizit nach Name in Ihrem Prompt anfordern (zum Beispiel „Verwenden Sie den Code-Reviewer-Agent, um...").

26## Vorteile der Verwendung von Subagenten

28### Kontextisolation

30Jeder Subagent läuft in seiner eigenen frischen Konversation. Zwischentool-Aufrufe und Ergebnisse bleiben innerhalb des Subagenten; nur seine abschließende Nachricht wird an den übergeordneten Agent zurückgegeben. Siehe [Was Subagenten erben](#what-subagents-inherit) für genau das, was sich im Kontext des Subagenten befindet.

32**Beispiel:** Ein `research-assistant`-Subagent kann Dutzende von Dateien durchsuchen, ohne dass dieser Inhalt in der Hauptkonversation angesammelt wird. Der übergeordnete Agent erhält eine prägnante Zusammenfassung, nicht jede Datei, die der Subagent gelesen hat.

34### Parallelisierung

36Mehrere Subagenten können gleichzeitig ausgeführt werden und beschleunigen komplexe Workflows dramatisch.

38**Beispiel:** Während einer Code-Überprüfung können Sie die Subagenten `style-checker`, `security-scanner` und `test-coverage` gleichzeitig ausführen und die Überprüfungszeit von Minuten auf Sekunden reduzieren.

40### Spezialisierte Anweisungen und Wissen

42Jeder Subagent kann maßgeschneiderte System-Prompts mit spezifischer Expertise, Best Practices und Einschränkungen haben.

44**Beispiel:** Ein `database-migration`-Subagent kann detailliertes Wissen über SQL-Best-Practices, Rollback-Strategien und Datenintegritätsprüfungen haben, die in den Anweisungen des Haupt-Agenten unnötiger Lärm wären.

46### Tool-Einschränkungen

48Subagenten können auf bestimmte Tools beschränkt werden, was das Risiko unbeabsichtigter Aktionen verringert.

50**Beispiel:** Ein `doc-reviewer`-Subagent könnte nur Zugriff auf Read- und Grep-Tools haben, um sicherzustellen, dass er Ihre Dokumentationsdateien analysieren, aber niemals versehentlich ändern kann.

52## Erstellen von Subagenten

54### Programmatische Definition (empfohlen)

56Definieren Sie Subagenten direkt in Ihrem Code mit dem Parameter `agents`. Dieses Beispiel erstellt zwei Subagenten: einen Code-Reviewer mit Nur-Lese-Zugriff und einen Test-Runner, der Befehle ausführen kann. Das `Agent`-Tool muss in `allowedTools` enthalten sein, da Claude Subagenten über das Agent-Tool aufruft.

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### AgentDefinition-Konfiguration

161

162| Feld | Typ | Erforderlich | Beschreibung |

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

168| `model` | `string` | Nein | Modell-Override für diesen Agent. Akzeptiert einen Alias wie `'sonnet'`, `'opus'`, `'haiku'`, `'inherit'` oder eine vollständige Modell-ID. Standardmäßig Haupt-Modell, falls weggelassen |

176

177Im Python SDK verwenden diese Feldnamen camelCase, um das Wire-Format zu entsprechen. Siehe die [`AgentDefinition`-Referenz](/de/agent-sdk/python#agentdefinition) für Details.

178

179<Note>

180 Subagenten können keine eigenen Subagenten spawnen. Fügen Sie `Agent` nicht in das `tools`-Array eines Subagenten ein.

181</Note>

182

183### Dateisystem-basierte Definition (Alternative)

184

185Sie können Subagenten auch als Markdown-Dateien in `.claude/agents/`-Verzeichnissen definieren. Siehe die [Claude Code Subagenten-Dokumentation](/de/sub-agents) für Details zu diesem Ansatz. Programmatisch definierte Agenten haben Vorrang vor dateisystem-basierten Agenten mit demselben Namen.

186

187<Note>

188 Auch ohne benutzerdefinierte Subagenten zu definieren, kann Claude den integrierten `general-purpose`-Subagenten spawnen, wenn `Agent` in Ihren `allowedTools` enthalten ist. Dies ist nützlich, um Recherche- oder Explorationsaufgaben zu delegieren, ohne spezialisierte Agenten zu erstellen.

189</Note>

190

191## Was Subagenten erben

192

193Das Kontextfenster eines Subagenten startet frisch (keine übergeordnete Konversation), ist aber nicht leer. Der einzige Kanal vom übergeordneten Agent zum Subagenten ist der Prompt-String des Agent-Tools, daher fügen Sie alle Dateipfade, Fehlermeldungen oder Entscheidungen, die der Subagent benötigt, direkt in diesen Prompt ein.

194

195| Der Subagent erhält | Der Subagent erhält nicht |

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

197| Seinen eigenen System-Prompt (`AgentDefinition.prompt`) und den Prompt des Agent-Tools | Die Konversationshistorie oder Tool-Ergebnisse des übergeordneten Agenten |

198| Projekt CLAUDE.md (geladen über `settingSources`) | Vorgeladener Skill-Inhalt, es sei denn, er ist in `AgentDefinition.skills` aufgelistet |

199| Tool-Definitionen (geerbt vom übergeordneten Agent oder die Teilmenge in `tools`) | Der System-Prompt des übergeordneten Agenten |

200

201<Note>

202 Der übergeordnete Agent erhält die abschließende Nachricht des Subagenten wörtlich als Agent-Tool-Ergebnis, kann sie aber in seiner eigenen Antwort zusammenfassen. Um die Ausgabe des Subagenten wörtlich in der benutzerorientierten Antwort zu bewahren, fügen Sie eine Anweisung dazu in den Prompt oder die `systemPrompt`-Option ein, die Sie an den **Haupt**-`query()`-Aufruf übergeben.

203</Note>

204

205## Aufrufen von Subagenten

206

207### Automatischer Aufruf

208

209Claude entscheidet automatisch, wann Subagenten basierend auf der Aufgabe und der `description` jedes Subagenten aufgerufen werden sollen. Wenn Sie beispielsweise einen `performance-optimizer`-Subagenten mit der Beschreibung „Performance-Optimierungsspezialist für Query-Tuning" definieren, wird Claude ihn aufrufen, wenn Ihr Prompt die Optimierung von Queries erwähnt.

210

211Schreiben Sie klare, spezifische Beschreibungen, damit Claude Aufgaben dem richtigen Subagenten zuordnen kann.

212

213### Expliziter Aufruf

214

215Um sicherzustellen, dass Claude einen bestimmten Subagenten verwendet, erwähnen Sie ihn nach Name in Ihrem Prompt:

216

217```text theme={null}

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

219```

220

221Dies umgeht das automatische Matching und ruft den benannten Subagenten direkt auf.

222

223### Dynamische Agent-Konfiguration

224

225Sie können Agent-Definitionen dynamisch basierend auf Laufzeitbedingungen erstellen. Dieses Beispiel erstellt einen Security-Reviewer mit verschiedenen Strenge-Leveln und verwendet ein leistungsfähigeres Modell für strenge Überprüfungen.

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## Erkennen von Subagenten-Aufrufen

300

301Subagenten werden über das Agent-Tool aufgerufen. Um zu erkennen, wann ein Subagent aufgerufen wird, suchen Sie nach `tool_use`-Blöcken, bei denen `name` `"Agent"` ist. Nachrichten aus dem Kontext eines Subagenten enthalten ein Feld `parent_tool_use_id`.

302

303<Note>

304 Der Tool-Name wurde in Claude Code v2.1.63 von `"Task"` zu `"Agent"` umbenannt. Aktuelle SDK-Releases geben `"Agent"` in `tool_use`-Blöcken aus, verwenden aber immer noch `"Task"` in der `system:init`-Tools-Liste und in `result.permission_denials[].tool_name`. Das Überprüfen beider Werte in `block.name` gewährleistet Kompatibilität über SDK-Versionen hinweg.

305</Note>

306

307Dieses Beispiel durchläuft gestreamte Nachrichten und protokolliert, wenn ein Subagent aufgerufen wird und wenn nachfolgende Nachrichten aus dem Ausführungskontext dieses Subagenten stammen.

308

309<Note>

310 Die Nachrichtenstruktur unterscheidet sich zwischen SDKs. In Python werden Inhaltsblöcke direkt über `message.content` aufgerufen. In TypeScript umhüllt `SDKAssistantMessage` die Claude API-Nachricht, daher wird auf den Inhalt über `message.message.content` zugegriffen.

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## Fortsetzen von Subagenten

393

394Subagenten können fortgesetzt werden, um dort fortzufahren, wo sie aufgehört haben. Fortgesetzte Subagenten behalten ihre vollständige Konversationshistorie, einschließlich aller vorherigen Tool-Aufrufe, Ergebnisse und Reasoning. Der Subagent setzt genau dort an, wo er gestoppt hat, anstatt von vorne zu beginnen.

395

396Wenn ein Subagent abgeschlossen ist, erhält Claude seine Agent-ID im Agent-Tool-Ergebnis. Um einen Subagenten programmatisch fortzusetzen:

397

3981. **Erfassen Sie die Session-ID**: Extrahieren Sie `session_id` aus Nachrichten während der ersten Abfrage

3992. **Extrahieren Sie die Agent-ID**: Analysieren Sie `agentId` aus dem Nachrichteninhalt

4003. **Setzen Sie die Session fort**: Übergeben Sie `resume: sessionId` in den Optionen der zweiten Abfrage und fügen Sie die Agent-ID in Ihren Prompt ein

401

402<Note>

403 Sie müssen dieselbe Session fortsetzen, um auf das Transkript des Subagenten zuzugreifen. Jeder `query()`-Aufruf startet standardmäßig eine neue Session, daher übergeben Sie `resume: sessionId`, um in derselben Session fortzufahren.

404

405 Wenn Sie einen benutzerdefinierten Agent verwenden (nicht einen integrierten), müssen Sie auch dieselbe Agent-Definition im Parameter `agents` für beide Abfragen übergeben.

406</Note>

407

408Das folgende Beispiel demonstriert diesen Ablauf: Die erste Abfrage führt einen Subagenten aus und erfasst die Session-ID und Agent-ID, dann setzt die zweite Abfrage die Session fort, um eine Folgefrage zu stellen, die Kontext aus der ersten Analyse erfordert.

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

504Subagenten-Transkripte bleiben unabhängig von der Hauptkonversation bestehen:

505

506* **Hauptkonversations-Komprimierung**: Wenn die Hauptkonversation komprimiert wird, sind Subagenten-Transkripte nicht betroffen. Sie werden in separaten Dateien gespeichert.

507* **Session-Persistenz**: Subagenten-Transkripte bleiben innerhalb ihrer Session bestehen. Sie können einen Subagenten nach dem Neustart von Claude Code fortsetzen, indem Sie dieselbe Session fortsetzen.

508* **Automatische Bereinigung**: Transkripte werden basierend auf der Einstellung `cleanupPeriodDays` bereinigt (Standard: 30 Tage).

509

510## Tool-Einschränkungen

511

512Subagenten können über das Feld `tools` eingeschränkten Tool-Zugriff haben:

513

514* **Feld weglassen**: Agent erbt alle verfügbaren Tools (Standard)

515* **Tools angeben**: Agent kann nur aufgelistete Tools verwenden

516

517Dieses Beispiel erstellt einen schreibgeschützten Analyse-Agent, der Code untersuchen, aber keine Dateien ändern oder Befehle ausführen kann.

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### Häufige Tool-Kombinationen

572

573| Anwendungsfall | Tools | Beschreibung |

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

575| Schreibgeschützte Analyse | `Read`, `Grep`, `Glob` | Kann Code untersuchen, aber nicht ändern oder ausführen |

576| Test-Ausführung | `Bash`, `Read`, `Grep` | Kann Befehle ausführen und Ausgabe analysieren |

577| Code-Änderung | `Read`, `Edit`, `Write`, `Grep`, `Glob` | Vollständiger Lese-/Schreibzugriff ohne Befehlsausführung |

578| Vollständiger Zugriff | Alle Tools | Erbt alle Tools vom übergeordneten Agent (Feld `tools` weglassen) |

579

580## Fehlerbehebung

581

582### Claude delegiert nicht an Subagenten

583

584Wenn Claude Aufgaben direkt abschließt, anstatt an Ihren Subagenten zu delegieren:

585

5861. **Fügen Sie das Agent-Tool ein**: Subagenten werden über das Agent-Tool aufgerufen, daher muss es in `allowedTools` enthalten sein

5872. **Verwenden Sie explizites Prompting**: Erwähnen Sie den Subagenten nach Name in Ihrem Prompt (zum Beispiel „Verwenden Sie den Code-Reviewer-Agent, um...")

5883. **Schreiben Sie eine klare Beschreibung**: Erklären Sie genau, wann der Subagent verwendet werden sollte, damit Claude Aufgaben angemessen zuordnen kann

589

590### Dateisystem-basierte Agenten werden nicht geladen

591

592Agenten, die in `.claude/agents/` definiert sind, werden nur beim Start geladen. Wenn Sie eine neue Agent-Datei erstellen, während Claude Code läuft, starten Sie die Session neu, um sie zu laden.

593

594### Windows: Fehler bei langen Prompts

595

596Unter Windows können Subagenten mit sehr langen Prompts aufgrund von Befehlszeilenlängenbeschränkungen (8191 Zeichen) fehlschlagen. Halten Sie Prompts prägnant oder verwenden Sie dateisystem-basierte Agenten für komplexe Anweisungen.

597

598## Verwandte Dokumentation

599

600* [Claude Code Subagenten](/de/sub-agents): umfassende Subagenten-Dokumentation einschließlich dateisystem-basierter Definitionen

601* [SDK-Übersicht](/de/agent-sdk/overview): Erste Schritte mit dem Claude Agent SDK

agent-sdk/typescript.md +3 −1

Details

358| `sessionStore` | [`SessionStore`](/de/agent-sdk/session-storage#the-sessionstore-interface) | `undefined` | Spiegeln Sie Sitzungstranskripte auf einem externen Backend, damit jeder Host sie fortsetzen kann. Siehe [Sitzungen im externen Speicher persistieren](/de/agent-sdk/session-storage) |358| `sessionStore` | [`SessionStore`](/de/agent-sdk/session-storage#the-sessionstore-interface) | `undefined` | Spiegeln Sie Sitzungstranskripte auf einem externen Backend, damit jeder Host sie fortsetzen kann. Siehe [Sitzungen im externen Speicher persistieren](/de/agent-sdk/session-storage) |

359| `settings` | `string \| Settings` | `undefined` | Inline-[Einstellungen](/de/settings)-Objekt oder Pfad zu einer Einstellungsdatei. Füllt die Flag-Einstellungsebene in der [Prioritätsreihenfolge](/de/settings#settings-precedence) auf. Ändern Sie zur Laufzeit mit [`applyFlagSettings()`](#applyflagsettings) |359| `settings` | `string \| Settings` | `undefined` | Inline-[Einstellungen](/de/settings)-Objekt oder Pfad zu einer Einstellungsdatei. Füllt die Flag-Einstellungsebene in der [Prioritätsreihenfolge](/de/settings#settings-precedence) auf. Ändern Sie zur Laufzeit mit [`applyFlagSettings()`](#applyflagsettings) |

360| `settingSources` | [`SettingSource`](#settingsource)`[]` | CLI-Standards (alle Quellen) | Steuern Sie, welche Dateisystem-Einstellungen geladen werden. Übergeben Sie `[]`, um Benutzer-, Projekt- und lokale Einstellungen zu deaktivieren. Verwaltete Richtlinieneinstellungen werden unabhängig davon geladen. Siehe [Claude Code-Funktionen verwenden](/de/agent-sdk/claude-code-features#what-settingsources-does-not-control) |360| `settingSources` | [`SettingSource`](#settingsource)`[]` | CLI-Standards (alle Quellen) | Steuern Sie, welche Dateisystem-Einstellungen geladen werden. Übergeben Sie `[]`, um Benutzer-, Projekt- und lokale Einstellungen zu deaktivieren. Verwaltete Richtlinieneinstellungen werden unabhängig davon geladen. Siehe [Claude Code-Funktionen verwenden](/de/agent-sdk/claude-code-features#what-settingsources-does-not-control) |

361| `skills` | `string[] \| 'all'` | `undefined` | Skills, die der Sitzung zur Verfügung stehen. Übergeben Sie `'all'`, um jeden entdeckten Skill zu aktivieren, oder eine Liste von Skill-Namen. Wenn gesetzt, aktiviert das SDK das Skill-Tool automatisch, ohne es in `allowedTools` aufzulisten. Siehe [Skills](/de/agent-sdk/skills) |

361| `spawnClaudeCodeProcess` | `(options: SpawnOptions) => SpawnedProcess` | `undefined` | Benutzerdefinierte Funktion zum Spawnen des Claude Code-Prozesses. Verwenden Sie, um Claude Code in VMs, Containern oder Remote-Umgebungen auszuführen |362| `spawnClaudeCodeProcess` | `(options: SpawnOptions) => SpawnedProcess` | `undefined` | Benutzerdefinierte Funktion zum Spawnen des Claude Code-Prozesses. Verwenden Sie, um Claude Code in VMs, Containern oder Remote-Umgebungen auszuführen |

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

532| `description` | Ja | Natürlichsprachige Beschreibung, wann dieser Agent verwendet werden soll |533| `description` | Ja | Natürlichsprachige Beschreibung, wann dieser Agent verwendet werden soll |

533| `tools` | Nein | Array von zulässigen Tool-Namen. Wenn weggelassen, erbt alle Tools vom übergeordneten Element |534| `tools` | Nein | Array von zulässigen Tool-Namen. Wenn weggelassen, erbt alle Tools vom übergeordneten Element. Um Skills in den Agent-Kontext vorzuladen, verwenden Sie das `skills`-Feld, anstatt `'Skill'` hier aufzulisten |

535| `prompt` | Ja | Die Systemeingabeaufforderung des Agenten |536| `prompt` | Ja | Die Systemeingabeaufforderung des Agenten |

536| `model` | Nein | Modellüberschreibung für diesen Agenten. Akzeptiert einen Alias wie `'sonnet'`, `'opus'`, `'haiku'`, `'inherit'` oder eine vollständige Modell-ID. Wenn weggelassen oder `'inherit'`, verwendet das Hauptmodell |537| `model` | Nein | Modellüberschreibung für diesen Agenten. Akzeptiert einen Alias wie `'sonnet'`, `'opus'`, `'haiku'`, `'inherit'` oder eine vollständige Modell-ID. Wenn weggelassen oder `'inherit'`, verwendet das Hauptmodell |

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 +7 −11

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# TypeScript SDK V2 Schnittstelle (Vorschau)~~5# TypeScript SDK V2 Sitzungs-API (veraltet)

6 6

~~7> Vorschau der vereinfachten V2 TypeScript Agent SDK mit sitzungsbasiertem Send/Stream-Muster für mehrteilige Gespräche.~~7> Referenz für die veraltete V2 TypeScript Agent SDK Sitzungs-API mit sitzungsbasiertem Send/Stream-Muster für mehrteilige Gespräche.

8 8

9<Warning>9<Warning>

10 Die V2-Schnittstelle ist eine **instabile Vorschau**. APIs können sich basierend auf Feedback ändern, bevor sie stabil werden. Einige Funktionen wie Session-Forking sind nur im [V1 SDK](/de/agent-sdk/typescript) verfügbar.10 Die V2 Sitzungs-API-Funktionen `unstable_v2_createSession`, `unstable_v2_resumeSession` und `unstable_v2_prompt` sind veraltet und werden in einer zukünftigen Version entfernt. Verwenden Sie stattdessen die [V1 `query()` API](/de/agent-sdk/typescript).

11</Warning>11</Warning>

12 12

13Das V2 Claude Agent TypeScript SDK entfernt die Notwendigkeit für asynchrone Generatoren und Yield-Koordination. Dies macht mehrteilige Gespräche einfacher, anstatt den Generator-Status über Turns hinweg zu verwalten, ist jeder Turn ein separater `send()`/`stream()`-Zyklus. Die API-Oberfläche reduziert sich auf drei Konzepte:13V2 war eine experimentelle Sitzungs-API, die die Notwendigkeit für asynchrone Generatoren und Yield-Koordination entfernte. Anstatt den Generator-Status über Turns hinweg zu verwalten, war jeder Turn ein separater `send()`/`stream()`-Zyklus. Die API-Oberfläche reduzierte sich auf drei Konzepte:

14 14

~~15* `createSession()` / `resumeSession()`: Starten oder fortsetzen eines Gesprächs~~15* `createSession()` / `resumeSession()`: Ein Gespräch starten oder fortsetzen

16* `session.send()`: Eine Nachricht senden16* `session.send()`: Eine Nachricht senden

17* `session.stream()`: Die Antwort abrufen17* `session.stream()`: Die Antwort abrufen

18 18

380 380

381## Funktionsverfügbarkeit381## Funktionsverfügbarkeit

382 382

383Nicht alle V1-Funktionen sind in V2 noch verfügbar. Die folgenden erfordern die Verwendung des [V1 SDK](/de/agent-sdk/typescript):383Die V2 Sitzungs-API unterstützt nicht alle V1-Funktionen. Die folgenden erfordern das [V1 SDK](/de/agent-sdk/typescript):

384 384

385* Session-Forking (`forkSession`-Option)385* Sitzungs-Forking (`forkSession`-Option)

386* Einige erweiterte Streaming-Eingabemuster386* Einige erweiterte Streaming-Eingabemuster

387 387

388## Feedback

~~389~~

390Teilen Sie Ihr Feedback zur V2-Schnittstelle mit, bevor sie stabil wird. Melden Sie Probleme und Vorschläge über [GitHub Issues](https://github.com/anthropics/claude-code/issues).

~~391~~

392## Siehe auch388## Siehe auch

393 389

394* [TypeScript SDK-Referenz (V1)](/de/agent-sdk/typescript) - Vollständige V1 SDK-Dokumentation390* [TypeScript SDK-Referenz (V1)](/de/agent-sdk/typescript) - Vollständige V1 SDK-Dokumentation

agent-teams.md +1 −1

Details

420Erkunden Sie verwandte Ansätze für parallele Arbeit und Delegation:420Erkunden Sie verwandte Ansätze für parallele Arbeit und Delegation:

421 421

422* **Leichte Delegation**: [subagents](/de/sub-agents) erzeugen Helper-Agenten für Recherche oder Überprüfung innerhalb Ihrer Sitzung, besser für Aufgaben, die keine Inter-Agent-Koordination benötigen422* **Leichte Delegation**: [subagents](/de/sub-agents) erzeugen Helper-Agenten für Recherche oder Überprüfung innerhalb Ihrer Sitzung, besser für Aufgaben, die keine Inter-Agent-Koordination benötigen

423* **Manuelle parallele Sitzungen**: [Git worktrees](/de/common-workflows#run-parallel-claude-code-sessions-with-git-worktrees) ermöglichen es Ihnen, mehrere Claude Code-Sitzungen selbst ohne automatisierte Teamkoordination auszuführen423* **Manuelle parallele Sitzungen**: [Git worktrees](/de/worktrees) ermöglichen es Ihnen, mehrere Claude Code-Sitzungen selbst ohne automatisierte Teamkoordination auszuführen

424* **Vergleichen Sie Ansätze**: siehe den [Subagent vs Agent-Team](/de/features-overview#compare-similar-features) Vergleich für eine Seite-an-Seite-Aufschlüsselung424* **Vergleichen Sie Ansätze**: siehe den [Subagent vs Agent-Team](/de/features-overview#compare-similar-features) Vergleich für eine Seite-an-Seite-Aufschlüsselung

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## Voraussetzungen81## Voraussetzungen

192 82

cli-reference.md +2 −2

Details

84| `--permission-mode` | Beginnen Sie in einem angegebenen [Berechtigungsmodus](/de/permission-modes). Akzeptiert `default`, `acceptEdits`, `plan`, `auto`, `dontAsk` oder `bypassPermissions`. Überschreibt `defaultMode` aus Einstellungsdateien | `claude --permission-mode plan` |84| `--permission-mode` | Beginnen Sie in einem angegebenen [Berechtigungsmodus](/de/permission-modes). Akzeptiert `default`, `acceptEdits`, `plan`, `auto`, `dontAsk` oder `bypassPermissions`. Überschreibt `defaultMode` aus Einstellungsdateien | `claude --permission-mode plan` |

85| `--permission-prompt-tool` | Geben Sie ein MCP-Tool an, um Berechtigungsaufforderungen im nicht-interaktiven Modus zu verarbeiten | `claude -p --permission-prompt-tool mcp_auth_tool "query"` |85| `--permission-prompt-tool` | Geben Sie ein MCP-Tool an, um Berechtigungsaufforderungen im nicht-interaktiven Modus zu verarbeiten | `claude -p --permission-prompt-tool mcp_auth_tool "query"` |

86| `--plugin-dir` | Laden Sie ein Plugin aus einem Verzeichnis oder `.zip` Archiv nur für diese Sitzung. Jedes Flag nimmt einen Pfad auf. Wiederholen Sie das Flag für mehrere Plugins: `--plugin-dir A --plugin-dir B.zip` | `claude --plugin-dir ./my-plugin` |86| `--plugin-dir` | Laden Sie ein Plugin aus einem Verzeichnis oder `.zip` Archiv nur für diese Sitzung. Jedes Flag nimmt einen Pfad auf. Wiederholen Sie das Flag für mehrere Plugins: `--plugin-dir A --plugin-dir B.zip` | `claude --plugin-dir ./my-plugin` |

87| `--plugin-url` | Rufen Sie ein Plugin `.zip` Archiv von einer URL nur für diese Sitzung ab. Jedes Flag nimmt eine URL auf. Wiederholen Sie das Flag für mehrere Plugins | `claude --plugin-url https://example.com/plugin.zip` |87| `--plugin-url` | Rufen Sie ein Plugin `.zip` Archiv von einer URL nur für diese Sitzung ab. Wiederholen Sie das Flag für mehrere Plugins, oder übergeben Sie durch Leerzeichen getrennte URLs in einem einzelnen Wert in Anführungszeichen | `claude --plugin-url https://example.com/plugin.zip` |

88| `--print`, `-p` | Geben Sie die Antwort ohne interaktiven Modus aus (siehe [Agent SDK-Dokumentation](/de/agent-sdk/overview) für Details zur programmatischen Verwendung) | `claude -p "query"` |88| `--print`, `-p` | Geben Sie die Antwort ohne interaktiven Modus aus (siehe [Agent SDK-Dokumentation](/de/agent-sdk/overview) für Details zur programmatischen Verwendung) | `claude -p "query"` |

89| `--remote` | Erstellen Sie eine neue [Web-Sitzung](/de/claude-code-on-the-web) auf claude.ai mit der bereitgestellten Aufgabenbeschreibung | `claude --remote "Fix the login bug"` |89| `--remote` | Erstellen Sie eine neue [Web-Sitzung](/de/claude-code-on-the-web) auf claude.ai mit der bereitgestellten Aufgabenbeschreibung | `claude --remote "Fix the login bug"` |

90| `--remote-control`, `--rc` | Starten Sie eine interaktive Sitzung mit aktiviertem [Remote Control](/de/remote-control#start-a-remote-control-session), sodass Sie sie auch von claude.ai oder der Claude App aus steuern können. Optional einen Namen für die Sitzung übergeben | `claude --remote-control "My Project"` |90| `--remote-control`, `--rc` | Starten Sie eine interaktive Sitzung mit aktiviertem [Remote Control](/de/remote-control#start-a-remote-control-session), sodass Sie sie auch von claude.ai oder der Claude App aus steuern können. Optional einen Namen für die Sitzung übergeben | `claude --remote-control "My Project"` |

103| `--tools` | Beschränken Sie, welche integrierten Tools Claude verwenden kann. Verwenden Sie `""`, um alle zu deaktivieren, `"default"` für alle oder Tool-Namen wie `"Bash,Edit,Read"` | `claude --tools "Bash,Edit,Read"` |103| `--tools` | Beschränken Sie, welche integrierten Tools Claude verwenden kann. Verwenden Sie `""`, um alle zu deaktivieren, `"default"` für alle oder Tool-Namen wie `"Bash,Edit,Read"` | `claude --tools "Bash,Edit,Read"` |

104| `--verbose` | Aktivieren Sie ausführliches Logging, zeigt vollständige Turn-by-Turn-Ausgabe. Überschreibt die [`viewMode`](/de/settings#available-settings) Einstellung für diese Sitzung | `claude --verbose` |104| `--verbose` | Aktivieren Sie ausführliches Logging, zeigt vollständige Turn-by-Turn-Ausgabe. Überschreibt die [`viewMode`](/de/settings#available-settings) Einstellung für diese Sitzung | `claude --verbose` |

106| `--worktree`, `-w` | Starten Sie Claude in einem isolierten [Git Worktree](/de/worktrees) bei `<repo>/.claude/worktrees/<name>`. Wenn kein Name angegeben wird, wird einer automatisch generiert | `claude -w feature-auth` |106| `--worktree`, `-w` | Starten Sie Claude in einem isolierten [Git Worktree](/de/worktrees) bei `<repo>/.claude/worktrees/<name>`. Wenn kein Name angegeben wird, wird einer automatisch generiert. Übergeben Sie `#<number>` oder eine GitHub Pull Request URL, um diesen PR von `origin` abzurufen und den Worktree davon zu verzweigen | `claude -w feature-auth` |

107 107

108### System-Prompt-Flags108### System-Prompt-Flags

109 109

commands.md +21 −3

Details

12 12

13Ein Befehl wird nur am Anfang Ihrer Nachricht erkannt. Text, der dem Befehlsnamen folgt, wird als Argumente an ihn übergeben.13Ein Befehl wird nur am Anfang Ihrer Nachricht erkannt. Text, der dem Befehlsnamen folgt, wird als Argumente an ihn übergeben.

14 14

15Die folgende Tabelle listet alle in Claude Code enthaltenen Befehle auf. Einträge, die mit **[Skill](/de/skills#bundled-skills)** gekennzeichnet sind, sind gebündelte Skills. Sie verwenden denselben Mechanismus wie Skills, die Sie selbst schreiben: eine Eingabeaufforderung, die Claude übergeben wird und die Claude auch automatisch aufrufen kann, wenn relevant. Alles andere ist ein integrierter Befehl, dessen Verhalten in die CLI codiert ist. Um Ihre eigenen Befehle hinzuzufügen, siehe [Skills](/de/skills).15## Befehle in einem typischen Workflow

17Die meisten Befehle sind an einem bestimmten Punkt in einer Sitzung nützlich, vom Einrichten eines Projekts bis zum Versand einer Änderung.

19**Erste Sitzung in einem Repository.** Führen Sie `/init` aus, um eine Starter-`CLAUDE.md` zu generieren, dann `/memory`, um sie zu verfeinern. Verwenden Sie `/mcp` und `/agents`, um alle Server oder Subagenten einzurichten, die das Projekt benötigt, und `/permissions`, um die Genehmigungsregeln festzulegen, die Sie möchten.

21**Während einer Aufgabe.** `/plan` wechselt vor einer großen Änderung in den Plan-Modus. `/model` und `/effort` passen an, wie viel Reasoning Sie ausgeben. Wenn das Gespräch lang wird, zeigt `/context`, wohin das Fenster geht, und `/compact` fasst es zusammen; verwenden Sie `/btw` für eine schnelle Nebenbemerkung, die die Historie nicht aufblähen sollte.

23**Bevor Sie versenden.** `/diff` zeigt, was sich geändert hat, `/simplify` überprüft kürzlich geänderte Dateien und wendet Qualitäts- und Effizienzfixes an, und `/review` oder `/security-review` geben einen tieferen schreibgeschützten Durchgang.

16 24

17Nicht jeder Befehl wird für jeden Benutzer angezeigt. Die Verfügbarkeit hängt von Ihrer Plattform, Ihrem Plan und Ihrer Umgebung ab. Beispielsweise wird `/desktop` nur auf macOS und Windows angezeigt, und `/upgrade` wird nur in Pro- und Max-Plänen angezeigt.25**Zwischen Sitzungen.** `/clear` startet frisch bei einer neuen Aufgabe, während die Projektmemory erhalten bleibt. `/resume` und `/branch` ermöglichen es Ihnen, zu einem früheren Gespräch zurückzukehren oder es zu verzweigen. `/teleport` zieht eine Web-Sitzung in dieses Terminal, und `/remote-control` ermöglicht es Ihnen, diese lokale Sitzung von einem anderen Gerät fortzusetzen.

27**Wenn etwas schief geht.** `/rewind` setzt Code und Gespräch zu einem Checkpoint zurück. `/doctor` und `/debug` diagnostizieren Installations- und Laufzeitprobleme, und `/feedback` meldet einen Fehler mit Sitzungskontext an.

29## Alle Befehle

31Die folgende Tabelle listet alle in Claude Code enthaltenen Befehle auf. Einträge, die mit **[Skill](/de/skills#bundled-skills)** gekennzeichnet sind, sind gebündelte Skills. Sie verwenden denselben Mechanismus wie Skills, die Sie selbst schreiben: eine Eingabeaufforderung, die Claude übergeben wird und die Claude auch automatisch aufrufen kann, wenn relevant. Alles andere ist ein integrierter Befehl, dessen Verhalten in die CLI codiert ist. Um Ihre eigenen Befehle hinzuzufügen, siehe [Skills](/de/skills).

18 32

19In der folgenden Tabelle gibt `<arg>` ein erforderliches Argument an und `[arg]` ein optionales.33In der folgenden Tabelle gibt `<arg>` ein erforderliches Argument an und `[arg]` ein optionales.

20 34

35<Note>

36 Nicht jeder Befehl wird für jeden Benutzer angezeigt. Die Verfügbarkeit hängt von Ihrer Plattform, Ihrem Plan und Ihrer Umgebung ab. Beispielsweise wird `/desktop` nur auf macOS und Windows angezeigt, und `/upgrade` wird nur in Pro- und Max-Plänen angezeigt.

37</Note>

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

23| `/add-dir <path>` | Fügen Sie ein Arbeitsverzeichnis für den Dateizugriff während der aktuellen Sitzung hinzu. Die meisten `.claude/`-Konfigurationen werden [nicht erkannt](/de/permissions#additional-directories-grant-file-access-not-configuration) aus dem hinzugefügten Verzeichnis. Sie können die Sitzung später aus dem hinzugefügten Verzeichnis mit `--continue` oder `--resume` fortsetzen |41| `/add-dir <path>` | Fügen Sie ein Arbeitsverzeichnis für den Dateizugriff während der aktuellen Sitzung hinzu. Die meisten `.claude/`-Konfigurationen werden [nicht erkannt](/de/permissions#additional-directories-grant-file-access-not-configuration) aus dem hinzugefügten Verzeichnis. Sie können die Sitzung später aus dem hinzugefügten Verzeichnis mit `--continue` oder `--resume` fortsetzen |

80| `/review [PR]` | Überprüfen Sie einen Pull Request lokal in Ihrer aktuellen Sitzung. Für eine tiefere Cloud-basierte Überprüfung siehe [`/ultrareview`](/de/ultrareview) |98| `/review [PR]` | Überprüfen Sie einen Pull Request lokal in Ihrer aktuellen Sitzung. Für eine tiefere Cloud-basierte Überprüfung siehe [`/ultrareview`](/de/ultrareview) |

81| `/rewind` | Spulen Sie das Gespräch und/oder den Code zu einem früheren Punkt zurück, oder fassen Sie ab einer ausgewählten Nachricht zusammen. Siehe [Checkpointing](/de/checkpointing). Aliase: `/checkpoint`, `/undo` |99| `/rewind` | Spulen Sie das Gespräch und/oder den Code zu einem früheren Punkt zurück, oder fassen Sie ab einer ausgewählten Nachricht zusammen. Siehe [Checkpointing](/de/checkpointing). Aliase: `/checkpoint`, `/undo` |

83| `/schedule [description]` | Erstellen, aktualisieren, listen oder führen Sie [Routinen](/de/routines) aus. Claude führt Sie conversational durch die Einrichtung. Alias: `/routines` |101| `/schedule [description]` | Erstellen, aktualisieren, listen oder führen Sie [Routinen](/de/routines) aus, die auf von Anthropic verwalteter Cloud-Infrastruktur ausgeführt werden. Claude führt Sie conversational durch die Einrichtung. Alias: `/routines` |

84| `/security-review` | Analysieren Sie ausstehende Änderungen im aktuellen Branch auf Sicherheitslücken. Überprüft den Git-Diff und identifiziert Risiken wie Injection, Authentifizierungsprobleme und Datenverlust |102| `/security-review` | Analysieren Sie ausstehende Änderungen im aktuellen Branch auf Sicherheitslücken. Überprüft den Git-Diff und identifiziert Risiken wie Injection, Authentifizierungsprobleme und Datenverlust |

85| `/setup-bedrock` | Konfigurieren Sie [Amazon Bedrock](/de/amazon-bedrock)-Authentifizierung, Region und Modell-Pins durch einen interaktiven Wizard. Nur sichtbar, wenn `CLAUDE_CODE_USE_BEDROCK=1` gesetzt ist. Erstbenutzer von Bedrock können auch auf diesen Wizard vom Login-Bildschirm zugreifen |103| `/setup-bedrock` | Konfigurieren Sie [Amazon Bedrock](/de/amazon-bedrock)-Authentifizierung, Region und Modell-Pins durch einen interaktiven Wizard. Nur sichtbar, wenn `CLAUDE_CODE_USE_BEDROCK=1` gesetzt ist. Erstbenutzer von Bedrock können auch auf diesen Wizard vom Login-Bildschirm zugreifen |

86| `/setup-vertex` | Konfigurieren Sie [Google Vertex AI](/de/google-vertex-ai)-Authentifizierung, Projekt, Region und Modell-Pins durch einen interaktiven Wizard. Nur sichtbar, wenn `CLAUDE_CODE_USE_VERTEX=1` gesetzt ist. Erstbenutzer von Vertex AI können auch auf diesen Wizard vom Login-Bildschirm zugreifen |104| `/setup-vertex` | Konfigurieren Sie [Google Vertex AI](/de/google-vertex-ai)-Authentifizierung, Projekt, Region und Modell-Pins durch einen interaktiven Wizard. Nur sichtbar, wenn `CLAUDE_CODE_USE_VERTEX=1` gesetzt ist. Erstbenutzer von Vertex AI können auch auf diesen Wizard vom Login-Bildschirm zugreifen |

desktop.md +18 −1

Details

564 564

565Jeder Eintrag erfordert `id`, `name` und `sshHost`. Die Felder `sshPort`, `sshIdentityFile` und `startDirectory` sind optional. Benutzer können auch `sshConfigs` zu ihrer eigenen `~/.claude/settings.json` hinzufügen, wo Verbindungen, die über den Dialog hinzugefügt werden, gespeichert sind.565Jeder Eintrag erfordert `id`, `name` und `sshHost`. Die Felder `sshPort`, `sshIdentityFile` und `startDirectory` sind optional. Benutzer können auch `sshConfigs` zu ihrer eigenen `~/.claude/settings.json` hinzufügen, wo Verbindungen, die über den Dialog hinzugefügt werden, gespeichert sind.

566 566

567#### SSH-Hosts einschränken, mit denen Benutzer sich verbinden können

568

569Administratoren können Desktop-SSH-Sitzungen auf einen genehmigten Satz von Hosts beschränken, indem sie `sshHostAllowlist` zu einer [verwalteten Einstellungsdatei](/de/settings#settings-precedence) hinzufügen. Wenn diese festgelegt ist, können Benutzer sich nur mit Hosts verbinden, deren aufgelöster Hostname einem der Muster entspricht. Setzen Sie es auf ein leeres Array, um SSH-Sitzungen vollständig zu deaktivieren.

570

571Das folgende Beispiel erlaubt Verbindungen zu jedem Host unter `devboxes.example.com` und zu einem einzelnen benannten Bastion-Host:

572

573```json theme={null}

574{

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

576}

577```

578

579Muster sind nicht case-sensitiv. `*` passt auf jeden Host, und `*.example.com` passt auf `example.com` und jede Subdomain. Alles andere ist eine exakte Übereinstimmung. Die Überprüfung wird gegen den Hostnamen nach `~/.ssh/config`-Auflösung über `ssh -G` durchgeführt, sodass `Host`-Aliase und `ProxyCommand`/`ProxyJump`-Einträge zulässig sind, solange der aufgelöste `HostName` passt.

580

581`sshHostAllowlist` wird nur aus verwalteten Einstellungen gelesen; Werte in Benutzer- oder Projekteinstellungen werden ignoriert. Nur die Claude Desktop-App berücksichtigt diese Einstellung; die Claude Code CLI und IDE-Erweiterungen lesen sie nicht, und sie beschränkt keine `ssh`-Befehle, die über das Bash-Tool ausgeführt werden. Sie regelt, mit welchen Hosts sich die Desktop-App verbindet, nicht den Netzwerk-Egress, daher kombinieren Sie sie mit den Netzwerk- oder Zero-Trust-Kontrollen Ihrer Organisation, wenn Sie eine harte Grenze benötigen.

582

567## Unternehmenskonfiguration583## Unternehmenskonfiguration

568 584

569Organisationen in Team- oder Enterprise-Plänen können das Verhalten der Desktop-App durch Admin-Konsolen-Steuerelemente, verwaltete Einstellungsdateien und Geräteverwaltungsrichtlinien verwalten.585Organisationen in Team- oder Enterprise-Plänen können das Verhalten der Desktop-App durch Admin-Konsolen-Steuerelemente, verwaltete Einstellungsdateien und Geräteverwaltungsrichtlinien verwalten.

582Verwaltete Einstellungen überschreiben Projekt- und Benutzereinstellungen und gelten, wenn Desktop CLI-Sitzungen startet. Sie können diese Schlüssel in der [verwalteten Einstellungsdatei](/de/settings#settings-precedence) Ihrer Organisation oder remote über die Admin-Konsole festlegen.598Verwaltete Einstellungen überschreiben Projekt- und Benutzereinstellungen und gelten, wenn Desktop CLI-Sitzungen startet. Sie können diese Schlüssel in der [verwalteten Einstellungsdatei](/de/settings#settings-precedence) Ihrer Organisation oder remote über die Admin-Konsole festlegen.

583 599

584| Schlüssel | Beschreibung |600| Schlüssel | Beschreibung |

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

586| `permissions.disableBypassPermissionsMode` | auf `"disable"` setzen, um Benutzer daran zu hindern, den Bypass-Berechtigungsmodus zu aktivieren. |602| `permissions.disableBypassPermissionsMode` | auf `"disable"` setzen, um Benutzer daran zu hindern, den Bypass-Berechtigungsmodus zu aktivieren. |

587| `disableAutoMode` | auf `"disable"` setzen, um Benutzer daran zu hindern, den [Auto](/de/permission-modes#eliminate-prompts-with-auto-mode)-Modus zu aktivieren. Entfernt Auto aus dem Moduswahlschalter. Auch unter `permissions` akzeptiert. |603| `disableAutoMode` | auf `"disable"` setzen, um Benutzer daran zu hindern, den [Auto](/de/permission-modes#eliminate-prompts-with-auto-mode)-Modus zu aktivieren. Entfernt Auto aus dem Moduswahlschalter. Auch unter `permissions` akzeptiert. |

588| `autoMode` | passen Sie an, was der Auto-Modus-Klassifizierer über Ihre Organisation vertraut und blockiert. Siehe [Auto-Modus konfigurieren](/de/auto-mode-config). |604| `autoMode` | passen Sie an, was der Auto-Modus-Klassifizierer über Ihre Organisation vertraut und blockiert. Siehe [Auto-Modus konfigurieren](/de/auto-mode-config). |

589| `sshConfigs` | vorkonfigurieren Sie [SSH-Verbindungen](#pre-configure-ssh-connections-for-your-team), die in der Umgebungs-Dropdown angezeigt werden. Benutzer können verwaltete Verbindungen nicht bearbeiten oder löschen. |605| `sshConfigs` | vorkonfigurieren Sie [SSH-Verbindungen](#pre-configure-ssh-connections-for-your-team), die in der Umgebungs-Dropdown angezeigt werden. Benutzer können verwaltete Verbindungen nicht bearbeiten oder löschen. |

606| `sshHostAllowlist` | beschränken Sie [SSH-Sitzungen](#restrict-which-ssh-hosts-users-can-connect-to) auf Hosts, deren aufgelöster Hostname einem dieser Muster entspricht. Ein leeres Array deaktiviert SSH-Sitzungen. Wird nur aus verwalteten Einstellungen gelesen. |

590 607

591Eine verwaltete Einstellungsdatei, die auf jedem Computer auf der Festplatte bereitgestellt wird, gilt für Desktop-Sitzungen. Verwaltete Einstellungen, die remote über die Admin-Konsole hochgeladen werden, erreichen derzeit nur CLI- und IDE-Sitzungen. Für Desktop-Bereitstellungen verteilen Sie die Datei daher über MDM oder verwenden Sie die [Admin-Konsolen-Steuerelemente](#admin-console-controls) oben.608Eine verwaltete Einstellungsdatei, die auf jedem Computer auf der Festplatte bereitgestellt wird, gilt für Desktop-Sitzungen. Verwaltete Einstellungen, die remote über die Admin-Konsole hochgeladen werden, erreichen derzeit nur CLI- und IDE-Sitzungen. Für Desktop-Bereitstellungen verteilen Sie die Datei daher über MDM oder verwenden Sie die [Admin-Konsolen-Steuerelemente](#admin-console-controls) oben.

592 609

env-vars.md +2 −0

Details

164| `CLAUDE_CODE_USE_POWERSHELL_TOOL` | Steuert das PowerShell-Tool. Unter Windows ohne Git Bash ist das Tool automatisch aktiviert; setzen Sie auf `0`, um es zu deaktivieren. Unter Windows mit installiertem Git Bash wird das Tool schrittweise eingeführt: Setzen Sie auf `1`, um sich anzumelden, oder auf `0`, um sich abzumelden. Unter Linux, macOS und WSL setzen Sie auf `1`, um es zu aktivieren, was `pwsh` auf Ihrem `PATH` erfordert. Wenn unter Windows aktiviert, kann Claude PowerShell-Befehle nativ ausführen, anstatt sie durch Git Bash zu leiten. Siehe [PowerShell-Tool](/de/tools-reference#powershell-tool) |164| `CLAUDE_CODE_USE_POWERSHELL_TOOL` | Steuert das PowerShell-Tool. Unter Windows ohne Git Bash ist das Tool automatisch aktiviert; setzen Sie auf `0`, um es zu deaktivieren. Unter Windows mit installiertem Git Bash wird das Tool schrittweise eingeführt: Setzen Sie auf `1`, um sich anzumelden, oder auf `0`, um sich abzumelden. Unter Linux, macOS und WSL setzen Sie auf `1`, um es zu aktivieren, was `pwsh` auf Ihrem `PATH` erfordert. Wenn unter Windows aktiviert, kann Claude PowerShell-Befehle nativ ausführen, anstatt sie durch Git Bash zu leiten. Siehe [PowerShell-Tool](/de/tools-reference#powershell-tool) |

166| `CLAUDE_CONFIG_DIR` | Überschreiben Sie das Konfigurationsverzeichnis (Standard: `~/.claude`). Alle Einstellungen, Anmeldedaten, Sitzungsverlauf und Plugins werden unter diesem Pfad gespeichert. Nützlich zum Ausführen mehrerer Konten nebeneinander: z. B. `alias claude-work='CLAUDE_CONFIG_DIR=~/.claude-work claude'` |166| `CLAUDE_CONFIG_DIR` | Überschreiben Sie das Konfigurationsverzeichnis (Standard: `~/.claude`). Alle Einstellungen, Anmeldedaten, Sitzungsverlauf und Plugins werden unter diesem Pfad gespeichert. Nützlich zum Ausführen mehrerer Konten nebeneinander: z. B. `alias claude-work='CLAUDE_CONFIG_DIR=~/.claude-work claude'` |

167| `CLAUDE_EFFORT` | Wird automatisch in Bash-Tool-Subprozessen und Hook-Befehlen auf die aktive [Anstrengungsstufe](/de/model-config#adjust-effort-level) für den Turn gesetzt: `low`, `medium`, `high`, `xhigh` oder `max`. Entspricht dem Feld `effort.level`, das an [Hooks](/de/hooks) übergeben wird. Wird nur gesetzt, wenn das aktuelle Modell den Effort-Parameter unterstützt |

167| `CLAUDE_ENABLE_BYTE_WATCHDOG` | Setzen Sie auf `1`, um den Byte-Level-Streaming-Idle-Watchdog zu erzwingen, oder auf `0`, um ihn zu deaktivieren. Wenn nicht gesetzt, ist der Watchdog standardmäßig für Anthropic API-Verbindungen aktiviert. Der Byte-Watchdog bricht eine Verbindung ab, wenn für die Dauer, die von `CLAUDE_STREAM_IDLE_TIMEOUT_MS` gesetzt ist, keine Bytes auf dem Draht ankommen, mit einem Minimum von 5 Minuten, unabhängig vom Event-Level-Watchdog |168| `CLAUDE_ENABLE_BYTE_WATCHDOG` | Setzen Sie auf `1`, um den Byte-Level-Streaming-Idle-Watchdog zu erzwingen, oder auf `0`, um ihn zu deaktivieren. Wenn nicht gesetzt, ist der Watchdog standardmäßig für Anthropic API-Verbindungen aktiviert. Der Byte-Watchdog bricht eine Verbindung ab, wenn für die Dauer, die von `CLAUDE_STREAM_IDLE_TIMEOUT_MS` gesetzt ist, keine Bytes auf dem Draht ankommen, mit einem Minimum von 5 Minuten, unabhängig vom Event-Level-Watchdog |

168| `CLAUDE_ENABLE_STREAM_WATCHDOG` | Setzen Sie auf `1`, um den Event-Level-Streaming-Idle-Watchdog zu aktivieren. Standardmäßig aus. Für Bedrock, Vertex und Foundry ist dies der einzige verfügbare Idle-Watchdog. Konfigurieren Sie das Timeout mit `CLAUDE_STREAM_IDLE_TIMEOUT_MS` |169| `CLAUDE_ENABLE_STREAM_WATCHDOG` | Setzen Sie auf `1`, um den Event-Level-Streaming-Idle-Watchdog zu aktivieren. Standardmäßig aus. Für Bedrock, Vertex und Foundry ist dies der einzige verfügbare Idle-Watchdog. Konfigurieren Sie das Timeout mit `CLAUDE_STREAM_IDLE_TIMEOUT_MS` |

169| `CLAUDE_ENV_FILE` | Pfad zu einem Shell-Skript, dessen Inhalte Claude Code vor jedem Bash-Befehl im gleichen Shell-Prozess ausführt, sodass Exporte in der Datei für den Befehl sichtbar sind. Verwenden Sie, um virtualenv- oder Conda-Aktivierung über Befehle hinweg beizubehalten. Wird auch dynamisch von [SessionStart](/de/hooks#persist-environment-variables), [Setup](/de/hooks#setup), [CwdChanged](/de/hooks#cwdchanged) und [FileChanged](/de/hooks#filechanged)-Hooks gefüllt |170| `CLAUDE_ENV_FILE` | Pfad zu einem Shell-Skript, dessen Inhalte Claude Code vor jedem Bash-Befehl im gleichen Shell-Prozess ausführt, sodass Exporte in der Datei für den Befehl sichtbar sind. Verwenden Sie, um virtualenv- oder Conda-Aktivierung über Befehle hinweg beizubehalten. Wird auch dynamisch von [SessionStart](/de/hooks#persist-environment-variables), [Setup](/de/hooks#setup), [CwdChanged](/de/hooks#cwdchanged) und [FileChanged](/de/hooks#filechanged)-Hooks gefüllt |

205| `MAX_THINKING_TOKENS` | Überschreiben Sie das [erweitertes Denken](https://platform.claude.com/docs/en/build-with-claude/extended-thinking)-Token-Budget. Die Obergrenze ist die [maximale Ausgabe-Token](https://platform.claude.com/docs/en/about-claude/models/overview#latest-models-comparison) des Modells minus eins. Setzen Sie auf `0`, um Denken vollständig zu deaktivieren. Bei Modellen mit [adaptivem Denken](/de/model-config#adjust-effort-level) wird das Budget ignoriert, es sei denn, adaptives Denken ist über `CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING` deaktiviert |206| `MAX_THINKING_TOKENS` | Überschreiben Sie das [erweitertes Denken](https://platform.claude.com/docs/en/build-with-claude/extended-thinking)-Token-Budget. Die Obergrenze ist die [maximale Ausgabe-Token](https://platform.claude.com/docs/en/about-claude/models/overview#latest-models-comparison) des Modells minus eins. Setzen Sie auf `0`, um Denken vollständig zu deaktivieren. Bei Modellen mit [adaptivem Denken](/de/model-config#adjust-effort-level) wird das Budget ignoriert, es sei denn, adaptives Denken ist über `CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING` deaktiviert |

206| `MCP_CLIENT_SECRET` | OAuth-Client-Secret für MCP-Server, die [vorkonfigurierte Anmeldedaten](/de/mcp#use-pre-configured-oauth-credentials) erfordern. Vermeidet die interaktive Eingabeaufforderung beim Hinzufügen eines Servers mit `--client-secret` |207| `MCP_CLIENT_SECRET` | OAuth-Client-Secret für MCP-Server, die [vorkonfigurierte Anmeldedaten](/de/mcp#use-pre-configured-oauth-credentials) erfordern. Vermeidet die interaktive Eingabeaufforderung beim Hinzufügen eines Servers mit `--client-secret` |

207| `MCP_CONNECTION_NONBLOCKING` | Setzen Sie auf `true` im nicht-interaktiven Modus (`-p`), um das Warten auf MCP-Verbindung vollständig zu überspringen. Nützlich für Skript-Pipelines, bei denen MCP-Tools nicht benötigt werden. Ohne diese Variable wartet die erste Abfrage bis zu 5 Sekunden auf `--mcp-config`-Server-Verbindungen. Server, die mit [`alwaysLoad: true`](/de/mcp#exempt-a-server-from-deferral) konfiguriert sind, blockieren den Start immer, unabhängig von dieser Variablen, da ihre Tools vorhanden sein müssen, wenn der erste Prompt erstellt wird |208| `MCP_CONNECTION_NONBLOCKING` | Setzen Sie auf `true` im nicht-interaktiven Modus (`-p`), um das Warten auf MCP-Verbindung vollständig zu überspringen. Nützlich für Skript-Pipelines, bei denen MCP-Tools nicht benötigt werden. Ohne diese Variable wartet die erste Abfrage bis zu 5 Sekunden auf `--mcp-config`-Server-Verbindungen. Server, die mit [`alwaysLoad: true`](/de/mcp#exempt-a-server-from-deferral) konfiguriert sind, blockieren den Start immer, unabhängig von dieser Variablen, da ihre Tools vorhanden sein müssen, wenn der erste Prompt erstellt wird |

209| `MCP_CONNECT_TIMEOUT_MS` | Wie lange die erste Abfrage wartet, in Millisekunden, auf den MCP-Verbindungs-Batch, bevor die Tool-Liste fotografiert wird (Standard: 5000). Server, die noch ausstehend sind, verbinden sich weiterhin im Hintergrund, erscheinen aber erst bei der nächsten Abfrage. Unterscheidet sich von `MCP_TIMEOUT`, das einen einzelnen Server-Verbindungsversuch begrenzt. Besonders relevant für nicht-interaktive Sitzungen, die eine einzelne Abfrage ausstellen und langsam verbindende Server sichtbar machen müssen |

208| `MCP_OAUTH_CALLBACK_PORT` | Fester Port für den OAuth-Redirect-Callback als Alternative zu `--callback-port` beim Hinzufügen eines MCP-Servers mit [vorkonfigurierten Anmeldedaten](/de/mcp#use-pre-configured-oauth-credentials) |210| `MCP_OAUTH_CALLBACK_PORT` | Fester Port für den OAuth-Redirect-Callback als Alternative zu `--callback-port` beim Hinzufügen eines MCP-Servers mit [vorkonfigurierten Anmeldedaten](/de/mcp#use-pre-configured-oauth-credentials) |

209| `MCP_REMOTE_SERVER_CONNECTION_BATCH_SIZE` | Maximale Anzahl von Remote-MCP-Servern (HTTP/SSE), die während des Starts parallel verbunden werden (Standard: 20) |211| `MCP_REMOTE_SERVER_CONNECTION_BATCH_SIZE` | Maximale Anzahl von Remote-MCP-Servern (HTTP/SSE), die während des Starts parallel verbunden werden (Standard: 20) |

210| `MCP_SERVER_CONNECTION_BATCH_SIZE` | Maximale Anzahl von lokalen MCP-Servern (stdio), die während des Starts parallel verbunden werden (Standard: 3) |212| `MCP_SERVER_CONNECTION_BATCH_SIZE` | Maximale Anzahl von lokalen MCP-Servern (stdio), die während des Starts parallel verbunden werden (Standard: 3) |

features-overview.md +1 −1

Details

249 249

250 **Kontextkosten:** Niedrig bis verwendet. Nur-Benutzer-Skills haben Null-Kosten bis aufgerufen.250 **Kontextkosten:** Niedrig bis verwendet. Nur-Benutzer-Skills haben Null-Kosten bis aufgerufen.

251 251

252 **In Subagents:** Skills funktionieren in Subagents anders. Anstelle von On-Demand-Laden werden Skills, die an einen Subagent übergeben werden, vollständig in seinen Kontext beim Start vorgeladen. Subagents erben Skills nicht von der Hauptsitzung; Sie müssen sie explizit angeben.252 **In Subagents:** Skills funktionieren in Subagents anders. Anstelle von On-Demand-Laden werden Skills, die im `skills:`-Feld des Subagenten aufgelistet sind, vollständig in seinen Kontext beim Start vorgeladen. Subagents können immer noch unlisted Project-, Benutzer- und Plugin-Skills durch das Skill-Tool entdecken und aufrufen.

253 253

254 <Tip>Verwenden Sie `disable-model-invocation: true` für Skills mit Nebenwirkungen. Dies spart Kontext und stellt sicher, dass nur Sie sie auslösen.</Tip>254 <Tip>Verwenden Sie `disable-model-invocation: true` für Skills mit Nebenwirkungen. Dies spart Kontext und stellt sicher, dass nur Sie sie auslösen.</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## Voraussetzungen81## Voraussetzungen

192 82

hooks.md +7 −6

Details

518Hook-Ereignisse erhalten diese Felder als JSON, zusätzlich zu ereignisspezifischen Feldern, die in jedem Abschnitt [Hook-Ereignis](#hook-events) dokumentiert sind. Für Command-Hooks kommt diese JSON über stdin an. Für HTTP-Hooks kommt sie als POST-Request-Body an.518Hook-Ereignisse erhalten diese Felder als JSON, zusätzlich zu ereignisspezifischen Feldern, die in jedem Abschnitt [Hook-Ereignis](#hook-events) dokumentiert sind. Für Command-Hooks kommt diese JSON über stdin an. Für HTTP-Hooks kommt sie als POST-Request-Body an.

519 519

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

524| `cwd` | Aktuelles Arbeitsverzeichnis, wenn der Hook aufgerufen wird |524| `cwd` | Aktuelles Arbeitsverzeichnis, wenn der Hook aufgerufen wird |

525| `permission_mode` | Aktueller [Berechtigungsmodus](/de/permissions#permission-modes): `"default"`, `"plan"`, `"acceptEdits"`, `"auto"`, `"dontAsk"` oder `"bypassPermissions"`. Nicht alle Ereignisse erhalten dieses Feld: siehe jedes Ereignis-JSON-Beispiel unten, um zu prüfen |525| `permission_mode` | Aktueller [Berechtigungsmodus](/de/permissions#permission-modes): `"default"`, `"plan"`, `"acceptEdits"`, `"auto"`, `"dontAsk"` oder `"bypassPermissions"`. Nicht alle Ereignisse erhalten dieses Feld: siehe jedes Ereignis-JSON-Beispiel unten, um zu prüfen |

526| `effort` | Objekt mit einem `level`-Feld, das die aktive [Anstrengungsstufe](/de/model-config#adjust-effort-level) für den Zug enthält: `"low"`, `"medium"`, `"high"`, `"xhigh"` oder `"max"`. Wenn die angeforderte Anstrengung das überschreitet, was das aktuelle Modell unterstützt, ist dies die herabgestufte Stufe, die das Modell tatsächlich verwendet hat, nicht die Stufe, die Sie angefordert haben. Das Objekt entspricht dem [Statuszeilen](/de/statusline#available-data)-Feld `effort`. Vorhanden für Ereignisse, die innerhalb eines Tool-Use-Kontexts ausgelöst werden, wie `PreToolUse`, `PostToolUse`, `Stop` und `SubagentStop`, wenn das aktuelle Modell den Anstrengungsparameter unterstützt. Die Stufe ist auch für Hook-Befehle und das Bash-Tool als die Umgebungsvariable `$CLAUDE_EFFORT` verfügbar. |

527 528

528Wenn mit `--agent` oder innerhalb eines Subagenten ausgeführt, sind zwei zusätzliche Felder enthalten:529Wenn mit `--agent` oder innerhalb eines Subagenten ausgeführt, sind zwei zusätzliche Felder enthalten:

1225 1226

1226Wenn das verschobene Tool nicht mehr verfügbar ist, wenn Sie fortsetzen, beendet sich der Prozess mit `stop_reason: "tool_deferred_unavailable"` und `is_error: true` bevor der Hook ausgelöst wird. Dies geschieht, wenn ein MCP-Server, der das Tool bereitgestellt hat, für die fortgesetzte Sitzung nicht verbunden ist. Die Nutzlast `deferred_tool_use` ist immer noch enthalten, damit Sie identifizieren können, welches Tool fehlte.1227Wenn das verschobene Tool nicht mehr verfügbar ist, wenn Sie fortsetzen, beendet sich der Prozess mit `stop_reason: "tool_deferred_unavailable"` und `is_error: true` bevor der Hook ausgelöst wird. Dies geschieht, wenn ein MCP-Server, der das Tool bereitgestellt hat, für die fortgesetzte Sitzung nicht verbunden ist. Die Nutzlast `deferred_tool_use` ist immer noch enthalten, damit Sie identifizieren können, welches Tool fehlte.

1227 1228

1228<Warning>1229<Note>

1229 `--resume` stellt den Berechtigungsmodus aus der vorherigen Sitzung nicht wieder her. Übergeben Sie das gleiche `--permission-mode`-Flag bei der Wiederaufnahme, das aktiv war, als das Tool verschoben wurde. Claude Code protokolliert eine Warnung, wenn sich die Modi unterscheiden.1230 `--resume` stellt den Berechtigungsmodus wieder her, der aktiv war, als das Tool verschoben wurde, daher müssen Sie `--permission-mode` nicht erneut übergeben. Die Ausnahmen sind `plan` und `bypassPermissions`, die niemals übertragen werden. Das explizite Übergeben von `--permission-mode` bei der Wiederaufnahme überschreibt den wiederhergestellten Wert.

1230</Warning>1231</Note>

1231 1232

1232### PermissionRequest1233### PermissionRequest

1233 1234

1357`PostToolUse`-Hooks können Claude nach der Tool-Ausführung Feedback geben. Zusätzlich zu den [JSON-Ausgabefeldern](#json-output), die für alle Hooks verfügbar sind, kann Ihr Hook-Skript diese ereignisspezifischen Felder zurückgeben:1358`PostToolUse`-Hooks können Claude nach der Tool-Ausführung Feedback geben. Zusätzlich zu den [JSON-Ausgabefeldern](#json-output), die für alle Hooks verfügbar sind, kann Ihr Hook-Skript diese ereignisspezifischen Felder zurückgeben:

1358 1359

1359| Feld | Beschreibung |1360| Feld | Beschreibung |

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

1361| `decision` | `"block"` fordert Claude mit dem `reason` auf. Weglassen, um die Aktion fortzusetzen |1362| `decision` | `"block"` fügt den `reason` neben dem Tool-Ergebnis hinzu. Claude sieht immer noch die ursprüngliche Ausgabe; um sie zu ersetzen, verwenden Sie `updatedToolOutput` |

1363| `additionalContext` | Zeichenkette, die zu Claudes Kontext zusammen mit dem Tool-Ergebnis hinzugefügt wird. Siehe [Kontext für Claude hinzufügen](#add-context-for-claude) |1364| `additionalContext` | Zeichenkette, die zu Claudes Kontext zusammen mit dem Tool-Ergebnis hinzugefügt wird. Siehe [Kontext für Claude hinzufügen](#add-context-for-claude) |

1364| `updatedToolOutput` | Ersetzt die Ausgabe des Tools durch den bereitgestellten Wert vor dem Senden an Claude. Der Wert muss der Ausgabeform des Tools entsprechen |1365| `updatedToolOutput` | Ersetzt die Ausgabe des Tools durch den bereitgestellten Wert vor dem Senden an Claude. Der Wert muss der Ausgabeform des Tools entsprechen |

memory.md +10 −0

Details

132Verwenden Sie Plan Mode für Änderungen unter `src/billing/`.132Verwenden Sie Plan Mode für Änderungen unter `src/billing/`.

133```133```

134 134

135Ein Symlink funktioniert auch, wenn Sie keine Claude-spezifischen Inhalte hinzufügen müssen:

136

137```bash theme={null}

138ln -s AGENTS.md CLAUDE.md

139```

140

141Unter Windows erfordert das Erstellen eines Symlinks Administratorrechte oder Developer Mode, daher verwenden Sie stattdessen den Import `@AGENTS.md`.

142

143Das Ausführen von [`/init`](/de/commands) in einem Repo, das bereits eine `AGENTS.md` hat, liest diese und integriert die relevanten Teile in die generierte `CLAUDE.md`. Es liest auch andere Tool-Konfigurationen wie `.cursorrules` und `.windsurfrules`.

144

135### Wie CLAUDE.md-Dateien geladen werden145### Wie CLAUDE.md-Dateien geladen werden

136 146

137Claude Code liest CLAUDE.md-Dateien, indem es die Verzeichnisstruktur von Ihrem aktuellen Arbeitsverzeichnis aus durchläuft und jedes Verzeichnis unterwegs auf `CLAUDE.md`- und `CLAUDE.local.md`-Dateien überprüft. Das bedeutet, wenn Sie Claude Code in `foo/bar/` ausführen, lädt es Anweisungen aus `foo/bar/CLAUDE.md`, `foo/CLAUDE.md` und allen `CLAUDE.local.md`-Dateien daneben.147Claude Code liest CLAUDE.md-Dateien, indem es die Verzeichnisstruktur von Ihrem aktuellen Arbeitsverzeichnis aus durchläuft und jedes Verzeichnis unterwegs auf `CLAUDE.md`- und `CLAUDE.local.md`-Dateien überprüft. Das bedeutet, wenn Sie Claude Code in `foo/bar/` ausführen, lädt es Anweisungen aus `foo/bar/CLAUDE.md`, `foo/CLAUDE.md` und allen `CLAUDE.local.md`-Dateien daneben.

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## Voraussetzungen81## Voraussetzungen

192 82

model-config.md +4 −0

Details

17 * Foundry: einen Bereitstellungsnamen17 * Foundry: einen Bereitstellungsnamen

18 * Vertex: einen Versionsnamen18 * Vertex: einen Versionsnamen

19 19

20<Note>

21 `ANTHROPIC_BASE_URL` ändert, wohin Anfragen gesendet werden, nicht welches Modell sie beantwortet. Um Claude durch ein LLM-Gateway zu leiten, siehe [LLM-Gateway-Konfiguration](/de/llm-gateway).

22</Note>

20### Modellaliase24### Modellaliase

21 25

22Modellaliase bieten eine bequeme Möglichkeit, Modelleinstellungen auszuwählen, ohne sich genaue Versionsnummern merken zu müssen:26Modellaliase bieten eine bequeme Möglichkeit, Modelleinstellungen auszuwählen, ohne sich genaue Versionsnummern merken zu müssen:

overview.md +1 −635

Details

6 6

7> Claude Code ist ein agentengestütztes Codierungswerkzeug, das Ihre Codebasis liest, Dateien bearbeitet, Befehle ausführt und sich in Ihre Entwicklungstools integriert. Verfügbar in Ihrem Terminal, IDE, Desktop-App und Browser.7> Claude Code ist ein agentengestütztes Codierungswerkzeug, das Ihre Codebasis liest, Dateien bearbeitet, Befehle ausführt und sich in Ihre Entwicklungstools integriert. Verfügbar in Ihrem Terminal, IDE, Desktop-App und Browser.

8 8

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

~~10 const TERM = {~~

~~11 mac: {~~

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

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

~~14 },~~

~~15 win: {~~

~~16 label: 'Windows'~~

~~17 },~~

~~18 brew: {~~

~~19 label: 'Homebrew',~~

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

~~21 },~~

~~22 winget: {~~

~~23 label: 'WinGet',~~

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

~~25 }~~

~~26 };~~

~~27 const WIN_VARIANTS = {~~

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

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

~~30 };~~

~~31 const TABS = [{~~

~~32 key: 'terminal',~~

~~33 label: 'Terminal'~~

~~34 }, {~~

~~35 key: 'desktop',~~

~~36 label: 'Desktop'~~

~~37 }, {~~

~~38 key: 'vscode',~~

~~39 label: 'VS Code'~~

~~40 }, {~~

~~41 key: 'jetbrains',~~

~~42 label: 'JetBrains'~~

~~43 }];~~

~~44 const ALT_TARGETS = {~~

~~45 desktop: {~~

~~46 name: 'Desktop',~~

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

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

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

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

~~51 },~~

~~52 vscode: {~~

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

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

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

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

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

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

~~59 },~~

~~60 jetbrains: {~~

~~61 name: 'JetBrains',~~

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

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

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

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

~~66 }~~

~~67 };~~

~~68 const PROVIDERS = [{~~

~~69 key: 'anthropic',~~

~~70 label: 'Anthropic'~~

~~71 }, {~~

~~72 key: 'bedrock',~~

~~73 label: 'Amazon Bedrock'~~

~~74 }, {~~

~~75 key: 'foundry',~~

~~76 label: 'Microsoft Foundry'~~

~~77 }, {~~

~~78 key: 'vertex',~~

~~79 label: 'Google Vertex AI'~~

~~80 }];~~

~~81 const PROVIDER_NOTICE = {~~

~~82 bedrock: <>~~

~~83 <strong>Configure your AWS account first.</strong> Running on Bedrock~~

~~84 requires model access enabled in the AWS console and IAM credentials.{' '}~~

~~85 <a href="/en/amazon-bedrock">Bedrock setup guide →</a>~~

~~86 </>,~~

~~87 vertex: <>~~

~~88 <strong>Configure your GCP project first.</strong> Running on Vertex AI~~

~~89 requires the Vertex API enabled and a service account with the right~~

~~90 permissions.{' '}~~

~~91 <a href="/en/google-vertex-ai">Vertex setup guide →</a>~~

~~92 </>,~~

~~93 foundry: <>~~

~~94 <strong>Configure your Azure resources first.</strong> Running on~~

~~95 Microsoft Foundry requires an Azure subscription with a Foundry resource~~

~~96 and model deployments provisioned.{' '}~~

~~97 <a href="/en/microsoft-foundry">Foundry setup guide →</a>~~

~~98 </>~~

~~99 };~~

100 const iconCheck = (size = 14) => <svg width={size} height={size} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="3" strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">

101 <polyline points="20 6 9 17 4 12" />

102 </svg>;

103 const iconCopy = (size = 14) => <svg width={size} height={size} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">

104 <rect x="9" y="9" width="13" height="13" rx="2" />

105 <path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1" />

106 </svg>;

107 const iconArrowRight = (size = 13) => <svg width={size} height={size} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2.5" strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">

108 <line x1="5" y1="12" x2="19" y2="12" />

109 <polyline points="12 5 19 12 12 19" />

110 </svg>;

111 const iconArrowUpRight = (size = 14) => <svg width={size} height={size} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2.5" strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">

112 <line x1="7" y1="17" x2="17" y2="7" />

113 <polyline points="7 7 17 7 17 17" />

114 </svg>;

115 const iconInfo = (size = 16) => <svg width={size} height={size} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">

116 <circle cx="12" cy="12" r="10" />

117 <line x1="12" y1="16" x2="12" y2="12" />

118 <line x1="12" y1="8" x2="12.01" y2="8" />

119 </svg>;

120 const [target, setTarget] = useState(defaultSurface);

121 const [team, setTeam] = useState(false);

122 const [provider, setProvider] = useState('anthropic');

123 const [pkg, setPkg] = useState(() => (/Win/).test(navigator.userAgent) ? 'win' : 'mac');

124 const [winCmd, setWinCmd] = useState(false);

125 const [copied, setCopied] = useState(null);

126 const copyTimer = useRef(null);

127 const handleCopy = async (text, key) => {

128 try {

129 await navigator.clipboard.writeText(text);

130 } catch {

131 const ta = document.createElement('textarea');

132 ta.value = text;

133 document.body.appendChild(ta);

134 ta.select();

135 document.execCommand('copy');

136 document.body.removeChild(ta);

137 }

138 clearTimeout(copyTimer.current);

139 setCopied(key);

140 copyTimer.current = setTimeout(() => setCopied(null), 1800);

141 };

142 const cardBodyCmd = (cmd, prompt) => {

143 const on = copied === 'term';

144 return <div className="cc-ic-card-body">

145 <span className="cc-ic-prompt">{prompt || '$'}</span>

146 <div className="cc-ic-cmd">{cmd}</div>

147 <button type="button" className={'cc-ic-copy' + (on ? ' cc-ic-copied' : '')} onClick={() => handleCopy(cmd, 'term')}>

148 {on ? iconCheck(13) : iconCopy(13)}

149 <span>{on ? 'Copied' : 'Copy'}</span>

150 </button>

151 </div>;

152 };

153 const isWinInstaller = pkg === 'win';

154 const isWinPrompt = pkg === 'win' || pkg === 'winget';

155 const terminalCmd = isWinInstaller ? WIN_VARIANTS[winCmd ? 'cmd' : 'ps'] : TERM[pkg].cmd;

156 const alt = ALT_TARGETS[target];

157 const showNotice = team && provider !== 'anthropic';

158 const STYLES = `

159.cc-ic {

160 --ic-slate: #141413;

161 --ic-clay: #d97757;

162 --ic-clay-deep: #c6613f;

163 --ic-gray-000: #ffffff;

164 --ic-gray-150: #f0eee6;

165 --ic-gray-550: #73726c;

166 --ic-gray-700: #3d3d3a;

167 --ic-border-subtle: rgba(31, 30, 29, 0.08);

168 --ic-border-default: rgba(31, 30, 29, 0.15);

169 --ic-border-strong: rgba(31, 30, 29, 0.3);

170 --ic-font-mono: ui-monospace, SFMono-Regular, Menlo, Monaco, 'Courier New', monospace;

171 font-family: 'Anthropic Sans', -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;

172 font-size: 14px; line-height: 1.5; color: var(--ic-slate);

173 margin: 8px 0 32px;

174}

175.dark .cc-ic {

176 --ic-slate: #f0eee6;

177 --ic-gray-000: #262624;

178 --ic-gray-150: #1f1e1d;

179 --ic-gray-550: #91908a;

180 --ic-gray-700: #bfbdb4;

181 --ic-border-subtle: rgba(240, 238, 230, 0.08);

182 --ic-border-default: rgba(240, 238, 230, 0.14);

183 --ic-border-strong: rgba(240, 238, 230, 0.28);

184}

185.dark .cc-ic-check { background: transparent; }

186.dark .cc-ic-card { border: 0.5px solid var(--ic-border-subtle); }

187.dark .cc-ic-p-pill.cc-ic-active { box-shadow: 0 1px 2px rgba(0, 0, 0, 0.3); }

188.cc-ic *, .cc-ic *::before, .cc-ic *::after { box-sizing: border-box; }

189.cc-ic a { text-decoration: none; }

190.cc-ic a:not([class]) { color: inherit; }

191.cc-ic button { font-family: inherit; cursor: pointer; }

~~192~~

193.cc-ic-tab-strip {

194 display: inline-flex; gap: 2px;

195 padding: 4px; background: var(--ic-gray-150);

196 border-radius: 10px; overflow-x: auto;

197 max-width: 100%;

198}

199.cc-ic-tab {

200 appearance: none; background: none; border: none;

201 padding: 10px 18px; font-size: 15px; font-weight: 430;

202 color: var(--ic-gray-550); border-radius: 7px;

203 white-space: nowrap;

204 transition: color 0.12s, background-color 0.12s;

205}

206.cc-ic-tab:hover { color: var(--ic-gray-700); }

207.cc-ic-tab.cc-ic-active {

208 color: var(--ic-slate); font-weight: 500;

209 background: var(--ic-gray-000);

210 box-shadow: 0 1px 3px rgba(0, 0, 0, 0.08);

211}

212.dark .cc-ic-tab.cc-ic-active { box-shadow: 0 1px 3px rgba(0, 0, 0, 0.4); }

~~213~~

214.cc-ic-team-wrap { padding: 16px 0 20px; }

215.cc-ic-team-toggle {

216 display: flex; align-items: center; gap: 12px; font-family: inherit;

217 padding: 12px 16px; font-size: 14px; font-weight: 430;

218 color: var(--ic-gray-700); cursor: pointer; user-select: none;

219 width: fit-content; background: var(--ic-gray-150);

220 border: 0.5px solid var(--ic-border-subtle); border-radius: 8px;

221 transition: border-color 0.15s;

222}

223.cc-ic-team-toggle:hover { border-color: var(--ic-border-default); }

224.cc-ic-team-toggle.cc-ic-checked {

225 background: rgba(217, 119, 87, 0.08);

226 border-color: rgba(217, 119, 87, 0.25);

227}

228.cc-ic-check {

229 width: 16px; height: 16px;

230 border: 1px solid var(--ic-border-strong); border-radius: 4px;

231 background: var(--ic-gray-000);

232 display: flex; align-items: center; justify-content: center;

233 flex-shrink: 0;

234}

235.cc-ic-check svg { color: #fff; display: none; }

236.cc-ic-team-toggle.cc-ic-checked .cc-ic-check { background: var(--ic-clay-deep); border-color: var(--ic-clay-deep); }

237.cc-ic-team-toggle.cc-ic-checked .cc-ic-check svg { display: block; }

~~238~~

239.cc-ic-team-reveal { display: flex; flex-direction: column; gap: 12px; margin-bottom: 16px; }

240.cc-ic-sales {

241 display: flex; align-items: center; justify-content: space-between;

242 gap: 16px; padding: 14px 16px;

243 background: var(--ic-gray-000); border: 0.5px solid var(--ic-border-default);

244 border-radius: 8px; flex-wrap: wrap;

245}

246.cc-ic-sales-text { font-size: 13px; color: var(--ic-gray-700); line-height: 1.5; flex: 1; min-width: 200px; }

247.cc-ic-sales-text strong { font-weight: 550; color: var(--ic-slate); }

248.cc-ic-sales-actions { display: flex; align-items: center; gap: 8px; flex-shrink: 0; }

249.cc-ic-btn-clay {

250 display: inline-flex; align-items: center; gap: 8px;

251 background: var(--ic-clay-deep); color: #fff; border: none;

252 border-radius: 8px; padding: 8px 14px;

253 font-size: 13px; font-weight: 500;

254 transition: background-color 0.15s; white-space: nowrap;

255}

256.cc-ic-btn-clay:hover { background: var(--ic-clay); }

257.cc-ic-btn-ghost {

258 display: inline-flex; align-items: center; gap: 8px;

259 background: transparent; color: var(--ic-gray-700);

260 border: 0.5px solid var(--ic-border-default);

261 border-radius: 8px; padding: 8px 14px;

262 font-size: 13px; font-weight: 500;

263}

264.cc-ic-btn-ghost:hover { background: rgba(0, 0, 0, 0.04); }

~~265~~

266.cc-ic-provider-bar {

267 display: flex; align-items: center; gap: 12px;

268 padding: 14px 16px; background: var(--ic-gray-150);

269 border-radius: 8px; font-size: 13px; flex-wrap: wrap;

270}

271.cc-ic-provider-bar .cc-ic-label { color: var(--ic-gray-550); flex-shrink: 0; }

272.cc-ic-provider-pills { display: flex; gap: 4px; flex-wrap: wrap; }

273.cc-ic-p-pill {

274 appearance: none; border: none; background: transparent;

275 padding: 6px 12px; border-radius: 6px;

276 font-size: 13px; font-weight: 430; color: var(--ic-gray-700);

277 white-space: nowrap;

278}

279.cc-ic-p-pill:hover { background: rgba(0, 0, 0, 0.04); }

280.cc-ic-p-pill.cc-ic-active {

281 background: var(--ic-gray-000); color: var(--ic-slate);

282 font-weight: 500; box-shadow: 0 1px 2px rgba(0, 0, 0, 0.05);

283}

284.cc-ic-provider-notice {

285 display: flex; padding: 16px 18px;

286 background: var(--ic-gray-000); border: 0.5px solid var(--ic-border-default);

287 border-radius: 8px; gap: 14px; align-items: flex-start;

288}

289.cc-ic-provider-notice > svg { color: var(--ic-gray-550); margin-top: 2px; flex-shrink: 0; }

290.cc-ic-provider-notice-body { font-size: 14px; line-height: 1.55; color: var(--ic-gray-700); }

291.cc-ic-provider-notice-body strong { font-weight: 550; color: var(--ic-slate); }

292.cc-ic-provider-notice-body a { color: var(--ic-clay-deep); font-weight: 500; }

293.cc-ic-provider-notice-body a:hover { text-decoration: underline; }

~~294~~

295.cc-ic-card { background: #141413; border-radius: 12px; overflow: hidden; }

296.cc-ic-subtabs {

297 display: flex; align-items: center;

298 background: #1a1918;

299 border-bottom: 0.5px solid rgba(255, 255, 255, 0.08);

300 padding: 0 8px; overflow-x: auto;

301}

302.cc-ic-subtab {

303 appearance: none; background: none; border: none;

304 padding: 12px 16px; font-size: 12px;

305 color: rgba(255, 255, 255, 0.5);

306 position: relative; white-space: nowrap;

307}

308.cc-ic-subtab:hover { color: rgba(255, 255, 255, 0.75); }

309.cc-ic-subtab.cc-ic-active { color: #fff; }

310.cc-ic-subtab.cc-ic-active::after {

311 content: ''; position: absolute;

312 left: 12px; right: 12px; bottom: -0.5px;

313 height: 2px; background: var(--ic-clay);

314}

315.cc-ic-shell-switch {

316 display: inline-flex; gap: 2px;

317 margin: 14px 26px 0; padding: 3px;

318 background: rgba(255, 255, 255, 0.06);

319 border: 0.5px solid rgba(255, 255, 255, 0.08);

320 border-radius: 8px;

321 font-family: inherit;

322}

323.cc-ic-shell-option {

324 font: inherit; font-size: 12px; font-weight: 500;

325 padding: 5px 12px; border-radius: 6px;

326 background: transparent; border: none;

327 color: rgba(255, 255, 255, 0.55);

328 cursor: pointer; user-select: none; white-space: nowrap;

329 transition: color 120ms ease, background-color 120ms ease;

330}

331.cc-ic-shell-option:hover { color: rgba(255, 255, 255, 0.85); }

332.cc-ic-shell-option.cc-ic-active {

333 background: rgba(255, 255, 255, 0.12);

334 color: #fff;

335 box-shadow: 0 1px 2px rgba(0, 0, 0, 0.25);

336}

~~337~~

338.cc-ic-card-body { padding: 24px 26px; display: flex; align-items: flex-start; gap: 14px; }

339.cc-ic-prompt {

340 color: var(--ic-clay); font-family: var(--ic-font-mono);

341 font-size: 17px; user-select: none; padding-top: 2px;

342}

343.cc-ic-cmd {

344 flex: 1; font-family: var(--ic-font-mono);

345 font-size: 17px; color: #f0eee6;

346 line-height: 1.55; white-space: pre-wrap; word-break: break-word;

347}

348.cc-ic-copy {

349 display: inline-flex; align-items: center; gap: 6px;

350 background: rgba(255, 255, 255, 0.08);

351 border: 0.5px solid rgba(255, 255, 255, 0.12);

352 color: rgba(255, 255, 255, 0.85);

353 padding: 7px 13px; border-radius: 8px;

354 font-size: 13px; font-weight: 500; flex-shrink: 0;

355}

356.cc-ic-copy:hover { background: rgba(255, 255, 255, 0.14); }

357.cc-ic-copy.cc-ic-copied { background: var(--ic-clay-deep); border-color: var(--ic-clay-deep); color: #fff; }

~~358~~

359.cc-ic-below {

360 margin-top: 12px; font-size: 13px; color: var(--ic-gray-550);

361 display: flex; gap: 16px; flex-wrap: wrap; align-items: baseline;

362}

363.cc-ic-below a { color: var(--ic-gray-700); border-bottom: 0.5px solid var(--ic-border-default); }

364.cc-ic-below a:hover { color: var(--ic-clay-deep); border-bottom-color: var(--ic-clay-deep); }

365.cc-ic-handoff {

366 padding: 22px 24px;

367 background: linear-gradient(180deg, #faf9f4 0%, #f3f1e9 100%);

368 border: 0.5px solid var(--ic-border-default);

369 border-radius: 12px;

370 box-shadow: 0 1px 2px rgba(31, 30, 29, 0.04), 0 6px 16px -4px rgba(31, 30, 29, 0.06);

371}

372.dark .cc-ic-handoff {

373 background: linear-gradient(180deg, #262624 0%, #1f1e1d 100%);

374 box-shadow: 0 1px 2px rgba(0, 0, 0, 0.3), 0 6px 16px -4px rgba(0, 0, 0, 0.4);

375}

376.cc-ic-handoff-title {

377 font-size: 16px; font-weight: 550; color: var(--ic-slate);

378 letter-spacing: -0.01em; margin-bottom: 4px;

379}

380.cc-ic-handoff-sub {

381 font-size: 14px; line-height: 1.5; color: var(--ic-gray-700);

382 margin-bottom: 18px;

383}

384.cc-ic-handoff-actions { display: flex; gap: 10px; flex-wrap: wrap; }

385.cc-ic-handoff-alt {

386 margin-top: 12px; font-size: 12px; color: var(--ic-gray-550);

387}

388.cc-ic-handoff-alt code {

389 font-family: var(--ic-font-mono); font-size: 11px;

390 background: var(--ic-gray-150); padding: 2px 6px;

391 border-radius: 4px; color: var(--ic-gray-700);

392}

393.cc-ic-copy-sm {

394 appearance: none; border: none;

395 display: inline-flex; align-items: center; justify-content: center;

396 width: 22px; height: 22px;

397 margin-left: 4px; vertical-align: middle;

398 background: var(--ic-gray-150); color: var(--ic-gray-550);

399 border-radius: 4px;

400 transition: color 0.1s, background-color 0.1s;

401}

402.cc-ic-copy-sm:hover { color: var(--ic-gray-700); background: var(--ic-border-default); }

403.cc-ic-copy-sm.cc-ic-copied { background: var(--ic-clay-deep); color: #fff; }

~~404~~

405@media (max-width: 720px) {

406 .cc-ic-tab { padding: 12px 14px; font-size: 14px; }

407 .cc-ic-sales-actions { width: 100%; }

408 .cc-ic-card-body { padding: 20px; }

409 .cc-ic-cmd { font-size: 15px; }

410}

411`;

412 return <div className="cc-ic not-prose">

413 <style>{STYLES}</style>

~~414~~

415 {}

416 <div className="cc-ic-tab-strip" role="tablist">

417 {TABS.map(t => <button key={t.key} type="button" role="tab" aria-selected={target === t.key} className={'cc-ic-tab' + (target === t.key ? ' cc-ic-active' : '')} onClick={() => setTarget(t.key)}>

418 {t.label}

419 </button>)}

420 </div>

~~421~~

422 {}

423 <div className="cc-ic-team-wrap">

424 <button type="button" role="switch" aria-checked={team} className={'cc-ic-team-toggle' + (team ? ' cc-ic-checked' : '')} onClick={() => setTeam(!team)}>

425 <span className="cc-ic-check">{iconCheck(11)}</span>

426 <span>

427 I’m buying for a team or company (SSO, AWS/Azure/GCP, central billing)

428 </span>

429 </button>

430 </div>

~~431~~

432 {}

433 {team && <div className="cc-ic-team-reveal">

434 <div className="cc-ic-sales">

435 <div className="cc-ic-sales-text">

436 <strong>Set up your team:</strong> self-serve or talk to sales.

437 </div>

438 <div className="cc-ic-sales-actions">

439 <a href="https://claude.ai/upgrade?initialPlanType=team&utm_source=claude_code&utm_medium=docs&utm_content=configurator_team_get_started" className="cc-ic-btn-ghost">

440 Get started

441 </a>

442 <a href="https://www.anthropic.com/contact-sales?utm_source=claude_code&utm_medium=docs&utm_content=configurator_team_contact_sales" className="cc-ic-btn-clay">

443 Contact sales {iconArrowRight()}

444 </a>

445 </div>

446 </div>

~~447~~

448 <div className="cc-ic-provider-bar">

449 <span className="cc-ic-label">Run on</span>

450 <div className="cc-ic-provider-pills" role="radiogroup" aria-label="Provider">

451 {PROVIDERS.map(p => <button key={p.key} type="button" role="radio" aria-checked={provider === p.key} className={'cc-ic-p-pill' + (provider === p.key ? ' cc-ic-active' : '')} onClick={() => setProvider(p.key)}>

452 {p.label}

453 </button>)}

454 </div>

455 </div>

~~456~~

457 {showNotice && <div className="cc-ic-provider-notice">

458 {iconInfo()}

459 <div className="cc-ic-provider-notice-body">

460 {PROVIDER_NOTICE[provider]}

461 </div>

462 </div>}

463 </div>}

~~464~~

465 {}

466 {target === 'terminal' && <div className="cc-ic-card">

467 <div className="cc-ic-subtabs" role="tablist" aria-label="Install method">

468 {Object.keys(TERM).map(k => <button key={k} type="button" role="tab" aria-selected={pkg === k} className={'cc-ic-subtab' + (pkg === k ? ' cc-ic-active' : '')} onClick={() => setPkg(k)}>

469 {TERM[k].label}

470 </button>)}

471 </div>

472 {isWinInstaller && <div className="cc-ic-shell-switch" role="tablist" aria-label="Shell">

473 {[{

474 k: 'ps',

475 label: 'PowerShell'

476 }, {

477 k: 'cmd',

478 label: 'CMD'

479 }].map(({k, label}) => {

480 const active = k === 'cmd' === winCmd;

481 return <button key={k} type="button" role="tab" aria-selected={active} className={'cc-ic-shell-option' + (active ? ' cc-ic-active' : '')} onClick={() => setWinCmd(k === 'cmd')}>

482 {label}

483 </button>;

484 })}

485 </div>}

486 {cardBodyCmd(terminalCmd, isWinPrompt ? '>' : '$')}

487 </div>}

~~488~~

489 {}

490 {target === 'terminal' && <div className="cc-ic-below">

491 {isWinInstaller && <span>

492 <a href="https://git-scm.com/downloads/win" target="_blank" rel="noopener">

493 Git for Windows

494 </a>{' '}

495 recommended. PowerShell is used if Git Bash is absent.

496 </span>}

497 {(pkg === 'brew' || pkg === 'winget') && <span>

498 Does not auto-update. Run{' '}

499 <code>{pkg === 'brew' ? 'brew upgrade claude-code' : 'winget upgrade Anthropic.ClaudeCode'}</code>{' '}

500 periodically.

501 </span>}

502 <a href="/en/troubleshoot-install">Installation troubleshooting</a>

503 </div>}

~~504~~

505 {alt && <div className="cc-ic-handoff">

506 <div className="cc-ic-handoff-title">Claude Code for {alt.name}</div>

507 <div className="cc-ic-handoff-sub">{alt.tagline}</div>

508 <div className="cc-ic-handoff-actions">

509 <a href={alt.installHref} className="cc-ic-btn-clay" {...alt.installHref.startsWith('http') ? {

510 target: '_blank',

511 rel: 'noopener'

512 } : {}}>

513 {alt.installLabel} {iconArrowUpRight(13)}

514 </a>

515 <a href={alt.guideHref} className="cc-ic-btn-ghost">

516 {alt.name} guide {iconArrowRight(12)}

517 </a>

518 </div>

519 {alt.altCmd && <div className="cc-ic-handoff-alt">

520 or run <code>{alt.altCmd}</code>

521 <button type="button" className={'cc-ic-copy-sm' + (copied === 'alt' ? ' cc-ic-copied' : '')} onClick={() => handleCopy(alt.altCmd, 'alt')} aria-label="Copy command">

522 {copied === 'alt' ? iconCheck(11) : iconCopy(11)}

523 </button>

524 </div>}

525 </div>}

526 </div>;

527};

~~528~~

529export const Experiment = ({flag, treatment, children}) => {

530 const VID_KEY = 'exp_vid';

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

532 const fnv1a = s => {

533 let h = 0x811c9dc5;

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

535 h ^= s.charCodeAt(i);

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

537 }

538 return h >>> 0;

539 };

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

541 const [decision] = useState(() => {

542 const params = new URLSearchParams(location.search);

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

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

545 if (force) {

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

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

548 if (k === flag) return {

549 variant: v || 'treatment',

550 track: false

551 };

552 }

553 }

554 if (navigator.globalPrivacyControl) {

555 return {

556 variant: 'control',

557 track: false

558 };

559 }

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

561 if (prefsMatch) {

562 try {

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

564 return {

565 variant: 'control',

566 track: false

567 };

568 }

569 } catch {

570 return {

571 variant: 'control',

572 track: false

573 };

574 }

575 } else {

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

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

578 return {

579 variant: 'control',

580 track: false

581 };

582 }

583 }

584 let vid;

585 try {

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

587 if (ajsMatch) {

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

589 } else {

590 vid = localStorage.getItem(VID_KEY);

591 if (!vid) {

592 vid = crypto.randomUUID();

593 }

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

595 }

596 try {

597 localStorage.setItem(VID_KEY, vid);

598 } catch {}

599 } catch {

600 return {

601 variant: 'control',

602 track: false

603 };

604 }

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

606 return {

607 variant,

608 track: true,

609 vid

610 };

611 });

612 useEffect(() => {

613 if (!decision.track) return;

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

615 method: 'POST',

616 headers: {

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

618 'x-service-name': 'claude_code_docs'

619 },

620 body: JSON.stringify({

621 events: [{

622 event_type: 'GrowthbookExperimentEvent',

623 event_data: {

624 device_id: decision.vid,

625 anonymous_id: decision.vid,

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

627 experiment_id: flag,

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

629 environment: 'production'

630 }

631 }]

632 }),

633 keepalive: true

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

635 }, []);

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

637};

~~638~~

639Claude Code ist ein KI-gestützter Codierassistent, der Ihnen hilft, Funktionen zu erstellen, Fehler zu beheben und Entwicklungsaufgaben zu automatisieren. Er versteht Ihre gesamte Codebasis und kann über mehrere Dateien und Tools hinweg arbeiten, um Aufgaben zu erledigen.9Claude Code ist ein KI-gestützter Codierassistent, der Ihnen hilft, Funktionen zu erstellen, Fehler zu beheben und Entwicklungsaufgaben zu automatisieren. Er versteht Ihre gesamte Codebasis und kann über mehrere Dateien und Tools hinweg arbeiten, um Aufgaben zu erledigen.

640 10

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

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

643</div>

~~644~~

645## Erste Schritte11## Erste Schritte

646 12

647Wählen Sie Ihre Umgebung, um zu beginnen. Die meisten Oberflächen erfordern ein [Claude-Abonnement](https://claude.com/pricing?utm_source=claude_code\&utm_medium=docs\&utm_content=overview_pricing) oder ein [Anthropic Console](https://console.anthropic.com/)-Konto. Das Terminal CLI und VS Code unterstützen auch [Drittanbieter](/de/third-party-integrations).13Wählen Sie Ihre Umgebung, um zu beginnen. Die meisten Oberflächen erfordern ein [Claude-Abonnement](https://claude.com/pricing?utm_source=claude_code\&utm_medium=docs\&utm_content=overview_pricing) oder ein [Anthropic Console](https://console.anthropic.com/)-Konto. Das Terminal CLI und VS Code unterstützen auch [Drittanbieter](/de/third-party-integrations).

798 <Accordion title="Passen Sie mit Anweisungen, Skills und Hooks an" icon="sliders">164 <Accordion title="Passen Sie mit Anweisungen, Skills und Hooks an" icon="sliders">

799 [`CLAUDE.md`](/de/memory) ist eine Markdown-Datei, die Sie im Stammverzeichnis Ihres Projekts hinzufügen und die Claude Code zu Beginn jeder Sitzung liest. Verwenden Sie sie, um Codierungsstandards, Architekturentscheidungen, bevorzugte Bibliotheken und Überprüfungschecklisten festzulegen. Claude erstellt auch [automatisches Gedächtnis](/de/memory#auto-memory), während es arbeitet, und speichert Erkenntnisse wie Build-Befehle und Debugging-Einblicke über Sitzungen hinweg, ohne dass Sie etwas schreiben müssen.165 [`CLAUDE.md`](/de/memory) ist eine Markdown-Datei, die Sie im Stammverzeichnis Ihres Projekts hinzufügen und die Claude Code zu Beginn jeder Sitzung liest. Verwenden Sie sie, um Codierungsstandards, Architekturentscheidungen, bevorzugte Bibliotheken und Überprüfungschecklisten festzulegen. Claude erstellt auch [automatisches Gedächtnis](/de/memory#auto-memory), während es arbeitet, und speichert Erkenntnisse wie Build-Befehle und Debugging-Einblicke über Sitzungen hinweg, ohne dass Sie etwas schreiben müssen.

800 166

801 Erstellen Sie [benutzerdefinierte Befehle](/de/skills), um wiederholbare Workflows zu verpacken, die Ihr Team teilen kann, wie `/review-pr` oder `/deploy-staging`.167 Erstellen Sie [Skills](/de/skills), um wiederholbare Workflows zu verpacken, die Ihr Team teilen kann, wie `/review-pr` oder `/deploy-staging`.

802 168

803 [Hooks](/de/hooks) ermöglichen es Ihnen, Shell-Befehle vor oder nach Claude Code-Aktionen auszuführen, wie automatische Formatierung nach jeder Dateibearbeitung oder Ausführung von Lint vor einem Commit.169 [Hooks](/de/hooks) ermöglichen es Ihnen, Shell-Befehle vor oder nach Claude Code-Aktionen auszuführen, wie automatische Formatierung nach jeder Dateibearbeitung oder Ausführung von Lint vor einem Commit.

804 </Accordion>170 </Accordion>

plugins.md +9 −1

Details

317 317

318Um ein Plugin zu testen, das bereits als `.zip`-Archiv verpackt und unter einer URL gehostet wird, z. B. ein CI-Build-Artefakt, verwenden Sie stattdessen `--plugin-url`. Claude Code ruft das Archiv beim Start ab und lädt es nur für diese Sitzung. Wenn das Abrufen fehlschlägt oder das Archiv ungültig ist, meldet Claude Code einen Plugin-Ladefehler und startet ohne es. Die gleichen [Vertrauensüberlegungen](/de/discover-plugins#security) gelten wie für jede andere Plugin-Quelle: Verweisen Sie dieses Flag nur auf Archive, die Sie kontrollieren oder denen Sie vertrauen.318Um ein Plugin zu testen, das bereits als `.zip`-Archiv verpackt und unter einer URL gehostet wird, z. B. ein CI-Build-Artefakt, verwenden Sie stattdessen `--plugin-url`. Claude Code ruft das Archiv beim Start ab und lädt es nur für diese Sitzung. Wenn das Abrufen fehlschlägt oder das Archiv ungültig ist, meldet Claude Code einen Plugin-Ladefehler und startet ohne es. Die gleichen [Vertrauensüberlegungen](/de/discover-plugins#security) gelten wie für jede andere Plugin-Quelle: Verweisen Sie dieses Flag nur auf Archive, die Sie kontrollieren oder denen Sie vertrauen.

319 319

320Um mehrere Plugins zu laden, wiederholen Sie das Flag für jede URL:

321

322```bash theme={null}

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

324```

325

326Oder übergeben Sie durch Leerzeichen getrennte URLs als ein Argument in Anführungszeichen:

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### Debuggen Sie Plugin-Probleme332### Debuggen Sie Plugin-Probleme

quickstart.md +3 −636

Details

6 6

7> Willkommen bei Claude Code!7> Willkommen bei 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~~

639Diese Schnellstartanleitung ermöglicht es Ihnen, in wenigen Minuten KI-gestützte Codierungshilfe zu nutzen. Am Ende werden Sie verstehen, wie Sie Claude Code für häufige Entwicklungsaufgaben einsetzen.9Diese Schnellstartanleitung ermöglicht es Ihnen, in wenigen Minuten KI-gestützte Codierungshilfe zu nutzen. Am Ende werden Sie verstehen, wie Sie Claude Code für häufige Entwicklungsaufgaben einsetzen.

640 10

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

~~642~~

643## Bevor Sie beginnen11## Bevor Sie beginnen

644 12

645Stellen Sie sicher, dass Sie folgende Voraussetzungen erfüllen:13Stellen Sie sicher, dass Sie folgende Voraussetzungen erfüllen:

647* Ein offenes Terminal oder eine offene Eingabeaufforderung15* Ein offenes Terminal oder eine offene Eingabeaufforderung

648 * Wenn Sie das Terminal noch nie verwendet haben, lesen Sie den [Terminal-Leitfaden](/de/terminal-guide)16 * Wenn Sie das Terminal noch nie verwendet haben, lesen Sie den [Terminal-Leitfaden](/de/terminal-guide)

649* Ein Codeprojekt zum Arbeiten17* Ein Codeprojekt zum Arbeiten

650* Ein [Claude-Abonnement](https://claude.com/pricing?utm_source=claude_code\&utm_medium=docs\&utm_content=quickstart_prereq) (Pro, Max, Teams oder Enterprise), ein [Claude Console](https://console.anthropic.com/)-Konto oder Zugriff über einen [unterstützten Cloud-Anbieter](/de/third-party-integrations)18* Ein [Claude-Abonnement](https://claude.com/pricing?utm_source=claude_code\&utm_medium=docs\&utm_content=quickstart_prereq) (Pro, Max, Team oder Enterprise), ein [Claude Console](https://console.anthropic.com/)-Konto oder Zugriff über einen [unterstützten Cloud-Anbieter](/de/third-party-integrations)

651 19

652<Note>20<Note>

653 Diese Anleitung behandelt die Terminal-CLI. Claude Code ist auch im [Web](https://claude.ai/code) verfügbar, als [Desktop-App](/de/desktop), in [VS Code](/de/vs-code) und [JetBrains IDEs](/de/jetbrains), in [Slack](/de/slack) und in CI/CD mit [GitHub Actions](/de/github-actions) und [GitLab](/de/gitlab-ci-cd). Siehe [alle Schnittstellen](/de/overview#use-claude-code-everywhere).21 Diese Anleitung behandelt die Terminal-CLI. Claude Code ist auch im [Web](https://claude.ai/code) verfügbar, als [Desktop-App](/de/desktop), in [VS Code](/de/vs-code) und [JetBrains IDEs](/de/jetbrains), in [Slack](/de/slack) und in CI/CD mit [GitHub Actions](/de/github-actions) und [GitLab](/de/gitlab-ci-cd). Siehe [alle Schnittstellen](/de/overview#use-claude-code-everywhere).

727 95

728Sie können sich mit einem dieser Kontotypen anmelden:96Sie können sich mit einem dieser Kontotypen anmelden:

729 97

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

731* [Claude Console](https://console.anthropic.com/) (API-Zugriff mit Prepaid-Guthaben). Bei der ersten Anmeldung wird automatisch ein „Claude Code"-Arbeitsbereich in der Console erstellt, um die Kosten zentral zu verfolgen.99* [Claude Console](https://console.anthropic.com/) (API-Zugriff mit Prepaid-Guthaben). Bei der ersten Anmeldung wird automatisch ein „Claude Code"-Arbeitsbereich in der Console erstellt, um die Kosten zentral zu verfolgen.

732* [Amazon Bedrock, Google Vertex AI oder Microsoft Foundry](/de/third-party-integrations) (Enterprise-Cloud-Anbieter)100* [Amazon Bedrock, Google Vertex AI oder Microsoft Foundry](/de/third-party-integrations) (Enterprise-Cloud-Anbieter)

733 101

902| `claude commit` | Einen Git-Commit erstellen | `claude commit` |

906 273

907Siehe die [CLI-Referenz](/de/cli-reference) für eine vollständige Liste der Befehle.274Siehe die [CLI-Referenz](/de/cli-reference) für eine vollständige Liste der Befehle.

908 275

settings.md +7 −3

Details

156`settings.json` unterstützt eine Reihe von Optionen:156`settings.json` unterstützt eine Reihe von Optionen:

157 157

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

160| `agent` | Führen Sie den Haupt-Thread als benannten Subagent aus. Wendet den Systemaufforderung, die Werkzeugbeschränkungen und das Modell des Subagent an. Siehe [Rufen Sie Subagents explizit auf](/de/sub-agents#invoke-subagents-explicitly) | `"code-reviewer"` |160| `agent` | Führen Sie den Haupt-Thread als benannten Subagent aus. Wendet den Systemaufforderung, die Werkzeugbeschränkungen und das Modell des Subagent an. Siehe [Rufen Sie Subagents explizit auf](/de/sub-agents#invoke-subagents-explicitly) | `"code-reviewer"` |

161| `allowedChannelPlugins` | (Nur verwaltete Einstellungen) Allowlist von Channel-Plugins, die Nachrichten pushen dürfen. Ersetzt die Standard-Anthropic-Allowlist, wenn gesetzt. Undefined = auf Standard zurückfallen, leeres Array = alle Channel-Plugins blockieren. Erfordert `channelsEnabled: true`. Siehe [Einschränken Sie, welche Channel-Plugins ausgeführt werden können](/de/channels#restrict-which-channel-plugins-can-run) | `[{ "marketplace": "claude-plugins-official", "plugin": "telegram" }]` |161| `allowedChannelPlugins` | (Nur verwaltete Einstellungen) Allowlist von Channel-Plugins, die Nachrichten pushen dürfen. Ersetzt die Standard-Anthropic-Allowlist, wenn gesetzt. Undefined = auf Standard zurückfallen, leeres Array = alle Channel-Plugins blockieren. Erfordert `channelsEnabled: true`. Siehe [Einschränken Sie, welche Channel-Plugins ausgeführt werden können](/de/channels#restrict-which-channel-plugins-can-run) | `[{ "marketplace": "claude-plugins-official", "plugin": "telegram" }]` |

162| `allowedHttpHookUrls` | Allowlist von URL-Mustern, auf die HTTP-Hooks abzielen können. Unterstützt `*` als Platzhalter. Wenn gesetzt, werden Hooks mit nicht übereinstimmenden URLs blockiert. Undefined = keine Einschränkung, leeres Array = alle HTTP-Hooks blockieren. Arrays werden über Einstellungsquellen zusammengeführt. Siehe [Hook-Konfiguration](#hook-configuration) | `["https://hooks.example.com/*"]` |162| `allowedHttpHookUrls` | Allowlist von URL-Mustern, auf die HTTP-Hooks abzielen können. Unterstützt `*` als Platzhalter. Wenn gesetzt, werden Hooks mit nicht übereinstimmenden URLs blockiert. Undefined = keine Einschränkung, leeres Array = alle HTTP-Hooks blockieren. Arrays werden über Einstellungsquellen zusammengeführt. Siehe [Hook-Konfiguration](#hook-configuration) | `["https://hooks.example.com/*"]` |

211| `modelOverrides` | Ordnen Sie Anthropic-Modell-IDs Anbieter-spezifischen Modell-IDs wie Bedrock-Inferenzprofil-ARNs zu. Jeder Modellwähler-Eintrag verwendet seinen zugeordneten Wert beim Aufrufen der Anbieter-API. Siehe [Modell-IDs pro Version überschreiben](/de/model-config#override-model-ids-per-version) | `{"claude-opus-4-6": "arn:aws:bedrock:..."}` |211| `modelOverrides` | Ordnen Sie Anthropic-Modell-IDs Anbieter-spezifischen Modell-IDs wie Bedrock-Inferenzprofil-ARNs zu. Jeder Modellwähler-Eintrag verwendet seinen zugeordneten Wert beim Aufrufen der Anbieter-API. Siehe [Modell-IDs pro Version überschreiben](/de/model-config#override-model-ids-per-version) | `{"claude-opus-4-6": "arn:aws:bedrock:..."}` |

212| `otelHeadersHelper` | Skript zum Generieren dynamischer OpenTelemetry-Header. Wird beim Start und regelmäßig ausgeführt. Setzen Sie das Aktualisierungsintervall mit [`CLAUDE_CODE_OTEL_HEADERS_HELPER_DEBOUNCE_MS`](/de/env-vars). Siehe [Dynamische Header](/de/monitoring-usage#dynamic-headers) | `/bin/generate_otel_headers.sh` |212| `otelHeadersHelper` | Skript zum Generieren dynamischer OpenTelemetry-Header. Wird beim Start und regelmäßig ausgeführt. Setzen Sie das Aktualisierungsintervall mit [`CLAUDE_CODE_OTEL_HEADERS_HELPER_DEBOUNCE_MS`](/de/env-vars). Siehe [Dynamische Header](/de/monitoring-usage#dynamic-headers) | `/bin/generate_otel_headers.sh` |

214| `parentSettingsBehavior` | {/* min-version: 2.1.133 */}(Nur verwaltete Einstellungen) Steuert, ob verwaltete Einstellungen, die programmgesteuert von einem eingebetteten Host-Prozess wie dem Agent SDK oder einer IDE-Erweiterung bereitgestellt werden, gelten, wenn auch eine von Admin bereitgestellte verwaltete Ebene vorhanden ist. `"first-wins"`: die von Parent bereitgestellten Einstellungen werden verworfen und nur die Admin-Ebene gilt. `"merge"`: die von Parent bereitgestellten Einstellungen gelten unter der Admin-Ebene, gefiltert, sodass sie die Richtlinie verschärfen, aber nicht lockern können. Hat keine Auswirkung, wenn keine Admin-Ebene bereitgestellt wird. Standard: `"first-wins"`. Erfordert Claude Code v2.1.133 oder später | `"merge"` |

216| `pluginTrustMessage` | (Nur verwaltete Einstellungen) Benutzerdefinierte Nachricht, die der vor der Installation angezeigten Plugin-Vertrauenswarnung angehängt wird. Verwenden Sie dies, um organisationsspezifischen Kontext hinzuzufügen, z. B. um zu bestätigen, dass Plugins aus Ihrem internen Marketplace überprüft sind. | `"All plugins from our marketplace are approved by IT"` |217| `pluginTrustMessage` | (Nur verwaltete Einstellungen) Benutzerdefinierte Nachricht, die der vor der Installation angezeigten Plugin-Vertrauenswarnung angehängt wird. Verwenden Sie dies, um organisationsspezifischen Kontext hinzuzufügen, z. B. um zu bestätigen, dass Plugins aus Ihrem internen Marketplace überprüft sind. | `"All plugins from our marketplace are approved by IT"` |

255 256

256### Worktree-Einstellungen257### Worktree-Einstellungen

257 258

258Konfigurieren Sie, wie `--worktree` Git-Worktrees erstellt und verwaltet. Verwenden Sie diese Einstellungen, um Speicherplatz und Startzeit in großen Monorepos zu reduzieren.259Konfigurieren Sie, wie `--worktree` Git-Worktrees erstellt und verwaltet.

259 260

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

263| `worktree.baseRef` | Welcher Ref neue Worktrees branchen von. `"fresh"` (Standard) brancht von `origin/<default-branch>` für einen sauberen Baum, der dem Remote entspricht. `"head"` brancht von Ihrem aktuellen lokalen `HEAD`, sodass nicht gepushte Commits und Feature-Branch-Status im Worktree vorhanden sind. Gilt für `--worktree`, das `EnterWorktree`-Tool und die Subagent-Isolation | `"head"` |

262| `worktree.symlinkDirectories` | Verzeichnisse, die vom Haupt-Repository in jeden Worktree symlinkt werden, um große Verzeichnisse auf der Festplatte zu duplizieren. Standardmäßig werden keine Verzeichnisse symlinkt | `["node_modules", ".cache"]` |264| `worktree.symlinkDirectories` | Verzeichnisse, die vom Haupt-Repository in jeden Worktree symlinkt werden, um große Verzeichnisse auf der Festplatte zu duplizieren. Standardmäßig werden keine Verzeichnisse symlinkt | `["node_modules", ".cache"]` |

263| `worktree.sparsePaths` | Verzeichnisse, die in jedem Worktree über Git Sparse-Checkout (Cone-Modus) ausgecheckt werden. Nur die aufgelisteten Pfade werden auf die Festplatte geschrieben, was in großen Monorepos schneller ist | `["packages/my-app", "shared/utils"]` |265| `worktree.sparsePaths` | Verzeichnisse, die in jedem Worktree über Git Sparse-Checkout (Cone-Modus) ausgecheckt werden. Nur die aufgelisteten Pfade werden auf die Festplatte geschrieben, was in großen Monorepos schneller ist | `["packages/my-app", "shared/utils"]` |

264 266

318| `network.socksProxyPort` | SOCKS5-Proxy-Port, der verwendet wird, wenn Sie Ihren eigenen Proxy verwenden möchten. Wenn nicht angegeben, führt Claude seinen eigenen Proxy aus. | `8081` |320| `network.socksProxyPort` | SOCKS5-Proxy-Port, der verwendet wird, wenn Sie Ihren eigenen Proxy verwenden möchten. Wenn nicht angegeben, führt Claude seinen eigenen Proxy aus. | `8081` |

319| `enableWeakerNestedSandbox` | Aktivieren Sie schwächere Sandbox für unprivilegierte Docker-Umgebungen (nur Linux und WSL2). **Reduziert die Sicherheit.** Standard: false | `true` |321| `enableWeakerNestedSandbox` | Aktivieren Sie schwächere Sandbox für unprivilegierte Docker-Umgebungen (nur Linux und WSL2). **Reduziert die Sicherheit.** Standard: false | `true` |

320| `enableWeakerNetworkIsolation` | (Nur macOS) Erlauben Sie den Zugriff auf den System-TLS-Vertrauensdienst (`com.apple.trustd.agent`) in der Sandbox. Erforderlich für Go-basierte Tools wie `gh`, `gcloud` und `terraform`, um TLS-Zertifikate zu überprüfen, wenn `httpProxyPort` mit einem MITM-Proxy und benutzerdefinierter CA verwendet wird. **Reduziert die Sicherheit** durch Öffnen eines möglichen Datenexfiltrationspfads. Standard: false | `true` |322| `enableWeakerNetworkIsolation` | (Nur macOS) Erlauben Sie den Zugriff auf den System-TLS-Vertrauensdienst (`com.apple.trustd.agent`) in der Sandbox. Erforderlich für Go-basierte Tools wie `gh`, `gcloud` und `terraform`, um TLS-Zertifikate zu überprüfen, wenn `httpProxyPort` mit einem MITM-Proxy und benutzerdefinierter CA verwendet wird. **Reduziert die Sicherheit** durch Öffnen eines möglichen Datenexfiltrationspfads. Standard: false | `true` |

323| `bwrapPath` | (Nur verwaltete Einstellungen, Linux/WSL2) Absoluter Pfad zur bubblewrap (`bwrap`) Binärdatei. Überschreibt automatische Erkennung über `PATH`. Wird nur aus [verwalteten Einstellungen](/de/settings#settings-files) berücksichtigt, nicht aus Benutzer- oder Projekteinstellungen. Nützlich, wenn `bwrap` an einem nicht standardmäßigen Ort in verwalteten Umgebungen installiert ist. | `/opt/admin/bwrap` |

324| `socatPath` | (Nur verwaltete Einstellungen, Linux/WSL2) Absoluter Pfad zur `socat` Binärdatei, die für den Sandbox-Netzwerk-Proxy verwendet wird. Überschreibt automatische Erkennung über `PATH`. Wird nur aus verwalteten Einstellungen berücksichtigt. | `/opt/admin/socat` |

321 325

322#### Sandbox-Pfadpräfixe326#### Sandbox-Pfadpräfixe

323 327

setup.md +2 −0

Details

398 398

399Unterstützte npm-Installationsplattformen sind `darwin-arm64`, `darwin-x64`, `linux-x64`, `linux-arm64`, `linux-x64-musl`, `linux-arm64-musl`, `win32-x64` und `win32-arm64`. Ihr Paketmanager muss optionale Abhängigkeiten zulassen. Siehe [Fehlerbehebung](/de/troubleshoot-install#native-binary-not-found-after-npm-install), wenn die Binärdatei nach der Installation fehlt.399Unterstützte npm-Installationsplattformen sind `darwin-arm64`, `darwin-x64`, `linux-x64`, `linux-arm64`, `linux-x64-musl`, `linux-arm64-musl`, `win32-x64` und `win32-arm64`. Ihr Paketmanager muss optionale Abhängigkeiten zulassen. Siehe [Fehlerbehebung](/de/troubleshoot-install#native-binary-not-found-after-npm-install), wenn die Binärdatei nach der Installation fehlt.

400 400

401Um eine npm-Installation zu aktualisieren, führen Sie `npm install -g @anthropic-ai/claude-code@latest` aus. Vermeiden Sie `npm update -g`, das den Semver-Bereich aus der ursprünglichen Installation respektiert und Sie möglicherweise nicht zur neuesten Version führt.

402

401<Warning>403<Warning>

402 Verwenden Sie NICHT `sudo npm install -g`, da dies zu Berechtigungsproblemen und Sicherheitsrisiken führen kann. Wenn Sie auf Berechtigungsfehler stoßen, siehe [Fehlerbehebung bei Berechtigungsfehlern](/de/troubleshoot-install#permission-errors-during-installation).404 Verwenden Sie NICHT `sudo npm install -g`, da dies zu Berechtigungsproblemen und Sicherheitsrisiken führen kann. Wenn Sie auf Berechtigungsfehler stoßen, siehe [Fehlerbehebung bei Berechtigungsfehlern](/de/troubleshoot-install#permission-errors-during-installation).

403</Warning>405</Warning>

sub-agents.md +3 −3

Details

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

263| `name` | Ja | Eindeutige Kennung mit Kleinbuchstaben und Bindestrichen |263| `name` | Ja | Eindeutige Kennung mit Kleinbuchstaben und Bindestrichen |

264| `description` | Ja | Wann Claude an diesen Subagenten delegieren sollte |264| `description` | Ja | Wann Claude an diesen Subagenten delegieren sollte |

265| `tools` | Nein | [Werkzeuge](#available-tools), die der Subagent verwenden kann. Erbt alle Werkzeuge, wenn weggelassen |265| `tools` | Nein | [Werkzeuge](#available-tools), die der Subagent verwenden kann. Erbt alle Werkzeuge, wenn weggelassen. Um Skills in den Kontext zu laden, verwenden Sie das `skills`-Feld statt `Skill` hier aufzulisten |

267| `model` | Nein | [Modell](#choose-a-model) zu verwenden: `sonnet`, `opus`, `haiku`, eine vollständige Modell-ID (z. B. `claude-opus-4-7`) oder `inherit`. Standard ist `inherit` |267| `model` | Nein | [Modell](#choose-a-model) zu verwenden: `sonnet`, `opus`, `haiku`, eine vollständige Modell-ID (z. B. `claude-opus-4-7`) oder `inherit`. Standard ist `inherit` |

268| `permissionMode` | Nein | [Berechtigungsmodus](#permission-modes): `default`, `acceptEdits`, `auto`, `dontAsk`, `bypassPermissions` oder `plan`. Ignoriert für [Plugin-Subagenten](#choose-the-subagent-scope) |268| `permissionMode` | Nein | [Berechtigungsmodus](#permission-modes): `default`, `acceptEdits`, `auto`, `dontAsk`, `bypassPermissions` oder `plan`. Ignoriert für [Plugin-Subagenten](#choose-the-subagent-scope) |

270| `skills` | Nein | [Skills](/de/skills) zum Laden in den Kontext des Subagenten beim Start. Der vollständige Skill-Inhalt wird eingespritzt, nicht nur zur Invokation verfügbar gemacht. Subagenten erben keine Skills von der übergeordneten Konversation |270| `skills` | Nein | [Skills](/de/skills) zum Vorausladen in den Kontext des Subagenten beim Start. Der vollständige Skill-Inhalt wird eingespritzt, nicht nur die Beschreibung. Subagenten können weiterhin unlisted Projekt-, Benutzer- und Plugin-Skills durch das Skill-Werkzeug aufrufen |

271| `mcpServers` | Nein | [MCP-Server](/de/mcp) verfügbar für diesen Subagenten. Jeder Eintrag ist entweder ein Servername, der auf einen bereits konfigurierten Server verweist (z. B. `"slack"`) oder eine Inline-Definition mit dem Servernamen als Schlüssel und einer vollständigen [MCP-Server-Konfiguration](/de/mcp#installing-mcp-servers) als Wert. Ignoriert für [Plugin-Subagenten](#choose-the-subagent-scope) |271| `mcpServers` | Nein | [MCP-Server](/de/mcp) verfügbar für diesen Subagenten. Jeder Eintrag ist entweder ein Servername, der auf einen bereits konfigurierten Server verweist (z. B. `"slack"`) oder eine Inline-Definition mit dem Servernamen als Schlüssel und einer vollständigen [MCP-Server-Konfiguration](/de/mcp#installing-mcp-servers) als Wert. Ignoriert für [Plugin-Subagenten](#choose-the-subagent-scope) |

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

421Der vollständige Inhalt jedes Skills wird in den Kontext des Subagenten eingespritzt, nicht nur zur Invokation verfügbar gemacht. Subagenten erben keine Skills von der übergeordneten Konversation; Sie müssen sie explizit auflisten.421Der vollständige Inhalt jedes aufgelisteten Skills wird in den Kontext des Subagenten eingespritzt. Dieses Feld steuert, welche Skills vorausgeladen werden, nicht welche Skills der Subagent zugreifen kann: ohne es kann der Subagent weiterhin Projekt-, Benutzer- und Plugin-Skills durch das Skill-Werkzeug während der Ausführung entdecken und aufrufen. Um einen Subagenten daran zu hindern, Skills überhaupt aufzurufen, lassen Sie `Skill` aus der [`tools`](#available-tools)-Liste weg oder fügen Sie es zu `disallowedTools` hinzu.

422 422

423Sie können keine Skills vorausladen, die [`disable-model-invocation: true`](/de/skills#control-who-invokes-a-skill) setzen, da das Vorausladen aus demselben Satz von Skills stammt, die Claude aufrufen kann. Wenn ein aufgelisteter Skill fehlt oder deaktiviert ist, überspringt Claude Code ihn und protokolliert eine Warnung im Debug-Protokoll.423Sie können keine Skills vorausladen, die [`disable-model-invocation: true`](/de/skills#control-who-invokes-a-skill) setzen, da das Vorausladen aus demselben Satz von Skills stammt, die Claude aufrufen kann. Wenn ein aufgelisteter Skill fehlt oder deaktiviert ist, überspringt Claude Code ihn und protokolliert eine Warnung im Debug-Protokoll.

424 424

terminal-config.md +1 −1

Details

107set -as terminal-features 'xterm*:extkeys'107set -as terminal-features 'xterm*:extkeys'

108```108```

109 109

110Die `allow-passthrough`-Zeile ermöglicht es, dass Benachrichtigungen und Fortschrittsaktualisierungen iTerm2, Ghostty oder Kitty erreichen, anstatt von tmux verschluckt zu werden. Die `extended-keys`-Zeilen ermöglichen es tmux, Shift+Enter von einfachem Enter zu unterscheiden, sodass die Zeilenumbruch-Verknüpfung funktioniert.110Die `allow-passthrough`-Zeile ermöglicht es, dass Benachrichtigungen und Fortschrittsaktualisierungen das äußere Terminal erreichen, anstatt von tmux verschluckt zu werden. Die `extended-keys`-Zeilen ermöglichen es tmux, Shift+Enter von einfachem Enter zu unterscheiden, sodass die Zeilenumbruch-Verknüpfung funktioniert.

111 111

112## Passen Sie das Farbschema an112## Passen Sie das Farbschema an

113 113

third-party-integrations.md +73 −1

Details

6 6

7> Erfahren Sie, wie Claude Code mit verschiedenen Drittanbieterdiensten und Infrastrukturen integriert werden kann, um Enterprise-Bereitstellungsanforderungen zu erfüllen.7> Erfahren Sie, wie Claude Code mit verschiedenen Drittanbieterdiensten und Infrastrukturen integriert werden kann, um Enterprise-Bereitstellungsanforderungen zu erfüllen.

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

9Organisationen können Claude Code direkt über Anthropic oder über einen Cloud-Anbieter bereitstellen. Diese Seite hilft Ihnen, die richtige Konfiguration auszuwählen.79Organisationen können Claude Code direkt über Anthropic oder über einen Cloud-Anbieter bereitstellen. Diese Seite hilft Ihnen, die richtige Konfiguration auszuwählen.

10 80

81<ContactSalesCard surface="third_party_overview" />

11## Bereitstellungsoptionen vergleichen83## Bereitstellungsoptionen vergleichen

12 84

13Für die meisten Organisationen bieten Claude for Teams oder Claude for Enterprise die beste Erfahrung. Teammitglieder erhalten Zugriff auf sowohl Claude Code als auch Claude im Web mit einem einzigen Abonnement, zentralisierte Abrechnung und ohne erforderliche Infrastruktureinrichtung.85Für die meisten Organisationen bieten Claude for Teams oder Claude for Enterprise die beste Erfahrung. Teammitglieder erhalten Zugriff auf sowohl Claude Code als auch Claude im Web mit einem einzigen Abonnement, zentralisierte Abrechnung und ohne erforderliche Infrastruktureinrichtung.

241 313

242### Pinnen Sie Modellversionen für Cloud-Anbieter314### Pinnen Sie Modellversionen für Cloud-Anbieter

243 315

244Wenn Sie über [Bedrock](/de/amazon-bedrock), [Vertex AI](/de/google-vertex-ai) oder [Foundry](/de/microsoft-foundry) bereitstellen, pinnen Sie spezifische Modellversionen mit `ANTHROPIC_DEFAULT_OPUS_MODEL`, `ANTHROPIC_DEFAULT_SONNET_MODEL` und `ANTHROPIC_DEFAULT_HAIKU_MODEL`. Ohne Pinning werden Claude Code-Aliase zur neuesten Version aufgelöst, was Benutzer unterbrechen kann, wenn Anthropic ein neues Modell veröffentlicht, das noch nicht in Ihrem Konto aktiviert ist. Siehe [Modellkonfiguration](/de/model-config#pin-models-for-third-party-deployments) für Details.316Wenn Sie über [Bedrock](/de/amazon-bedrock), [Vertex AI](/de/google-vertex-ai) oder [Foundry](/de/microsoft-foundry) bereitstellen, pinnen Sie spezifische Modellversionen mit `ANTHROPIC_DEFAULT_OPUS_MODEL`, `ANTHROPIC_DEFAULT_SONNET_MODEL` und `ANTHROPIC_DEFAULT_HAIKU_MODEL`. Ohne Pinning werden Modellaliase zur neuesten Version aufgelöst, die möglicherweise noch nicht in Ihrem Konto aktiviert ist, wenn Anthropic ein Update veröffentlicht. Pinning ermöglicht es Ihnen, zu kontrollieren, wann Ihre Benutzer zu einem neuen Modell wechseln. Siehe [Modellkonfiguration](/de/model-config#pin-models-for-third-party-deployments) für Details zu dem, was jeder Anbieter tut, wenn die neueste Version nicht verfügbar ist.

245 317

246### Konfigurieren Sie Sicherheitsrichtlinien318### Konfigurieren Sie Sicherheitsrichtlinien

247 319

vs-code.md +3 −1

Details

32 32

33Oder drücken Sie in VS Code `Cmd+Shift+X` (Mac) oder `Ctrl+Shift+X` (Windows/Linux), um die Ansicht „Erweiterungen" zu öffnen, suchen Sie nach „Claude Code" und klicken Sie auf **Installieren**.33Oder drücken Sie in VS Code `Cmd+Shift+X` (Mac) oder `Ctrl+Shift+X` (Windows/Linux), um die Ansicht „Erweiterungen" zu öffnen, suchen Sie nach „Claude Code" und klicken Sie auf **Installieren**.

34 34

35Die Erweiterung wird auch in anderen VS Code-Forks wie Windsurf oder Kiro installiert. Suchen Sie nach „Claude Code" in der Ansicht „Erweiterungen" des Editors, oder installieren Sie aus der [Open VSX-Registrierung](https://open-vsx.org/extension/Anthropic/claude-code). Wenn Ihr Editor die Erweiterung nicht installieren kann, führen Sie stattdessen `claude` in seinem integrierten Terminal aus. Die [CLI](/de/quickstart) funktioniert in jedem Terminal.

35<Note>Wenn die Erweiterung nach der Installation nicht angezeigt wird, starten Sie VS Code neu oder führen Sie „Developer: Reload Window" aus der Befehlspalette aus.</Note>37<Note>Wenn die Erweiterung nach der Installation nicht angezeigt wird, starten Sie VS Code neu oder führen Sie „Developer: Reload Window" aus der Befehlspalette aus.</Note>

36 38

37## Erste Schritte39## Erste Schritte

318| `environmentVariables` | `[]` | Legen Sie Umgebungsvariablen für den Claude-Prozess fest. Verwenden Sie stattdessen Claude Code-Einstellungen für gemeinsame Konfiguration. |320| `environmentVariables` | `[]` | Legen Sie Umgebungsvariablen für den Claude-Prozess fest. Verwenden Sie stattdessen Claude Code-Einstellungen für gemeinsame Konfiguration. |

320| `allowDangerouslySkipPermissions` | `false` | Fügt [Auto-Modus](/de/permission-modes#eliminate-prompts-with-auto-mode) und Bypass-Berechtigungen zum Moduswahlschalter hinzu. Auto-Modus hat [Plan-, Admin-, Modell- und Anbieteranforderungen](/de/permission-modes#eliminate-prompts-with-auto-mode), daher bleibt die Option möglicherweise auch mit diesem Umschalter nicht verfügbar. Verwenden Sie Bypass-Berechtigungen nur in Sandboxes ohne Internetzugang. |322| `allowDangerouslySkipPermissions` | `false` | Fügt [Auto-Modus](/de/permission-modes#eliminate-prompts-with-auto-mode) und Bypass-Berechtigungen zum Moduswahlschalter hinzu. Auto-Modus hat [Plan-, Admin-, Modell- und Anbieteranforderungen](/de/permission-modes#eliminate-prompts-with-auto-mode), daher bleibt die Option möglicherweise auch mit diesem Umschalter nicht verfügbar. Verwenden Sie Bypass-Berechtigungen nur in Sandboxes ohne Internetzugang. |

321| `claudeProcessWrapper` | - | Ausführbarer Pfad, der zum Starten des Claude-Prozesses verwendet wird |323| `claudeProcessWrapper` | - | Ausführbare Datei, die zum Starten des Claude-Prozesses verwendet wird. Der Pfad der gebündelten Binärdatei wird als Argument übergeben, wenn vorhanden. Setzen Sie dies auf eine separat installierte `claude`-Binärdatei, wenn der Erweiterungsbuild keine für Ihre Plattform enthält. |

322 324

323## VS Code-Erweiterung vs. Claude Code CLI325## VS Code-Erweiterung vs. Claude Code CLI

324 326

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