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

# Personnaliser les Ops

> Découvrez comment colorer vos Ops pour mieux les repérer, comment modifier ce qui est journalisé et comment contrôler le taux d’échantillonnage

Une op Weave est une fonction versionnée qui journalise automatiquement tous les Appels. Ce guide s’adresse aux développeurs qui utilisent Weave pour instrumenter leur code et vous montre comment créer des Ops, personnaliser leur apparence dans l’interface Weave, contrôler les données que Weave journalise et gérer l’échantillonnage ainsi que la suppression.

<Tabs>
  <Tab title="Python">
    Pour créer une op, décorez une fonction Python avec `weave.op()`.

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

    @weave.op()
    def track_me(v):
        return v + 5

    weave.init('intro-example')
    track_me(15)
    ```

    L’appel d’une op crée une nouvelle version de l’op si le code a changé depuis le dernier appel, et journalise les entrées et les sorties de la fonction.

    Les fonctions que vous décorez avec `@weave.op()` se comportent normalement (sans gestion des versions du code ni suivi) si vous n’appelez pas `weave.init('your-project-name')` avant de les appeler.

    Vous pouvez [mettre en service](/fr/weave/guides/tools/serve) ou [déployer](/fr/weave/guides/tools/deploy) des Ops à l’aide du toolbelt de Weave.
  </Tab>

  <Tab title="TypeScript">
    Pour créer une op, enveloppez une fonction TypeScript avec `weave.op`.

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

    function trackMe(v: number) {
        return v + 5
    }

    const trackMeOp = weave.op(trackMe)
    trackMeOp(15)

    // Vous pouvez aussi le faire en ligne, ce qui peut être plus pratique
    const trackMeInline = weave.op((v: number) => v + 5)
    trackMeInline(15)
    ```
  </Tab>
</Tabs>

<div id="customize-display-names">
  ## Personnaliser les noms d’affichage
</div>

Un nom d’affichage personnalisé facilite l’identification d’un Op dans l’interface Weave, en particulier lorsque le nom de la fonction est générique ou généré automatiquement.

<Tabs>
  <Tab title="Python">
    Vous pouvez personnaliser le nom d’affichage de l’op en définissant le paramètre `name` dans le décorateur `@weave.op` :

    ```python lines theme={null}
    @weave.op(name="custom_name")
    def func():
        ...
    ```
  </Tab>

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

<div id="apply-kinds-and-colors">
  ## Appliquer des types et des couleurs
</div>

