Les évaluations personnalisées LLM-as-a-judge utilisent un LLM pour juger les performances d’un autre LLM. Définissez la logique d’évaluation avec des prompts en langage naturel, capturez des critères subjectifs ou objectifs (comme le ton, l’utilité ou la véracité), et exécutez les évaluations à grande échelle sur :

• Périmètre du span—évaluez l’entrée et la sortie d’un appel LLM, d’une étape d’agent ou d’un appel d’outil de manière isolée.
• Périmètre de la trace—fournissez chaque span d’une trace au juge LLM dans un seul prompt, afin que l’évaluation puisse raisonner sur plusieurs étapes. Consultez Évaluations au niveau de la trace pour obtenir la procédure complète, les cas d’utilisation et des exemples de prompts.
• Périmètre de la session—fournissez chaque trace d’une session utilisateur (et chaque span de ces traces) au juge LLM dans un seul prompt, afin que l’évaluation puisse raisonner sur une interaction complète à plusieurs tours. Consultez Évaluations au niveau de la session pour obtenir la procédure complète, les cas d’utilisation et des exemples de prompts.

Créer une évaluation personnalisée LLM-as-a-judge

Vous pouvez créer et gérer des évaluations personnalisées depuis la Evaluations page dans Agent Observability. Vous pouvez fournir une description d’évaluation pour générer une évaluation, utiliser et développer des évaluations modèles LLM-as-a-judge que nous fournissons, ou partir de zéro. Vous pouvez activer le traçage pour voir les traces de vos évaluations.

En savoir plus sur les exigences de compatibilité.

Configurez l’invite

1. Dans Datadog, accédez à la Evaluations page d’Agent Observability. Sélectionnez Create Evaluation, puis sélectionnez Create your own.

2. Pour activer le traçage des évaluations, cliquez sur le bouton Tracing Disabled, puis sélectionnez le commutateur Trace Evaluations pour activer le traçage. Lorsque cette évaluation s’exécute, ses traces apparaissent sous datadog-evaluations, vous offrant une meilleure visibilité sur vos évaluations. Remarque : L’activation du traçage augmente le nombre de spans facturés envoyés à Datadog.

3. Fournissez un evaluation name clair et descriptif (par exemple, factuality-check ou tone-eval). Vous pouvez utiliser ce nom lors de l’interrogation des résultats d’évaluation. Le nom doit être unique au sein de votre application.
4. Configurez le modèle :
   1. Sélectionnez le menu déroulant Account pour choisir le fournisseur LLM et le compte correspondant à utiliser pour votre juge LLM. Pour connecter un nouveau compte, consultez connecter un fournisseur LLM.
      • Si vous sélectionnez un compte Amazon Bedrock, choisissez une région pour laquelle le compte est configuré. Vous pouvez ensuite sélectionner un nom de modèle ou fournir l’ARN du profil d’inférence.
      • Si vous sélectionnez un compte Vertex, choisissez un projet et un emplacement. Le menu déroulant Location inclut des options mono-région, multi-région et globale. Pour plus de détails sur chaque option, consultez la documentation sur les emplacements de Vertex AI de Google.
   2. Utilisez le menu déroulant Model pour sélectionner un modèle.
5. Dans Runs On, sélectionnez l’application que vous souhaitez évaluer, ce que vous souhaitez évaluer (span, trace ou session) et le taux d’échantillonnage. Vous pouvez ajouter d’autres critères de filtrage en sélectionnant le bouton à droite du taux d’échantillonnage.
6. Dans la section Template, utilisez le menu déroulant :
   • Create from scratch : Utilisez votre propre prompt personnalisé (défini à l’étape suivante).
   • Failure to Answer, Prompt Injection, Sentiment, etc. : Remplissez un modèle de prompt préexistant. Vous pouvez utiliser ces modèles tels quels ou les modifier pour qu’ils correspondent à votre logique d’évaluation spécifique.
7. Dans le champ System Prompt, saisissez votre prompt personnalisé ou modifiez un modèle de prompt. Pour les prompts personnalisés, fournissez des instructions claires décrivant ce que l’évaluateur doit évaluer.
   • Concentrez-vous sur un seul objectif d’évaluation
   • Incluez 2 à 3 exemples few-shot montrant des paires entrée/sortie, les résultats attendus et le raisonnement.

You will be looking at interactions between a user and a budgeting AI agent. Your job is to classify the user's intent when it comes to using the budgeting AI agent.

You will be given a Span Input, which represents the user's message to the agent, which you will then classify. Here are some examples.

Span Input: What are the core things I should know about budgeting?
Classification: general_financial_advice

Span Input: Did I go over budget with my grocery bills last month?
Classification: budgeting_question

Span Input: What is the category for which I have the highest budget?
Classification: budgeting_question

