> ## Documentation Index
> Fetch the complete documentation index at: https://wb-21fd5541-wbdocs-1882.mintlify.site/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 via 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 dans votre code, il suit et consigne automatiquement les appels LLM effectués avec le SDK Anthropic, aussi bien en [Python](https://github.com/anthropics/anthropic-sdk-python) qu'en [TypeScript](https://github.com/anthropics/anthropic-sdk-typescript). Weave le fait en appelant automatiquement la méthode `Messages.create()` d'Anthropic.

<div id="traces">
  ## Traces
</div>

Weave capture automatiquement les traces du SDK Anthropic lorsque vous ajoutez `weave.init("your-team-name/your-project-name")` à votre code. Si vous ne spécifiez pas de nom d’équipe comme argument dans `weave.init()`, Weave envoie la sortie vers votre [entité W\&B par défaut](/fr/platform/app/settings-page/user-settings/#default-team). Si vous ne spécifiez pas de nom de projet, Weave ne parvient pas à s’initialiser.

Les exemples suivants montrent comment intégrer Weave dans un appel simple à Anthropic :

<Tabs>
  <Tab title="Python">
    ```python lines {6} theme={null}
    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 theme={null}
    import Anthropic from '@anthropic-ai/sdk';
    import * as weave from 'weave';
    import { wrapAnthropic } from 'weave';

    await weave.init('anthropic_project');

    // Enveloppez le client Anthropic pour activer le tracing
    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>

En incluant `weave.init()` dans le code, Weave capture automatiquement les informations de tracing et affiche des liens. Vous pouvez consulter les traces dans l’interface Weave en cliquant sur ces liens.

[<img src="https://mintcdn.com/wb-21fd5541-wbdocs-1882/kTNBEU9hU1PbozeW/weave/guides/integrations/imgs/anthropic_trace.png?fit=max&auto=format&n=kTNBEU9hU1PbozeW&q=85&s=a2a4a9e0e0c0edc62670c167dcba038e" alt="anthropic_trace.png" width="3024" height="1594" data-path="weave/guides/integrations/imgs/anthropic_trace.png" />](https://wandb.ai/capecape/anthropic_project/weave/calls)

<div id="wrapping-with-your-own-ops">
  ## Utiliser vos propres ops
</div>

Les ops Weave versionnent automatiquement votre code au fil de vos expériences et en capturent les entrées et les sorties. En décorant une fonction avec [`@weave.op()`](https://docs.wandb.ai/weave/guides/tracking/ops) (Python) ou en l'encapsulant avec [`weave.op()`](/fr/weave/reference/typescript-sdk/functions/op) (TypeScript), si elle appelle [`Anthropic.messages.create()`](https://platform.claude.com/docs/en/build-with-claude/working-with-messages), Weave suit automatiquement ses entrées et ses sorties.

Les exemples suivants montrent comment suivre une fonction :

<Tabs>
  <Tab title="Python">
    ```python lines {5,10,24} theme={null}
    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 theme={null}
    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>

En décorant ou en encapsulant la fonction avec `weave.op()`, Weave capture le code de la fonction, ses entrées 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/wb-21fd5541-wbdocs-1882/kTNBEU9hU1PbozeW/weave/guides/integrations/imgs/anthropic_ops.png?fit=max&auto=format&n=kTNBEU9hU1PbozeW&q=85&s=d96c84d2ce0c71bc925788a164625023" alt="anthropic_ops.png" width="2682" height="1282" data-path="weave/guides/integrations/imgs/anthropic_ops.png" />](https://docs.wandb.ai/weave/guides/tracking/ops)

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

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

Il est difficile d’organiser l’expérimentation lorsqu’il y a de nombreux éléments en jeu. En utilisant la classe [`Model`](/fr/weave/guides/core-types/models), vous pouvez capturer et organiser les détails de vos expériences dans votre application, comme votre prompt système ou le modèle que vous utilisez. Cela facilite l’organisation et la comparaison des différentes itérations de votre application.

En plus de gérer les versions du code et de capturer les entrées/sorties, les [`Model`](/fr/weave/guides/core-types/models) capturent des paramètres structurés qui contrôlent le comportement de votre application. Cela peut vous aider à déterminer quels paramètres fonctionnent le mieux. Vous pouvez également utiliser les Weave Models avec `serve` et les [`Évaluations`](/fr/weave/guides/core-types/evaluations).

Dans l’exemple suivant, vous pouvez expérimenter avec `model` et `temperature` :

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

class JokerModel(weave.Model): # Remplacer par `weave.Model`
  model: str
  temperature: float

  @weave.op()
  def predict(self, topic): # Remplacer 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 enregistre une nouvelle version de `JokerModel`. Vous pouvez ainsi associer des données de trace à vos modifications de code et déterminer plus facilement quelles configurations sont les mieux adaptées à votre cas d’usage.

[<img src="https://mintcdn.com/wb-21fd5541-wbdocs-1882/kTNBEU9hU1PbozeW/weave/guides/integrations/imgs/anthropic_model.png?fit=max&auto=format&n=kTNBEU9hU1PbozeW&q=85&s=0946ad20cf853d491632809ebe0c1b6f" alt="anthropic_model.png" width="3008" height="1464" data-path="weave/guides/integrations/imgs/anthropic_model.png" />](https://wandb.ai/capecape/anthropic_project/weave/calls)

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

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 fonction. Weave suit automatiquement les définitions d’outils, les requêtes d’utilisation d’outils et les résultats des outils tout au long de la conversation.

Les exemples tronqués suivants montrent une configuration d’outil Anthropic :

<Tabs>
  <Tab title="Python">
    ```python lines theme={null}
    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 theme={null}
    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 de Claude et les résultats des outils à chaque étape de la conversation.

[<img src="https://mintcdn.com/wb-21fd5541-wbdocs-1882/kTNBEU9hU1PbozeW/weave/guides/integrations/imgs/anthropic_tool.png?fit=max&auto=format&n=kTNBEU9hU1PbozeW&q=85&s=cab9f29cbd7938732f6c28048d2644a2" alt="anthropic_tool.png" width="2628" height="1218" data-path="weave/guides/integrations/imgs/anthropic_tool.png" />](https://wandb.ai/capecape/anthropic_project/weave/calls)