Soportaron los evaluadores integrados y los campos de verdad fundamental.Requisitos previos Exactitud con la respuesta esperada GoalSuccessRate con afirmaciones La trayectoria coincide con la trayectoria esperada Combinar todos los campos de información básica en una sola solicitud Comprender los campos de entrada de referencia ignorados Fundamenta la verdad en los evaluadores personalizados

Evaluaciones de verdad sobre el terreno

La verdad fundamental es la respuesta correcta conocida o el comportamiento esperado de una entrada determinada: el «estándar de referencia» con el que se comparan los resultados reales. Para la evaluación de los agentes, la verdad fundamental transforma la evaluación subjetiva de la calidad en una medición objetiva, lo que permite la detección de regresiones, los conjuntos de datos de referencia y una precisión específica de un dominio que los evaluadores genéricos no pueden proporcionar por sí solos.

Con las evaluaciones de la verdad básica, al llamar a la API Evaluate, usted proporciona entradas de referencia a lo largo de los períodos de sesión. El servicio utiliza estas entradas de referencia para comparar el comportamiento real de su agente con el comportamiento esperado. Los evaluadores que no utilizan un campo de verdad fundamental en particular lo ignoran e indican qué campos no se utilizaron en la respuesta.

Temas

Soportaron los evaluadores integrados y los campos de verdad fundamental.
Requisitos previos
Exactitud con la respuesta esperada
GoalSuccessRate con afirmaciones
La trayectoria coincide con la trayectoria esperada
Combinar todos los campos de información básica en una sola solicitud
Comprender los campos de entrada de referencia ignorados
Fundamenta la verdad en los evaluadores personalizados

Soportaron los evaluadores integrados y los campos de verdad fundamental.

La siguiente tabla muestra qué evaluadores integrados admiten la verdad fundamental y qué campos utilizan.

Evaluador	Nivel	Campo de verdad fundamental	Description (Descripción)
`Builtin.Correctness`	Rastreo	`expectedResponse`	Mide la precisión con la que la respuesta del agente coincide con la respuesta esperada. Utiliza la LLM-as-a-Judge puntuación.
`Builtin.GoalSuccessRate`	Session	`assertions`	Valida si el comportamiento del agente cumple con las afirmaciones del lenguaje natural durante toda la sesión. Utiliza la puntuación. LLM-as-a-Judge
`Builtin.TrajectoryExactOrderMatch`	Session	`expectedTrajectory`	Comprueba que la secuencia real de llamadas a la herramienta coincide exactamente con la secuencia esperada: las mismas herramientas, el mismo orden, sin extras. Puntuación programática (sin llamadas LLM).
`Builtin.TrajectoryInOrderMatch`	Session	`expectedTrajectory`	Comprueba que todas las herramientas esperadas aparecen en orden dentro de la secuencia real, pero permite utilizar herramientas adicionales entre ellas. Puntuación programática.
`Builtin.TrajectoryAnyOrderMatch`	Session	`expectedTrajectory`	Comprueba que todas las herramientas esperadas estén presentes en la secuencia real, independientemente del orden. Se permiten herramientas adicionales. Puntuación programática.

nota

Los evaluadores personalizados también respaldan los campos de verdad básica mediante marcadores de posición en sus instrucciones de evaluación. Consulte Fundamentos reales en los evaluadores personalizados para obtener más información.

En la siguiente tabla se describen los campos de verdad fundamental.

Campo	Tipo	Alcance	Description (Descripción)
`expectedResponse`	Cadena	Rastreo	La respuesta esperada del agente para un turno específico. Con el alcance de una traza y se utiliza `traceId` el contexto de entrada de referencia.
`assertions`	Lista de cadenas	Session	Declaraciones en lenguaje natural que deberían ser ciertas sobre el comportamiento del agente a lo largo de la sesión.
`expectedTrajectory`	Lista de nombres de herramientas	Session	La secuencia esperada de llamadas de herramientas para la sesión.

