Contrôler le suivi automatique des appels LLM

Contrôlez la façon dont W&B Weave enregistre automatiquement les appels à OpenAI, Anthropic et à d’autres bibliothèques LLM

Si vous utilisez des bibliothèques de fournisseurs de LLM (comme OpenAI, Anthropic, Cohere ou Mistral) dans votre application, le patching automatique permet à Weave de prendre en charge le tracing de tous vos appels LLM pour vous. Lorsque vous appelez weave.init(), Weave intercepte automatiquement (applique un patch à) les bibliothèques clientes LLM prises en charge. Le code de votre application reste inchangé : vous utilisez le SDK du fournisseur comme d’habitude, et chaque requête est enregistrée comme un Appel Weave. Vous bénéficiez d’un tracing complet avec une configuration minimale.

Cette page explique quand et comment modifier ce comportement : désactiver le suivi automatique, le limiter à certains fournisseurs spécifiques, ou post-traiter les entrées et sorties (par exemple, pour masquer des données personnelles identifiables).

​

Comportement par défaut

Par défaut, Weave patche automatiquement et suit les appels aux bibliothèques LLM courantes telles que openai et anthropic. Appelez weave.init(...) au début de votre programme et utilisez ces bibliothèques normalement. Leurs appels apparaîtront dans les Traces de votre projet.

​

Configurer le patching automatique

Python

L’argument autopatch_settings est obsolète. Utilisez implicitly_patch_integrations=False pour désactiver le patching implicite, ou appelez des fonctions de patch spécifiques comme patch_openai(settings={...}) pour configurer les paramètres de chaque intégration.

Weave fournit par défaut un patching implicite automatique pour toutes les intégrations prises en charge :

Patching implicite (automatique) : les bibliothèques sont automatiquement patchées, quel que soit le moment où elles sont importées.

# Option 1 : importer avant weave.init()
import openai
import weave
weave.init('your-team-name/your-project-name')  # OpenAI est automatiquement patché !

# Option 2 : importer après weave.init()
import weave
weave.init('your-team-name/your-project-name')
import anthropic  # Patché automatiquement via le hook d'import !

Désactiver le patching implicite : vous pouvez désactiver le patching automatique si vous préférez un contrôle explicite.

import weave

# Option 1 : via le paramètre settings
weave.init('your-team-name/your-project-name', settings={'implicitly_patch_integrations': False})

# Option 2 : via une variable d'environnement
# Définissez WEAVE_IMPLICITLY_PATCH_INTEGRATIONS=false avant d'exécuter votre script

# Lorsque le patching implicite est désactivé, vous devez patcher explicitement les intégrations
import openai
weave.patch_openai()  # Désormais requis pour le Tracing OpenAI

Patching explicite (manuel) : vous pouvez patcher explicitement les intégrations pour un contrôle plus fin.

import weave
weave.init('your-team-name/your-project-name')
weave.integrations.patch_openai()  # Active le Tracing OpenAI
weave.integrations.patch_anthropic()  # Active le Tracing Anthropic

​

Post-traiter les entrées et les sorties

Vous pouvez personnaliser la façon dont les entrées et les sorties sont enregistrées (par exemple, pour masquer des données personnelles identifiables ou des secrets) en passant des paramètres à la fonction de patch :

import weave.integrations

def redact_inputs(inputs: dict) -> dict:
    if "email" in inputs:
        inputs["email"] = "[REDACTED]"
    return inputs

weave.init(...)
weave.integrations.patch_openai(
    settings={
        "op_settings": {"postprocess_inputs": redact_inputs}
    }
)

Pour en savoir plus sur la gestion des données sensibles, voir comment utiliser Weave avec des données PII.

TypeScript

Le SDK TypeScript prend uniquement en charge le patching automatique pour OpenAI et Anthropic. OpenAI est automatiquement patché lorsque vous importez Weave et ne nécessite aucune configuration supplémentaire.

De plus, le SDK TypeScript ne prend pas en charge :

• la configuration ou la désactivation du patching automatique ;
• le post-traitement des entrées/sorties.

Dans les cas limites où le patching automatique ne fonctionne pas (ESM, bundlers comme Next.js), utilisez un encapsulage explicite :

import OpenAI from 'openai'
import * as weave from 'weave'
import { wrapOpenAI } from 'weave'

const client = wrapOpenAI(new OpenAI())
await weave.init('your-team-name/your-project-name')

Pour plus de détails sur la configuration ESM et le dépannage, voir le guide d’intégration du SDK TypeScript.