> ## Documentation Index
> Fetch the complete documentation index at: https://wb-21fd5541-docs-hivemind-launch.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Claude Agent SDK

> Utilisez W&B Weave avec le Claude Agent SDK pour tracer les requêtes de votre agent, les appels d'outils et les conversations en plusieurs tours.

Le [Claude Agent SDK](https://github.com/anthropics/claude-agent-sdk-python) est un SDK Python d’Anthropic conçu pour créer des applications agentiques avec Claude. W\&B Weave trace automatiquement les appels du Claude Agent SDK lorsque vous appelez `weave.init()`, en capturant les requêtes, l’utilisation d’outils et les conversations en plusieurs tours.

<div id="prerequisites">
  ## Prérequis
</div>

Avant d’exécuter l’exemple de code :

* Remplacez `your-team-name` par la valeur appropriée pour appeler `weave.init()` à la ligne 109 du code.
* Définissez `WANDB_API_KEY` et `ANTHROPIC_API_KEY` dans votre environnement.
  * Pour plus d’informations sur les clés API W\&B, voir [Clés API](/fr/platform/app/settings-page/user-settings#api-keys).

<div id="installation">
  ## Installation
</div>

Installez les dépendances requises avec `pip` :

```bash theme={null}
pip install weave claude-agent-sdk
```

<div id="get-started">
  ## Pour commencer
</div>

Weave patche automatiquement le SDK et trace chaque requête lorsque `weave.init()` est appelé avant d’utiliser le Claude Agent SDK.

L’exemple suivant illustre trois fonctionnalités :

* **Requêtes simples en un seul appel** à l’aide de la fonction `query()`, y compris les réponses du modèle et le coût.
* **Utilisation d’outils MCP** avec `ClaudeSDKClient`. Le Claude Agent SDK prend en charge des outils personnalisés via des serveurs MCP en cours de processus.
  * Weave trace les définitions des outils, leurs invocations et leurs résultats, en plus des requêtes de l’agent.
  * La démo MCP définit deux outils MCP et exécute une requête qui les utilise.
* **Conversations en plusieurs tours** regroupées dans une seule trace avec `weave.thread()`, afin que vous puissiez voir l’intégralité du déroulement de la conversation dans la Weave UI.
  * Weave capture chaque tour comme enfant du thread, afin que vous puissiez voir l’intégralité du déroulement de la conversation dans la Weave UI.

```python lines theme={null}
"""Weave + Claude Agent SDK : tracing des requêtes, outils et conversations.

Appelez `weave.init()` pour patcher automatiquement le SDK — chaque requête, appel d'outil et
conversation en plusieurs tours est enregistré comme une trace consultable dans la Weave UI.
"""

import anyio

import weave
from claude_agent_sdk import (
    AssistantMessage,
    ClaudeAgentOptions,
    ClaudeSDKClient,
    ResultMessage,
    TextBlock,
    ToolUseBlock,
    create_sdk_mcp_server,
    tool,
)

# --- 1. Définir les outils MCP ---

@tool("add", "Add two numbers", {"a": float, "b": float})
async def add(args: dict) -> dict:
    return {"content": [{"type": "text", "text": str(args["a"] + args["b"])}]}


@tool("multiply", "Multiply two numbers", {"a": float, "b": float})
async def multiply(args: dict) -> dict:
    return {"content": [{"type": "text", "text": str(args["a"] * args["b"])}]}


math_server = create_sdk_mcp_server(
    name="math", version="1.0.0", tools=[add, multiply],
)


# --- 2. Requête simple en une seule passe ---

async def simple_query():
    from claude_agent_sdk import query

    async for msg in query(prompt="What is 2+2?"):
        if isinstance(msg, AssistantMessage):
            for block in msg.content:
                if isinstance(block, TextBlock):
                    print(block.text, end="")
        elif isinstance(msg, ResultMessage):
            print(f"\ncost=${msg.total_cost_usd:.4f}")


# --- 3. Utilisation des outils MCP ---

async def tool_query():
    options = ClaudeAgentOptions(
        mcp_servers={"math": math_server},
        allowed_tools=["mcp__math__add", "mcp__math__multiply"],
    )

    async with ClaudeSDKClient(options=options) as client:
        await client.query("Using the math tools, compute (3 + 7) * 2.")
        async for msg in client.receive_response():
            if isinstance(msg, AssistantMessage):
                for block in msg.content:
                    if isinstance(block, ToolUseBlock):
                        print(f"  [tool] {block.name}({block.input})")
                    elif isinstance(block, TextBlock):
                        print(block.text, end="")
            elif isinstance(msg, ResultMessage):
                print(f"\ncost=${msg.total_cost_usd:.4f}")


# --- 4. Conversation en plusieurs tours avec contexte de thread ---

async def threaded_conversation():
    with weave.thread("my-conversation") as t:
        print(f"thread_id={t.thread_id}")

        async with ClaudeSDKClient() as client:
            for prompt in [
                "Name a famous sorting algorithm.",
                "What is its time complexity?",
            ]:
                await client.query(prompt)
                reply = ""
                async for msg in client.receive_response():
                    if isinstance(msg, AssistantMessage):
                        reply += "".join(
                            b.text for b in msg.content if isinstance(b, TextBlock)
                        )
                    elif isinstance(msg, ResultMessage):
                        print(f"Q: {prompt}\nA: {reply.strip()[:120]}\n")


# --- Exécuter tous les exemples ---

async def main():
    print("=== Simple Query ===")
    await simple_query()

    print("\n=== MCP Tool Use ===")
    await tool_query()

    print("\n=== Multi-Turn Thread ===")
    await threaded_conversation()


if __name__ == "__main__":
    weave.init("your-team-name/claude-agent-sdk-demo")
    anyio.run(main)
```

<div id="view-traces">
  ## Voir les traces
</div>

Lorsque vous exécutez l’exemple, Weave affiche des liens vers le tableau de bord Weave. Suivez-les pour voir vos traces, notamment les entrées de requête, les réponses du modèle, les appels d’outils et les fils de conversation.