RAG evalueren met RAGAS

Waarom RAG evalueren moeilijk is

RAG-evaluatie is uitdagender dan gewone model-evaluatie omdat je drie componenten tegelijk meet: de retriever, de context en de generator. Een goed antwoord kan gebaseerd zijn op slechte retrieval, bijvoorbeeld doordat het model de gaten vulde met parametrische kennis. Andersom kan slechte retrieval leiden tot een antwoord dat goed oogt maar feitelijk incorrect is.

Je hebt daarom twee soorten evaluatie nodig:

1. Component-evaluatie: hoe goed is de retriever afzonderlijk?
2. End-to-end-evaluatie: hoe goed is het systeem als geheel?

Testset opbouwen

Begin met een set representatieve vragen met een verwacht antwoord (ground_truth). Houd de bronnen erbij zodat je later ook recall kunt controleren.

interface RAGTestCase {
  question: string;
  ground_truth: string;
  source_documents?: string[];
}

const testCases: RAGTestCase[] = [
  {
    question: "Hoe vraag ik verlof aan?",
    ground_truth: "Verlof aanvragen doe je via het HR-portaal. Log in, ga naar Verlof, selecteer de data en kies het verloftype. Je leidinggevende ontvangt automatisch een goedkeuringsverzoek.",
    source_documents: ["hr-handleiding-sectie-3"],
  },
];

Context precision meten

Context precision meet hoe relevant de opgehaalde chunks zijn en of de relevante chunks bovenaan staan:

async function measureContextPrecision(
  question: string,
  retrievedDocs: string[],
  groundTruth: string
): Promise<number> {
  const relevanceScores = await Promise.all(
    retrievedDocs.map(async (doc) => {
      const response = await anthropic.messages.create({
        model: "claude-haiku-4-5",
        max_tokens: 10,
        messages: [{
          role: "user",
          content: `Is dit document relevant voor de vraag en het verwachte antwoord?
Antwoord alleen: ja of nee.

Vraag: ${question}
Verwacht antwoord: ${groundTruth}
Document: ${doc}`,
        }],
      });
      const text = response.content[0].type === "text" ? response.content[0].text.toLowerCase() : "";
      return text.includes("ja") ? 1 : 0;
    })
  );

  let precisionAtK = 0;
  let relevantSoFar = 0;
  for (let k = 0; k < relevanceScores.length; k++) {
    if (relevanceScores[k] === 1) {
      relevantSoFar++;
      precisionAtK += relevantSoFar / (k + 1);
    }
  }
  const totalRelevant = relevanceScores.reduce((a, b) => a + b, 0);
  return totalRelevant > 0 ? precisionAtK / totalRelevant : 0;
}

Faithfulness meten

Faithfulness meet of het gegenereerde antwoord consistent is met de context. De aanpak is in twee stappen: extraheer eerst de feitelijke claims, controleer daarna of elke claim door de context wordt ondersteund.

async function measureFaithfulness(
  answer: string,
  context: string[]
): Promise<number> {
  const claimsResponse = await anthropic.messages.create({
    model: "claude-haiku-4-5",
    max_tokens: 500,
    messages: [{
      role: "user",
      content: `Extraheer alle feitelijke claims uit dit antwoord als een JSON-array van strings.

Antwoord: ${answer}

Geef alleen de JSON-array terug:`,
    }],
  });
  const claimsText = claimsResponse.content[0].type === "text" ? claimsResponse.content[0].text : "[]";
  const claims: string[] = JSON.parse(claimsText.match(/\[.*\]/s)?.[0] ?? "[]");

  if (claims.length === 0) return 1;

  const contextStr = context.join("

");
  const supportedChecks = await Promise.all(
    claims.map(async (claim) => {
      const response = await anthropic.messages.create({
        model: "claude-haiku-4-5",
        max_tokens: 10,
        messages: [{
          role: "user",
          content: `Wordt deze claim ondersteund door de context? Antwoord alleen: ja of nee.

Context: ${contextStr}
Claim: ${claim}`,
        }],
      });
      const text = response.content[0].type === "text" ? response.content[0].text.toLowerCase() : "";
      return text.includes("ja") ? 1 : 0;
    })
  );

  return supportedChecks.reduce((a, b) => a + b, 0) / claims.length;
}

Answer relevance meten

Answer relevance keert de vraag om: laat het model vragen genereren die bij het antwoord passen en meet hoe sterk die op de oorspronkelijke vraag lijken via embeddings.

async function measureAnswerRelevance(
  question: string,
  answer: string,
  numVariants = 3
): Promise<number> {
  const variantsResponse = await anthropic.messages.create({
    model: "claude-haiku-4-5",
    max_tokens: 300,
    messages: [{
      role: "user",
      content: `Genereer ${numVariants} mogelijke vragen die dit antwoord zou beantwoorden.
Geef elke vraag op een nieuwe regel.

Antwoord: ${answer}`,
    }],
  });
  const variantsText = variantsResponse.content[0].type === "text" ? variantsResponse.content[0].text : "";
  const generatedQuestions = variantsText.split("
").filter(Boolean).slice(0, numVariants);

  const questionEmbedding = await embedText(question);
  const similarities = await Promise.all(
    generatedQuestions.map(async (q) => {
      const emb = await embedText(q);
      return cosineSimilarity(questionEmbedding, emb);
    })
  );

  return similarities.reduce((a, b) => a + b, 0) / similarities.length;
}

Complete evaluatiepipeline

Knoop de metrieken aan elkaar en draai ze over je hele testset. Het gemiddelde per metriek vormt je RAGAS-rapport.

async function evaluateRAGSystem(
  testCases: RAGTestCase[],
  ragFunction: (q: string) => Promise<{ answer: string; retrieved_docs: string[] }>
): Promise<RAGASReport> {
  const results = await Promise.all(
    testCases.map(async (tc) => {
      const { answer, retrieved_docs } = await ragFunction(tc.question);
      const [contextPrecision, faithfulness, answerRelevance] = await Promise.all([
        measureContextPrecision(tc.question, retrieved_docs, tc.ground_truth),
        measureFaithfulness(answer, retrieved_docs),
        measureAnswerRelevance(tc.question, answer),
      ]);
      return { contextPrecision, faithfulness, answerRelevance };
    })
  );

  const avg = (key: keyof typeof results[0]) =>
    results.reduce((sum, r) => sum + r[key], 0) / results.length;

  return {
    context_precision: avg("contextPrecision"),
    faithfulness: avg("faithfulness"),
    answer_relevance: avg("answerRelevance"),
    num_test_cases: testCases.length,
  };
}

Interpretatie van scores