Los campos de información básica son opcionales. Si los omite, los evaluadores volverán al modo libre de verdades fundamentales (por ejemplo, si Builtin.Correctness siguen funcionando sin expectedResponse ellos, solo evalúan en función del contexto).
Puede proporcionar todos los campos de veracidad básica en una sola solicitud. El servicio selecciona los campos relevantes para cada evaluador e informa ignoredReferenceInputFields en la respuesta de los campos que no se utilizaron.
No es necesario que proporciones todos expectedResponse los rastros. Las trazas sin verdad fundamental se evalúan mediante la variante libre de verdad fundamental del evaluador.

Requisitos previos

Python 3.10 o versiones posteriores
Un agente implementado en AgentCore Runtime con la observabilidad habilitada o un agente creado con un marco compatible configurado con Observability. AgentCore Marcos compatibles:
- Strands Agents
- LangGraph con opentelemetry-instrumentation-langchain o openinference-instrumentation-langchain
La búsqueda de transacciones está habilitada en CloudWatch : consulte Habilitar la búsqueda de transacciones
AWS credenciales configuradas con permisos para bedrock-agentcorebedrock-agentcore-control, y logs (CloudWatch)

Para obtener instrucciones sobre cómo descargar los intervalos de sesión, consulte Introducción a la evaluación bajo demanda.

Acerca de los ejemplos

Los ejemplos de esta página utilizan el agente de muestra de los tutoriales de AgentCore evaluación. El agente tiene dos herramientas (calculatory) y weather se implementa en AgentCore Runtime con la observabilidad habilitada.

Los ejemplos suponen una sesión de dos turnos:

Turno 1: «¿Cuánto es 15 + 27?» — el agente usa la calculator herramienta y responde con el resultado.
Turno 2: «¿Qué tiempo hace?» — el agente usa la weather herramienta y responde con el clima actual.

Antes de realizar las evaluaciones, llame a su agente y espere de 2 a 5 minutos para que ingiera los datos de CloudWatch telemetría.

Las siguientes constantes se utilizan en todos los ejemplos de esta página. Sustitúyalas por sus propios valores:


REGION       = "<region-code>"
AGENT_ID     = "my-agent-id"
SESSION_ID   = "my-session-id"
TRACE_ID_1   = "<trace-id-1>"   # Turn 1: "What is 15 + 27?"
TRACE_ID_2   = "<trace-id-2>"   # Turn 2: "What's the weather?"

Exactitud con la respuesta esperada

Builtin.Correctnesses un evaluador a nivel de trazas que mide la precisión con la que la respuesta del agente coincide con la respuesta esperada. Cuando usted la proporcionaexpectedResponse, el evaluador compara la respuesta real del agente con su verdad fundamental mediante una puntuación. LLM-as-a-Judge

ejemplo

AgentCore SDK


from bedrock_agentcore.evaluation import EvaluationClient, ReferenceInputs

client = EvaluationClient(region_name=REGION)

# String form — matched against the last trace in the session
results = client.run(
    evaluator_ids=["Builtin.Correctness"],
    agent_id=AGENT_ID,
    session_id=SESSION_ID,
    reference_inputs=ReferenceInputs(
        expected_response="The weather is sunny",
    ),
)

for r in results:
    print(f"Trace: {r['context']['spanContext'].get('traceId', 'session')}")
    print(f"Score: {r['value']}, Label: {r['label']}")

Para segmentar un rastreo específico, usa un dictado expected_response que mapee los ID de rastreo con las respuestas esperadas:


results = client.run(
    evaluator_ids=["Builtin.Correctness"],
    agent_id=AGENT_ID,
    session_id=SESSION_ID,
    reference_inputs=ReferenceInputs(
        expected_response={
            TRACE_ID_1: "15 + 27 = 42",
            TRACE_ID_2: "The weather is sunny",
        },
    ),
)

