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

# Tracer votre code

> Instrumentez votre code afin que son exécution apparaisse sous forme de traces détaillées dans W&B Weave.

Ce guide explique comment instrumenter votre application afin que son exécution apparaisse sous forme de traces détaillées dans W\&B Weave. Les traces vous aident à déboguer, évaluer et surveiller du code reposant sur des LLM : elles capturent les entrées, les sorties et la structure de chaque opération sous forme d’Appel.

Pour visualiser l’exécution de votre code sous forme de traces détaillées dans Weave, vous devez créer des Appels. Les sections suivantes décrivent les trois principales méthodes pour y parvenir, de la plus automatique à la plus manuelle :

* Suivi automatique des appels aux bibliothèques de LLM.
* Suivi des fonctions personnalisées avec `weave.op`.
* Suivi manuel des Appels directement à l’aide de l’API.

Choisissez l’approche adaptée au niveau de contrôle dont vous avez besoin sur ce qui est tracé.

<h2 id="automatic-tracking-of-llm-library-calls">
  Suivi automatique des appels aux bibliothèques LLM
</h2>

Weave s’intègre automatiquement à de nombreux frameworks et bibliothèques courants, tels que `openai`, `anthropic`, `cohere`, `mistral` et `LangChain`. Importez la bibliothèque LLM ou le framework, puis initialisez votre projet Weave. Weave trace alors automatiquement dans votre projet tous les appels effectués vers le LLM ou la plateforme, sans aucune autre modification du code. Pour obtenir la liste complète des intégrations de bibliothèques prises en charge, consultez [Aperçu des intégrations](/fr/products/wandb/weave/guides/integrations).

<Tabs>
  <Tab title="Python">
    ```python lines theme={"system"}
    import weave

    from openai import OpenAI
    client = OpenAI()

    # Initialiser Weave Tracing
    weave.init('intro-example')

    response = client.chat.completions.create(
        model="gpt-4",
        messages=[
            {
                "role": "user",
                "content": "How are you?"
            }
        ],
        temperature=0.8,
        max_tokens=64,
        top_p=1,
    )
    ```
  </Tab>

  <Tab title="TypeScript">
    ```typescript twoslash lines theme={"system"}
    // @noErrors
    import OpenAI from 'openai'
    import * as weave from 'weave'

    const client = new OpenAI()

    // Initialiser Weave Tracing
    await weave.init('intro-example')

    const response = await client.chat.completions.create({
      model: 'gpt-4',
      messages: [
        {
          role: 'user',
          content: 'How are you?',
        },
      ],
      temperature: 0.8,
      max_tokens: 64,
      top_p: 1,
    });
    ```

    Pour un guide de configuration complet des projets JavaScript et TypeScript, consultez le [SDK TypeScript : guide d’intégration des outils tiers](/fr/products/wandb/weave/guides/integrations/js).
  </Tab>
</Tabs>

Pour mieux contrôler ce comportement automatique, consultez [Configurer le suivi automatique des appels LLM](/fr/products/wandb/weave/guides/integrations/autopatching).

<h2 id="track-custom-functions">
  Suivre des fonctions personnalisées
</h2>

Les applications LLM comportent souvent une logique supplémentaire que vous souhaitez suivre : prétraitement et post-traitement, prompts, etc. Utilisez cette approche lorsque vous voulez que Weave capture vos propres fonctions en plus des appels LLM qu’il trace automatiquement.