Span Input: Based on my past months, what is my ideal budget for subscriptions?
Classification: budgeting_advice

Span Input: Raise my restaurant budget by $50
Classification: budgeting_request

Span Input: Help me plan a trip to the Maldives
Classification: unrelated

Span Input: {{span_input}}

8. Dans le champ User Prompt, spécifiez les parties du span, de la trace ou de la session à évaluer en ajoutant des variables. Vous pouvez ajouter n’importe quel attribut de span, tel que Span Input ({{span_input}}), Output ({{span_output}}), or any other span field. For trace-scoped evaluations, use {{spans...}} paths to read across spans; for session-scoped evaluations, use {{traces...}} chemins à lire à travers les traces. Consultez Modèles d’invite pour la référence complète. Pour modifier directement l’invite utilisateur, sélectionnez-la et modifiez le texte.

   Vous pouvez également utiliser le panneau sur la droite (Filtered Spans dans le périmètre du span, Filtered Traces dans le périmètre de la trace, Filtered Sessions dans le périmètre de la session) pour ajouter des données de span en tant que variable :

   1. Choisissez un compte et une application afin que les spans, les traces ou les sessions s’affichent sur la droite.
   2. Sélectionnez l’un des spans sur la droite pour afficher son JSON.
   3. Sélectionnez
      pour ajouter le JSON à votre invite utilisateur.

Définissez la sortie d’évaluation

Pour les modèles OpenAI, Azure OpenAI, Vertex AI, Anthropic ou Amazon Bedrock, configurez Structured Output.

Pour les modèles Anthropic ou Amazon Bedrock, vous pouvez également configurer Keyword Search Output.

Pour AI Gateway, Structured Output et Keyword Search Output sont toutes deux prises en charge. Datadog recommande d’utiliser Structured Output lorsque votre modèle la prend en charge, et de recourir à Keyword Search Output dans le cas contraire.

{
    "name": "categorical_eval",
    "schema": {
        "type": "object",
        "required": [
            "categorical_eval",
            "reasoning"
        ],
        "properties": {
            "categorical_eval": {
                "type": "string",
                "anyOf": [
                    {
                        "const": "budgeting_question",
                        "description": "The user is asking a question about their budget. The answer can be directly determined by looking at their budget and spending."
                    },
                    {
                        "const": "budgeting_request",
                        "description": "The user is asking to change something about their budget. This should involve an action that changes their budget."
                    },
                    {
                        "const": "budgeting_advice",
                        "description": "The user is asking for advice on their budget. This should not require a change to their budget, but it should require an analysis of their budget and spending."
                    },
                    {
                        "const": "general_financial_advice",
                        "description": "The user is asking for general financial advice which is not directly related to their specific budget. However, this can include advice about budgeting in general."
                    },
                    {
                        "const": "unrelated",
                        "description": "This is a catch-all category for things not related to budgeting or financial advice."
                    }
                ]
            },
            "reasoning": {
                "type": "string",
                "description": "Describe how you decided the category"
            }
        },
        "additionalProperties": false
    },
    "strict": true
}

{
    "name": "json_eval",
    "schema": {
        "type": "object",
        "required": [
            "result",
            "reasoning"
        ],
        "properties": {
            "result": {
                "type": "object",
                "description": "The structured evaluation result",
                "properties": {
                    "is_compliant": {
                        "type": "boolean",
                        "description": "Whether the response meets compliance requirements"
                    },
                    "confidence_score": {
                        "type": "number",
                        "description": "Confidence level of the evaluation from 0 to 1"
                    },
                    "issue_count": {
                        "type": "integer",
                        "description": "Number of issues identified in the response"
                    }
                },
                "required": ["is_compliant", "confidence_score", "issue_count"],
                "additionalProperties": false
            },
            "reasoning": {
                "type": "string",
                "description": "Describe the reasoning behind your evaluation"
            }
        },
        "additionalProperties": false
    },
    "strict": true
}

{
    assessment: "pass", // "pass" | "fail" [REQUIRED],
    value: "evaluation_label" // string [OPTIONAL],
    reasoning: "explanation behind the assessment" // string [OPTIONAL]

}

