Las evaluaciones personalizadas de LLM-as-a-judge utilizan un LLM para evaluar el rendimiento de otro LLM. Defina la lógica de evaluación con prompts en lenguaje natural, capture criterios subjetivos u objetivos (como el tono, la utilidad o la veracidad) y ejecute las evaluaciones a escala en:

• Contexto de tramo—califique la entrada y la salida de una llamada a un LLM, un paso de agente o una invocación de herramienta de forma aislada.
• Contexto de traza—envíe cada tramo de una traza al LLM juez en un solo prompt, para que la evaluación pueda razonar a través de los pasos. Consulte Evaluaciones a nivel de traza para ver el tutorial completo, los casos de uso y ejemplos de prompts.
• Contexto de sesión—envíe cada traza en una sesión de usuario (y cada tramo en esas trazas) al LLM juez en un solo prompt, para que la evaluación pueda razonar a través de toda una interacción de varios turnos. Consulte Evaluaciones a nivel de sesión para ver el tutorial completo, los casos de uso y ejemplos de prompts.

Crear una evaluación personalizada de LLM-as-a-judge

Puede crear y gestionar evaluaciones personalizadas desde la página de Evaluaciones en Agent Observability. Puede proporcionar una descripción de evaluación para generar una evaluación, utilizar y desarrollar plantillas de evaluaciones de LLM-as-a-judge que proporcionamos, o comenzar desde cero. Puede habilitar el rastreo para ver las trazas de sus evaluaciones.

Obtenga más información sobre los requisitos de compatibilidad.

Configure el prompt

1. En Datadog, navegue a la página de Evaluaciones de Agent Observability. Seleccione Create Evaluation, luego seleccione Create your own.

2. Para habilitar el rastreo para las evaluaciones, haga clic en el botón Tracing Disabled, luego seleccione el interruptor Trace Evaluations para habilitar el rastreo. Cuando se ejecuta esta evaluación, sus trazas aparecen bajo datadog-evaluations, lo que le brinda una mayor visibilidad de sus evaluaciones. Nota: Habilitar el rastreo aumenta la cantidad de tramos facturados enviados a Datadog.

3. Proporcione un evaluation name claro y descriptivo (por ejemplo, factuality-check o tone-eval). Puede usar este nombre al consultar los resultados de la evaluación. El nombre debe ser único dentro de su aplicación.
4. Configure el modelo:
   1. Seleccione el menú desplegable Account para elegir el proveedor de LLM y la cuenta correspondiente que usará para su LLM juez. Para conectar una cuenta nueva, consulte conectar un proveedor de LLM.
      • Si selecciona una cuenta Amazon Bedrock, elija una región para la cual esté configurada la cuenta. Luego puede seleccionar un nombre de modelo o proporcionar el ARN del perfil de inferencia.
      • Si selecciona una cuenta Vertex, elija un proyecto y una ubicación. El menú desplegable Location incluye opciones de región única, multirregión y globales. Para obtener detalles sobre cada opción, consulte la documentación de ubicaciones de Vertex AI de Google.
   2. Utilice el menú desplegable Model para seleccionar un modelo.
5. En Runs On, seleccione la aplicación que desea evaluar, qué desea evaluar (tramo, traza o sesión) y la tasa de muestreo. Puede agregar más criterios de filtrado seleccionando el botón a la derecha de la tasa de muestreo.
6. En la sección Template, utilice el menú desplegable:
   • Create from scratch: Utilice su propio prompt personalizado (definido en el siguiente paso).
   • Failure to Answer, Prompt Injection, Sentiment, etc.: Complete una plantilla de prompt preexistente. Puede usar estas plantillas tal cual o modificarlas para que coincidan con su lógica de evaluación específica.
