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

# Personnaliser les ops

> Découvrez comment attribuer une couleur à vos ops pour une meilleure visibilité, comment modifier les données journalisées et comment contrôler le taux d’échantillonnage

Un Weave Op 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. Il explique comment créer des ops, personnaliser leur affichage dans l’interface Weights & Biases, contrôler les données journalisées par Weave, et gérer l’échantillonnage et la suppression.

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

    ```python lines theme={"system"}
    import weave

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

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

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

    Les fonctions décorées 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 [servir](/fr/products/wandb/weave/guides/tools/serve) ou [déployer](/fr/products/wandb/weave/guides/tools/deploy) des ops à l’aide des outils de Weave.
  </Tab>

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

    ```typescript twoslash lines theme={"system"}
    // @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>

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

Un nom d’affichage personnalisé permet d’identifier plus facilement un op dans l’interface Weights & Biases, en particulier lorsque le nom de la fonction est générique ou généré automatiquement.

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

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

  <Tab title="TypeScript">
    ```text theme={"system"}
    This feature is not available in TypeScript yet.
    ```
  </Tab>
</Tabs>

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

Pour mieux organiser vos ops dans l’interface Weights & Biases, appliquez des types et des couleurs personnalisés en ajoutant les arguments `kind` et `color` aux décorateurs `@weave.op` de votre code. Par exemple, le code suivant attribue à la fonction parente la valeur `LLM` pour `kind` et `blue` pour `color`, et à une fonction imbriquée la valeur `tool` pour `kind` et `red` pour `color` :

<Tabs>
  <Tab title="Python">
    ```python lines theme={"system"}
    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={"system"}
    This feature is not available in TypeScript yet.
    ```
  </Tab>
</Tabs>

Les couleurs et les types s’appliquent alors à vos ops dans l’interface Weights & Biases, comme ceci :

<Frame>
  <img src="https://mintcdn.com/coreweave-dbfa0e8d/3Dv_sw2eg8feUJlx/products/wandb/weave/_media/weave_colors_kinds.png?fit=max&auto=format&n=3Dv_sw2eg8feUJlx&q=85&s=b2bac689704aa30088eea3c1311fc492" alt="L’interface Weights & Biases, affichant 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="1234" height="605" data-path="products/wandb/weave/_media/weave_colors_kinds.png" />
</Frame>

Les valeurs disponibles pour `kind` sont :

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

Les valeurs disponibles pour `color` sont :

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

<h2 id="customize-logged-inputs-and-outputs">
  Personnaliser les entrées et sorties journalisées
</h2>

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

    `postprocess_inputs` accepte un dict dont les clés sont les noms des arguments et les valeurs, les valeurs de ces arguments, puis renvoie un dict contenant les entrées transformées.

    `postprocess_output` accepte n’importe quelle valeur que la fonction renverrait normalement et renvoie la sortie transformée.

    ```python lines theme={"system"}
    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={"system"}
    Cette fonctionnalité n’est pas encore disponible en TypeScript.
    ```
  </Tab>
</Tabs>

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

<Tabs>
  <Tab title="Python">
    Pour contrôler la fréquence à laquelle Weave trace les appels d’un op, définissez le paramètre `tracing_sample_rate` dans le décorateur `@weave.op`. Cette option est utile pour les ops appelés très fréquemment, pour lesquels il suffit de tracer une partie des appels.

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

    Weave applique les taux d’échantillonnage uniquement aux ops de plus haut niveau. Si un op imbriqué possède un taux d’échantillonnage mais qu’il est d’abord appelé par un op parent, Weave ignore le taux d’échantillonnage de l’op imbriqué.

    ```python lines theme={"system"}
    @weave.op(tracing_sample_rate=0.1)  # Tracer uniquement ~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’un op :

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

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

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

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

Par défaut, Weave affiche un lien vers chaque Appel au moment où il le journalise. Pour ne plus afficher les liens d’Appel pendant la journalisation, définissez la variable d’environnement `WEAVE_PRINT_CALL_LINK` sur `false`. Cela permet de réduire la verbosité de la sortie et d’alléger vos journaux.

```bash lines theme={"system"}
export WEAVE_PRINT_CALL_LINK=false
```

<h2 id="delete-an-op">
  Supprimer un op
</h2>

Supprimer une version d’un op la retire de votre projet. Utilisez cette opération pour faire le ménage parmi les versions obsolètes ou superflues.

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

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

    Toute tentative d’accès à un op supprimé renvoie une erreur.
  </Tab>

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


## Related topics

- [Personnaliser les couleurs des runs](/fr/products/wandb/runs/run-colors.md)