Claude Code Masterkurs – KI-gestuetztes Programmieren lernen mit Anthropics Coding-Agent

Claude Agent SDK

Level 3 | 40 Minuten

Eigene autonome AI-Agents mit dem Agent SDK bauen und deployen

Lernziele

Was ist das Claude Agent SDK?

Das Claude Agent SDK ist die Programmier-Schnittstelle mit der du eigene autonome KI-Agents als eigenständige Programme bauen kannst — unabhängig von der Claude Code CLI. Stell dir vor, Claude Code ist ein fertiges Auto das du fährst. Das Agent SDK ist der Bausatz mit dem du dein eigenes Auto konstruierst. Mit dem SDK kannst du Agents bauen die in eigenen Anwendungen laufen: Eine Desktop-App die automatisch E-Mails beantwortet, ein Backend-Service der Kundenanfragen analysiert, ein CLI-Tool das deinen speziellen Workflow automatisiert, oder ein Slack-Bot der Code-Reviews durchführt. Der Unterschied zu Claude Code: Claude Code ist ein FERTIGES Tool das du konfigurierst und nutzt. Das Agent SDK ist ein FRAMEWORK mit dem du dein eigenes Tool baust. Claude Code nutzt intern das Agent SDK — du kannst damit also Dinge bauen die genauso mächtig sind wie Claude Code selbst, aber für deinen spezifischen Anwendungsfall maßgeschneidert. Das SDK ist verfügbar für TypeScript/JavaScript und Python. Es bietet: Model-Kommunikation (Messages an Claude senden und Antworten empfangen), Tool-Definition (eigene Funktionen die der Agent aufrufen kann), Subagent-Management (weitere Agents spawnen und koordinieren), MCP-Integration (bestehende MCP Server einbinden), und Context-Management (Kontext kontrollieren und optimieren). Typische Einsatzszenarien: Automatisierte CI/CD-Agents die über einfache Code-Reviews hinausgehen, interne Unternehmens-Tools die mit proprietären Daten arbeiten, Produkt-Features die KI-Funktionalität in eure App einbetten, und spezialisierte Entwickler-Tools für euer Team. Das SDK wird aktiv von Anthropic weiterentwickelt und ist bereits Production-ready. Große Unternehmen nutzen es für interne Tooling, und die Open-Source-Community baut immer mehr Projekte darauf auf.

CLAUDE CODE vs. AGENT SDK
━━━━━━━━━━━━━━━━━━━━━━━━

CLAUDE CODE (das Produkt):
├── Fertiges CLI-Tool
├── Interaktiv im Terminal
├── Eingebaute Tools (Read, Write, Bash, etc.)
├── MCP Server Support
├── Slash Commands, Skills, Hooks
└── Für Entwickler zum direkten Nutzen

AGENT SDK (die Engine):
├── Python/TypeScript Library
├── Programmatisch steuerbar
├── Eigene Tools definierbar
├── MCP Server integrierbar
├── Subagents und Delegation
├── Streaming Responses
├── Multi-Turn Conversations
└── Für Entwickler zum Bauen eigener Produkte

ANWENDUNGSFÄLLE FÜR DAS SDK:
→ Eigener Code Review Bot für dein Team
→ Automatisierte Bug-Triage in GitHub Issues
→ Custom Documentation Generator
→ CI/CD Agents die Features implementieren
→ Slack Bot der Code-Fragen beantwortet
→ IDE-Plugin mit eigener AI-Logik

Quickstart: Erster Agent in 5 Minuten

