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

# Tracer des fonctions imbriquées

> Découvrez comment suivre des structures d'appel profondément imbriquées avec Tracing dans W&B

Ce tutoriel vous montre comment tracer des fonctions imbriquées dans Weave afin de pouvoir surveiller le flux d'exécution complet d'une application basée sur un LLM, y compris ses sous-fonctions et leurs relations parent-enfant. À la fin, vous saurez capturer, visualiser et ajouter des métadonnées à des traces imbriquées dans la page **Traces** de Weave.

Les applications basées sur des LLM peuvent contenir plusieurs appels LLM, des traitements de données supplémentaires et une logique de validation qu'il est important de surveiller. Vous pouvez suivre ces fonctions imbriquées et leurs relations parent-enfant dans Weave à l'aide du décorateur `@weave.op()` (Python), ou les encapsuler avec `weave.op()` (TypeScript).

Décorez les fonctions et sous-fonctions avec le niveau de granularité le plus fin possible afin de capturer le flux d'exécution complet de l'application. Cela vous aide à mieux comprendre et orienter le comportement de votre application.

<div id="trace-nested-functions">
  ## Tracer des fonctions imbriquées
</div>

Cette section présente pas à pas un exemple qui trace une fonction et ses sous-fonctions imbriquées. Le code suivant s'appuie sur l'[exemple de démarrage rapide](/fr/weave/quickstart) et ajoute une logique pour compter les éléments renvoyés par le LLM et les encapsuler dans une fonction de plus haut niveau. De plus, l'exemple utilise `weave.op()` pour tracer chaque fonction, son ordre d'appel et sa relation parent-enfant :

