Serviço de avaliação de IA generativa do Vertex AI

O recurso vertex-eval conecta adk-eval ao serviço de avaliação de IA generativa do Vertex AI. Os julgamentos baseados em modelos são executados no autorater do serviço, em vez de um LLM local, e as trajetórias das ferramentas são avaliadas pelas métricas de trajetória baseadas em computação do serviço. Cada chamada é uma única solicitação POST para projects.locations:evaluateInstances (v1beta1).

Configuração

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

A autenticação usa as Credenciais Padrão do Aplicativo (gcloud auth application-default login ou a identidade da carga de trabalho de um contêiner implantado). O chamador precisa da permissão aiplatform.endpoints.predict (roles/aiplatform.user).

Juiz respaldado por serviço

VertexEvalJudge espelha a superfície de avaliação de LlmJudge — mesmos nomes de métodos, mesmos tipos de resultado — portanto, integra-se ao código escrito para o juiz 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(())
}

Diferenças em relação a LlmJudge, ambas consequências do serviço retornar um par {score, explanation} por avaliação:

• Os veredictos booleanos (equivalent, is_safe, hallucination_free) são derivados da pontuação — um valor igual ou superior a 0,5 conta como aprovação.
• issues contém a explicação do serviço como uma única entrada, em vez de uma lista analisada.

Métricas de trajetória

VertexEvalClient::evaluate_trajectory mapeia os valores de adk-eval ToolUse para o formato Trajectory de transmissão (name → toolName, args → JSON-codificado toolInput) e retorna a pontuação:

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(())
}

Configuração do modelo avaliador

AutoraterConfig seleciona o modelo avaliador e a amostragem para métricas baseadas em modelos; o servidor o ignora para métricas baseadas em computação:

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 aceita qualquer PointwiseMetricSpec — o metricPromptTemplate contém variáveis {placeholder} renderizadas no servidor a partir do objeto de instância:

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 é a alternativa de baixo nível: envia por POST qualquer corpo EvaluateInstancesRequest e retorna a resposta bruta, alcançando todas as outras métricas compatíveis com o serviço (BLEU, ROUGE, pareadas, métricas de chamadas de ferramentas).

Tratamento de erros

Os erros são valores estruturados AdkError com o componente eval e códigos eval.vertex.* (eval.vertex.rate_limited, eval.vertex.unauthorized, eval.vertex.invalid_response, ...). Os métodos VertexEvalJudge retornam o EvalError::JudgeError do crate, correspondente a LlmJudge.

Veja também

• Avaliação de agentes — o avaliador, os critérios e os avaliadores locais
• Visão geral da avaliação de IA generativa do Vertex AI
• Referência de projects.locations.evaluateInstances REST