Comment utiliser le SDK Claude Agent avec Claude Sonnet 4.5

Le SDK Claude Agent décrit une boucle d'agent structurée comprenant quatre étapes clés : collecte de contexte, prise de décision, vérification du travail, et répéter.

Dans la pratique, commencez par une recherche contextuelle et ajoutez une recherche sémantique lorsque la rapidité est requise. Les actions doivent se concentrer sur les outils à signal élevé, les scripts bash et les intégrations avec des services externes via le protocole Model Context Protocol. 

La vérification combine des contrôles basés sur des règles, un retour visuel et une assistance LLM facultative. Il est recommandé de procéder à des itérations continues afin d'affiner les performances, d'étendre les outils et d'améliorer les capacités de recherche à mesure que les fonctionnalités se développent.

Caractéristiques principales :

1. SDK : TypeScript et Python pour les backends web/Node.js et la science des données, avec des concepts communs afin que les équipes puissent réutiliser les modèles dans toutes les piles.
2. Modes : Diffusion en continu pour une expérience utilisateur interactive à faible latence et exécution unique pour les traitements par lots ou déterministes : sélectionnez l'option adaptée à chaque tâche afin d'équilibrer vitesse et contrôle.
3. Gestion du contexte : Compactage automatique et contrôle contextuel à long terme pour éviter les débordements et maintenir les agents sur leur cursus pendant les sessions prolongées.
4. Outillage : Opérations sur les fichiers intégrées, exécution de code et recherche sur le Web, ainsi qu'une extensibilité pour les outils et données externes via MCP.
5. Autorisations : Contrôles de capacités précis (par exemple, autorisation/refus par outil et modes de politique) pour limiter les actions possibles d'un agent en production.
6. Prêt pour la production : Gestion intégrée des erreurs, gestion des sessions et surveillance pour vous permettre de déployer des agents fiables avec une observabilité dès le premier jour.
7. Intégration de Claude : Mise en cache automatique des invites et optimisations des performances afin de réduire la latence et les coûts tout en améliorant le débit.
8. Authentification : Veuillez utiliser une clé API Claude ou passer par des fournisseurs tels qu'Amazon Bedrock et Google Vertex AI afin de vous adapter à votre environnement de déploiement.
9. Messages du système : Définissez le rôle, l'expertise et les garde-fous afin de façonner le comportement des agents de manière cohérente dans toutes les tâches et sessions.
10. Intégrations (MCP) : Connectez des outils personnalisés, des bases de données et des API via le protocole ouvert Model Context Protocol, une norme soutenue par Anthropic avec des SDK TypeScript officiels et un écosystème en pleine expansion.

Commencer à utiliser le SDK Claude Agent en Python

Avant de commencer à développer des projets, il est nécessaire de remplir certaines conditions préalables, d'installer l'interface CLI Claude Code et le SDK Claude Agent.

Conditions préalables

• Veuillez vous assurer que vous disposez de la version 3.10 ou supérieure de Python. 
• Pour utiliser efficacement l'interface CLI Claude Code, il est également nécessaire d'installer Node.js version 18 ou supérieure ainsi que le package NPM.

Veuillez installer Claude Code CLI.

Pour Windows : 

Veuillez ouvrir PowerShell et exécuter la commande suivante pour télécharger et installer Claude Code :

irm https://claude.ai/install.ps1 | iex

Après l'installation, veuillez ajouter C:\Users\\.local\bin au PATH de votre système. Veuillez redémarrer PowerShell, et vous devriez constater que Claude est en cours d'exécution.

Pour les autres plateformes :

Si Node.js et NPM sont déjà installés, veuillez essayer d'exécuter la commande suivante dans le terminal pour installer Claude Code :

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

Veuillez suivre les instructions pour configurer vos variables d'environnement afin de pouvoir accéder à Claude Code en saisissant simplement « claude » dans le terminal.

Configuration de Claude Code

Après avoir installé Claude Code, veuillez l'ouvrir en saisissant « claude » dans le terminal et en vous connectant. Si vous disposez d'un abonnement Claude Pro ou Max, veuillez sélectionner « Se connecter avec votre compte d'abonnement » afin que l'utilisation soit facturée sur votre abonnement.

Si vous préférez le paiement à l'utilisation, veuillez vous authentifier à l'aide d'une clé API ; la facturation s'effectuera via la console Anthropic. 