<Tabs>
  <Tab title="Python">
    ```python {1,7,26,32,42} theme={null}
    import weave
    import json
    from openai import OpenAI

    client = OpenAI()

    @weave.op()
    def extract_dinos(sentence: str) -> dict:
        response = client.chat.completions.create(
            model="gpt-4o",
            messages=[
                {
                    "role": "system",
                    "content": """Extract any dinosaur `name`, their `common_name`, \
    names and whether its `diet` is a herbivore or carnivore, in JSON format."""
                },
                {
                    "role": "user",
                    "content": sentence
                }
                ],
                response_format={ "type": "json_object" }
            )
        return response.choices[0].message.content

    @weave.op()
    def count_dinos(dino_data: dict) -> int:
        # compter le nombre d'éléments dans la liste renvoyée
        k = list(dino_data.keys())[0]
        return len(dino_data[k])

    @weave.op()
    def dino_tracker(sentence: str) -> dict:
        # extraire les dinosaures à l'aide d'un LLM
        dino_data = extract_dinos(sentence)

        # compter le nombre de dinosaures renvoyés
        dino_data = json.loads(dino_data)
        n_dinos = count_dinos(dino_data)
        return {"n_dinosaurs": n_dinos, "dinosaurs": dino_data}

    weave.init('jurassic-park')

    sentence = """I watched as a Tyrannosaurus rex (T. rex) chased after a Triceratops (Trike), \
    both carnivore and herbivore locked in an ancient dance. Meanwhile, a gentle giant \
    Brachiosaurus (Brachi) calmly munched on treetops, blissfully unaware of the chaos below."""

    result = dino_tracker(sentence)
    print(result)
    ```

    **Fonctions imbriquées**

    Lorsque vous exécutez le code ci-dessus, la page **Traces** affiche les entrées et les sorties des deux fonctions imbriquées (`extract_dinos` et `count_dinos`), ainsi que la trace OpenAI enregistrée automatiquement.

    <img src="https://mintcdn.com/wb-21fd5541/aRvhhwVWqlxBzke5/images/tutorial_tracing_2_nested_dinos.png?fit=max&auto=format&n=aRvhhwVWqlxBzke5&q=85&s=738409adb3ed286689728052142a50a5" alt="Page Traces de Weave avec fonctions imbriquées, montrant le panneau central de l'arborescence de trace et le panneau de détails pour l'Appel sélectionné" width="1354" height="1334" data-path="images/tutorial_tracing_2_nested_dinos.png" />
  </Tab>

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

    const openai = new OpenAI();

    const extractDinos = weave.op(async (sentence: string) => {
      const response = await openai.chat.completions.create({
        model: 'gpt-4o',
        messages: [
          {
            role: 'system',
            content:
              'Extract any dinosaur `name`, their `common_name`, names and whether its `diet` is a herbivore or carnivore, in JSON format.',
          },
          {role: 'user', content: sentence},
        ],
        response_format: {type: 'json_object'},
      });
      return response.choices[0].message.content;
    });

    const countDinos = weave.op(async (dinoData: string) => {
      const parsed = JSON.parse(dinoData);
      return Object.keys(parsed).length;
    });

    const dinoTracker = weave.op(async (sentence: string) => {
      const dinoData = await extractDinos(sentence);
      const nDinos = await countDinos(dinoData);
      return {nDinos, dinoData};
    });

    async function main() {
      await weave.init('jurassic-park');

      const sentence = `I watched as a Tyrannosaurus rex (T. rex) chased after a Triceratops (Trike),
            both carnivore and herbivore locked in an ancient dance. Meanwhile, a gentle giant
            Brachiosaurus (Brachi) calmly munched on treetops, blissfully unaware of the chaos below.`;

      const result = await dinoTracker(sentence);
      console.log(result);
    }

    main();

    ```

    **Fonctions imbriquées**

    Lorsque vous exécutez le code ci-dessus, la page **Traces** affiche les entrées et les sorties des deux fonctions imbriquées (`extract_dinos` et `count_dinos`), ainsi que la trace OpenAI enregistrée automatiquement.

    <img src="https://mintcdn.com/wb-21fd5541/aRvhhwVWqlxBzke5/images/tutorial_tracing_2_nested_dinos.png?fit=max&auto=format&n=aRvhhwVWqlxBzke5&q=85&s=738409adb3ed286689728052142a50a5" alt="Page Traces de Weave avec fonctions imbriquées, montrant le panneau central de l'arborescence de trace et le panneau de détails pour l'Appel sélectionné" width="1354" height="1334" data-path="images/tutorial_tracing_2_nested_dinos.png" />
  </Tab>
</Tabs>

Après avoir exécuté le code, vous disposez dans Weave d'une trace imbriquée complète qui capture chaque appel de fonction et sa relation avec les autres.

<div id="track-metadata">
  ## Suivre les métadonnées
</div>

Maintenant que Weave trace vos fonctions imbriquées, vous pouvez enrichir ces traces avec un contexte supplémentaire sur l’exécution, comme l’utilisateur ou l’environnement. Vous pouvez suivre les métadonnées à l’aide du gestionnaire de contexte `weave.attributes`, en lui passant un dictionnaire des métadonnées à suivre au moment de l’appel.

En reprenant l’exemple précédent :

<Tabs>
  <Tab title="Python">
    ```python lines {1,10-11} theme={null}
    import weave

    weave.init('jurassic-park')

    sentence = """I watched as a Tyrannosaurus rex (T. rex) chased after a Triceratops (Trike), \
    both carnivore and herbivore locked in an ancient dance. Meanwhile, a gentle giant \
    Brachiosaurus (Brachi) calmly munched on treetops, blissfully unaware of the chaos below."""

    # suivre les métadonnées avec la fonction définie précédemment
    with weave.attributes({'user_id': 'lukas', 'env': 'production'}):
        result = dino_tracker(sentence)
    ```
  </Tab>

  <Tab title="TypeScript">
    ```plaintext theme={null}
    Cette fonctionnalité n'est pas encore disponible en TypeScript.
    ```
  </Tab>
</Tabs>

<Note>
  Suivez les métadonnées au moment de l’exécution, comme vos ID utilisateur et l’environnement de votre code (développement, préproduction ou production).

  Pour suivre les paramètres système, comme un prompt système, utilisez [Weave Models](/fr/weave/guides/core-types/models).
</Note>

Pour plus d’informations sur l’utilisation des attributs, voir [Définir et journaliser des attributs](/fr/weave/guides/tools/attributes).

<div id="whats-next">
  ## Et ensuite
</div>

* Suivez le [tutoriel sur la gestion des versions des applications](/fr/weave/tutorial-weave_models) pour enregistrer, gérer les versions et organiser les modifications ad hoc des prompts, des modèles et des applications.