OrkaJS
Orka.JS

Métriques d'Évaluation

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

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 } from '@orka-js/core';
import { OpenAIAdapter } from '@orka-js/openai';
import { MemoryVectorAdapter } from '@orka-js/memory';
 
const orka = createOrka({
llm: new OpenAIAdapter({ apiKey: process.env.OPENAI_API_KEY! }),
vectorDB: new MemoryVectorAdapter(),
});
 
// 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 :

relevance

Pertinence Contextuelle

Mesure l'alignement entre l'intention utilisateur et la réponse générée.

Target> 0.8
correctness

Justesse Sémantique

Valide l'exactitude factuelle par rapport à la vérité terrain, tolérant les variations linguistiques.

Target> 0.7
faithfulness

Fidélité de l'Ancrage

Garantit que la réponse dérive exclusivement des documents récupérés.

Target> 0.85
hallucination

Taux d'Hallucination

Identifie les informations fabriquées absentes du contexte source.

Target< 0.15
cost

Coût Opérationnel

Consommation agrégée de tokens (Input + Output) par cycle d'inférence.

TargetMonitor

# Métriques RAGAS

La suite RAGAS fournit quatre métriques de niveau production pour l'évaluation RAG. Importez-les depuis @orka-js/evaluation — elles partagent la même interface MetricFn que les métriques intégrées.

contextPrecision

Précision Contextuelle

LLM Judge

Juge LLM : quelle fraction des chunks récupérés est réellement utile pour la réponse ?

Target> 0.75
contextRecall

Rappel Contextuel

LLM Judge

Juge LLM : le contexte récupéré couvre-t-il tous les aspects de la réponse attendue ?

Target> 0.70
answerRelevance

Pertinence de la Réponse

Embedding

Similarité cosinus entre l'embedding de la question et celui de la réponse. Score élevé = réponse reste dans le sujet.

Target> 0.80
semanticSimilarity

Similarité Sémantique

Embedding

Similarité cosinus entre l'embedding de la sortie générée et celui de la sortie attendue. Nécessite expectedOutput.

Target> 0.85
ragas-evaluation.ts
import {
contextPrecision,
contextRecall,
answerRelevance,
semanticSimilarity,
cosineSimilarity,
ragasMetrics,
} from '@orka-js/evaluation';
import { OpenAIAdapter } from '@orka-js/openai';
 
const llm = new OpenAIAdapter({ apiKey: process.env.OPENAI_API_KEY! });
 
// Use individually
const precision = await contextPrecision({
input: 'What is the capital of France?',
output: 'Paris is the capital of France.',
context: ['France is a country in Europe. Its capital is Paris.', 'Unrelated text.'],
llm,
});
console.log(precision.score); // e.g. 0.87
 
// Use the ragasMetrics bundle with orka.evaluate()
const summary = await orka.evaluate({
dataset,
metrics: Object.values(ragasMetrics),
});
 
// cosineSimilarity helper
const sim = cosineSimilarity([0.1, 0.9, 0.3], [0.2, 0.8, 0.4]);
console.log(sim); // 0.998

# 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],
});

Interface de Contexte d'Évaluation

MetricFn Schema & LLM-as-Judge Readiness

input / outputCore Data

Type: string

Le couple d'inférence central : prompt original vs réponse générée. Source primaire d'analyse de dérive sémantique.

expectedOutputGround Truth

Type: string | undefined

Référence de vérité terrain. Essentiel pour calculer le score d'exactitude ou de correction.

contextRetrieval

Type: ChunkResult[]

Les preuves de récupération. Utilisé pour mesurer la Fidélité et la Précision Contextuelle.

llmJudge

Type: LLMAdapter

Active le pattern LLM-as-Judge. Permet une évaluation récursive via un modèle à haut raisonnement.

# 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
}

Cadre d'Assurance Qualité

Production Readiness Standards

Benchmarks Cibles

Faithfulness> 0.85

Ancrage factuel strict.

Hallucination< 0.15

Déviance maximale tolérée.

Stratégies Recommandées

  • Évaluation Holistique : Combinez pertinence, justesse et fidélité pour une vue à 360°.

  • Personnalisation : Adaptez les métriques aux contraintes métier (Ton, PII, Format).

  • Portier CI/CD : Tests de régression automatisés à chaque commit pour éviter la dérive.

Imports Tree-shakeable

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