Servicio de evaluación de Gen AI de Vertex AI

La funcionalidad vertex-eval conecta adk-eval con el Servicio de evaluación de Gen AI de Vertex AI. Las evaluaciones basadas en modelos se ejecutan en el autorater del servicio en lugar de un LLM local, y las trayectorias de herramientas se puntúan mediante las métricas de trayectoria basadas en computación del servicio. Cada llamada es un único POST a projects.locations:evaluateInstances (v1beta1).

Configuración

[dependencies]
adk-eval = { version = "2.1.0", features = ["vertex-eval"] }

La autenticación utiliza credenciales predeterminadas de la aplicación (gcloud auth application-default login o la identidad de carga de trabajo de un contenedor desplegado). El emisor de la llamada necesita el permiso aiplatform.endpoints.predict (roles/aiplatform.user).

Juez respaldado por servicio

VertexEvalJudge refleja la superficie de evaluación de LlmJudge — los mismos nombres de métodos, los mismos tipos de resultado — por lo que se integra directamente en el código escrito para el juez local:

use adk_eval::{VertexEvalClient, VertexEvalConfig, VertexEvalJudge};
use adk_eval::criteria::{Rubric, RubricConfig};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = VertexEvalConfig::from_env()?;
    let judge = VertexEvalJudge::new(VertexEvalClient::new_with_adc(config)?);

    // Semantic equivalence (pointwiseMetricInput under the hood)
    let result = judge
        .semantic_match("The capital is Paris", "Paris is the capital of France", None)
        .await?;
    println!("score={} equivalent={}", result.score, result.equivalent);

    // Rubric-based quality, weight-normalized like LlmJudge
    let rubrics = RubricConfig {
        rubrics: vec![
            Rubric::new("Accuracy", "Response is factually correct").with_weight(2.0),
            Rubric::new("Clarity", "Response is easy to follow"),
        ],
    };
    let quality = judge.evaluate_rubrics("agent output", "task context", &rubrics).await?;
    println!("overall={}", quality.overall_score);

    // Safety and hallucination checks
    let safety = judge.evaluate_safety("agent output").await?;
    let hallucination = judge
        .detect_hallucinations("agent output", "provided context", Some("ground truth"))
        .await?;
    println!("safe={} grounded={}", safety.is_safe, hallucination.hallucination_free);
    Ok(())
}

Diferencias con LlmJudge, ambas consecuencias de que el servicio devuelva un par de {score, explanation} por evaluación:

• Los veredictos booleanos (equivalent, is_safe, hallucination_free) se derivan de la puntuación: un valor igual o superior a 0.5 cuenta como aprobado.
• issues contiene la explicación del servicio como una única entrada, en lugar de una lista analizada.

Métricas de trayectoria

VertexEvalClient::evaluate_trajectory asigna los valores adk-eval ToolUse a la forma Trajectory del protocolo (name → toolName, args → JSON-codificado toolInput) y devuelve la puntuación:

use adk_eval::{TrajectoryMetric, VertexEvalClient, VertexEvalConfig};
use adk_eval::schema::ToolUse;
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = VertexEvalClient::new_with_adc(VertexEvalConfig::from_env()?)?;

    let predicted = vec![ToolUse::new("get_weather").with_args(json!({ "city": "Paris" }))];
    let reference = predicted.clone();

    let score = client
        .evaluate_trajectory(TrajectoryMetric::ExactMatch, &predicted, &reference)
        .await?;
    assert_eq!(score, 1.0);
    Ok(())
}

Configuración del modelo evaluador

AutoraterConfig selecciona el modelo evaluador y el muestreo para las métricas basadas en modelos; el servidor lo ignora para las métricas basadas en computación:

use adk_eval::{AutoraterConfig, VertexEvalClient, VertexEvalConfig};

fn build() -> adk_core::Result<VertexEvalClient> {
    let client = VertexEvalClient::new_with_adc(VertexEvalConfig::from_env()?)?
        .with_autorater_config(
            AutoraterConfig::new()
                .with_autorater_model(
                    "projects/p/locations/us-central1/publishers/google/models/gemini-3.7-flash",
                )
                .with_sampling_count(1),
        );
    Ok(client)
}

Métricas personalizadas

evaluate_pointwise acepta cualquier PointwiseMetricSpec; el metricPromptTemplate contiene variables {placeholder} representadas en el servidor a partir del objeto de instancia:

use adk_eval::{PointwiseMetricSpec, VertexEvalClient, VertexEvalConfig};
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = VertexEvalClient::new_with_adc(VertexEvalConfig::from_env()?)?;

    let spec = PointwiseMetricSpec::new(
        "Rate the politeness of the response from 0.0 to 1.0.\n\nResponse:\n{response}",
    );
    let result = client
        .evaluate_pointwise(&spec, &json!({ "response": "Thanks for asking!" }))
        .await?;
    println!("score={:?} explanation={:?}", result.score, result.explanation);
    Ok(())
}

evaluate_instances es el mecanismo de escape sin procesar: envía mediante POST cualquier cuerpo EvaluateInstancesRequest y devuelve la respuesta sin procesar, lo que permite acceder a todas las demás métricas compatibles con el servicio (BLEU, ROUGE, métricas por pares y métricas de llamadas a herramientas).

Gestión de errores

Los errores son valores AdkError estructurados con el componente eval y códigos eval.vertex.* (eval.vertex.rate_limited, eval.vertex.unauthorized, eval.vertex.invalid_response, ...). Los métodos VertexEvalJudge devuelven el EvalError::JudgeError del crate, de acuerdo con LlmJudge.

Véase también

• Evaluación de agentes — el evaluador, los criterios y los evaluadores locales
• Descripción general de la evaluación de Vertex AI Gen AI
• Referencia de projects.locations.evaluateInstances REST