Passer au contenu principal
Le Claude Agent SDK 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.

Prérequis

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.

Installation

Installez les dépendances requises avec pip :
pip install weave claude-agent-sdk

Pour commencer

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.
"""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)

Voir les traces

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.