Pour mieux organiser vos Ops dans l’interface Weave, attribuez-leur des types et des couleurs personnalisés en ajoutant les arguments `kind` et `color` aux décorateurs `@weave.op` dans votre code. Par exemple, le code suivant attribue le type `LLM` et la couleur `blue` à la fonction parente, ainsi que le type `tool` et la couleur `red` à une fonction imbriquée :

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

    weave.init("[YOUR-TEAM-NAME]/[YOUR-PROJECT-NAME]")

    @weave.op(kind="LLM", color="blue")
    def llm_func():
        @weave.op(kind="tool", color="red")
        def tool_func():
            return "tool result"

        tool_result = tool_func()
        
        return f"llm result with {tool_result}"

    llm_func()
    ```
  </Tab>

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

Cela applique ces couleurs et ces types à vos Ops dans l’interface Weave, comme ceci :

<Frame>
  <img src="https://mintcdn.com/wb-21fd5541/mYTjDOL9RmCf9f6G/images/weave/weave_colors_kinds.png?fit=max&auto=format&n=mYTjDOL9RmCf9f6G&q=85&s=1da0fd3625dbba102fa17c7d3b6c4f03" alt="La interface Weave, montrant un appel parent avec le type LLM et la couleur blue, ainsi qu’un appel imbriqué avec le type tool et la couleur red." width="1288" height="605" data-path="images/weave/weave_colors_kinds.png" />
</Frame>

Les valeurs `kind` disponibles sont :

* `agent`
* `llm`
* `tool`
* `search`

Les valeurs `color` disponibles sont :

* `red`
* `orange`
* `yellow`
* `green`
* `blue`
* `purple`

<div id="customize-logged-inputs-and-outputs">
  ## Personnaliser les entrées et sorties enregistrées
</div>

<Tabs>
  <Tab title="Python">
    Pour modifier les données que Weave enregistre sans modifier la fonction d’origine (par exemple, pour masquer des données sensibles), passez `postprocess_inputs` et `postprocess_output` au décorateur `op`.

    `postprocess_inputs` prend en entrée un `dict` où les clés sont les noms des arguments et les valeurs, les valeurs des arguments, puis renvoie un `dict` contenant les entrées transformées.

    `postprocess_output` prend en entrée n’importe quelle valeur normalement renvoyée par la fonction et renvoie la sortie transformée.

    ```python lines theme={null}
    from dataclasses import dataclass
    from typing import Any
    import weave

    @dataclass
    class CustomObject:
        x: int
        secret_password: str

    def postprocess_inputs(inputs: dict[str, Any]) -> dict[str, Any]:
        return {k:v for k,v in inputs.items() if k != "hide_me"}

    def postprocess_output(output: CustomObject) -> CustomObject:
        return CustomObject(x=output.x, secret_password="REDACTED")

    @weave.op(
        postprocess_inputs=postprocess_inputs,
        postprocess_output=postprocess_output,
    )
    def func(a: int, hide_me: str) -> CustomObject:
        return CustomObject(x=a, secret_password=hide_me)

    weave.init('hide-data-example')
    func(a=1, hide_me="password123")
    ```
  </Tab>

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

<div id="control-sampling-rate">
  ## Contrôler le taux d’échantillonnage
</div>

<Tabs>
  <Tab title="Python">
    Pour contrôler la fréquence à laquelle Weave trace les appels d’une op, définissez le paramètre `tracing_sample_rate` dans le décorateur `@weave.op`. Utilisez cette option pour les Ops à haute fréquence lorsque vous n’avez besoin de tracer qu’un sous-ensemble des appels.

    Collectez toutes les traces pendant le développement de l’agent afin de mieux définir et comprendre son comportement. En production, configurez l’échantillonnage des traces pour réduire les coûts tout en conservant l’observabilité du comportement de votre agent.

    Weave applique les taux d’échantillonnage uniquement aux Ops de plus haut niveau. Si une op imbriquée possède un taux d’échantillonnage mais qu’une op parente l’appelle d’abord, Weave ignore le taux d’échantillonnage de l’op imbriquée.

    ```python lines theme={null}
    @weave.op(tracing_sample_rate=0.1)  # Tracer seulement ~10 % des appels
    def high_frequency_op(x: int) -> int:
        return x + 1

    @weave.op(tracing_sample_rate=1.0)  # Toujours tracer (par défaut)
    def always_traced_op(x: int) -> int:
        return x + 1
    ```

    Lorsque Weave n’échantillonne pas l’appel d’une op :

    * La fonction s’exécute normalement.
    * Weave ne reçoit aucune donnée de trace.
    * Weave ne trace pas les Ops enfants pour cet appel.

    Le taux d’échantillonnage doit être compris entre 0.0 et 1.0 inclus.
  </Tab>

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

<div id="control-call-link-output">
  ## Contrôler l’affichage des liens d’appel
</div>

Par défaut, Weave affiche un lien vers chaque Appel au moment de sa journalisation. Pour empêcher l’affichage des liens d’appel pendant le logging, définissez la variable d’environnement `WEAVE_PRINT_CALL_LINK` sur `false`. Utilisez ce réglage pour réduire la verbosité de la sortie et alléger vos journaux.

```bash lines theme={null}
export WEAVE_PRINT_CALL_LINK=false
```

<div id="delete-an-op">
  ## Supprimer un Op
</div>

La suppression d’une version d’un Op la retire de votre projet. Utilisez cette action pour nettoyer les versions obsolètes ou indésirables.

<Tabs>
  <Tab title="Python">
    Pour supprimer une version d'un Op, appelez `.delete()` sur la référence de l'Op.

    ```python lines theme={null}
    weave.init('intro-example')
    my_op_ref = weave.ref('track_me:v1')
    my_op_ref.delete()
    ```

    Tenter d'accéder à un Op supprimé renvoie une erreur.
  </Tab>

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