> ## Documentation Index
> Fetch the complete documentation index at: https://wb-21fd5541-docs-hivemind-launch.mintlify.site/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 celle-ci apparaisse sous forme de traces détaillées dans W&B Weave.

Pour afficher votre code en cours d’exécution sous forme de traces détaillées dans Weave, créez des appels. Vous pouvez procéder de trois façons principales :

<div id="1-automatic-tracking-of-llm-library-calls">
  ## 1. Suivi automatique des appels de bibliothèques LLM
</div>

Weave s’intègre automatiquement à de nombreuses intégrations et frameworks courants, comme `openai`, `anthropic`, `cohere`, `mistral` et `LangChain`.
Importez la bibliothèque LLM ou le framework, initialisez votre projet Weave, puis Weave trace automatiquement tous les appels effectués vers le LLM ou la plateforme dans votre projet,
sans aucune 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 lines theme={null}
    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 JS / TS, voir le [SDK TypeScript : guide d’intégration tierce](/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="2-tracking-of-custom-functions">
  ## 2. 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.

<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écorer 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 lines theme={null}
    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 lines theme={null}
    const myFunctionOp = weave.op((name: string) => `Hello, ${name}!`)
    ```

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

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

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 lines theme={null}
    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 lines theme={null}
    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. 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">
    ```plaintext 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, ce qui vous permet d'obtenir 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-docs-hivemind-launch/IJ5wvwHtTZtWc35M/weave/guides/tracking/imgs/threadpoolexecutor.png?fit=max&auto=format&n=IJ5wvwHtTZtWc35M&q=85&s=37f45d42ef6e502ffa53e67b7257d2e7" 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="3-manual-call-tracking">
  ## 3. Suivi manuel des appels
</div>

Vous pouvez également créer manuellement des appels directement via l'API.

<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})

        # ... 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">
    ```plaintext 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>