AgentCore CLI


# Expected response matched against the last trace
agentcore run eval \
  --agent AGENT_NAME \
  --session-id SESSION_ID \
  --evaluator-arn "arn:aws:bedrock-agentcore:::evaluator/Builtin.Correctness" \
  --expected-response "The weather is sunny"

# Target a specific trace
agentcore run eval \
  --agent AGENT_NAME \
  --session-id SESSION_ID \
  --evaluator-arn "arn:aws:bedrock-agentcore:::evaluator/Builtin.Correctness" \
  --trace-id TRACE_ID_1 \
  --expected-response "15 + 27 = 42"

# ARN mode — evaluate an agent outside the CLI project
agentcore run eval \
  --runtime-arn arn:aws:bedrock-agentcore:<region-code>:<account-id>:runtime/<agent-id> \
  --session-id SESSION_ID \
  --evaluator-arn "arn:aws:bedrock-agentcore:::evaluator/Builtin.Correctness" \
  --expected-response "The weather is sunny"

Starter Toolkit SDK


from bedrock_agentcore_starter_toolkit import Evaluation, ReferenceInputs

eval_client = Evaluation(region=REGION)

# String form — matched against the last trace
results = eval_client.run(
    agent_id=AGENT_ID,
    session_id=SESSION_ID,
    evaluators=["Builtin.Correctness"],
    reference_inputs=ReferenceInputs(
        expected_response="The weather is sunny",
    ),
)

for r in results.get_successful_results():
    print(f"Score: {r.value:.2f}, Label: {r.label}")

Para segmentar un rastreo específico, pasa una tupla de(trace_id, expected_response):


results = eval_client.run(
    agent_id=AGENT_ID,
    session_id=SESSION_ID,
    evaluators=["Builtin.Correctness"],
    reference_inputs=ReferenceInputs(
        expected_response=(TRACE_ID_1, "15 + 27 = 42"),
    ),
)

Starter Toolkit CLI


# Expected response matched against the last trace
agentcore eval run \
  --agent-id AGENT_ID \
  --session-id SESSION_ID \
  --evaluator "Builtin.Correctness" \
  --expected-response "The weather is sunny"

# Target a specific trace
agentcore eval run \
  --agent-id AGENT_ID \
  --session-id SESSION_ID \
  --trace-id TRACE_ID_1 \
  --evaluator "Builtin.Correctness" \
  --expected-response "15 + 27 = 42"

# Save results to a file
agentcore eval run \
  --agent-id AGENT_ID \
  --session-id SESSION_ID \
  --evaluator "Builtin.Correctness" \
  --expected-response "The weather is sunny" \
  --output results.json

AWS SDK (boto3)


import boto3

client = boto3.client("bedrock-agentcore", region_name=REGION)

response = client.evaluate(
    evaluatorId="Builtin.Correctness",
    evaluationInput={"sessionSpans": session_spans_and_log_events},
    evaluationReferenceInputs=[
        {
            "context": {
                "spanContext": {
                    "sessionId": SESSION_ID,
                    "traceId": TRACE_ID_1
                }
            },
            "expectedResponse": {"text": "15 + 27 = 42"}
        },
        {
            "context": {
                "spanContext": {
                    "sessionId": SESSION_ID,
                    "traceId": TRACE_ID_2
                }
            },
            "expectedResponse": {"text": "The weather is sunny"}
        }
    ]
)

for result in response["evaluationResults"]:
    print(f"Score: {result['value']}, Label: {result['label']}")

GoalSuccessRate con afirmaciones

Builtin.GoalSuccessRatees un evaluador a nivel de sesión que valida si el comportamiento del agente satisface un conjunto de afirmaciones en lenguaje natural. Las afirmaciones permiten comprobar el uso de la herramienta, el contenido de las respuestas, el orden de las acciones o cualquier otro comportamiento observable a lo largo de toda la conversación.

