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

# Tracez votre code

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

Ce guide vous montre 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 le code basé sur des LLM en capturant les entrées, les sorties et la structure de chaque opération sous forme d’Appel.

Pour voir votre code en cours d’exécution sous forme de traces détaillées dans Weave, créez des Appels. Les sections suivantes décrivent les trois principales façons de procéder, de la plus automatisée à la plus manuelle :

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

Choisissez l’approche qui correspond au niveau de contrôle dont vous avez besoin sur les éléments à tracer.

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

Weave s’intègre automatiquement à de nombreuses bibliothèques et frameworks courants, tels que `openai`, `anthropic`, `cohere`, `mistral` et `LangChain`. Importez la bibliothèque LLM ou le framework, puis initialisez votre projet Weave. Weave trace ensuite automatiquement tous les Appels adressés au LLM ou à la plateforme dans votre projet, sans nécessiter de modification de code supplémentaire. Pour obtenir la liste complète des intégrations de bibliothèques prises en charge, voir [Aperçu des intégrations](/fr/weave/guides/integrations/).

<Tabs>
  <Tab title="Python">
    ```python lines theme={null}
    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={null}
    // @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 obtenir un guide complet de configuration pour les projets JavaScript et TypeScript, voir le [SDK TypeScript : guide d’intégration de bibliothèques tierces](/fr/weave/guides/integrations/js).
  </Tab>
</Tabs>

Si vous souhaitez mieux contrôler le comportement automatique, voir [Configurer le suivi automatique des Appels LLM](/fr/weave/guides/integrations/autopatching).

<div id="track-custom-functions">
  ## Suivi des fonctions personnalisées
</div>

Les applications LLM comportent souvent une logique supplémentaire (comme le prétraitement/post-traitement, les prompts, etc.) que vous souhaitez suivre. Utilisez cette approche lorsque vous souhaitez 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/weave/reference/python-sdk/#function-op). Par exemple :

    ```python lines theme={null}
    import weave

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

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

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

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

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

    ```typescript twoslash lines theme={null}
    // @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 aussi le faire directement en ligne :

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

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

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

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

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

En plus des fonctions autonomes, vous pouvez également suivre les méthodes de classe et d’instance. Vous pouvez suivre n’importe quelle méthode d’une classe en la décorant avec `weave.op`.

<Tabs>
  <Tab title="Python">
    ```python lines theme={null}
    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>
      **Utilisation 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 plus récent** : les décorateurs sont pris en charge nativement et aucune configuration supplémentaire n’est requise.
      * **TypeScript antérieur à v5.0** : activez la prise en charge expérimentale des décorateurs. Pour plus de détails, voir 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 le Tracing.

    ```typescript twoslash lines theme={null}
    // @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={null}
    // @noErrors
    class MathOps {
        @weave.op
        static square(n: number): number {
            return n * n;
        }
    }
    ```
  </Tab>
</Tabs>

<div id="trace-parallel-multi-threaded-function-calls">
  ### Tracer des appels de fonction parallèles (multithread)
</div>

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

<Tabs>
  <Tab title="Python">
    L'exemple de code suivant montre comment utiliser [`ThreadPoolExecutor`](/fr/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 deuxième 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)` signifie que chaque appel à `func` conserve le même contexte de trace parent.

    ```python lines theme={null}
    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={null}
    Cette fonctionnalité n'est pas encore disponible dans le SDK TypeScript.
    ```
  </Tab>
</Tabs>

Dans la Weave UI, cela produit un seul appel parent avec cinq appels enfants imbriqués. Vous obtenez une trace entièrement hiérarchisée, même si les opérations d'incrémentation s'exécutent en parallèle.

<img src="https://mintcdn.com/wb-21fd5541/4ANo4MV8FzCjYewG/weave/guides/tracking/imgs/threadpoolexecutor.png?fit=max&auto=format&n=4ANo4MV8FzCjYewG&q=85&s=ec1fa79cd0f5817a7b5de1aed5aca11c" alt="La Trace UI, montrant un seul appel parent pour outer, avec cinq appels enfants imbriqués." width="720" height="418" data-path="weave/guides/tracking/imgs/threadpoolexecutor.png" />

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

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 via l’API. Cette approche vous donne un contrôle complet sur le moment où un appel commence et se termine, au prix de davantage de code standard.

<Tabs>
  <Tab title="Python">
    ```python lines theme={null}
    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={null}
    Cette fonctionnalité n'est pas encore disponible dans le SDK TypeScript.
    ```
  </Tab>

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

    ```bash lines theme={null}
    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>