<Tabs>
  <Tab title="Python">
    Weave vous permet de suivre manuellement ces appels à l’aide du décorateur [`@weave.op`](/fr/products/wandb/weave/reference/python-sdk#function-op). Par exemple :

    ```python lines theme={"system"}
    import weave

    # Initialiser Weave Tracing
    weave.init('intro-example')

    # Décorer votre fonction
    @weave.op
    def my_function(name: str):
        return f"Hello, {name}!"

    # Appeler votre fonction -- Weave suivra automatiquement les entrées et les sorties
    print(my_function("World"))
    ```

    Vous pouvez également suivre les [méthodes de classes](#track-class-and-object-methods).
  </Tab>

  <Tab title="TypeScript">
    Weave vous permet de suivre manuellement ces appels en encapsulant votre fonction avec [`weave.op`](/fr/products/wandb/weave/reference/typescript-sdk/functions/op). Par exemple :

    ```typescript twoslash lines theme={"system"}
    // @noErrors
    import * as weave from 'weave'

    await weave.init('intro-example')

    function myFunction(name: string) {
        return `Hello, ${name}!`
    }

    const myFunctionOp = weave.op(myFunction)
    ```

    Vous pouvez également définir l’encapsulation en ligne :

    ```typescript twoslash lines theme={"system"}
    // @noErrors
    const myFunctionOp = weave.op((name: string) => `Hello, ${name}!`)
    ```

    Cela fonctionne aussi bien pour les fonctions que pour les méthodes de classes :

    ```typescript twoslash lines theme={"system"}
    // @noErrors
    class MyClass {
        constructor() {
            this.myMethod = weave.op(this.myMethod)
        }

        myMethod(name: string) {
            return `Hello, ${name}!`
        }
    }
    ```
  </Tab>
</Tabs>

<h3 id="track-class-and-object-methods">
  Suivre les méthodes de classe et d’objet
</h3>

Outre les fonctions autonomes, vous pouvez suivre les méthodes de classe et d’objet. Pour suivre n’importe quelle méthode d’une classe, décorez-la avec `weave.op`.

<Tabs>
  <Tab title="Python">
    ```python lines theme={"system"}
    import weave

    # Initialiser Weave Tracing
    weave.init("intro-example")

    class MyClass:
        # Décorez votre méthode
        @weave.op
        def my_method(self, name: str):
            return f"Hello, {name}!"

    instance = MyClass()

    # Appelez votre méthode -- Weave suivra automatiquement les entrées et les sorties
    print(instance.my_method("World"))
    ```
  </Tab>

  <Tab title="TypeScript">
    <Important>
      **Utiliser des décorateurs en TypeScript**

      Pour utiliser le décorateur `@weave.op` dans votre code TypeScript, assurez-vous que votre environnement est correctement configuré :

      * **TypeScript v5.0 ou version ultérieure** : les décorateurs sont pris en charge nativement, sans configuration supplémentaire.
      * **TypeScript antérieur à la v5.0** : activez la prise en charge expérimentale des décorateurs. Pour plus de détails, consultez la [documentation officielle de TypeScript sur les décorateurs](https://www.typescriptlang.org/docs/handbook/decorators.html).
    </Important>

    Vous pouvez appliquer `@weave.op` aux méthodes d’instance pour les tracer.

    ```typescript twoslash lines theme={"system"}
    // @noErrors
    class Foo {
        @weave.op
        async predict(prompt: string) {
            return "bar"
        }
    }
    ```

    Vous pouvez également appliquer `@weave.op` aux méthodes statiques pour surveiller les fonctions utilitaires d’une classe.

    ```typescript twoslash lines theme={"system"}
    // @noErrors
    class MathOps {
        @weave.op
        static square(n: number): number {
            return n * n;
        }
    }
    ```
  </Tab>
</Tabs>

<h3 id="trace-parallel-multi-threaded-function-calls">
  Tracer les appels de fonctions parallèles (multithread)
</h3>

Par défaut, les appels parallèles apparaissent tous dans Weave comme des appels racines distincts, ce qui rend la hiérarchie de la trace difficile à suivre. Pour les imbriquer correctement sous le même op parent, utilisez un `ThreadPoolExecutor`.

<Tabs>
  <Tab title="Python">
    L’exemple de code suivant illustre l’utilisation de [`ThreadPoolExecutor`](/fr/products/wandb/weave/reference/python-sdk/trace/util#class-contextawarethreadpoolexecutor).
    La première fonction, `func`, est un op simple qui prend `x` et renvoie `x+1`. La seconde fonction, `outer`, est un autre op qui accepte une liste d’entrées.
    Dans `outer`, l’utilisation de `ThreadPoolExecutor` et de `exc.map(func, inputs)` garantit que chaque appel à `func` conserve le même contexte de la trace parente.

    ```python lines theme={"system"}
    import weave

    @weave.op
    def func(x):
        return x+1

    @weave.op
    def outer(inputs):
        with weave.ThreadPoolExecutor() as exc:
            exc.map(func, inputs)

    # Mettez à jour le nom de votre projet Weave
    client = weave.init('my-weave-project')
    outer([1,2,3,4,5])
    ```
  </Tab>

  <Tab title="TypeScript">
    ```text theme={"system"}
    This feature is not available in the TypeScript SDK yet.
    ```
  </Tab>
</Tabs>

Dans l’interface de Weights & Biases, vous obtenez ainsi un seul appel parent comportant cinq appels enfants imbriqués. La trace est entièrement hiérarchique, même si les incréments s’exécutent en parallèle.

<img src="https://mintcdn.com/coreweave-dbfa0e8d/3Dv_sw2eg8feUJlx/products/wandb/weave/_media/threadpoolexecutor.png?fit=max&auto=format&n=3Dv_sw2eg8feUJlx&q=85&s=4184d6f408770b1a9df810397986e689" alt="L’interface Trace, montrant un seul appel parent pour outer, avec cinq appels enfants imbriqués." width="720" height="418" data-path="products/wandb/weave/_media/threadpoolexecutor.png" />

<h2 id="manual-call-tracking">
  Suivi manuel des appels
</h2>

Si ni l’intégration automatique ni le décorateur `weave.op` ne conviennent à votre flux de travail, vous pouvez créer manuellement des appels directement à l’aide de l’API. Cette approche vous offre un contrôle complet sur le début et la fin d’un appel, au prix d’un code répétitif plus abondant.

<Tabs>
  <Tab title="Python">
    ```python lines theme={"system"}
    import weave

    # Initialiser Weave Tracing
    client = weave.init('intro-example')

    def my_function(name: str):
        # Démarrer un appel
        call = client.create_call(op="my_function", inputs={"name": name})

        # ... le code de votre fonction ...

        # Terminer un appel
        client.finish_call(call, output="Hello, World!")

        # Appeler votre fonction
        print(my_function("World"))
    ```
  </Tab>

  <Tab title="TypeScript">
    ```text theme={"system"}
    Cette fonctionnalité n’est pas encore disponible dans le SDK TypeScript.
    ```
  </Tab>

  <Tab title="HTTP API">
    * Démarrer un appel : [POST `/call/start`](/fr/products/wandb/weave/reference/service-api/calls/call-start).
    * Terminer un appel : [POST `/call/end`](/fr/products/wandb/weave/reference/service-api/calls/call-end).

    ```bash lines theme={"system"}
    curl -L 'https://trace.wandb.ai/call/start' \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json' \
    -d '{
        "start": {
            "project_id": "string",
            "id": "string",
            "op_name": "string",
            "display_name": "string",
            "trace_id": "string",
            "parent_id": "string",
            "started_at": "2024-09-08T20:07:34.849Z",
            "attributes": {},
            "inputs": {},
            "wb_run_id": "string"
        }
    }
    ```
  </Tab>
</Tabs>


## Related topics

- [Découvrir Weave avec Serverless Inference](/fr/products/wandb/weave/quickstart-inference.md)