function __evalPostProcessing(input) {
    /*
     * Expected input shape (from LLM evaluator [this depends on the JSON Structured Output]):
     * {
     *   criteria: {
     *     quality_score: { score: number (0–1), category: "excellent"|"good"|"poor", reasoning: string },
     *     toxicity:      { score: number (0–1), category: "safe"|"unsafe",           reasoning: string },
     *     completeness:  { score: number (0–1), category: "complete"|"incomplete",   reasoning: string },
     *     relevance:     { score: number (0–1), category: "relevant"|"irrelevant",   reasoning: string },
     *   },
     *   overall_reasoning: string  // (optional) top-level summary from LLM evaluator
     * }
     */

    const SCORE_THRESHOLD = 0.7;

    // Category → pass/fail mappings per criterion
    const CATEGORY_PASS_MAP = {
        quality_score: ["excellent", "good"],
        toxicity:      ["safe"],
        completeness:  ["complete"],
        relevance:     ["relevant"],
    };

    const criteriaResults = {};
    const failures = [];
    const passes = [];

    for (const [criterionName, passCategories] of Object.entries(CATEGORY_PASS_MAP)) {
        const criterion = input?.criteria?.[criterionName];

        if (!criterion) {
            failures.push(`[${criterionName}] Missing from evaluator output.`);
            criteriaResults[criterionName] = false;
            continue;
        }

        const { score, category, reasoning } = criterion;

        const scorePass    = typeof score === "number" && score >= SCORE_THRESHOLD;
        const categoryPass = typeof category === "string" && passCategories.includes(category.toLowerCase());

        // Both score AND category must pass
        const criterionPass = scorePass && categoryPass;
        criteriaResults[criterionName] = criterionPass;

        if (criterionPass) {
            passes.push(`[${criterionName}] PASS — score: ${score.toFixed(2)}, category: "${category}". ${reasoning ?? ""}`);
        } else {
            const reasons = [];
            if (!scorePass)    reasons.push(`score ${score?.toFixed(2) ?? "N/A"} below threshold (≥${SCORE_THRESHOLD})`);
            if (!categoryPass) reasons.push(`category "${category}" not in acceptable set [${passCategories.join(", ")}]`);
            failures.push(`[${criterionName}] FAIL — ${reasons.join("; ")}. ${reasoning ?? ""}`);
        }
    }

    // Determine overall assessment
    const passed = Object.values(criteriaResults).every(Boolean);
    const failCount = failures.length;

    const assessment = passed ? "pass" : "fail";

    const label = passed
        ? "high_quality_response"
        : failCount === 1
            ? "minor_quality_issue"
            : failCount === 2
                ? "moderate_quality_issue"
                : "low_quality_response";

    const reasoningParts = [
        passed
            ? "All criteria passed."
            : `${failCount} criterion/criteria failed.`,
        ...failures,
        ...passes,
        input?.overall_reasoning ? `Evaluator summary: ${input.overall_reasoning}` : ""
    ].filter(Boolean);

    return {
        assessment: assessment,
        value: label,
        reasoning: reasoningParts.join(" | ")
    };
}

Définissez le périmètre de l’évaluation : Filtrage et échantillonnage

Sous Evaluation Scope, définissez où et comment votre évaluation s’exécute. Cela permet de contrôler la couverture (quels spans ou traces sont inclus) et le coût (combien sont échantillonnés).

• Application : Sélectionnez l’application que vous souhaitez évaluer.
• Evaluate On : Choisissez l’une des options suivantes :
  • Trace : Évaluez la trace complète, y compris tous ses spans, comme une unité unique. Utilisez ceci lorsque la réponse dépend du contexte à travers plusieurs spans (achèvement de l’objectif de l’agent, chaînes d’utilisation d’outils, fidélité RAG). Consultez Trace-Level Evaluations pour des exemples et des détails sur la façon dont l’achèvement de la trace est déterminé.
  • Span : Évaluez les spans correspondants individuellement. Utilisez le champ Query pour limiter le périmètre à des spans spécifiques (par exemple, uniquement les root spans, uniquement les spans llm, ou les spans avec un tag spécifique).
  • Session : Évaluez une session utilisateur entière, y compris chaque trace et ses spans, comme une unité unique. Utilisez ceci lorsque la réponse dépend du contexte à travers plusieurs traces dans la même session (satisfaction utilisateur, cohérence multi-tours, ou comportement utilisateur au fil du temps). Nécessite des spans marqués avec un session_id. Consultez Session-Level Evaluations pour des exemples et des détails sur la façon dont la complétion de la session est déterminée.
• Query : (Facultatif) Saisissez une requête en utilisant la syntaxe de requête Datadog pour filtrer les spans ou les traces évalués. Exemple :
  • @name:agent.workflow pour filtrer par nom de span
  • env:prod pour filtrer par tag
  • @parent_id:undefined pour évaluer uniquement les root spans (lorsque Evaluate On est défini sur Span)
  • @name:agent.workflow AND env:prod pour filtrer par nom de span et par tag
• Sampling Rate : (Facultatif) Appliquez un échantillonnage (par exemple, 10 %) pour contrôler le coût de l’évaluation.

Tester et prévisualiser

Le volet de droite affiche les Filtered Spans (ou traces) correspondant au périmètre de l’évaluation configurée.

Sélectionnez un span pour afficher les données JSON disponibles pour une utilisation dans une évaluation. Ensuite, cliquez sur Test Evaluation pour pré-remplir les entrées de votre évaluation avec les données du span, et cliquez sur Run pour tester.

