Vérifications rapides

Les vérifications rapides sont des micro-scorers composables destinés aux assertions courantes, telles que « la sortie contient X » ou « l’Agent a appelé le Tool Y ». Elles ne nécessitent aucun LLM, s’exécutent instantanément et s’intègrent au même tableau scorers: [...] que tout autre scorer.

Quand utiliser les vérifications rapides

Utilisez les vérifications rapides lorsque vous avez besoin d’assertions déterministes et rapides :

• Vérifier que le texte produit contient ou exclut certaines chaînes
• Confirmer qu’un Agent a appelé (ou évité) certains Tools
• Valider l’ordre des appels de Tool et leurs limites quantitatives
• Conditionner les pipelines CI à l’aide de vérifications binaires sans coût
• Combiner ces vérifications avec des scorers fondés sur des LLM pour une évaluation à plusieurs niveaux

Pour une évaluation subjective ou sémantique, utilisez plutôt des scorers fondés sur des LLM.

Démarrage rapide

src/evals/weather-checks.ts

import { checks } from '@mastra/evals/checks'
import { runEvals } from '@mastra/core/evals'
import { weatherAgent } from '../agents'

const result = await runEvals({
  data: [{ input: 'What is the weather in Brooklyn?' }],
  target: weatherAgent,
  scorers: [checks.includes('Brooklyn'), checks.calledTool('get_weather'), checks.noToolErrors()],
})

console.log(result.scores)
// { 'check-includes': 1, 'check-called-tool': 1, 'check-no-tool-errors': 1 }

Vérifications disponibles

Les vérifications rapides se répartissent dans les catégories suivantes :

Vérifications du texte

Ces scorers évaluent le texte produit par l’Agent :

Vérification	Fonction	Score
checks.includes(str)	La sortie contient la sous-chaîne	1 ou 0
checks.excludes(str)	La sortie ne contient pas la sous-chaîne	1 ou 0
checks.equals(str)	La sortie correspond exactement à la chaîne	1 ou 0
checks.matches(regex)	La sortie correspond à l’expression régulière	1 ou 0
checks.similarity(str)	Similarité avec la chaîne selon le coefficient de Dice	0 à 1 (ou binaire avec threshold)

Vérifications des appels de Tool

Ces scorers évaluent l’utilisation des Tools pendant l’exécution de l’Agent :

Vérification	Fonction	Score
checks.calledTool(name)	Le Tool a été appelé au moins N fois	1 ou 0
checks.didNotCall(name)	Le Tool n’a pas été appelé	1 ou 0
checks.toolOrder([...])	Les Tools ont été appelés dans l’ordre attendu	1 ou 0
checks.maxToolCalls(n)	Le nombre total d’appels de Tool ne dépasse pas N	1 ou 0
checks.usedNoTools()	Aucun Tool n’a été appelé	1 ou 0
checks.noToolErrors()	Aucun appel de Tool n’a produit d’erreur	1 ou 0

Combiner les vérifications avec des scorers LLM

Les vérifications se combinent avec des scorers fondés sur des LLM dans un même appel à runEvals. Utilisez les vérifications comme conditions déterministes et les scorers LLM pour l’évaluation qualitative :

src/evals/layered-eval.ts

import { checks } from '@mastra/evals/checks'
import { createFaithfulnessScorer } from '@mastra/evals/scorers/prebuilt'
import { runEvals } from '@mastra/core/evals'
import { myAgent } from '../agents'

const result = await runEvals({
  data: [
    {
      input: 'What is the weather in Brooklyn?',
      context: ['Brooklyn weather data: sunny, 72°F'],
    },
  ],
  target: myAgent,
  scorers: [
    // Deterministic checks (instant, free)
    checks.includes('Brooklyn'),
    checks.calledTool('get_weather'),
    checks.excludes('error'),
    checks.noToolErrors(),

    // LLM-based scorer (semantic, costs tokens)
    createFaithfulnessScorer({ model: 'openai/gpt-5-mini' }),
  ],
})

Utiliser les vérifications pour l’évaluation en direct

Associez des vérifications aux Agents pour assurer un suivi continu :

src/agents/weather-agent.ts

import { Agent } from '@mastra/core/agent'
import { checks } from '@mastra/evals/checks'

export const weatherAgent = new Agent({
  id: 'weather-agent',
  name: 'Weather Agent',
  instructions: 'Answer weather questions using the get_weather tool.',
  model: 'openai/gpt-5.6-sol',
  tools: { get_weather: weatherTool },
  scorers: {
    noErrors: {
      scorer: checks.noToolErrors(),
      sampling: { type: 'ratio', rate: 1 },
    },
    mentionCity: {
      scorer: checks.includes('Brooklyn'),
      sampling: { type: 'ratio', rate: 0.5 },
    },
  },
})

Fonctionnement des vérifications

Chaque vérification est une instance standard de createScorer() comportant une étape preprocess et une étape generateScore. Elles suivent le même pipeline en quatre étapes que tout autre scorer :

1. preprocess : extrait et normalise les données pertinentes de l’exécution de l’Agent (contenu textuel, appels de Tool)
2. generateScore : convertit le résultat prétraité en score (généralement binaire, 1 ou 0)

Comme les vérifications ignorent les étapes analyze et generateReason et n’appellent aucun LLM, elles s’exécutent en quelques microsecondes. Consultez la référence des vérifications rapides pour découvrir l’API complète, notamment tous les paramètres et options de chaque vérification.

Pages connexes

• Référence des vérifications rapides
• Scorers intégrés
• Scorers personnalisés
• Référence de runEvals()