Das Agent SDK ermöglicht es dir, eigene autonome AI-Agents als eigenständige Programme zu bauen. In 5 Minuten hast du deinen ersten Agent: Ein Programm das Claude's Intelligenz nutzt, eigene Tools hat und Aufgaben selbstständig erledigt — unabhängig von der Claude Code CLI. Schritt 1 — Projekt erstellen: 'npm init -y && npm install @anthropic-ai/agent-sdk'. Das installiert das SDK und seine Dependencies. Du brauchst Node.js 18+ und einen ANTHROPIC_API_KEY. Schritt 2 — Agent schreiben: Erstelle eine Datei agent.ts. Importiere den Agent aus dem SDK, definiere einen System-Prompt ('Du bist ein Code-Analyse-Agent'), und starte den Agent mit einer Aufgabe. 15 Zeilen Code reichen für einen funktionierenden Agent. Schritt 3 — Tools hinzufügen: Der Agent braucht Tools um mit der Welt zu interagieren. Definiere ein Tool als TypeScript-Funktion: Name, Beschreibung, Parameter-Schema und Handler-Funktion. Zum Beispiel ein 'read_file' Tool das eine Datei liest und den Inhalt zurückgibt. Schritt 4 — Ausführen: 'npx tsx agent.ts'. Der Agent startet, bekommt seine Aufgabe, nutzt seine Tools und gibt das Ergebnis aus. Du siehst jeden Schritt den der Agent macht. Der Unterschied zu Slash Commands und Skills: Diese erweitern Claude Code (das bestehende Tool). Das Agent SDK lässt dich ein EIGENES Tool bauen — mit eigener Logik, eigenen Tools und eigener Oberfläche. Du bist nicht mehr auf die Claude Code CLI beschränkt. Typische Einsatzszenarien: Ein Slack-Bot der Code-Fragen beantwortet. Ein CLI-Tool das automatisch Changelogs generiert. Ein Backend-Service der Kundenanfragen analysiert. Eine Desktop-App die lokale Dateien organisiert. Das SDK ist Production-ready und wird von Anthropic aktiv weiterentwickelt. Große Unternehmen nutzen es bereits für interne Tooling.

# Installation (Python):
pip install claude-agent-sdk

# Installation (TypeScript/Node):
npm install @anthropic-ai/agent-sdk
# Minimaler Agent in Python
from claude_agent_sdk import Agent, Tool

# 1. Agent erstellen
agent = Agent(
    model="claude-sonnet-4.5",
    system_prompt="Du bist ein Code-Review Agent. "
                  "Analysiere Code auf Bugs und Best Practices.",
    max_turns=10,
)

# 2. Agent ausführen
result = agent.run(
    prompt="Reviewe diese Python-Datei: @src/main.py",
    tools=["read", "write", "bash"],
    working_directory="./my-project",
)

# 3. Ergebnis verarbeiten
print(result.output)
print(f"Kosten: " + str(result.cost.total_usd))
print(f"Turns: " + str(result.turns_used))
// Minimaler Agent in TypeScript
import { Agent } from '@anthropic-ai/agent-sdk';

const agent = new Agent({
  model: 'claude-sonnet-4.5',
  systemPrompt: 'Du bist ein hilfreicher Coding-Agent. '
    + 'Du kannst Dateien lesen, bearbeiten und Befehle ausführen.',
  maxTurns: 10,
});

const result = await agent.run({
  prompt: 'Erstelle Unit Tests für src/utils.ts',
  tools: ['read', 'write', 'bash'],
  workingDirectory: './my-project',
});

console.log(result.output);
console.log('Kosten: 
  

 + result.cost.totalUsd.toFixed(2));

Custom Tools definieren

Im Agent SDK definierst du Tools als TypeScript-Funktionen die dein Agent aufrufen kann. Jedes Tool hat drei Teile: Einen Namen der beschreibt was es tut, eine Beschreibung die Claude erklärt wann und wie es das Tool nutzen soll, und ein Schema für die Parameter. Die Tool-Definition folgt einem klaren Pattern: Du erstellst ein Objekt mit name (string), description (string), parameters (JSON Schema), und execute (async function). Claude liest Namen und Beschreibung um zu entscheiden wann es das Tool nutzt, und ruft execute mit den passenden Parametern auf. Die Beschreibung ist der wichtigste Teil: Claude entscheidet basierend auf der Beschreibung ob und wann es ein Tool nutzt. 'Liest eine Datei' ist vage. 'Liest den Inhalt einer Datei im Projektverzeichnis. Nutze dieses Tool wenn du den Code einer Datei analysieren musst. Gibt den vollständigen Dateiinhalt als String zurück.' gibt Claude klare Guidance. Das Parameter-Schema nutzt JSON Schema zur Validierung: Du definierst welche Parameter erwartet werden, welchen Typ sie haben, welche optional sind und welche Standardwerte gelten. Das SDK validiert automatisch und gibt bei falschen Parametern eine hilfreiche Fehlermeldung. Beispiele für typische Tools: read_file (Datei lesen), write_file (Datei schreiben), run_command (Shell-Befehl ausführen), search_code (Code durchsuchen), call_api (HTTP-Request machen), query_database (Datenbank-Abfrage). Sicherheitshinweis: Tools sind AKTIONEN die dein Agent ausführen kann. Definiere nur Tools die der Agent wirklich braucht und validiere alle Eingaben. Ein unkontrolliertes run_command Tool ist ein Sicherheitsrisiko.

from claude_agent_sdk import Agent, Tool