nota

En los ejemplos que aparecen a continuación se utilizan afirmaciones que validan el uso de las herramientas, pero las aseveraciones son un lenguaje natural de formato libre. Puede utilizarlas para hacer afirmaciones sobre cualquier aspecto del comportamiento de los agentes, como el tono de respuesta, la precisión de los hechos, el cumplimiento de las normas de seguridad o la lógica empresarial.

ejemplo

AgentCore SDK


from bedrock_agentcore.evaluation import EvaluationClient, ReferenceInputs

client = EvaluationClient(region_name=REGION)

results = client.run(
    evaluator_ids=["Builtin.GoalSuccessRate"],
    agent_id=AGENT_ID,
    session_id=SESSION_ID,
    reference_inputs=ReferenceInputs(
        assertions=[
            "Agent used the calculator tool to compute the result",
            "Agent returned the correct numerical answer of 42",
            "Agent used the weather tool when asked about weather",
        ],
    ),
)

for r in results:
    print(f"Score: {r['value']}, Label: {r['label']}")
    print(f"Explanation: {r['explanation'][:200]}")

AgentCore CLI


agentcore run eval \
  --agent AGENT_NAME \
  --session-id SESSION_ID \
  --evaluator-arn "arn:aws:bedrock-agentcore:::evaluator/Builtin.GoalSuccessRate" \
  --assertion "Agent used the calculator tool to compute the result" \
  --assertion "Agent returned the correct numerical answer of 42" \
  --assertion "Agent used the weather tool when asked about weather"

# ARN mode — evaluate an agent outside the CLI project
agentcore run eval \
  --runtime-arn arn:aws:bedrock-agentcore:<region-code>:<account-id>:runtime/<agent-id> \
  --session-id SESSION_ID \
  --evaluator-arn "arn:aws:bedrock-agentcore:::evaluator/Builtin.GoalSuccessRate" \
  --assertion "Agent used the calculator tool to compute the result" \
  --assertion "Agent returned the correct numerical answer of 42"

Starter Toolkit SDK


from bedrock_agentcore_starter_toolkit import Evaluation, ReferenceInputs

eval_client = Evaluation(region=REGION)

results = eval_client.run(
    agent_id=AGENT_ID,
    session_id=SESSION_ID,
    evaluators=["Builtin.GoalSuccessRate"],
    reference_inputs=ReferenceInputs(
        assertions=[
            "Agent used the calculator tool to compute the result",
            "Agent returned the correct numerical answer of 42",
            "Agent used the weather tool when asked about weather",
        ],
    ),
)

for r in results.get_successful_results():
    print(f"Score: {r.value:.2f}, Label: {r.label}")

Starter Toolkit CLI


agentcore eval run \
  --agent-id AGENT_ID \
  --session-id SESSION_ID \
  --evaluator "Builtin.GoalSuccessRate" \
  --assertion "Agent used the calculator tool to compute the result" \
  --assertion "Agent returned the correct numerical answer of 42" \
  --assertion "Agent used the weather tool when asked about weather"

AWS SDK (boto3)


import boto3

client = boto3.client("bedrock-agentcore", region_name=REGION)

response = client.evaluate(
    evaluatorId="Builtin.GoalSuccessRate",
    evaluationInput={"sessionSpans": session_spans_and_log_events},
    evaluationReferenceInputs=[
        {
            "context": {
                "spanContext": {
                    "sessionId": SESSION_ID
                }
            },
            "assertions": [
                {"text": "Agent used the calculator tool to compute the result"},
                {"text": "Agent returned the correct numerical answer of 42"},
                {"text": "Agent used the weather tool when asked about weather"}
            ]
        }
    ]
)

for result in response["evaluationResults"]:
    print(f"Score: {result['value']}, Label: {result['label']}")

La trayectoria coincide con la trayectoria esperada

