Métriques d'Évaluation

Mesurez la qualité de vos réponses LLM avec des métriques d'évaluation intégrées et personnalisées.

Pourquoi l'Évaluation ?

Les sorties LLM sont non-déterministes et peuvent varier en qualité. Les métriques d'évaluation vous aident à mesurer et suivre la qualité de votre système RAG, détecter les régressions, et comparer différentes configurations. Orka fournit des métriques intégrées et la possibilité de créer les vôtres.

dataset-evaluation.ts

import { createOrka, OpenAIAdapter, MemoryVectorDB } from 'orkajs';
 
const orka = createOrka({
  llm: new OpenAIAdapter({ apiKey: process.env.OPENAI_API_KEY! }),
  vectorDB: new MemoryVectorDB(),
});
 
// Define your evaluation dataset
const dataset = [
  {
    input: 'What is Orka AI?',
    expectedOutput: 'A TypeScript framework for building LLM applications.',
    knowledge: 'docs',  // Knowledge base to use for RAG
  },
  {
    input: 'How do I install Orka?',
    expectedOutput: 'Run npm install orkajs',
    knowledge: 'docs',
  },
];
 
// Run evaluation with multiple metrics
const summary = await orka.evaluate({
  dataset,
  metrics: ['relevance', 'correctness', 'faithfulness', 'hallucination'],
});
 
console.log(summary.metrics);
// {
//   relevance:     { average: 0.95, min: 0.9, max: 1.0 },
//   correctness:   { average: 0.88, min: 0.85, max: 0.92 },
//   faithfulness:  { average: 0.92, min: 0.88, max: 0.96 },
//   hallucination: { average: 0.05, min: 0.0, max: 0.1 },
// }
 
console.log(summary.results);  // Detailed per-case results
console.log(summary.passed);   // true if all thresholds met

# Métriques Intégrées

Orka fournit cinq métriques intégrées qui couvrent les aspects les plus importants de la qualité RAG :

relevancePlus haut = mieux

Mesure la pertinence de la réponse générée par rapport à la question originale. Utilise LLM-as-judge pour scorer de 0 (complètement non pertinent) à 1 (parfaitement pertinent).

Cible : > 0.8 pour les systèmes en production

correctnessPlus haut = mieux

Compare la réponse générée à la sortie attendue en utilisant la similarité sémantique. Prend en compte les paraphrases et formulations différentes qui transmettent le même sens.

Cible : > 0.7 (permet les paraphrases)

faithfulnessPlus haut = mieux

Mesure si la réponse est ancrée dans le contexte récupéré. Une réponse fidèle ne contient que des informations traçables aux documents sources.

Cible : > 0.85 pour les systèmes RAG

hallucinationPlus bas = mieux

Détecte les informations dans la réponse qui ne sont PAS présentes dans le contexte fourni. C'est l'inverse de faithfulness et signale spécifiquement le contenu fabriqué.

Cible : < 0.15 pour les systèmes en production

costInformatif

Suit la consommation de tokens par cas d'évaluation. Utile pour surveiller les coûts et optimiser les longueurs de prompts.

# Métriques Personnalisées

Créez des métriques personnalisées pour des vérifications de qualité spécifiques à votre domaine. Une métrique personnalisée est une fonction async qui reçoit le contexte d'évaluation et retourne un score.

custom-metrics.ts

import type { MetricFn } from 'orkajs';
 
// Custom metric: Check professionalism of tone
const toneCheck: MetricFn = async ({ input, output, context, llm }) => {
  const result = await llm.generate(
    `Rate the professionalism of this response on a scale of 0.0 to 1.0.
     Question: ${input}
     Response: ${output}
     Reply with ONLY a number.`,
    { temperature: 0, maxTokens: 10 }
  );
 
  const score = parseFloat(result.content.trim());
  return {
    name: 'professionalism',
    score: isNaN(score) ? 0 : Math.min(1, Math.max(0, score)),
  };
};
 
// Custom metric: Check response length
const lengthCheck: MetricFn = async ({ output }) => {
  const wordCount = output.split(/\s+/).length;
  // Penalize very short or very long responses
  const idealLength = 50;
  const score = Math.max(0, 1 - Math.abs(wordCount - idealLength) / idealLength);
  return { name: 'length_appropriateness', score };
};
 
// Use alongside built-in metrics
const summary = await orka.evaluate({
  dataset: [...],
  metrics: ['relevance', 'faithfulness', toneCheck, lengthCheck],
});

- Contexte MetricFn

input: string

La question/entrée originale du dataset

output: string

La réponse générée par le LLM

expectedOutput?: string

La réponse attendue du dataset (si fournie)

context?: ChunkResult[]

Chunks récupérés utilisés pour générer la réponse

llm: LLMAdapter

Adaptateur LLM pour faire des appels supplémentaires (ex: LLM-as-judge)

# Résultat de l'Évaluation

interface EvaluationSummary {
  metrics: {
    [metricName: string]: {
      average: number;  // Average score across all cases
      min: number;      // Minimum score
      max: number;      // Maximum score
      stdDev: number;   // Standard deviation
    };
  };
  results: EvaluationResult[];  // Per-case detailed results
  passed: boolean;              // True if all thresholds met
  totalCases: number;           // Number of test cases
  totalLatencyMs: number;       // Total evaluation time
  totalTokens: number;          // Total tokens consumed
}

💡 Bonnes Pratiques

Utilisez les quatre métriques pour le RAG : relevance, correctness, faithfulness, hallucination
Un bon système RAG devrait avoir faithfulness > 0.85 et hallucination < 0.15
Créez des métriques personnalisées pour des vérifications spécifiques (ton, longueur, format)
Exécutez les évaluations en CI/CD pour détecter les régressions avant le déploiement

Imports Tree-shakeable

// ✅ Import evaluation types
import type { MetricFn, EvaluationSummary } from 'orkajs';
 
// ✅ Import built-in metrics individually
import { relevance, correctness, faithfulness, hallucination } from 'orkajs/evaluation';