> ## Documentation Index
> Fetch the complete documentation index at: https://wb-21fd5541-docs-hivemind-launch.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Configurer des moniteurs

> Attribuez passivement des scores au trafic de production pour faire ressortir les tendances et les problèmes

Les moniteurs utilisent des juges LLM pour attribuer passivement des scores au trafic de production afin de faire ressortir les tendances et les problèmes dans vos applications LLM. Par exemple, vous pouvez surveiller les réponses de votre application pour en évaluer l'exactitude ou la pertinence, ou surveiller les entrées des utilisateurs afin d'identifier des tendances dans les questions qu'ils posent à vos agents. Les moniteurs stockent 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 modèles historiques.

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

Les moniteurs ne nécessitent aucune modification du code de votre application. Configurez-les à l'aide de l'interface Weave de W\&B.

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

<div id="how-to-create-a-monitor-in-weave">
  ## Comment créer un moniteur dans Weave
</div>

Pour créer un moniteur dans Weave :

1. Ouvrez la [interface W\&B](https://wandb.ai/home), puis ouvrez votre projet Weave.

2. Dans la barre latérale de navigation de Weave, sélectionnez **Monitors**, puis cliquez sur le bouton **+ New Monitor**. La boîte de dialogue **Create new monitor** s'ouvre.

3. Dans le menu Create new monitor, configurez les champs suivants :
   * **Nom** : doit commencer par une lettre ou un chiffre. Peut contenir des lettres, des chiffres, des tirets et des tirets bas.
   * **Description** (facultatif) : expliquez ce que fait le moniteur.
   * Bascule **Moniteur actif** : activez ou désactivez le moniteur.
   * **Appels à surveiller** :
     * **Opérations** : choisissez une ou plusieurs `@weave.op` à surveiller. Vous devez journaliser au moins une trace qui utilise l'op pour qu'elle apparaisse dans la liste des ops disponibles.
     * **Filtre** (facultatif) : restreignez les appels éligibles (par exemple, selon `max_tokens` ou `top_p`).
     * **Taux d'échantillonnage** : le pourcentage d'appels à scorer (de 0 % à 100 %).
       <Tip>
         Un taux d'échantillonnage plus faible réduit les coûts, car chaque appel de scoring entraîne un coût.
       </Tip>
   * **Configuration LLM-as-a-judge** :
     * **Nom du scorer** : doit commencer par une lettre ou un chiffre. Peut contenir des lettres, des chiffres, des tirets et des tirets bas.
     * **Scorer l'audio** : filtre les modèles LLM disponibles pour n'afficher que les modèles compatibles avec l'audio, et ouvre le champ Media Scoring JSON Paths.
     * **Scorer les images** : filtre les modèles LLM disponibles pour n'afficher que les modèles compatibles avec les images, et ouvre le champ Media Scoring JSON Paths.
     * **Modèle juge** : sélectionnez le modèle qui scorera vos ops. Le menu contient les modèles LLM commerciaux que vous avez configurés dans votre compte W\&B, ainsi que les [modèles Serverless Inference](/fr/inference/models). Les modèles compatibles avec l'audio affichent le libellé **Audio Input** à côté de leur nom. Pour le modèle sélectionné, configurez les paramètres suivants :
       * **Nom de la configuration** : un nom pour cette configuration de modèle.
       * **Prompt système** : définit le rôle et la personnalité du modèle juge, par exemple, "You are an impartial AI judge."
       * **Format de réponse** : le format dans lequel le juge doit produire sa réponse, par exemple un `json_object` ou du `text` brut.
       * **Prompt de scoring** : la tâche d'évaluation utilisée pour scorer vos ops. Vous pouvez référencer des [variables de prompt](/fr/weave/guides/evaluation/scorers#access-variables-from-your-ops-in-scoring-prompts) de vos ops dans vos prompts de scoring. Par exemple, "Evaluate whether `{output}` is accurate based on `{ground_truth}`."
     * **Media Scoring JSON Paths** : spécifiez des expressions JSONPath (RFC 9535) pour extraire des médias de vos données de trace. Si aucun chemin n'est spécifié, tous les médias scorable provenant des messages utilisateur seront inclus. Ce champ apparaît lorsque vous activez **Scorer l'audio** ou **Scorer les images**.

4. Une fois les champs du moniteur configurés, cliquez sur **Create monitor**. Cela ajoute le moniteur à votre projet Weave. Lorsque 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 aussi [comparer](/fr/weave/guides/tools/comparison) et visualiser les données de trace du moniteur dans la Weave UI, ou les télécharger dans différents formats (par exemple, CSV et JSON) à l'aide du bouton de téléchargement (<Icon icon="download" iconType="regular" />) dans l'onglet Traces.

Weave stocke automatiquement tous les résultats du scorer dans le champ `feedback` de l'objet [Appel](/fr/weave/guides/tracking/tracing#calls).

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

L'exemple suivant crée un moniteur qui évalue la véracité des énoncés générés.

1. Définissez une fonction qui génère des énoncés. Certains sont vrais, d'autres non :

<Tabs>
  <Tab title="Python">
    ```python theme={null}
    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 theme={null}
    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. Cela rend l'op disponible pour la surveillance dans l'UI W\&B.

3. Ouvrez votre projet Weave dans l'UI W\&B et sélectionnez **Monitors** dans la barre latérale. Sélectionnez ensuite **New Monitor**.

4. Dans le menu Create new monitor, configurez les champs avec les valeurs suivantes :
   * **Name** : `truthfulness-monitor`
   * **Description** : `Évalue la véracité des énoncés générés.`
   * **moniteur actif** : Activez l'option.
   * **opération** : Sélectionnez `generate_statement`.
   * **taux d’échantillonnage** : Définissez `100%` pour scorer chaque Appel.
   * **nom du scorer** : `truthfulness-scorer`
   * **modèle juge** : `o3-mini-2025-01-31`
   * **prompt système** : `You are an impartial AI judge. Your task is to evaluate the truthfulness of statements.`
   * **format de réponse** : `json_object`
   * **prompt de scoring** :
     ```text theme={null}
     Évaluez si l'énoncé de sortie est exact sur la base de l'énoncé d'entrée.

     Voici l'énoncé d'entrée : {ground_truth}

     Voici l'énoncé de sortie : {output}

     La réponse doit être un objet JSON avec les champs suivants :
     - is_true: un booléen indiquant si l'énoncé de sortie est vrai ou faux d'après l'énoncé d'entrée.
     - reasoning: votre raisonnement expliquant pourquoi l'énoncé est vrai ou faux.
     ```

5. Cliquez sur **Create Monitor**. Cela ajoute le moniteur à votre projet Weave.

6. Dans votre script, appelez votre fonction avec des énoncés de véracité variable pour tester la fonction de score :

<Tabs>
  <Tab title="Python">
    ```python theme={null}
    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 theme={null}
    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 énoncés différents, ouvrez l'UI W\&B et accédez à l'onglet **Traces**. Sélectionnez n'importe quelle trace **LLMAsAJudgeScorer.score** pour voir les résultats.

<img src="https://mintcdn.com/wb-21fd5541-docs-hivemind-launch/HbhUDAG_r2i2K_Pk/weave/guides/evaluation/img/monitors-4.png?fit=max&auto=format&n=HbhUDAG_r2i2K_Pk&q=85&s=e58dec7afc74856f85a3c31dc2b6efb3" alt="Trace du moniteur" width="3024" height="1428" data-path="weave/guides/evaluation/img/monitors-4.png" />