Enfin, définissez vos préférences en matière de thème et d'interface/CLI afin que tout soit adapté à votre flux de travail dès le premier jour.

J'ai configuré mon Claude Code avec la clé API. Vous pouvez consulter la configuration ici :

Veuillez installer le SDK Claude Agent.

Veuillez vous assurer que Python est correctement installé, puis ouvrez votre terminal. Pour installer le SDK Claude Agent, veuillez exécuter :

pip install claude-agent-sdk

Remarque : Si vous rencontrez un problème, veuillez vous assurer que vous avez installé l'interface CLINotFoundError, veuillez vous assurer que vous avez installé l'interface CLI ci-dessus et que Claude est inclus dans votre PATH.

Développement de projets avec Claude Agent SDK et Claude Sonnet 4.5

Nous allons maintenant créer trois projets simples en utilisant le SDK Claude Agent comme cadre, le code Claude pour les outils et l'utilisation de l'ordinateur, et Claude Sonnet 4.5 comme modèle d'IA.

1. Plan du blog en une seule partie : Une requête simple et unique qui illustre l'utilisation de base du SDK Claude Agent sans outils.
2. InspireBot CLI : Ce projet combine des fonctionnalités de recherche sur le Web avec un outil personnalisé de secours pour les citations motivantes.
3. Application NoteSmith Multi-Tool : Une application de prise de notes complète comprenant de multiples outils, des crochets de sécurité et un suivi de l'utilisation.

Tout le code source est disponible sur le dépôt GitHub : kingabzpro/claude-agent-projects

1. Plan de blog en une seule partie

Dans le cadre de ce projet, nous utilisons la fonction SDK's query() avec Claude Sonnet 4.5 pour créer un plan de blog. Il s'agit d'une requête simple et unique qui présente l'utilisation de base du SDK Claude Agent sans aucun outil.

Le code comprend : 

1. s de streaming asynchrone: Utilise asyncio avec l'itérateur asynchronequery() du SDK pour une sortie non bloquante, token par token.
2. s sur les invites et les options: Définit les grandes lignes d'un blog PROMPT et configure le modèle/la persona via ClaudeAgentOptions.
3. Flux de messages tapés: Itère sur les messages ; extrait uniquement le contenu de l' AssistantMessage → TextBlock.
4. Sortie en temps réel: Affiche le texte au fur et à mesure de son arrivée (end="") pour une vue claire de la console de streaming.
5. s de gestion des résultats: Ignore l' ResultMessage, permettant au flux de se terminer naturellement.
6. Point d'entrée: Exécute tout avec l' asyncio.run(main()) lorsque le script est exécuté.
7. Personnalisable et minimaliste: Facile à échanger modèle/invite ; script léger, idéal pour les démonstrations ou les 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())

Nous exécuterons le script, puis enregistrerons le résultat sous forme de fichier Markdown. 

python oneshot_outline.py > outline.md 

Vous pouvez ouvrir le fichier Markdown et constater qu'il a généré un texte technique correct. 

Vous pouvez revenir à votre tableau de bord à l'adresse suivante : https://console.anthropic.com/usage pour vérifier votre utilisation. Comme vous pouvez le constater, le modèle utilise Claude Sonnet 4.5.

2. InspireBot CLI

Dans le cadre de ce projet, nous développons un générateur de motivation convivial pour terminal qui diffuse des citations à l'aide de Claude Sonnet 4.5. Il effectue d'abord une recherche sur le Web, puis se tourne vers un outil personnalisé inspire_me qui renvoie des citations aléatoires.

Le code comprend :

• s de l'outil de secours personnalisé: Définit inspire_me avec des citations motivantes prédéfinies, enregistrées via create_sdk_mcp_server.
• Aides CLI: is_tty, typewrite, bold, faint ajoutent une animation de machine à écrire et une sortie stylisée dans le terminal.
• s sur les invites et les options: Configuré avec ClaudeAgentOptions, permettant l'utilisation d'outils (WebSearch + inspire_me) et d'un personnage système « InspireBot ».
• L'outil de streaming fait appel à l': Itère sur les messages, affichant l'utilisation de l'outil (ToolUseBlock), les résultats (ToolResultBlock) et la sortie finale (TextBlock).
• Logique de repli: Si aucune sortie utilisable n'apparaît, le système affiche par défaut une citation locale aléatoire.
• s UX interactives: Affiche les entrées/résultats de l'outil de streaming, puis anime la ligne finale inspirante avec un effet de machine à écrire.

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())

