6 6
7> Erstellen Sie produktive KI-Agenten mit Claude Code als Bibliothek7> Erstellen Sie produktive KI-Agenten mit Claude Code als Bibliothek
8 8
9Erstellen Sie KI-Agenten, die autonom Dateien lesen, Befehle ausführen, das Web durchsuchen, Code bearbeiten und vieles mehr. Das Agent SDK bietet Ihnen die gleichen Tools, die Agent-Schleife und das Kontextmanagement, die Claude Code antreiben, programmierbar in Python und TypeScript. Informationen zur Überlegung hinter dem Agent-Harness-Design finden Sie unter [A harness for every task: dynamic workflows in Claude Code](https://claude.com/blog/a-harness-for-every-task-dynamic-workflows-in-claude-code) im Blog.9Ein Agent ist eine Anwendung, die eine Aufgabe durch Planung eigener Schritte und Aufrufen von Tools abschließt, die Dateien lesen, Befehle ausführen oder Code bearbeiten. Das Agent SDK bietet Ihnen die gleichen Tools, die [Agent-Schleife](/docs/de/agent-sdk/agent-loop) und das Kontextmanagement, die Claude Code antreiben, programmierbar in Python und TypeScript.
10 10
11<CodeGroup>11<h2 id="compare-the-agent-sdk-to-other-claude-tools">
12 ```python Python theme={null}12 Vergleichen Sie das Agent SDK mit anderen Claude-Tools
13 import asyncio
14 from claude_agent_sdk import query, ClaudeAgentOptions
15
16
17 async def main():
18 async for message in query(
19 prompt="Find and fix the bug in auth.py",
20 options=ClaudeAgentOptions(allowed_tools=["Read", "Edit", "Bash"]),
21 ):
22 print(message) # Claude reads the file, finds the bug, edits it
23
24
25 asyncio.run(main())
26 ```
27
28 ```typescript TypeScript theme={null}
29 import { query } from "@anthropic-ai/claude-agent-sdk";
30
31 for await (const message of query({
32 prompt: "Find and fix the bug in auth.ts",
33 options: { allowedTools: ["Read", "Edit", "Bash"] }
34 })) {
35 console.log(message); // Claude reads the file, finds the bug, edits it
36 }
37 ```
38</CodeGroup>
39
40Das Agent SDK enthält integrierte Tools zum Lesen von Dateien, Ausführen von Befehlen und Bearbeiten von Code, sodass Ihr Agent sofort arbeiten kann, ohne dass Sie die Tool-Ausführung implementieren müssen. Tauchen Sie in den Schnellstart ein oder erkunden Sie echte Agenten, die mit dem SDK erstellt wurden:
41
42<CardGroup cols={2}>
43 <Card title="Schnellstart" icon="play" href="/de/agent-sdk/quickstart">
44 Erstellen Sie einen Fehlerbereinigungsagenten in wenigen Minuten
45 </Card>
46
47 <Card title="Beispielagenten" icon="star" href="https://github.com/anthropics/claude-agent-sdk-demos">
48 E-Mail-Assistent, Forschungsagent und mehr
49 </Card>
50</CardGroup>
51
52<h2 id="get-started">
53 Erste Schritte
54</h2>13</h2>
55 14
56<Steps>15Das Agent SDK, die CLI, das Client SDK und Managed Agents erfüllen jeweils unterschiedliche Anforderungen. Verwenden Sie die Tabelle, um das Tool zu finden, das zu Ihrem Projekt passt.
57 <Step title="Installieren Sie das SDK">
58 <Tabs>
59 <Tab title="TypeScript">
60 ```bash theme={null}
61 npm install @anthropic-ai/claude-agent-sdk
62 ```
63 </Tab>
64
65 <Tab title="Python (uv)">
66 [uv](https://docs.astral.sh/uv/) ist ein schneller Python-Paketmanager, der virtuelle Umgebungen automatisch verwaltet:
67
68 ```bash theme={null}
69 uv init
70 uv add claude-agent-sdk
71 ```
72 </Tab>
73
74 <Tab title="Python (pip)">
75 Erstellen und aktivieren Sie eine virtuelle Umgebung und installieren Sie dann das Paket. Die Installation in einer virtuellen Umgebung vermeidet den Fehler `error: externally-managed-environment`, den System-Python bei neueren Debian-, Ubuntu- und Homebrew-Installationen für `pip install` außerhalb einer venv zurückgibt.
76
77 Auf macOS oder Linux:
78
79 ```bash theme={null}
80 python3 -m venv .venv
81 source .venv/bin/activate
82 pip install claude-agent-sdk
83 ```
84
85 Auf Windows:
86
87 ```powershell theme={null}
88 py -m venv .venv
89 .venv\Scripts\Activate.ps1
90 pip install claude-agent-sdk
91 ```
92
93 Wenn PowerShell `Activate.ps1` mit einem Ausführungsrichtlinienfehler blockiert, führen Sie zuerst `Set-ExecutionPolicy -Scope Process RemoteSigned` aus.
94
95 Das Python-Paket erfordert Python 3.10 oder später. Wenn pip `No matching distribution found for claude-agent-sdk` meldet, ist Ihr Interpreter älter als 3.10. Führen Sie `python3 --version` auf macOS oder Linux oder `py --version` auf Windows aus, um dies zu überprüfen.
96 </Tab>
97 </Tabs>
98
99 <Note>
100 Das TypeScript SDK bündelt eine native Claude Code-Binärdatei für Ihre Plattform als optionale Abhängigkeit, sodass Sie Claude Code nicht separat installieren müssen.
101 </Note>
102 </Step>
103
104 <Step title="Legen Sie Ihren API-Schlüssel fest">
105 Rufen Sie einen API-Schlüssel aus der [Konsole](https://platform.claude.com/) ab und legen Sie ihn als Umgebungsvariable fest.
106
107 Auf macOS oder Linux:
108
109 ```bash theme={null}
110 export ANTHROPIC_API_KEY=sk-ant-xxxxx
111 ```
112
113 Auf Windows PowerShell:
114
115 ```powershell theme={null}
116 $env:ANTHROPIC_API_KEY = "sk-ant-xxxxx"
117 ```
118
119 Das SDK unterstützt auch Authentifizierung über Drittanbieter-API-Anbieter:
120
121 * **Amazon Bedrock**: Setzen Sie die Umgebungsvariable `CLAUDE_CODE_USE_BEDROCK=1` und konfigurieren Sie AWS-Anmeldedaten
122 * **Claude Platform on AWS**: Setzen Sie `CLAUDE_CODE_USE_ANTHROPIC_AWS=1` und `ANTHROPIC_AWS_WORKSPACE_ID` und konfigurieren Sie AWS-Anmeldedaten
123 * **Google Cloud's Agent Platform**: Setzen Sie die Umgebungsvariable `CLAUDE_CODE_USE_VERTEX=1` und konfigurieren Sie Google Cloud-Anmeldedaten
124 * **Microsoft Azure**: Setzen Sie die Umgebungsvariable `CLAUDE_CODE_USE_FOUNDRY=1` und konfigurieren Sie Azure-Anmeldedaten
125
126 Weitere Informationen finden Sie in den Einrichtungsleitfäden für [Amazon Bedrock](/de/amazon-bedrock), [Claude Platform on AWS](/de/claude-platform-on-aws), [Google Cloud's Agent Platform](/de/google-vertex-ai) oder [Microsoft Foundry](/de/microsoft-foundry).
127
128 <Note>
129 Sofern nicht zuvor genehmigt, erlaubt Anthropic Drittentwicklern nicht, claude.ai-Anmeldungen oder Ratenlimits für ihre Produkte anzubieten, einschließlich Agenten, die auf dem Claude Agent SDK basieren. Verwenden Sie stattdessen die in diesem Dokument beschriebenen API-Schlüssel-Authentifizierungsmethoden.
130 </Note>
131 </Step>
132 16
133 <Step title="Führen Sie Ihren ersten Agenten aus">17| Wenn Sie... | Verwenden Sie | Warum |
134 Dieses Beispiel erstellt einen Agenten, der Dateien in Ihrem aktuellen Verzeichnis mit integrierten Tools auflistet.18| ------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------- |
19| Einen Agenten erstellen, ohne die Tool-Schleife selbst zu implementieren | **Agent SDK** | Eine Bibliothek, die die Agent-Schleife in Ihrem eigenen Prozess in Python oder TypeScript ausführt. |
20| Interaktive Entwicklung durchführen oder einmalige Aufgaben von einem Terminal aus ausführen | [**Claude Code CLI**](/docs/de/overview) | Die Terminal-Schnittstelle, entwickelt für tägliche interaktive Nutzung. |
21| Die API direkt aufrufen und die Tool-Schleife selbst implementieren | [**Client SDK**](https://platform.claude.com/docs/en/api/client-sdks) | Direkter Zugriff auf die Anthropic API statt auf Claude Code. Sie implementieren die Tool-Schleife selbst. |
22| Langfristig laufende oder asynchrone Agenten ausführen, ohne Ihre eigene Sandbox oder Session-Infrastruktur zu verwalten | [**Managed Agents**](https://platform.claude.com/docs/en/managed-agents/overview) | Gehostete REST API, ein separates Produkt vom Agent SDK. Anthropic führt den Agenten und die Sandbox aus. |
135 23
136 <CodeGroup>24Das SDK ist nur als Bibliothek für Python und TypeScript verfügbar. Um die gleiche Agent-Schleife aus einer anderen Sprache zu steuern, [führen Sie die CLI als Unterprozess aus](/docs/de/headless) mit dem Flag `-p` und `--output-format json`.
137 ```python Python theme={null}
138 import asyncio
139 from claude_agent_sdk import query, ClaudeAgentOptions
140
141
142 async def main():
143 async for message in query(
144 prompt="What files are in this directory?",
145 options=ClaudeAgentOptions(allowed_tools=["Bash", "Glob"]),
146 ):
147 if hasattr(message, "result"):
148 print(message.result)
149
150
151 asyncio.run(main())
152 ```
153
154 ```typescript TypeScript theme={null}
155 import { query } from "@anthropic-ai/claude-agent-sdk";
156
157 for await (const message of query({
158 prompt: "What files are in this directory?",
159 options: { allowedTools: ["Bash", "Glob"] }
160 })) {
161 if ("result" in message) console.log(message.result);
162 }
163 ```
164 </CodeGroup>
165 </Step>
166</Steps>
167
168**Bereit zum Erstellen?** Folgen Sie dem [Schnellstart](/de/agent-sdk/quickstart), um einen Agenten zu erstellen, der Fehler in wenigen Minuten findet und behebt.
169 25
170<h2 id="capabilities">26<h2 id="capabilities">
171 Funktionen27 Funktionen
172</h2>28</h2>
173 29
174Alles, was Claude Code leistungsstark macht, ist im SDK verfügbar:30Diese Claude Code-Funktionen sind im SDK verfügbar:
175
176<Tabs>
177 <Tab title="Integrierte Tools">
178 Ihr Agent kann Dateien lesen, Befehle ausführen und Codebases sofort durchsuchen. Wichtige Tools sind:
179
180 | Tool | Was es tut |
181 | --------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------- |
182 | **Read** | Lesen Sie jede Datei im Arbeitsverzeichnis |
183 | **Write** | Erstellen Sie neue Dateien |
184 | **Edit** | Nehmen Sie präzise Änderungen an vorhandenen Dateien vor |
185 | **Bash** | Führen Sie Terminalbefehle, Skripte und Git-Operationen aus |
186 | **Monitor** | Überwachen Sie ein Hintergrundskript und reagieren Sie auf jede Ausgabezeile als Ereignis |
187 | **Glob** | Suchen Sie Dateien nach Muster (`**/*.ts`, `src/**/*.py`) |
188 | **Grep** | Durchsuchen Sie Dateiinhalte mit Regex |
189 | **WebSearch** | Durchsuchen Sie das Web nach aktuellen Informationen |
190 | **WebFetch** | Rufen Sie Webseiteninhalte ab und analysieren Sie sie |
191 | **[AskUserQuestion](/de/agent-sdk/user-input#handle-clarifying-questions)** | Stellen Sie dem Benutzer Klärungsfragen mit Mehrfachauswahloptionen |
192
193 Dieses Beispiel erstellt einen Agenten, der Ihre Codebasis nach TODO-Kommentaren durchsucht:
194
195 <CodeGroup>
196 ```python Python theme={null}
197 import asyncio
198 from claude_agent_sdk import query, ClaudeAgentOptions
199
200
201 async def main():
202 async for message in query(
203 prompt="Find all TODO comments and create a summary",
204 options=ClaudeAgentOptions(allowed_tools=["Read", "Glob", "Grep"]),
205 ):
206 if hasattr(message, "result"):
207 print(message.result)
208
209
210 asyncio.run(main())
211 ```
212
213 ```typescript TypeScript theme={null}
214 import { query } from "@anthropic-ai/claude-agent-sdk";
215
216 for await (const message of query({
217 prompt: "Find all TODO comments and create a summary",
218 options: { allowedTools: ["Read", "Glob", "Grep"] }
219 })) {
220 if ("result" in message) console.log(message.result);
221 }
222 ```
223 </CodeGroup>
224 </Tab>
225
226 <Tab title="Hooks">
227 Führen Sie benutzerdefinierten Code an wichtigen Punkten im Agent-Lebenszyklus aus. SDK-Hooks verwenden Callback-Funktionen, um Agent-Verhalten zu validieren, zu protokollieren, zu blockieren oder zu transformieren.
228
229 **Verfügbare Hooks:** `PreToolUse`, `PostToolUse`, `Stop`, `SessionStart`, `SessionEnd`, `UserPromptSubmit` und mehr.
230
231 Dieses Beispiel protokolliert alle Dateiänderungen in einer Audit-Datei:
232
233 <CodeGroup>
234 ```python Python theme={null}
235 import asyncio
236 from datetime import datetime
237 from claude_agent_sdk import query, ClaudeAgentOptions, HookMatcher
238
239
240 async def log_file_change(input_data, tool_use_id, context):
241 file_path = input_data.get("tool_input", {}).get("file_path", "unknown")
242 with open("./audit.log", "a") as f:
243 f.write(f"{datetime.now()}: modified {file_path}\n")
244 return {}
245
246
247 async def main():
248 async for message in query(
249 prompt="Refactor utils.py to improve readability",
250 options=ClaudeAgentOptions(
251 permission_mode="acceptEdits",
252 hooks={
253 "PostToolUse": [
254 HookMatcher(matcher="Edit|Write", hooks=[log_file_change])
255 ]
256 },
257 ),
258 ):
259 if hasattr(message, "result"):
260 print(message.result)
261
262
263 asyncio.run(main())
264 ```
265
266 ```typescript TypeScript theme={null}
267 import { query, HookCallback } from "@anthropic-ai/claude-agent-sdk";
268 import { appendFile } from "fs/promises";
269
270 const logFileChange: HookCallback = async (input) => {
271 const filePath = (input as any).tool_input?.file_path ?? "unknown";
272 await appendFile("./audit.log", `${new Date().toISOString()}: modified ${filePath}\n`);
273 return {};
274 };
275
276 for await (const message of query({
277 prompt: "Refactor utils.py to improve readability",
278 options: {
279 permissionMode: "acceptEdits",
280 hooks: {
281 PostToolUse: [{ matcher: "Edit|Write", hooks: [logFileChange] }]
282 }
283 }
284 })) {
285 if ("result" in message) console.log(message.result);
286 }
287 ```
288 </CodeGroup>
289
290 [Weitere Informationen zu Hooks →](/de/agent-sdk/hooks)
291 </Tab>
292
293 <Tab title="Subagenten">
294 Spawnen Sie spezialisierte Agenten, um fokussierte Teilaufgaben zu bewältigen. Ihr Hauptagent delegiert Arbeit, und Subagenten berichten mit Ergebnissen zurück.
295 31
296 Definieren Sie benutzerdefinierte Agenten mit spezialisierten Anweisungen. Subagenten werden über das Agent-Tool aufgerufen, daher fügen Sie `Agent` in `allowedTools` ein, um diese Aufrufe automatisch zu genehmigen:32| Funktion | Was es tut | Weitere Informationen |
33| -------------------------- | -------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
34| Integrierte Tools | Dateien lesen, schreiben, bearbeiten, Befehle ausführen und das Web durchsuchen | [Tools-Referenz](/docs/de/tools-reference) |
35| Hooks | Benutzerdefinierten Code an wichtigen Punkten im Agent-Lebenszyklus ausführen | [Hooks](/docs/de/agent-sdk/hooks) |
36| Subagenten | Spezialisierte Agenten für fokussierte Teilaufgaben spawnen | [Subagenten](/docs/de/agent-sdk/subagents) |
37| MCP | Externe Tools und Datenquellen über das Model Context Protocol verbinden | [MCP](/docs/de/agent-sdk/mcp) |
38| Berechtigungen | Kontrollieren, welche Tools automatisch ausgeführt werden, welche Genehmigung benötigen | [Berechtigungen](/docs/de/agent-sdk/permissions) |
39| Sitzungen | Kontext über mehrere Austausche hinweg beibehalten, später fortsetzen oder verzweigen | [Sitzungen](/docs/de/agent-sdk/sessions) |
40| Skills, Befehle und Memory | Automatisch aus dem `.claude/`-Verzeichnis Ihres Projekts und aus `~/.claude/` laden, wie in Claude Code | [Skills](/docs/de/agent-sdk/skills), [Befehle](/docs/de/agent-sdk/skills#commands-in-agent-sdk-sessions), [Memory](/docs/de/agent-sdk/modifying-system-prompts), [Konfigurationsladung](/docs/de/agent-sdk/claude-code-features) |
41| Plugins | Skills, Agenten, Hooks und MCP-Server verpacken und nach lokalem Pfad laden | [Plugins](/docs/de/agent-sdk/plugins) |
297 42
298 <CodeGroup>43<h2 id="get-started">
299 ```python Python theme={null}44 Erste Schritte
300 import asyncio
301 from claude_agent_sdk import query, ClaudeAgentOptions, AgentDefinition
302
303
304 async def main():
305 async for message in query(
306 prompt="Use the code-reviewer agent to review this codebase",
307 options=ClaudeAgentOptions(
308 allowed_tools=["Read", "Glob", "Grep", "Agent"],
309 agents={
310 "code-reviewer": AgentDefinition(
311 description="Expert code reviewer for quality and security reviews.",
312 prompt="Analyze code quality and suggest improvements.",
313 tools=["Read", "Glob", "Grep"],
314 )
315 },
316 ),
317 ):
318 if hasattr(message, "result"):
319 print(message.result)
320
321
322 asyncio.run(main())
323 ```
324
325 ```typescript TypeScript theme={null}
326 import { query } from "@anthropic-ai/claude-agent-sdk";
327
328 for await (const message of query({
329 prompt: "Use the code-reviewer agent to review this codebase",
330 options: {
331 allowedTools: ["Read", "Glob", "Grep", "Agent"],
332 agents: {
333 "code-reviewer": {
334 description: "Expert code reviewer for quality and security reviews.",
335 prompt: "Analyze code quality and suggest improvements.",
336 tools: ["Read", "Glob", "Grep"]
337 }
338 }
339 }
340 })) {
341 if ("result" in message) console.log(message.result);
342 }
343 ```
344 </CodeGroup>
345
346 Nachrichten aus dem Kontext eines Subagenten enthalten ein `parent_tool_use_id`-Feld, mit dem Sie verfolgen können, welche Nachrichten zu welcher Subagenten-Ausführung gehören.
347
348 [Weitere Informationen zu Subagenten →](/de/agent-sdk/subagents)
349 </Tab>
350
351 <Tab title="MCP">
352 Verbinden Sie sich mit externen Systemen über das Model Context Protocol: Datenbanken, Browser, APIs und [hunderte mehr](https://github.com/modelcontextprotocol/servers).
353
354 Dieses Beispiel verbindet den [Playwright MCP-Server](https://github.com/microsoft/playwright-mcp), um Ihrem Agenten Browser-Automatisierungsfunktionen zu geben:
355
356 <CodeGroup>
357 ```python Python theme={null}
358 import asyncio
359 from claude_agent_sdk import query, ClaudeAgentOptions
360
361
362 async def main():
363 async for message in query(
364 prompt="Open example.com and describe what you see",
365 options=ClaudeAgentOptions(
366 mcp_servers={
367 "playwright": {"command": "npx", "args": ["@playwright/mcp@latest"]}
368 }
369 ),
370 ):
371 if hasattr(message, "result"):
372 print(message.result)
373
374
375 asyncio.run(main())
376 ```
377
378 ```typescript TypeScript theme={null}
379 import { query } from "@anthropic-ai/claude-agent-sdk";
380
381 for await (const message of query({
382 prompt: "Open example.com and describe what you see",
383 options: {
384 mcpServers: {
385 playwright: { command: "npx", args: ["@playwright/mcp@latest"] }
386 }
387 }
388 })) {
389 if ("result" in message) console.log(message.result);
390 }
391 ```
392 </CodeGroup>
393
394 [Weitere Informationen zu MCP →](/de/agent-sdk/mcp)
395 </Tab>
396
397 <Tab title="Berechtigungen">
398 Kontrollieren Sie genau, welche Tools Ihr Agent verwenden kann. Erlauben Sie sichere Operationen, blockieren Sie gefährliche oder erfordern Sie Genehmigung für sensible Aktionen.
399
400 <Note>
401 Für interaktive Genehmigungseingabeaufforderungen und das `AskUserQuestion`-Tool siehe [Genehmigungen und Benutzereingaben verarbeiten](/de/agent-sdk/user-input).
402 </Note>
403
404 Dieses Beispiel erstellt einen schreibgeschützten Agenten, der Code analysieren, aber nicht ändern kann. `allowed_tools` genehmigt `Read`, `Glob` und `Grep` vorab.
405
406 <CodeGroup>
407 ```python Python theme={null}
408 import asyncio
409 from claude_agent_sdk import query, ClaudeAgentOptions
410
411
412 async def main():
413 async for message in query(
414 prompt="Review this code for best practices",
415 options=ClaudeAgentOptions(
416 allowed_tools=["Read", "Glob", "Grep"],
417 ),
418 ):
419 if hasattr(message, "result"):
420 print(message.result)
421
422
423 asyncio.run(main())
424 ```
425
426 ```typescript TypeScript theme={null}
427 import { query } from "@anthropic-ai/claude-agent-sdk";
428
429 for await (const message of query({
430 prompt: "Review this code for best practices",
431 options: {
432 allowedTools: ["Read", "Glob", "Grep"]
433 }
434 })) {
435 if ("result" in message) console.log(message.result);
436 }
437 ```
438 </CodeGroup>
439
440 [Weitere Informationen zu Berechtigungen →](/de/agent-sdk/permissions)
441 </Tab>
442
443 <Tab title="Sitzungen">
444 Behalten Sie den Kontext über mehrere Austausche hinweg bei. Claude merkt sich gelesene Dateien, durchgeführte Analysen und Gesprächsverlauf. Setzen Sie Sitzungen später fort oder verzweigen Sie sie, um verschiedene Ansätze zu erkunden.
445
446 Dieses Beispiel erfasst die Sitzungs-ID aus der ersten Abfrage und setzt sie dann fort, um mit vollständigem Kontext fortzufahren:
447
448 <CodeGroup>
449 ```python Python theme={null}
450 import asyncio
451 from claude_agent_sdk import query, ClaudeAgentOptions, SystemMessage, ResultMessage
452
453
454 async def main():
455 session_id = None
456
457 # First query: capture the session ID
458 async for message in query(
459 prompt="Read the authentication module",
460 options=ClaudeAgentOptions(allowed_tools=["Read", "Glob"]),
461 ):
462 if isinstance(message, SystemMessage) and message.subtype == "init":
463 session_id = message.data["session_id"]
464
465 # Resume with full context from the first query
466 async for message in query(
467 prompt="Now find all places that call it", # "it" = auth module
468 options=ClaudeAgentOptions(resume=session_id),
469 ):
470 if isinstance(message, ResultMessage):
471 print(message.result)
472
473
474 asyncio.run(main())
475 ```
476
477 ```typescript TypeScript theme={null}
478 import { query } from "@anthropic-ai/claude-agent-sdk";
479
480 let sessionId: string | undefined;
481
482 // First query: capture the session ID
483 for await (const message of query({
484 prompt: "Read the authentication module",
485 options: { allowedTools: ["Read", "Glob"] }
486 })) {
487 if (message.type === "system" && message.subtype === "init") {
488 sessionId = message.session_id;
489 }
490 }
491
492 // Resume with full context from the first query
493 for await (const message of query({
494 prompt: "Now find all places that call it", // "it" = auth module
495 options: { resume: sessionId }
496 })) {
497 if ("result" in message) console.log(message.result);
498 }
499 ```
500 </CodeGroup>
501
502 [Weitere Informationen zu Sitzungen →](/de/agent-sdk/sessions)
503 </Tab>
504</Tabs>
505
506<h3 id="claude-code-features">
507 Claude Code-Funktionen
508</h3>
509
510Das SDK unterstützt auch die dateisystembasierte Konfiguration von Claude Code. Mit Standardoptionen lädt das SDK diese aus `.claude/` in Ihrem Arbeitsverzeichnis und `~/.claude/`. Um einzuschränken, welche Quellen geladen werden, setzen Sie `setting_sources` (Python) oder `settingSources` (TypeScript) in Ihren Optionen.
511
512| Funktion | Beschreibung | Speicherort |
513| ------------------------------------------------ | ----------------------------------------------------------------------------------------------------- | --------------------------------------- |
514| [Skills](/de/agent-sdk/skills) | Spezialisierte Funktionen, die Claude automatisch verwendet oder die Sie mit `/name` aufrufen | `.claude/skills/*/SKILL.md` |
515| [Befehle](/de/agent-sdk/slash-commands) | Benutzerdefinierte Befehle im Legacy-Format. Verwenden Sie Skills für neue benutzerdefinierte Befehle | `.claude/commands/*.md` |
516| [Memory](/de/agent-sdk/modifying-system-prompts) | Projektkontext und Anweisungen | `CLAUDE.md` oder `.claude/CLAUDE.md` |
517| [Plugins](/de/agent-sdk/plugins) | Erweitern Sie mit Skills, Agenten, Hooks und MCP-Servern | Programmgesteuert über `plugins`-Option |
518
519<h2 id="compare-the-agent-sdk-to-other-claude-tools">
520 Vergleichen Sie das Agent SDK mit anderen Claude-Tools
521</h2>45</h2>
522 46
523Die Claude-Plattform bietet mehrere Möglichkeiten, mit Claude zu erstellen. So passt das Agent SDK:47Folgen Sie der [Schnellstartanleitung](/docs/de/agent-sdk/quickstart), um das SDK zu installieren, Ihren API-Schlüssel festzulegen und Ihren ersten Agent zu erstellen – einen, der Fehler in vorhandenem Code findet und behebt.
524
525<Tabs>
526 <Tab title="Agent SDK vs Client SDK">
527 Das [Anthropic Client SDK](https://platform.claude.com/docs/de/api/client-sdks) bietet Ihnen direkten API-Zugriff: Sie senden Eingabeaufforderungen und implementieren die Tool-Ausführung selbst. Das **Agent SDK** bietet Ihnen Claude mit integrierter Tool-Ausführung.
528
529 Mit dem Client SDK implementieren Sie eine Tool-Schleife. Mit dem Agent SDK handhabt Claude es:
530
531 <CodeGroup>
532 ```python Python theme={null}
533 # Client SDK: You implement the tool loop
534 response = client.messages.create(...)
535 while response.stop_reason == "tool_use":
536 result = your_tool_executor(response.tool_use)
537 response = client.messages.create(tool_result=result, **params)
538
539 # Agent SDK: Claude handles tools autonomously
540 async for message in query(prompt="Fix the bug in auth.py"):
541 print(message)
542 ```
543
544 ```typescript TypeScript theme={null}
545 // Client SDK: You implement the tool loop
546 let response = await client.messages.create({ ...params });
547 while (response.stop_reason === "tool_use") {
548 const result = yourToolExecutor(response.tool_use);
549 response = await client.messages.create({ tool_result: result, ...params });
550 }
551 48
552 // Agent SDK: Claude handles tools autonomously49<Note>
553 for await (const message of query({ prompt: "Fix the bug in auth.ts" })) {50 Sofern nicht vorher genehmigt, erlaubt Anthropic Drittentwicklern nicht, claude.ai-Anmeldungen oder Ratenlimits für ihre Produkte anzubieten, einschließlich Agents, die auf dem Claude Agent SDK basieren. Verwenden Sie stattdessen die in der [Schnellstartanleitung](/docs/de/agent-sdk/quickstart) beschriebenen API-Schlüssel-Authentifizierungsmethoden.
554 console.log(message);51</Note>
555 }
556 ```
557 </CodeGroup>
558 </Tab>
559
560 <Tab title="Agent SDK vs Claude Code CLI">
561 Gleiche Funktionen, andere Schnittstelle:
562
563 | Anwendungsfall | Beste Wahl |
564 | ------------------------------ | ---------- |
565 | Interaktive Entwicklung | CLI |
566 | CI/CD-Pipelines | SDK |
567 | Benutzerdefinierte Anwendungen | SDK |
568 | Einmalige Aufgaben | CLI |
569 | Produktionsautomatisierung | SDK |
570
571 Viele Teams verwenden beide: CLI für die tägliche Entwicklung, SDK für die Produktion. Workflows lassen sich direkt zwischen ihnen übersetzen.
572 </Tab>
573
574 <Tab title="Agent SDK vs Managed Agents">
575 [Managed Agents](https://platform.claude.com/docs/de/managed-agents/overview) ist eine gehostete REST-API: Anthropic führt den Agent und die Sandbox aus, und Ihre Anwendung sendet Ereignisse und streamt Ergebnisse zurück. Das **Agent SDK** ist eine Bibliothek, die die Agent-Schleife in Ihrem eigenen Prozess ausführt.
576
577 | | Agent SDK | Managed Agents |
578 | ---------------------------- | --------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------- |
579 | **Läuft in** | Ihr Prozess, Ihre Infrastruktur | Von Anthropic verwaltete Infrastruktur |
580 | **Schnittstelle** | Python- oder TypeScript-Bibliothek | REST-API |
581 | **Agent arbeitet an** | Dateien in Ihrer Infrastruktur | Eine verwaltete Sandbox pro Sitzung |
582 | **Sitzungsstatus** | JSONL auf Ihrem Dateisystem | Von Anthropic gehostetes Ereignisprotokoll |
583 | **Benutzerdefinierte Tools** | In-Process-Python- oder TypeScript-Funktionen | Claude löst das Tool aus; Sie führen es aus und geben Ergebnisse zurück |
584 | **Am besten für** | Lokale Prototypisierung, Agents, die direkt auf Ihrem Dateisystem und Ihren Diensten arbeiten | Produktions-Agents ohne Betrieb von Sandbox- oder Sitzungsinfrastruktur, langfristige und asynchrone Sitzungen |
585
586 Ein häufiger Weg ist die Prototypisierung mit dem Agent SDK lokal und dann der Wechsel zu Managed Agents für die Produktion.
587 </Tab>
588</Tabs>
589 52
590<h2 id="changelog">53<h2 id="changelog">
591 Änderungsprotokoll54 Änderungsprotokoll
596* **TypeScript SDK**: [CHANGELOG.md anzeigen](https://github.com/anthropics/claude-agent-sdk-typescript/blob/main/CHANGELOG.md)59* **TypeScript SDK**: [CHANGELOG.md anzeigen](https://github.com/anthropics/claude-agent-sdk-typescript/blob/main/CHANGELOG.md)
597* **Python SDK**: [CHANGELOG.md anzeigen](https://github.com/anthropics/claude-agent-sdk-python/blob/main/CHANGELOG.md)60* **Python SDK**: [CHANGELOG.md anzeigen](https://github.com/anthropics/claude-agent-sdk-python/blob/main/CHANGELOG.md)
598 61
599<h2 id="reporting-bugs">62<h2 id="report-bugs">
600 Fehler melden63 Fehler melden
601</h2>64</h2>
602 65
634 Nächste Schritte97 Nächste Schritte
635</h2>98</h2>
636 99
637<CardGroup cols={2}>100Diese Ressourcen behandeln tiefere technische Details und Beispielprojekte für die Entwicklung mit dem Agent SDK.
638 <Card title="Schnellstart" icon="play" href="/de/agent-sdk/quickstart">
639 Erstellen Sie einen Agenten, der Fehler in wenigen Minuten findet und behebt
640 </Card>
641
642 <Card title="Beispielagenten" icon="star" href="https://github.com/anthropics/claude-agent-sdk-demos">
643 E-Mail-Assistent, Forschungsagent und mehr
644 </Card>
645
646 <Card title="TypeScript SDK" icon="code" href="/de/agent-sdk/typescript">
647 Vollständige TypeScript-API-Referenz und Beispiele
648 </Card>
649 101
650 <Card title="Python SDK" icon="code" href="/de/agent-sdk/python">102* [Schnellstart](/docs/de/agent-sdk/quickstart): Erstellen Sie Ihren ersten Agenten, der Fehler findet und behebt
651 Vollständige Python-API-Referenz und Beispiele103* [Migrationsleitfaden](/docs/de/agent-sdk/migration-guide): Migrieren Sie von den Claude Code SDK-Paketen zum Agent SDK
652 </Card>104* [Agent-Schleife](/docs/de/agent-sdk/agent-loop): Wie Claude plant, Tools aufruft und entscheidet, wann eine Aufgabe abgeschlossen ist
653</CardGroup>105* [Beispielagenten](https://github.com/anthropics/claude-agent-sdk-demos): Demo-Apps für die lokale Entwicklung
106* [TypeScript SDK](/docs/de/agent-sdk/typescript): Vollständige TypeScript-API-Referenz und Beispiele
107* [Python SDK](/docs/de/agent-sdk/python): Vollständige Python-API-Referenz und Beispiele
108* [Agent-Harness-Design](https://claude.com/blog/a-harness-for-every-task-dynamic-workflows-in-claude-code): Wie das Claude Code-Team dynamische Workflows verwendet, um viele Subagenten gleichzeitig zu orchestrieren
