Passer au contenu principal
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.
Pour créer une op, décorez une fonction Python avec weave.op().
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 ou déployer des Ops à l’aide du toolbelt de Weave.

​
Personnaliser les noms d’affichage

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.
Vous pouvez personnaliser le nom d’affichage de l’op en définissant le paramètre name dans le décorateur @weave.op :
@weave.op(name="custom_name")
def func():
    ...

​
Appliquer des types et des couleurs

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 : 
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()
Cela applique ces couleurs et ces types à vos Ops dans l’interface Weave, comme ceci :
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.
Les valeurs kind disponibles sont :
  • agent
  • llm
  • tool
  • search
Les valeurs color disponibles sont :
  • red
  • orange
  • yellow
  • green
  • blue
  • purple

​
Personnaliser les entrées et sorties enregistrées

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.
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")

​
Contrôler le taux d’échantillonnage

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.
@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.
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. 
export WEAVE_PRINT_CALL_LINK=false

​
Supprimer un Op

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.
Pour supprimer une version d’un Op, appelez .delete() sur la référence de l’Op.
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.