> ## 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 des fonctions imbriquées
> Découvrez comment suivre des structures d’appels profondément imbriquées grâce au traçage W&B
Ce tutoriel vous montre comment tracer des fonctions imbriquées dans Weave afin de 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. À l’issue de ce tutoriel, vous saurez capturer et visualiser des traces imbriquées, et leur ajouter des métadonnées, dans la page **Traces** de Weave.
Les applications basées sur des LLM peuvent comporter 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 en les encapsulant avec `weave.op()` (TypeScript).
Décorez les fonctions et sous-fonctions de la manière la plus granulaire possible afin de capturer le flux d’exécution complet de l’application. Vous pourrez ainsi mieux comprendre et façonner le comportement de votre application.
Tracer des fonctions imbriquées
Cette section détaille pas à pas un exemple qui trace une fonction et ses sous-fonctions imbriquées. Le code suivant reprend l’[exemple de démarrage rapide](/fr/products/wandb/weave/quickstart) et y ajoute une logique qui compte les éléments renvoyés par le LLM, puis les encapsule 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 :
```python {1,7,26,32,42} theme={"system"}
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 journalisée automatiquement.
```typescript twoslash theme={"system"}
// @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 journalisée automatiquement.
Une fois le code exécuté, vous obtenez dans Weave une trace imbriquée complète qui capture chaque appel de fonction ainsi que ses liens avec les autres appels.
Maintenant que Weave trace vos fonctions imbriquées, vous pouvez enrichir ces traces avec des informations de contexte supplémentaires sur le run, comme l’utilisateur ou l’environnement. Pour suivre des métadonnées, utilisez le gestionnaire de contexte `weave.attributes` en lui transmettant un dictionnaire des métadonnées à suivre au moment de l’appel.
Reprenons l’exemple précédent :
```python lines {1,10-11} theme={"system"}
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 en parallèle de la fonction définie précédemment
with weave.attributes({'user_id': 'lukas', 'env': 'production'}):
result = dino_tracker(sentence)
```
```plaintext theme={"system"}
This feature is not available in TypeScript yet.
```
Suivez les métadonnées au moment de l’exécution, comme les ID de vos utilisateurs et l’environnement d’exécution de votre code (développement, staging ou production).
Pour suivre les paramètres système, comme un prompt système, utilisez les [Weave Models](/fr/products/wandb/weave/guides/core-types/models).
Pour plus d’informations sur l’utilisation des attributs, consultez [Définir et journaliser des attributs](/fr/products/wandb/weave/guides/tools/attributes).
Étapes suivantes
* Suivez le [tutoriel sur la gestion des versions des applications](/fr/products/wandb/weave/tutorial-weave_models) pour capturer, versionner et organiser les modifications ad hoc apportées aux prompts, aux modèles et aux applications.