7. En el campo System Prompt, ingrese su prompt personalizado o modifique una plantilla de prompt. Para prompts personalizados, proporcione instrucciones claras que describan lo que el evaluador debe valorar.
   • Concéntrese en un único objetivo de evaluación
   • Incluya 2-3 ejemplos de few-shot que muestren pares de entrada/salida, resultados esperados y razonamiento.

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. En el campo User Prompt, especifique qué partes del tramo, traza o sesión evaluar agregando variables. Puede agregar cualquier atributo de tramo, como Tramo Input ("{{tramo_input}}), Output ({{tramo_output}}), or any other span field. For trace-scoped evaluations, use {{tramos...}} paths to read across spans; for session-scoped evaluations, use {{trazas...}} rutas para leer a través de las trazas. Consulte Plantillas de prompts para obtener la referencia completa. Para editar el prompt del usuario directamente, selecciónelo y edite el texto.

   También puede usar el panel de la derecha (Filtered Spans en el ámbito del tramo, Filtered Traces en el ámbito de la traza, Filtered Sessions en el contexto de la sesión) para agregar datos de tramo como una variable:

   1. Elija una cuenta y una aplicación para que los tramos, trazas o sesiones aparezcan a la derecha.
   2. Seleccione uno de los tramos a la derecha para ver su JSON.
   3. Seleccione
      para agregar el JSON a su prompt de usuario.

Defina la salida de evaluación

Para modelos de OpenAI, Azure OpenAI, Vertex AI, Anthropic o Amazon Bedrock, configure Salida estructurada.

Para modelos de Anthropic o Amazon Bedrock, también puede configurar Búsqueda por palabras clave.

Para AI Gateway, se admiten tanto Salida estructurada como Búsqueda por palabras clave. Datadog recomienda usar Salida estructurada cuando su modelo la admita y, de lo contrario, recurrir a Búsqueda por palabras clave.

{
    "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(" | ")
    };
}

Defina el contexto de la evaluación: Filtrado y muestreo

En Evaluation Scope, defina dónde y cómo se ejecuta su evaluación. Esto ayuda a controlar la cobertura (qué tramos o trazas se incluyen) y el costo (cuántos se muestrean).

• Application: Seleccione la aplicación que desea evaluar.
• Evaluate On: Elija una de las siguientes opciones:
  • Trace: Evalúe la traza completa, incluidos todos sus tramos, como una sola unidad. Use esto cuando la respuesta dependa del contexto en múltiples tramos (finalización del objetivo del Agent, cadenas de uso de herramientas, fidelidad de RAG). Consulte Evaluaciones a nivel de traza para ver ejemplos y detalles sobre cómo se determina la finalización de la traza.
  • Span: Evalúe los tramos coincidentes individualmente. Use el campo Query para limitar a tramos específicos (por ejemplo, solo tramos raíz, solo tramos llm, o tramos con una etiqueta específica).
  • Session: Evalúe una sesión de usuario completa, incluyendo cada traza y sus tramos, como una sola unidad. Use esto cuando la respuesta dependa del contexto en múltiples trazas en la misma sesión (satisfacción del usuario, coherencia de múltiples turnos o comportamiento del usuario a lo largo del tiempo). Requiere tramos etiquetados con un session_id. Consulte Evaluaciones a nivel de sesión para ver ejemplos y detalles sobre cómo se determina la finalización de la sesión.
• Query: (Opcional) Ingrese una consulta usando la sintaxis de consulta de Datadog para filtrar qué tramos o trazas se evalúan. Por ejemplo:
  • @name:agent.workflow para filtrar por nombre de tramo
  • env:prod para filtrar por etiqueta
  • @parent_id:undefined para evaluar solo los tramos raíz (cuando Evaluate On se establece en Span)
  • @name:agent.workflow AND env:prod para filtrar por nombre de tramo y etiqueta
• Sampling Rate: (Opcional) Aplique muestreo (por ejemplo, 10%) para controlar el costo de la evaluación.

Pruebe y previsualice

El panel de la derecha muestra Filtered Spans (o trazas) correspondientes al alcance de evaluación configurado.

Seleccione un tramo para mostrar los datos JSON disponibles para su uso en una evaluación. Luego, haga clic en Test Evaluation para rellenar previamente las entradas de su evaluación con datos del tramo, y haga clic en Run para probar.

Ver y utilizar resultados

