> ## 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

> Utilisez Weave pour suivre et consigner automatiquement les appels LLM effectués avec le SDK Anthropic

<a target="_blank" href="https://colab.research.google.com/github/wandb/examples/blob/master/weave/docs/quickstart_anthropic.ipynb" aria-label="Ouvrir dans Google Colab">
  <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Ouvrir dans Colab" />
</a>

Lorsque vous intégrez Weave à votre code, il suit et consigne automatiquement les appels LLM effectués avec le SDK Anthropic, en [Python](https://github.com/anthropics/anthropic-sdk-python) comme en [TypeScript](https://github.com/anthropics/anthropic-sdk-typescript). Pour ce faire, Weave invoque automatiquement la méthode `Messages.create()` d’Anthropic.

Ce guide vous montre comment capturer les traces, encapsuler vos propres fonctions sous forme d’ops, créer un `Model` réutilisable pour vos expérimentations et suivre l’utilisation d’outils lorsque vous travaillez avec le SDK Anthropic. Appliquez ces approches pour déboguer, comparer et améliorer par itérations vos applications basées sur Claude, sans écrire de code de journalisation personnalisé.

<h2 id="traces">
  Traces
</h2>

Weave capture automatiquement les traces du SDK Anthropic dès que vous ajoutez `weave.init("your-team-name/your-project-name")` à votre code. Si vous ne passez pas de nom d’équipe en argument de `weave.init()`, Weave journalise la sortie dans votre [entity W\&B par défaut](/fr/products/wandb/platform/app/settings-page/user-settings#default-team). Si vous ne spécifiez pas de nom de projet, l’initialisation de Weave échoue.

Les exemples suivants montrent comment intégrer Weave à un appel de base à Anthropic :

<Tabs>
  <Tab title="Python">
    ```python lines {6} theme={"system"}
    import weave    
    # utilisez la bibliothèque anthropic comme d'habitude
    import os
    from anthropic import Anthropic

    weave.init("anthropic_project")

    client = Anthropic(
        api_key=os.environ.get("ANTHROPIC_API_KEY"),
    )

    message = client.messages.create(
        max_tokens=1024,
        messages=[
            {
                "role": "user",
                "content": "Tell me a joke about a dog",
            }
        ],
        model="claude-3-opus-20240229",
    )
    print(message.content)
    ```
  </Tab>

  <Tab title="TypeScript">
    ```typescript twoslash theme={"system"}
    // @noErrors
    import Anthropic from '@anthropic-ai/sdk';
    import * as weave from 'weave';
    import { wrapAnthropic } from 'weave';

    await weave.init('anthropic_project');

    // Encapsuler le client Anthropic pour activer le traçage
    const client = wrapAnthropic(new Anthropic());

    const message = await client.messages.create({
        max_tokens: 1024,
        messages: [
            {
                role: 'user',
                content: 'Tell me a joke about a dog',
            }
        ],
        model: 'claude-3-opus-20240229',
    });

    console.log(message.content);
    ```
  </Tab>
</Tabs>

Lorsque vous incluez `weave.init()` dans votre code, Weave capture automatiquement les informations de traçage et affiche des liens. Cliquez sur ces liens pour consulter les traces dans l’interface Weights & Biases.

[<img src="https://mintcdn.com/coreweave-dbfa0e8d/3Dv_sw2eg8feUJlx/products/wandb/weave/_media/anthropic_trace.png?fit=max&auto=format&n=3Dv_sw2eg8feUJlx&q=85&s=65de4a109defabbb0e1b0da9524a9729" alt="anthropic_trace.png" width="2908" height="1594" data-path="products/wandb/weave/_media/anthropic_trace.png" />](https://forge.coreweave.com/wandb/capecape/anthropic_project/weave/calls)

<h2 id="wrap-with-your-own-ops">
  Encapsuler avec vos propres ops
</h2>

Si `weave.init()` suffit à capturer les appels au SDK Anthropic, décorer vos propres fonctions avec des ops vous permet d’obtenir des traces plus riches, qui incluent la logique de votre application autour de chaque appel de modèle.

Les ops Weave versionnent automatiquement votre code au fil de vos expériences et capturent ses entrées et ses sorties. Décorez une fonction avec [`@weave.op()`](/fr/products/wandb/weave/guides/tracking/ops) en Python, ou encapsulez-la avec [`weave.op()`](/fr/products/wandb/weave/reference/typescript-sdk/functions/op) en TypeScript, pour appeler [`Anthropic.messages.create()`](https://platform.claude.com/docs/en/build-with-claude/working-with-messages): Weave suit alors les entrées et les sorties à votre place.

Les exemples suivants montrent comment suivre une fonction :

<Tabs>
  <Tab title="Python">
    ```python lines {5,10,24} theme={"system"}
    import weave
    import os
    from anthropic import Anthropic

    weave.init("anthropic_project")
    client = Anthropic(
        api_key=os.environ.get("ANTHROPIC_API_KEY"),
    )

    @weave.op()
    def call_anthropic(user_input:str, model:str) -> str:
        message = client.messages.create(
        max_tokens=1024,
        messages=[
            {
                "role": "user",
                "content": user_input,
            }
            ],
            model=model,
        )
        return message.content[0].text

    @weave.op()
    def generate_joke(topic: str) -> str:
        return call_anthropic(f"Tell me a joke about {topic}", model="claude-3-haiku-20240307")

    print(generate_joke("chickens"))
    print(generate_joke("cars"))
    ```
  </Tab>

  <Tab title="TypeScript">
    ```typescript twoslash theme={"system"}
    // @noErrors
    import Anthropic from '@anthropic-ai/sdk';
    import * as weave from 'weave';
    import { wrapAnthropic } from 'weave';

    await weave.init('anthropic_project');
    const client = wrapAnthropic(new Anthropic());

    const callAnthropic = weave.op(async function callAnthropic(
        userInput: string,
        model: string
    ): Promise<string> {
        const message = await client.messages.create({
            max_tokens: 1024,
            messages: [
                {
                    role: 'user',
                    content: userInput,
                }
            ],
            model: model,
        });
        const content = message.content[0];
        return content.type === 'text' ? content.text : '';
    });

    const generateJoke = weave.op(async function generateJoke(
        topic: string
    ): Promise<string> {
        return callAnthropic(`Tell me a joke about ${topic}`, 'claude-3-haiku-20240307');
    });

    console.log(await generateJoke('chickens'));
    console.log(await generateJoke('cars'));
    ```
  </Tab>
</Tabs>

Lorsque vous décorez une fonction avec `weave.op()`, Weave capture son code, son entrée et sa sortie. Vous pouvez utiliser des ops pour suivre n’importe quelle fonction, y compris des fonctions imbriquées.

[<img src="https://mintcdn.com/coreweave-dbfa0e8d/3Dv_sw2eg8feUJlx/products/wandb/weave/_media/anthropic_ops.png?fit=max&auto=format&n=3Dv_sw2eg8feUJlx&q=85&s=f113e2cae615ba622c85b095fd506c73" alt="anthropic_ops.png" width="2566" height="1278" data-path="products/wandb/weave/_media/anthropic_ops.png" />](/fr/products/wandb/weave/guides/tracking/ops)

<h2 id="create-a-model-for-easier-experimentation">
  Créer un `Model` pour faciliter l’expérimentation
</h2>

Une fois le traçage des appels individuels en place, l’étape suivante consiste à regrouper les paramètres associés afin de pouvoir comparer différentes configurations.

<Note>
  La classe `weave.Model` est disponible uniquement dans le SDK Python de Weave. En TypeScript, utilisez le wrapper `weave.op()` pour suivre des fonctions avec des paramètres structurés.
</Note>

Il est difficile d’organiser ses expériences lorsque de nombreux éléments évoluent en même temps. La classe [`Model`](/fr/products/wandb/weave/guides/core-types/models) vous permet de capturer et d’organiser les détails expérimentaux de votre application, comme votre prompt système ou le modèle que vous utilisez. Vous pouvez ainsi organiser et comparer les différentes itérations de votre application.

En plus d’assurer la gestion des versions du code et de capturer les entrées et les sorties, les modèles capturent des paramètres structurés qui contrôlent le comportement de votre application. Vous pouvez ainsi identifier plus facilement les paramètres les plus efficaces. Vous pouvez également utiliser les modèles Weave avec `serve` et les [évaluations](/fr/products/wandb/weave/guides/core-types/evaluations).

Dans l’exemple suivant, vous pouvez faire varier `model` et `temperature` :

```python lines theme={"system"}
import weave    
# utilisez la bibliothèque anthropic comme d’habitude
import os
from anthropic import Anthropic
weave.init('joker-anthropic')

class JokerModel(weave.Model): # Remplacez par `weave.Model`
  model: str
  temperature: float
  
  @weave.op()
  def predict(self, topic): # Remplacez par `predict`
    client = Anthropic()
    message = client.messages.create(
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": f"Tell me a joke about {topic}",
        }
        ],
        model=self.model,
        temperature=self.temperature
    )
    return message.content[0].text


joker = JokerModel(
    model="claude-3-haiku-20240307",
    temperature = 0.1)
result = joker.predict("Chickens and Robots")
print(result)
```

Chaque fois que vous modifiez l’une de ces valeurs, Weave crée et suit une nouvelle version de `JokerModel`. Vous pouvez ainsi associer les données de trace aux modifications de votre code, ce qui vous aide à déterminer quelles configurations conviennent le mieux à votre cas d’usage.

[<img src="https://mintcdn.com/coreweave-dbfa0e8d/3Dv_sw2eg8feUJlx/products/wandb/weave/_media/anthropic_model.png?fit=max&auto=format&n=3Dv_sw2eg8feUJlx&q=85&s=68d81f117bb003f5aaaf46d5f731b79c" alt="anthropic_model.png" width="2892" height="1464" data-path="products/wandb/weave/_media/anthropic_model.png" />](https://forge.coreweave.com/wandb/capecape/anthropic_project/weave/calls)

<h2 id="tools-function-calling">
  Outils (appel de fonctions)
</h2>

En plus des messages standard, Weave instrumente l’interface d’utilisation d’outils d’Anthropic, ce qui vous permet de tracer vos flux de travail agentiques de bout en bout.

Anthropic fournit une interface d’[outils](https://platform.claude.com/docs/en/agents-and-tools/tool-use/overview) qui permet à Claude de demander des appels de fonctions. Weave suit automatiquement les définitions d’outils, les requêtes d’utilisation d’outils et les résultats d’outils tout au long de la conversation.

Les exemples tronqués suivants illustrent une configuration d’outils Anthropic :

<Tabs>
  <Tab title="Python">
    ```python lines theme={"system"}
    message = client.messages.create(
        max_tokens=1024,
        messages=[
            {
                "role": "user",
                "content": "What's the weather like in San Francisco?",
            }
        ],
        tools=[
            {
                "name": "get_weather",
                "description": "Get the current weather in a given location",
                "input_schema": {
                    "type": "object",
                    "properties": {
                        "location": {
                            "type": "string",
                            "description": "The city and state, e.g. San Francisco, CA",
                        }
                    },
                    "required": ["location"],
                },
            },
        ],
        model=model,
    )

    print(message)
    ```
  </Tab>

  <Tab title="TypeScript">
    ```typescript twoslash theme={"system"}
    // @noErrors
    const message = await client.messages.create({
        max_tokens: 1024,
        messages: [
            {
                role: 'user',
                content: "What's the weather like in San Francisco?",
            }
        ],
        tools: [
            {
                name: 'get_weather',
                description: 'Get the current weather in a given location',
                input_schema: {
                    type: 'object',
                    properties: {
                        location: {
                            type: 'string',
                            description: 'The city and state, e.g. San Francisco, CA',
                        }
                    },
                    required: ['location'],
                },
            },
        ],
        model: 'claude-3-opus-20240229',
    });

    console.log(message);
    ```
  </Tab>
</Tabs>

Weave capture automatiquement les définitions d’outils, les requêtes d’utilisation d’outils émises par Claude et les résultats d’outils à chaque étape de la conversation.

[<img src="https://mintcdn.com/coreweave-dbfa0e8d/3Dv_sw2eg8feUJlx/products/wandb/weave/_media/anthropic_tool.png?fit=max&auto=format&n=3Dv_sw2eg8feUJlx&q=85&s=7afe7a26d7b84964a5aa948c8e7a4a31" alt="anthropic_tool.png" width="2512" height="1218" data-path="products/wandb/weave/_media/anthropic_tool.png" />](https://forge.coreweave.com/wandb/capecape/anthropic_project/weave/calls)


## Related topics

- [Connect Claude Code and Claude Desktop to CoreWeave Inference](/products/inference/connect-claude-code-and-desktop.md)