Nous exécuterons le script avec le sujet par défaut à l'aide de la commande suivante :  

python inspire_web.py

Comme nous pouvons le constater, il affiche les outils utilisés, les données saisies dans ces outils, puis génère une citation motivante.  

Veuillez fournir au script Python un sujet personnalisé :  

python inspire_web.py "Sadness and Love"

Cette fonction renvoie une citation motivante contenant les mots-clés « amour » et « tristesse ».

3. Application multifonctionnelle NoteSmith

Dans le cadre de ce projet, nous développons un assistant de recherche multifonctionnel qui permet de sauvegarder et de rechercher des notes localement, de résumer des pages web et de diffuser les résultats avec Claude Sonnet 4.5. Il combine des outils MCP personnalisés, des outils intégrés et un crochet de sécurité pour une expérience CLI plus riche.

Le code comprend :

• s relatives au stockage local: Enregistre les notes sur le disque avec horodatage ; prend en charge la recherche insensible à la casse à l'aide d'une logique grep simple.
• Outils MCP personnalisés: save_note (stockage de texte) et find_note (rechercher des notes), enregistrés auprès de create_sdk_mcp_server.
• Crochet de sécurité: block_dangerous_bash empêche l'exécution de commandes shell nuisibles (par exemple, rm -rf /) avant l'exécution de l'outil.
• Invite système et commandes: Définit /summarize, /note ,/find, /help ,/exit; invite à utiliser l'outil (WebFetch, save_note, find_note).
• Interaction en streaming: Utilise ClaudeSDKClient pour gérer AssistantMessage, ToolUseBlock, ToolResultBlock, l'impression de texte et les résultats des outils en temps réel.
• Suivi de l'utilisation de l': Imprime un pied de page avec le nom du modèle, les jetons et le coût dansla sortie standard d' , tout en conservant la sortie principale propre.
• Interface de chat: Fonctionne comme un REPL léger où vous saisissez des commandes (/note, /find, /summarize) et obtenez des réponses immédiates, ce qui donne l'impression de discuter avec un assistant.

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())

Pour exécuter l'application, veuillez saisir la commande suivante dans le terminal :

python note_smith.py

Cela lancera l'interface de chat CLI avec des commandes utiles.

Nous allons d'abord résumer la page Web. J'ai fourni l'URL de mon site web portfolio :

/résumer abid.work

Tout d'abord, l'agent déterminera les outils à utiliser, récupérera le contenu de la page Web, extraira cinq points clés et les affichera dans l'interface de chat. À la fin, un rapport d'utilisation comprenant le nom du modèle, l'utilisation des jetons et le coût s'affichera.

I'll fetch and summarize the content from that URL for you.                                    
🛠️  Using tool: WebFetch with input: {"url": "https://abid.work", "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 --

Ensuite, enregistrons une note :

/note qu'est-ce que l'amour

Nous lui avons demandé d'enregistrer la note avec le texte « qu'est-ce que l'amour ».

🛠️  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 --

Enfin, nous trouverons la note en fournissant un mot-clé provenant de la note :

/trouver l'amour

Comme vous pouvez le constater, le fichier a été localisé et son contenu affiché.

🛠️  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 --

Conclusion 

Le SDK Claude Agent est simple à configurer, en particulier si Claude Code est déjà installé localement. Il suffit d'installer le package SDK. 

Le SDK Python propose deux méthodes principales pour interagir avec Claude :

• query() – une API de génération de texte simple, idéale pour les cas d'utilisation légers, mais qui ne prend pas en charge les outils.
• ClaudeSDKClient – une API agentique complète qui vous permet de reprendre des sessions, d'utiliser des outils, de conserver le contrôle manuel, et bien plus encore.

Dans ce tutoriel, nous avons examiné le dernier modèle d'Anthropic, Claude Sonnet 4.5, et présenté le nouveau SDK Claude Agent. Nous avons suivi le processus d'installation et créé trois exemples de projets afin de démontrer ses capacités.

Si vous souhaitez expérimenter les workflows agentics, je vous recommande vivement d'essayer ce SDK.