Después de Save and Publish su evaluación, Datadog ejecuta automáticamente su evaluación en los tramos seleccionados. Alternativamente, puede Save as Draft y editar o habilitar su evaluación más tarde.

Los resultados están disponibles en todo Agent Observability casi en tiempo real para las evaluaciones publicadas. Puede encontrar sus resultados personalizados de LLM-as-a-judge para un tramo específico en la pestaña Evaluations, junto con otras evaluaciones.

Cada resultado de evaluación incluye:

• El valor evaluado (por ejemplo, True, 9 o Neutral)
• El razonamiento (cuando está habilitado)
• El indicador de aprobado/reprobado (según sus criterios de evaluación)

Utilice la sintaxis @evaluation.<evaluation_name>.value para consultar o visualizar los resultados.

Por ejemplo:

@evaluation.helpfulness-check.value

Usted puede:

• Filtrar trazas por resultados de evaluación (ejemplo, @evaluation.helpfulness-check.value)
• Filtrar por estado de evaluación de aprobado/reprobado (ejemplo, @evaluation.helpfulness-check.assessment:fail)
• Utilizar los resultados de evaluación como facets
• Ver resultados agregados en la sección Evaluation de la página Agent Observability Overview.
• Crear seguimientos para alertar sobre cambios en el rendimiento o regresiones.

Uso en experimentos

Para reutilizar una evaluación personalizada de LLM-as-a-judge en un Experimento de LLM local, haga referencia a ella por nombre usando RemoteEvaluator desde el 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()

Puede combinar RemoteEvaluator con otros evaluadores locales en el mismo experimento. Para el mapeo de entrada personalizado, el manejo de errores y más opciones, consulte RemoteEvaluator en la Guía para desarrolladores de evaluación.

Mejores prácticas para evaluaciones personalizadas confiables

• Empiece poco a poco: Apunte a un único modo de falla bien definido antes de escalar.
• Habilite el razonamiento cuando necesite decisiones explicables y para mejorar la precisión en tareas de razonamiento complejas.
• Itere: Ejecute, inspeccione los resultados y refine su prompt.
• Valide: Verifique periódicamente la precisión del evaluador utilizando trazas muestreadas.
• Documente su rúbrica: Defina claramente qué significan “Aprobado” y “Reprobado” para evitar desviaciones con el tiempo.
• Realinee su evaluador: Reevalúe el prompt y los ejemplos de few-shot cuando el LLM subyacente se actualice.

Uso estimado de tokens

Puede hacer un seguimiento del uso de tokens de sus evaluaciones de LLM utilizando el LLM Evaluations Token Usage dashboard.

Si necesita más detalles, las siguientes métricas le permiten realizar un seguimiento de los recursos de LLM consumidos para potenciar las evaluaciones:

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

Cada una de estas métricas tiene etiquetas ml_app, model_server, model_provider, model_name y evaluation_name, lo que le permite identificar aplicaciones, modelos y evaluaciones específicas que contribuyen a su uso.

Configure evaluaciones de LLM-as-a-judge desde la API

Puede utilizar operaciones CRUD básicas para manipular configuraciones de evaluación administradas, después de tener la DD_API_KEY clave de API especificada en su entorno.

• GET configuraciones de evaluación existentes
• PUT configuraciones de evaluación existentes
• DELETE configuraciones de evaluación existentes

Lecturas adicionales

Documentación, enlaces y artículos útiles adicionales:

Impulsar el ROI de la IA: cómo Datadog conecta el costo, el rendimiento y la infraestructura para que usted pueda escalar de manera responsableBLOG Obtenga visibilidad de los flujos de trabajo de los agentes de Strands con Datadog LLM ObservabilityBLOG Creación de un marco de evaluación de LLM: mejores prácticasBLOG Conozca los términos y conceptos de Agent ObservabilityDOCUMENTACIÓN Aprenda a configurar Agent ObservabilityDOCUMENTACIÓN Conozca las evaluaciones gestionadasDOCUMENTACIÓN Uso de LLM-as-a-judge para una evaluación automatizada y versátilHUGGING FACE