# Eigenes Tool definieren
@Tool(
    name="search_jira",
    description="Sucht nach Jira-Tickets basierend auf Query",
)
def search_jira(query: str, project: str = "MYAPP") -> str:
    """Sucht Jira nach relevanten Tickets."""
    import requests
    response = requests.get(
        f"https://company.atlassian.net/rest/api/3/search",
        params={"jql": f'project={project} AND text~"{query}"'},
        auth=("user@company.com", JIRA_TOKEN),
    )
    tickets = response.json()["issues"]
    return "\n".join([
        f"- {t['key']}: {t['fields']['summary']}"
        for t in tickets[:5]
    ])

# Agent mit Custom Tool
agent = Agent(
    model="claude-sonnet-4.5",
    system_prompt="Du bist ein Bug-Triage Agent.",
    tools=["read", search_jira],  # Eingebaute + Custom Tools
)

result = agent.run(
    prompt="Der Login ist kaputt. Finde verwandte Jira-Tickets "
           "und analysiere den Auth-Code.",
)

Subagents im SDK

Auch im Agent SDK kannst du Subagents spawnen — eigenständige Agent-Instanzen mit separatem Kontext die bestimmte Teilaufgaben übernehmen und das Ergebnis an den Hauptagent zurückmelden. Die API ist elegant: Du erstellst einen neuen Agent mit eigenem System-Prompt und eigenen Tools, gibst ihm eine Aufgabe, und wartest auf das Ergebnis. Der Subagent arbeitet in seinem eigenen Context Window und verschmutzt den Kontext des Hauptagents nicht. Typische Einsatzszenarien: Der Hauptagent koordiniert ein großes Projekt. Subagent A analysiert die bestehende Codebase. Subagent B implementiert neue Features basierend auf der Analyse. Subagent C schreibt Tests. Jeder Agent ist spezialisiert und hat seine eigenen Tools. Fortgeschrittene Patterns: Du kannst Subagents mit verschiedenen Modellen betreiben (Haiku für Exploration, Sonnet für Implementation), verschiedene Tool-Sets geben (Analyse-Agent hat nur Read, Implementation-Agent hat Read+Write), und verschiedene System-Prompts für verschiedene Rollen. Die Koordination zwischen Hauptagent und Subagents erfolgt über Message-Passing: Der Hauptagent formuliert die Aufgabe als Text, der Subagent arbeitet sie ab und gibt ein Text-Ergebnis zurück. Für strukturierten Datenaustausch kannst du JSON als Format vorgeben. Das SDK unterstützt sowohl sequentielle als auch parallele Subagent-Ausführung. Parallele Ausführung mit Promise.all ist besonders nützlich wenn mehrere unabhängige Analysen gleichzeitig laufen sollen.

from claude_agent_sdk import Agent, SubAgent

# Haupt-Agent (Orchestrator)
orchestrator = Agent(
    model="claude-sonnet-4.5",
    system_prompt="Du koordinierst Code-Reviews.",
)

# Spezialisierte Subagents
security_reviewer = SubAgent(
    model="claude-sonnet-4.5",
    system_prompt="Du prüfst Code auf Sicherheitslücken.",
    tools=["read"],
)

performance_reviewer = SubAgent(
    model="claude-haiku-4.5",  # Günstigeres Modell reicht!
    system_prompt="Du prüfst Code auf Performance-Probleme.",
    tools=["read"],
)

test_writer = SubAgent(
    model="claude-haiku-4.5",
    system_prompt="Du schreibst Unit Tests.",
    tools=["read", "write"],
)

# Orchestrator nutzt Subagents
result = orchestrator.run(
    prompt="Führe ein vollständiges Review durch für src/api/",
    sub_agents={
        "security": security_reviewer,
        "performance": performance_reviewer,
        "tests": test_writer,
    },
)
# → Subagents laufen PARALLEL mit eigenen Contexts!
# → Orchestrator fasst Ergebnisse zusammen

MCP Server im Agent SDK

