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

# Configurer des moniteurs personnalisés

> Évaluer passivement le trafic de production pour faire ressortir les tendances et les problèmes

<Note>
  Les moniteurs personnalisés constituent l’ancienne approche de surveillance du trafic de production. Pour toute nouvelle mise en œuvre, utilisez **Signals** dans Weave for Agents. Voir [Afficher les signaux d’agent](/fr/products/wandb/weave/guides/tracking/view-agent-signals).
</Note>

Cette page vous explique comment configurer des moniteurs personnalisés dans W\&B Weave afin d’évaluer passivement le trafic de production et de faire ressortir les tendances et les problèmes de vos applications LLM. Utilisez ce guide lorsque vous souhaitez définir vos propres critères d’évaluation pour les traces de production, au-delà des signaux prédéfinis de Weave.

Les moniteurs s’appuient sur des juges LLM pour évaluer passivement le trafic de production et faire ressortir les tendances et les problèmes de vos applications LLM. Vous pouvez par exemple surveiller l’exactitude ou l’utilité des réponses de votre application, ou encore analyser les entrées des utilisateurs afin d’identifier les sujets sur lesquels ils interrogent le plus souvent vos agents. Les moniteurs enregistrent automatiquement tous les résultats d’évaluation dans la base de données de Weave, ce qui vous permet d’analyser les tendances et les schémas dans le temps.

Vous pouvez surveiller le texte, les images et l’audio présents dans les entrées et les sorties de votre application.

Les moniteurs ne nécessitent aucune modification du code de votre application. Il suffit de les configurer depuis l’interface utilisateur de Weights & Biases.

Si vous devez intervenir activement sur le comportement de votre application en fonction des scores, utilisez plutôt des [garde-fous](/fr/products/wandb/weave/guides/evaluation/guardrails).

<h2 id="signals-and-custom-monitors">
  Signaux et moniteurs personnalisés
</h2>

Utilisez les [signaux](/fr/products/wandb/weave/guides/evaluation/monitors), des évaluateurs automatisés prédéfinis pour les traces de production, pour mettre rapidement en place la surveillance en production, puis ajoutez des moniteurs personnalisés pour les critères d’évaluation propres à votre application.

| | Signaux | Moniteurs personnalisés |
| - | - | - |
| **Configuration** | Activation en un clic, aucun prompt à rédiger | Contrôle complet du prompt d’évaluation, du modèle et des paramètres |
| **Portée** | Classificateurs de qualité et d’erreurs prédéfinis | Tout critère d’évaluation que vous définissez |
| **Sélection des traces** | Automatique (traces racines réussies pour la qualité, traces en échec pour les erreurs) | Opérations, filtres et taux d’échantillonnage configurables |
| **Modèle** | Serverless Inference (prédéfini) | Tout modèle commercial ou Serverless Inference |
| **Cas d’usage** | Surveillance rapide en production avec des classificateurs éprouvés | Critères d’évaluation personnalisés propres à votre application |

<h2 id="create-a-monitor-in-weave">
  Créer un moniteur dans Weave
</h2>

Pour créer un moniteur personnalisé dans Weave :