Los evaluadores de trayectoria comparan la secuencia real de uso de herramientas del agente con una secuencia esperada de nombres de herramientas. Hay tres variantes disponibles, cada una con un rigor de coincidencia diferente. Los tres son evaluadores a nivel de sesión y utilizan la puntuación programática (no se utilizan llamadas LLM, por lo que el uso de fichas es nulo).

Evaluador	Regla de coincidencia	Ejemplo
`Builtin.TrajectoryExactOrderMatch`	La real debe coincidir exactamente con la esperada: mismas herramientas, mismo orden, sin extras	Esperado:`[calculator, weather]`, Actual: `[calculator, weather]` → Aprobado. Actual: `[calculator, weather, calculator]` → Fallo.
`Builtin.TrajectoryInOrderMatch`	Las herramientas esperadas deben aparecer en orden, pero se permiten herramientas adicionales entre ellas	Esperado:`[calculator, weather]`, Actual: `[calculator, some_tool, weather]` → Aprobado.
`Builtin.TrajectoryAnyOrderMatch`	Todas las herramientas esperadas deben estar presentes, no importa el orden, se admiten extras	Esperado:`[calculator, weather]`, Actual: `[weather, calculator]` → Aprobado.

ejemplo

AgentCore SDK


from bedrock_agentcore.evaluation import EvaluationClient, ReferenceInputs

client = EvaluationClient(region_name=REGION)

results = client.run(
    evaluator_ids=[
        "Builtin.TrajectoryExactOrderMatch",
        "Builtin.TrajectoryInOrderMatch",
        "Builtin.TrajectoryAnyOrderMatch",
    ],
    agent_id=AGENT_ID,
    session_id=SESSION_ID,
    reference_inputs=ReferenceInputs(
        expected_trajectory=["calculator", "weather"],
    ),
)

for r in results:
    print(f"{r['evaluatorId']}: {r['value']} ({r['label']})")
    print(f"  {r['explanation'][:150]}")

AgentCore CLI

Los nombres de las herramientas se pasan como una lista separada por comas:


agentcore run eval \
  --agent AGENT_NAME \
  --session-id SESSION_ID \
  --evaluator-arn "arn:aws:bedrock-agentcore:::evaluator/Builtin.TrajectoryExactOrderMatch" \
  --evaluator-arn "arn:aws:bedrock-agentcore:::evaluator/Builtin.TrajectoryInOrderMatch" \
  --evaluator-arn "arn:aws:bedrock-agentcore:::evaluator/Builtin.TrajectoryAnyOrderMatch" \
  --expected-trajectory "calculator,weather"

# ARN mode — evaluate an agent outside the CLI project
agentcore run eval \
  --runtime-arn arn:aws:bedrock-agentcore:<region-code>:<account-id>:runtime/<agent-id> \
  --session-id SESSION_ID \
  --evaluator-arn "arn:aws:bedrock-agentcore:::evaluator/Builtin.TrajectoryExactOrderMatch" \
  --expected-trajectory "calculator,weather"

Starter Toolkit SDK


from bedrock_agentcore_starter_toolkit import Evaluation, ReferenceInputs

eval_client = Evaluation(region=REGION)

results = eval_client.run(
    agent_id=AGENT_ID,
    session_id=SESSION_ID,
    evaluators=[
        "Builtin.TrajectoryExactOrderMatch",
        "Builtin.TrajectoryInOrderMatch",
        "Builtin.TrajectoryAnyOrderMatch",
    ],
    reference_inputs=ReferenceInputs(
        expected_trajectory=["calculator", "weather"],
    ),
)

for r in results.get_successful_results():
    print(f"{r.evaluator_name}: {r.value:.2f} ({r.label})")

Starter Toolkit CLI

Los nombres de las herramientas se pasan como una lista separada por comas:


agentcore eval run \
  --agent-id AGENT_ID \
  --session-id SESSION_ID \
  --evaluator "Builtin.TrajectoryExactOrderMatch" \
  --evaluator "Builtin.TrajectoryInOrderMatch" \
  --evaluator "Builtin.TrajectoryAnyOrderMatch" \
  --expected-trajectory "calculator,weather"

AWS SDK (boto3)


import boto3

client = boto3.client("bedrock-agentcore", region_name=REGION)

for evaluator in [
    "Builtin.TrajectoryExactOrderMatch",
    "Builtin.TrajectoryInOrderMatch",
    "Builtin.TrajectoryAnyOrderMatch",
]:
    response = client.evaluate(
        evaluatorId=evaluator,
        evaluationInput={"sessionSpans": session_spans_and_log_events},
        evaluationReferenceInputs=[
            {
                "context": {
                    "spanContext": {
                        "sessionId": SESSION_ID
                    }
                },
                "expectedTrajectory": {
                    "toolNames": ["calculator", "weather"]
                }
            }
        ]
    )

    for result in response["evaluationResults"]:
        print(f"{result['evaluatorId']}: {result['value']} ({result['label']})")

Combinar todos los campos de información básica en una sola solicitud

Puede analizar todos los campos de información básica juntos en una sola convocatoria de evaluación. El servicio dirige cada campo al evaluador correspondiente e ignora los campos que un evaluador determinado no utiliza. Esto significa que puede crear las entradas de referencia una vez y reutilizarlas en distintos evaluadores sin modificar la carga útil.

ejemplo

AgentCore SDK


from bedrock_agentcore.evaluation import EvaluationClient, ReferenceInputs

client = EvaluationClient(region_name=REGION)

results = client.run(
    evaluator_ids=[
        "Builtin.Correctness",
        "Builtin.GoalSuccessRate",
        "Builtin.TrajectoryExactOrderMatch",
        "Builtin.TrajectoryInOrderMatch",
        "Builtin.TrajectoryAnyOrderMatch",
    ],
    agent_id=AGENT_ID,
    session_id=SESSION_ID,
    reference_inputs=ReferenceInputs(
        expected_response="The weather is sunny",
        assertions=[
            "Agent used the calculator tool for math",
            "Agent used the weather tool when asked about weather",
        ],
        expected_trajectory=["calculator", "weather"],
    ),
)

for r in results:
    ignored = r.get("ignoredReferenceInputFields", [])
    print(f"{r['evaluatorId']}: {r['value']} ({r['label']})")
    if ignored:
        print(f"  Ignored fields: {ignored}")

AgentCore CLI


agentcore run eval \
  --agent AGENT_NAME \
  --session-id SESSION_ID \
  --evaluator-arn "arn:aws:bedrock-agentcore:::evaluator/Builtin.Correctness" \
  --evaluator-arn "arn:aws:bedrock-agentcore:::evaluator/Builtin.GoalSuccessRate" \
  --evaluator-arn "arn:aws:bedrock-agentcore:::evaluator/Builtin.TrajectoryExactOrderMatch" \
  --assertion "Agent used the calculator tool for math" \
  --assertion "Agent used the weather tool when asked about weather" \
  --expected-trajectory "calculator,weather" \
  --expected-response "The weather is sunny" \
  --output results.json

Starter Toolkit SDK


from bedrock_agentcore_starter_toolkit import Evaluation, ReferenceInputs

eval_client = Evaluation(region=REGION)

results = eval_client.run(
    agent_id=AGENT_ID,
    session_id=SESSION_ID,
    evaluators=[
        "Builtin.Correctness",
        "Builtin.GoalSuccessRate",
        "Builtin.TrajectoryExactOrderMatch",
        "Builtin.TrajectoryInOrderMatch",
        "Builtin.TrajectoryAnyOrderMatch",
    ],
    reference_inputs=ReferenceInputs(
        expected_response="The weather is sunny",
        assertions=[
            "Agent used the calculator tool for math",
            "Agent used the weather tool when asked about weather",
        ],
        expected_trajectory=["calculator", "weather"],
    ),
)