Das Agent SDK unterstützt MCP-Server direkt — du kannst bestehende MCP-Server in deinen Custom Agent einbinden und damit auf hunderte externe Tools und Datenquellen zugreifen, ohne sie selbst implementieren zu müssen. Die Integration ist einfach: Du konfigurierst den MCP-Server in der Agent-Definition (Transport-Typ, Startbefehl, Umgebungsvariablen) und das SDK macht die Tools des Servers automatisch für deinen Agent verfügbar. Claude sieht die MCP-Tools genauso wie deine eigenen Custom Tools. Praktisches Beispiel: Dein Agent braucht Datenbankzugriff. Statt ein eigenes query_database Tool zu schreiben, bindest du den PostgreSQL MCP Server ein. Der Server stellt automatisch Tools wie query, list_tables, describe_table bereit — getestet, optimiert und mit korrektem Error-Handling. Du kannst MCP-Server und Custom Tools kombinieren: Der GitHub MCP Server gibt deinem Agent Zugriff auf Repositories und Issues. Dein Custom Tool call_internal_api gibt Zugriff auf interne Services. Der Agent nutzt beides nahtlos. Für die Konfiguration nutzt du das gleiche Format wie in der Claude Code CLI: Server-Name, Transport-Typ (stdio oder sse), Startbefehl und Umgebungsvariablen. Das bedeutet: Du kannst die gleiche MCP-Konfiguration in der CLI und im SDK verwenden. Sicherheitshinweis: MCP-Server geben deinem Agent Zugriff auf externe Dienste. Prüfe welche Tools ein Server bereitstellt und ob dein Agent all diese Fähigkeiten wirklich braucht. Nutze Tool-Filtering um nur spezifische MCP-Tools freizugeben.

from claude_agent_sdk import Agent, MCPServer

# MCP Server einbinden
agent = Agent(
    model="claude-sonnet-4.5",
    system_prompt="Du bist ein Frontend-Review Agent.",
    mcp_servers=[
        MCPServer(
            name="playwright",
            command="npx",
            args=["-y", "@anthropic-ai/mcp-playwright"],
        ),
        MCPServer(
            name="github",
            command="npx",
            args=["-y", "@anthropic-ai/mcp-github"],
            env={"GITHUB_TOKEN": os.environ["GITHUB_TOKEN"]},
        ),
    ],
)

# Agent kann jetzt Browser steuern UND GitHub nutzen
result = agent.run(
    prompt="Öffne localhost:3000, mache einen Screenshot, "
           "und erstelle ein GitHub Issue wenn Fehler sichtbar sind.",
)

IDE-Integration: Xcode & Co.

Das Agent SDK lässt sich in verschiedene Entwicklungsumgebungen integrieren — nicht nur als CLI-Tool, sondern als eingebetteter Agent in Desktop-Anwendungen, IDE-Plugins und Web-Interfaces. Die Architektur des SDK ist bewusst flexibel gehalten. Die Xcode-Integration ist ein prominentes Beispiel: Anthropic hat demonstriert wie ein SDK-basierter Agent direkt in Xcode eingebettet wird. Der Agent versteht Swift-Code, interagiert mit dem Xcode Build System und kann Tests ausführen — alles innerhalb der IDE. Für VS Code Plugins nutzt du das SDK mit der VS Code Extension API: Dein Agent läuft als Background-Process, erhält Kontext aus dem Editor (offene Dateien, Cursor-Position, Diagnostics) und gibt Ergebnisse zurück die als Inline-Annotations oder Side-Panel angezeigt werden. Web-Integration: Das SDK funktioniert auch in Backend-Services die eine Web-UI bedienen. Der Agent läuft auf dem Server, empfängt Aufgaben über eine REST API und gibt Ergebnisse als JSON zurück. Die Web-UI zeigt den Fortschritt in Echtzeit. Electron/Desktop-Apps: Für eigenständige Desktop-Anwendungen nutzt du das SDK direkt in deinem Electron-Main-Process. Der Agent hat Zugriff auf das lokale Dateisystem und kann als vollwertiger Code-Assistent mit eigener UI fungieren. Die Gemeinsamkeit aller Integrationen: Das SDK stellt die KI-Logik bereit (Model-Kommunikation, Tool-Execution, Context-Management), du stellst die UI und die spezifische Integration bereit. Das trennt Concerns sauber und macht das SDK vielseitig einsetzbar. Das SDK-Ökosystem wächst: Die Community baut Integrationen für immer mehr Plattformen — von Vim-Plugins bis zu Slack-Bots. Die offene Architektur ermöglicht Integrationen die Anthropic selbst nicht vorgesehen hat.

🎓 Agent SDK ZusammenfassungAgent SDK = Die Engine hinter Claude CodePython & TypeScript: Zwei offizielle SDKs ✅ Custom Tools: Eigene Funktionen als Tools registrieren ✅ Subagents: Parallele, spezialisierte Worker ✅ MCP: Externe Tools nahtlos einbinden ✅ Streaming: Echtzeit-Updates für UI-Integrationen ✅ IDE-Integration: Xcode, VS Code, eigene IDEs ✅ Production-Ready: Gleiche Engine wie Claude Code selbst