> ## Documentation Index
> Fetch the complete documentation index at: https://docs.coreweave.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Anthropic

> Tracez les appels du SDK Anthropic dans Agent Lens avec le SDK CoreWeave Forge.

Le SDK CoreWeave Forge trace automatiquement les appels que vous effectuez avec le SDK Anthropic pour Python et Node.js. Une fois le traçage initialisé, chaque appel effectué dans une conversation est enregistré dans Agent Lens sous forme de span LLM, avec ses messages, ses appels d’outil, ses médias, les paramètres de la requête, l’utilisation des jetons et l’utilisation du cache de prompts. Vous n’avez rien à modifier dans votre façon d’appeler le SDK Anthropic.

L’intégration trace l’API Messages, y compris le streaming, le helper de flux Messages et le parsing des sorties structurées. En TypeScript, elle trace également les appels à l’API Message Batches en tant qu’opérations d’outil.

<h2 id="prerequisites">
  Prérequis
</h2>

* Un compte CoreWeave Forge et une [clé API](https://forge.coreweave.com/settings#apikeys) définie dans la variable d’environnement `WANDB_API_KEY`.
* Une [clé API Anthropic](https://console.anthropic.com/settings/keys) définie dans la variable d’environnement `ANTHROPIC_API_KEY`.
* Pour Python : Python 3.10 ou version ultérieure et `anthropic` 0.18.0 ou version ultérieure.
* Pour TypeScript : Node.js 18.19 ou version ultérieure (ou 20.6 ou version ultérieure) et `@anthropic-ai/sdk` 0.52.0 ou version ultérieure.

<h2 id="install-packages">
  Installer les paquets
</h2>

<CodeGroup>
  ```bash Python theme={"system"}
  pip install "coreweave[anthropic]"
  ```

  ```bash TypeScript theme={"system"}
  npm install @coreweave/forge-sdk @anthropic-ai/sdk
  ```
</CodeGroup>

<h2 id="trace-anthropic-conversations">
  Tracer les conversations Anthropic
</h2>

Appelez `tracing.init()` avec les noms de votre équipe et de votre projet Forge. En Python, `tracing.init()` patche le SDK Anthropic, que vous l’importiez avant ou après l’appel. En TypeScript, démarrez Node avec l’option d’instrumentation indiquée dans l’onglet TypeScript.

Agent Lens n’affiche que les appels exécutés au sein d’une conversation. Un appel effectué en dehors d’une conversation n’a pas d’ID de conversation et n’apparaît donc pas dans Agent Lens. Créez une conversation par session d’agent, puis démarrez un tour de conversation pour chaque message utilisateur. Tous les tours partagent l’ID de la conversation : Agent Lens les regroupe donc en une seule conversation, et chaque appel devient un span LLM du tour dans lequel il s’exécute.

<Tabs>
  <Tab title="Python">
    ```python lines theme={"system"}
    from anthropic import Anthropic
    from coreweave.forge.agentlens import tracing

    tracing.init("[YOUR-TEAM]/[YOUR-PROJECT]")
    client = Anthropic()

    questions = [
        "What is inference latency?",
        "How does batching affect it?",
        "Summarize what we discussed in one sentence.",
    ]

    history = []
    with tracing.Conversation(agent_name="support-agent") as conversation:
        for question in questions:
            with conversation.start_turn(user_message=question):
                history.append({"role": "user", "content": question})
                response = client.messages.create(
                    model="claude-sonnet-5",
                    max_tokens=256,
                    messages=history,
                )
                answer = response.content[0].text
                history.append({"role": "assistant", "content": answer})
                print(answer)

    tracing.shutdown()
    ```
  </Tab>

  <Tab title="TypeScript">
    Encapsulez chaque exécution d’agent dans `tracing.runIsolated()` afin que sa conversation et ses tours restent isolés des autres exécutions simultanées.

    ```typescript lines title="app.mjs" theme={"system"}
    import Anthropic from '@anthropic-ai/sdk';
    import {tracing} from '@coreweave/forge-sdk/agentlens';

    await tracing.init('[YOUR-TEAM]/[YOUR-PROJECT]');
    const anthropic = new Anthropic();

    const questions = [
      'What is inference latency?',
      'How does batching affect it?',
      'Summarize what we discussed in one sentence.',
    ];

    await tracing.runIsolated(async () => {
      const conversation = tracing.startConversation({agentName: 'support-agent'});
      const history = [];
      try {
        for (const question of questions) {
          const turn = conversation.startTurn({userMessage: question});
          try {
            history.push({role: 'user', content: question});
            const response = await anthropic.messages.create({
              model: 'claude-sonnet-5',
              max_tokens: 256,
              messages: history,
            });
            const answer = response.content[0].text;
            history.push({role: 'assistant', content: answer});
            console.log(answer);
          } finally {
            turn.end();
          }
        }
      } finally {
        conversation.end();
      }
    });

    await tracing.shutdown();
    ```

    Exécutez le script avec l’option d’instrumentation. Celle-ci charge l’instrumentation Forge avant votre code, de sorte que le SDK Anthropic soit patché au moment où votre code l’importe :

    ```bash theme={"system"}
    node --import=@coreweave/forge-sdk/instrument app.mjs
    ```

    Si vous ne pouvez pas utiliser cette option, par exemple parce qu’un bundler regroupe vos dépendances dans un seul fichier, encapsulez plutôt le client :

    ```typescript theme={"system"}
    import {integrations} from '@coreweave/forge-sdk/agentlens';

    const anthropic = integrations.wrapAnthropic(new Anthropic());
    ```

    Si vous exécutez le code sans cette option, `tracing.init()` affiche un avertissement, une seule fois. Vous pouvez l’ignorer si vous encapsulez vos clients.
  </Tab>
</Tabs>

Pour ajouter ultérieurement des tours à une conversation existante, par exemple dans une application web qui traite un tour de conversation par requête, transmettez le même `conversation_id` (Python) ou `conversationId` (TypeScript) chaque fois que vous créez la conversation.

Pour en savoir plus sur les conversations, les tours de conversation et les autres types de spans, consultez [Tracer vos agents](/fr/products/agent-lens/tracing/instrument).

<h2 id="turn-off-automatic-patching">
  Désactiver le patching automatique
</h2>

En Python, passez `autopatch_integrations=False` à `tracing.init()`. Vous pouvez ensuite appliquer et retirer vous-même le patch du SDK Anthropic avec `tracing.integrations.patch_anthropic()` et `tracing.integrations.unpatch_anthropic()`.

En TypeScript, exécutez votre code sans l’option `--import=@coreweave/forge-sdk/instrument`, puis encapsulez avec `integrations.wrapAnthropic()` uniquement les clients que vous souhaitez tracer.

<h2 id="view-your-traces">
  Afficher vos traces
</h2>

Dans [CoreWeave Forge](https://forge.coreweave.com), sélectionnez Agent Lens dans le menu des produits, choisissez votre projet dans le sélecteur de projet en haut du menu latéral, puis sélectionnez **Conversations**. Pour plus d’informations, voir [Afficher l’activité des agents](/fr/products/agent-lens/conversations/view-activity).