for r in results.get_successful_results():
    print(f"{r.evaluator_name}: {r.value:.2f} ({r.label})")

AWS SDK (boto3)


import boto3

client = boto3.client("bedrock-agentcore", region_name=REGION)

reference_inputs = [
    {
        "context": {
            "spanContext": {"sessionId": SESSION_ID}
        },
        "assertions": [
            {"text": "Agent used the calculator tool for math"},
            {"text": "Agent used the weather tool when asked about weather"}
        ],
        "expectedTrajectory": {
            "toolNames": ["calculator", "weather"]
        }
    },
    {
        "context": {
            "spanContext": {
                "sessionId": SESSION_ID,
                "traceId": TRACE_ID_2
            }
        },
        "expectedResponse": {"text": "The weather is sunny"}
    }
]

for evaluator in ["Builtin.Correctness", "Builtin.GoalSuccessRate",
                   "Builtin.TrajectoryExactOrderMatch"]:
    response = client.evaluate(
        evaluatorId=evaluator,
        evaluationInput={"sessionSpans": session_spans_and_log_events},
        evaluationReferenceInputs=reference_inputs
    )
    for result in response["evaluationResults"]:
        ignored = result.get("ignoredReferenceInputFields", [])
        print(f"{result['evaluatorId']}: {result['value']} ({result['label']})")
        if ignored:
            print(f"  Ignored fields: {ignored}")

Comprender los campos de entrada de referencia ignorados

Cuando se proporcionan campos de verdad fundamental que un evaluador no utiliza, la respuesta incluye una ignoredReferenceInputFields matriz con los campos no utilizados. Se trata de información, no de un error: la evaluación se completa satisfactoriamente.

Por ejemplo, si llamas Builtin.Helpfulness con la expectedResponse información proporcionada, el evaluador ignora la verdad fundamental (Helpfulness no la usa) y devuelve:


{
  "evaluatorId": "Builtin.Helpfulness",
  "value": 0.83,
  "label": "Very Helpful",
  "explanation": "...",
  "ignoredReferenceInputFields": ["expectedResponse"]
}

Este comportamiento se debe a un diseño: permite construir un único conjunto de entradas de referencia y utilizarlas en varios evaluadores sin ajustar la carga útil de cada una de ellas.

Fundamenta la verdad en los evaluadores personalizados

Los evaluadores personalizados pueden utilizar campos de información básica como marcadores de posición en sus instrucciones de evaluación. Al crear un evaluador personalizado, puede hacer referencia a los siguientes marcadores de posición:

Session-level evaluadores personalizados:{context},,,, {available_tools} {actual_tool_trajectory} {expected_tool_trajectory} {assertions}
Trace-level evaluadores personalizados:{context},, {assistant_turn} {expected_response}

Por ejemplo, un evaluador a nivel de rastreo personalizado que compruebe la similitud de las respuestas podría utilizar:


Compare the agent's response with the expected response.
Agent response: {assistant_turn}
Expected response: {expected_response}
Rate how closely the agent's response matches the expected response on a scale of 0 to 1.

Cuando se invoca a este evaluador expectedResponse en las entradas de referencia, el servicio sustituye el marcador de posición por el valor real de la verdad fundamental antes de puntuar.

Para obtener más información sobre la creación de evaluadores personalizados, consulte Evaluadores personalizados.

nota

Los evaluadores personalizados que utilizan marcadores de posición basados en la verdad ({assertions},{expected_response},{expected_tool_trajectory}) no se pueden utilizar en las configuraciones de evaluación en línea, ya que las evaluaciones en línea supervisan el tráfico de producción en directo cuando los valores de la verdad fundamental no están disponibles.

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

Cómo empezar con la evaluación bajo demanda

Comprensión de los intervalos de entrada