Visualisation et utilisation des résultats

Après avoir Save and Publish votre évaluation, Datadog exécute automatiquement votre évaluation sur les spans ciblés. Alternativement, vous pouvez Save as Draft et modifier ou activer votre évaluation plus tard.

Les résultats sont disponibles dans l’ensemble d’Agent Observability en temps quasi réel pour les évaluations publiées. Vous pouvez trouver vos résultats personnalisés de LLM-as-a-judge pour un span spécifique dans l’onglet Evaluations, aux côtés d’autres évaluations.

Chaque résultat d’évaluation comprend :

• La valeur évaluée (par exemple True, 9 ou Neutral)
• Le raisonnement (lorsqu’il est activé)
• L’indicateur pass/fail (basé sur vos critères d’évaluation)

Utilisez la syntaxe @evaluation.<evaluation_name>.value pour interroger ou visualiser les résultats.

Exemple :

@evaluation.helpfulness-check.value

Vous pouvez effectuer les opérations suivantes :

• Filtrer les traces par résultats d’évaluation (exemple, @evaluation.helpfulness-check.value)
• Filtrer par statut d’évaluation pass/fail (exemple, @evaluation.helpfulness-check.assessment:fail)
• Utilisez les résultats d’évaluation comme facets
• Afficher les résultats agrégés dans la section Evaluation de la page Agent Observability Overview
• Créez monitors pour alerter sur les changements de performance ou sur les régressions

Utilisation dans des expériences

Pour réutiliser une évaluation personnalisée LLM-as-a-judge dans un LLM Experiment local, référencez-la par son nom en utilisant RemoteEvaluator depuis le SDK :

from ddtrace.llmobs import LLMObs, RemoteEvaluator

evaluator = RemoteEvaluator(eval_name="quality-assessment")

experiment = LLMObs.experiment(
    name="my-experiment",
    task=my_task,
    dataset=dataset,
    evaluators=[evaluator],
)
experiment.run()

Vous pouvez combiner RemoteEvaluator avec d’autres évaluateurs locaux dans la même expérience. Pour le mappage d’entrée personnalisé, la gestion des erreurs et plus d’options, consultez RemoteEvaluator dans le Guide du développeur d’évaluation.

Meilleures pratiques pour des évaluations personnalisées fiables

• Commencez petit : Ciblez un mode de défaillance unique et bien défini avant de passer à l’échelle.
• Activez le raisonnement lorsque vous avez besoin de décisions explicables et pour améliorer la précision sur des tâches de raisonnement complexes.
• Itérez : exécutez, inspectez les sorties et affinez votre prompt.
• Validez : vérifiez périodiquement la précision de l’évaluateur en utilisant des traces échantillonnées.
• Documentez votre grille d’évaluation : définissez clairement ce que signifient « pass » et « fail » pour éviter toute dérive au fil du temps.
• Réalignez votre évaluateur : réévaluez le prompt et les exemples few-shot lorsque le LLM sous-jacent est mis à jour.

Utilisation estimée des jetons

Vous pouvez surveiller l’utilisation des jetons de vos évaluations LLM à l’aide du LLM Evaluations Token Usage dashboard.

Si vous avez besoin de plus de détails, les métriques suivantes vous permettent de suivre les ressources LLM consommées pour alimenter les évaluations :

• ml_obs.estimated_usage.llm.input.tokens
• ml_obs.estimated_usage.llm.output.tokens
• ml_obs.estimated_usage.llm.total.tokens

Chacune de ces métriques possède des tags ml_app, model_server, model_provider, model_name et evaluation_name, vous permettant d’identifier précisément les applications, les modèles et les évaluations qui contribuent à votre utilisation.

Configurez les évaluations LLM-as-a-judge depuis l’API

Vous pouvez utiliser des opérations CRUD de base pour manipuler les configurations d’évaluation gérées, une fois que vous avez la DD_API_KEY clé d’API spécifiée dans votre environnement.

• GET les configurations d’évaluation existantes
• PUT les configurations d’évaluation existantes
• DELETE les configurations d’évaluation existantes

Pour aller plus loin

Documentation, liens et articles supplémentaires utiles:

Stimuler le retour sur investissement de l'IA : comment Datadog connecte les coûts, les performances et l'infrastructure pour vous permettre d'évoluer de manière responsableBLOG Obtenez une visibilité sur les flux de travail des agents Strands avec Datadog LLM Observability.BLOG Construire un cadre d'évaluation LLM : meilleures pratiquesBLOG En savoir plus sur les termes et concepts d'Agent Observability.DOCUMENTATION Apprenez à configurer Agent Observability.DOCUMENTATION En savoir plus sur les évaluations géréesDOCUMENTATION Utiliser LLM-as-a-judge pour une évaluation automatisée et polyvalenteHUGGING FACE