1. Ouvrez l’[interface utilisateur de Weights & Biases](https://forge.coreweave.com/wandb), puis ouvrez votre projet Weights & Biases.

2. Dans la barre latérale de Weave, sélectionnez **Moniteurs**, puis cliquez sur le bouton **+ New Moniteur**. La boîte de dialogue modale **Create new moniteur** s’ouvre.

3. Dans le menu **Create new moniteur**, configurez les champs suivants :
   * **Name** : doit commencer par une lettre ou un chiffre. Peut contenir des lettres, des chiffres, des traits d’union et des caractères de soulignement.
   * **Description** (facultatif) : décrivez le rôle du moniteur.
   * Bouton bascule **Active moniteur** : activez ou désactivez le moniteur.
   * **Calls to moniteur** :
     * **Operations** : choisissez un ou plusieurs `@weave.op` à surveiller. Vous devez journaliser au moins une trace utilisant l’op pour qu’il apparaisse dans la liste des ops disponibles.
     * **Filter** (facultatif) : restreignez les appels éligibles (par exemple, selon `max_tokens` ou `top_p`).
     * **Sampling rate** : le pourcentage d’appels à évaluer (de 0 % à 100 %).
       <Tip>
         Un taux d’échantillonnage plus faible permet de réduire les coûts, puisque chaque appel d’évaluation est facturé.
       </Tip>
   * **LLM-as-a-judge configuration** :
     * **Scorer name** : doit commencer par une lettre ou un chiffre. Peut contenir des lettres, des chiffres, des traits d’union et des caractères de soulignement.
     * **Score Audio** : filtre les modèles LLM disponibles pour n’afficher que ceux qui prennent en charge l’audio, et ouvre le champ **Media Scoring JSON Paths**.
     * **Score Images** : filtre les modèles LLM disponibles pour n’afficher que ceux qui prennent en charge les images, et ouvre le champ **Media Scoring JSON Paths**.
     * **Judge model** : sélectionnez le modèle chargé d’évaluer vos ops. Le menu contient les modèles LLM commerciaux que vous avez configurés dans votre compte CoreWeave Forge, ainsi que les [modèles Serverless Inference](/fr/products/inference/serverless/models). Les modèles prenant en charge l’audio affichent une étiquette **Audio Input** à côté de leur nom. Pour le modèle sélectionné, configurez les paramètres suivants :
       * **Configuration name** : un nom pour cette configuration de modèle.
       * **System prompt** : définit le rôle et la persona du modèle juge, par exemple « You are an impartial AI judge. »
       * **Response format** : le format dans lequel le juge produit sa réponse, par exemple `json_object` ou `text` brut.
       * **Scoring prompt** : la tâche d’évaluation appliquée à vos ops. Vous pouvez référencer des [variables de prompt](/fr/products/wandb/weave/guides/evaluation/scorers#access-variables-from-your-ops-in-scoring-prompts) issues de vos ops dans vos prompts d’évaluation. Par exemple : « Évaluez si `{output}` est exact au regard de `{ground_truth}`. »
     * **Media Scoring JSON Paths** : spécifiez des expressions JSONPath (RFC 9535) pour extraire les médias de vos données de trace. Si vous ne spécifiez aucun chemin, le moniteur inclut tous les médias évaluables des messages utilisateur. Ce champ apparaît lorsque vous activez **Score Audio** ou **Score Images**.

4. Une fois les champs du moniteur configurés, sélectionnez **Create moniteur**. Le moniteur est alors ajouté à votre projet Weights & Biases. Dès que votre code commence à générer des traces, vous pouvez consulter les scores dans l’onglet **Traces** en sélectionnant le nom du moniteur, puis en examinant les données dans le panneau qui s’affiche.

Vous pouvez également [comparer](/fr/products/wandb/weave/guides/tools/comparison) et visualiser les données de trace du moniteur dans l’interface utilisateur de Weights & Biases, ou les télécharger dans des formats tels que CSV et JSON à l’aide du bouton de téléchargement (<Icon icon="download" iconType="regular" />) de l’onglet **Traces**.

Weave stocke automatiquement tous les résultats des évaluateurs dans le champ `feedback` de l’objet [Call](/fr/products/wandb/weave/guides/tracking/tracing#calls).

<h3 id="example-create-a-truthfulness-monitor">
  Exemple : créer un moniteur de véracité
</h3>

L’exemple de bout en bout suivant explique comment créer un moniteur qui évalue la véracité d’affirmations générées. À la fin, vous disposerez d’un moniteur actif qui évalue un op d’exemple dans votre projet Weave, et les traces évaluées seront visibles dans l’interface Weights & Biases.

1. Définissez une fonction qui génère des affirmations, dont certaines sont vraies et d’autres non :

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

    weave.init("my-team/my-weave-project")

    client = openai.OpenAI()

    @weave.op()
    def generate_statement(ground_truth: str) -> str:
        if random.random() < 0.5:
            response = client.chat.completions.create(
                model="gpt-4.1",
                messages=[
                    {
                        "role": "user",
                        "content": f"Generate a statement that is incorrect based on this fact: {ground_truth}"
                    }
                ]
            )
            return response.choices[0].message.content
        else:
            return ground_truth

    generate_statement("The Earth revolves around the Sun.")
    ```
  </Tab>

  <Tab title="TypeScript">
    ```typescript lines twoslash theme={"system"}
    // @noErrors
    import * as weave from 'weave';
    import OpenAI from 'openai';

    await weave.init('my-team/my-weave-project');

    const client = new OpenAI();

    const generateStatement = weave.op(async (ground_truth: string): Promise<string> => {
      if (Math.random() < 0.5) {
        const response = await client.chat.completions.create({
          model: 'gpt-4.1',
          messages: [
            {
              role: 'user',
              content: `Generate a statement that is incorrect based on this fact: ${ground_truth}`,
            },
          ],
        });
        return response.choices[0]?.message?.content ?? '';
      }
      return ground_truth;
    });

    await generateStatement("The Earth revolves around the Sun.");
    ```
  </Tab>
</Tabs>

2. Exécutez la fonction au moins une fois pour journaliser une trace dans votre projet. L’op pourra ainsi être surveillé dans l’interface Weights & Biases.

3. Ouvrez votre projet dans l’interface Weights & Biases et sélectionnez **Monitors** dans la barre latérale, puis **New Monitor**.

4. Dans le menu **Create new monitor**, renseignez les champs avec les valeurs suivantes :
   * **Name** : `truthfulness-monitor`
   * **Description** : `Evaluates the truthfulness of generated statements.`
   * **Active monitor** : basculez sur **on**.
   * **Operations** : sélectionnez `generate_statement`.
   * **Sampling rate** : définissez la valeur sur `100%` pour évaluer chaque appel.
   * **Scorer name** : `truthfulness-scorer`
   * **Judge model** : `o3-mini-2025-01-31`
   * **System prompt** : `You are an impartial AI judge. Your task is to evaluate the truthfulness of statements.`
   * **Response format** : `json_object`
   * **Scoring prompt** :
     ```text theme={"system"}
     Evaluate whether the output statement is accurate based on the input statement.

     This is the input statement: {ground_truth}

     This is the output statement: {output}

     The response should be a JSON object with the following fields:
     - is_true: a boolean stating whether the output statement is true or false based on the input statement.
     - reasoning: your reasoning as to why the statement is true or false.
     ```

5. Sélectionnez **Create monitor**. Le moniteur est alors ajouté à votre projet Weave.

6. Dans votre script, appelez votre fonction avec des affirmations plus ou moins véridiques pour tester la fonction de score :

<Tabs>
  <Tab title="Python">
    ```python lines theme={"system"}
    generate_statement("The Earth revolves around the Sun.")
    generate_statement("Water freezes at 0 degrees Celsius.")
    generate_statement("The Great Wall of China was built over several centuries.")
    ```
  </Tab>

  <Tab title="TypeScript">
    ```typescript lines twoslash theme={"system"}
    // @noErrors
    await generateStatement("The Earth revolves around the Sun.");
    await generateStatement("Water freezes at 0 degrees Celsius.");
    await generateStatement("The Great Wall of China was built over several centuries.");
    ```
  </Tab>
</Tabs>

7. Après avoir exécuté le script avec plusieurs affirmations différentes, ouvrez l’interface Weights & Biases et accédez à l’onglet **Traces**. Sélectionnez une trace **LLMAsAJudgeScorer.score** pour afficher les résultats.

<img src="https://mintcdn.com/coreweave-dbfa0e8d/3Dv_sw2eg8feUJlx/products/wandb/weave/_media/monitors-4.png?fit=max&auto=format&n=3Dv_sw2eg8feUJlx&q=85&s=ec94ddd6080f595a516bd6932d2972b9" alt="Trace du moniteur" width="2912" height="1428" data-path="products/wandb/weave/_media/monitors-4.png" />

Vous disposez désormais d’un moniteur de véracité opérationnel qui évalue chaque invocation de `generate_statement` et stocke les résultats aux côtés de la trace d’origine, prêts à être analysés et comparés dans l’interface de Weights & Biases.