> ## Documentation Index > Fetch the complete documentation index at: https://docs.galileo.ai/llms.txt > Use this file to discover all available pages before exploring further. # Context Relevance (Query Adherence) > Understand how to measure the relevance of context provided to user queries export const BooleanClassificationReport = ({report, negativeLabel = "Not Advanced", positiveLabel = "Advanced", negativeClass = "False", positiveClass = "True", maxWidth = 520}) => { const parseReport = reportStr => { const lines = reportStr.trim().split('\n').filter(line => line.trim()); const result = { classes: [], accuracy: null, macroAvg: null, weightedAvg: null, totalSupport: null }; for (const line of lines) { const parts = line.trim().split(/\s+/); if (parts[0] === 'precision') continue; if (parts.length >= 5 && !['accuracy', 'macro', 'weighted'].includes(parts[0])) { result.classes.push({ name: parts[0], precision: parseFloat(parts[1]), recall: parseFloat(parts[2]), f1: parseFloat(parts[3]), support: parseInt(parts[4], 10) }); } if (parts[0] === 'accuracy') { result.accuracy = parseFloat(parts[1]); result.totalSupport = parseInt(parts[2], 10); } if (parts[0] === 'macro' && parts[1] === 'avg') { result.macroAvg = { precision: parseFloat(parts[2]), recall: parseFloat(parts[3]), f1: parseFloat(parts[4]), support: parseInt(parts[5], 10) }; } if (parts[0] === 'weighted' && parts[1] === 'avg') { result.weightedAvg = { precision: parseFloat(parts[2]), recall: parseFloat(parts[3]), f1: parseFloat(parts[4]), support: parseInt(parts[5], 10) }; } } return result; }; const parsed = parseReport(report); if (parsed.classes.length < 2) { return
BooleanClassificationReport: Could not parse report. Expected at least 2 classes.
; } const negClass = parsed.classes.find(c => c.name === negativeClass) || parsed.classes[0]; const posClass = parsed.classes.find(c => c.name === positiveClass) || parsed.classes[1]; const tnPlusFp = negClass.support; const tpPlusFn = posClass.support; const tn = Math.round(negClass.recall * tnPlusFp); const fp = tnPlusFp - tn; const tp = Math.round(posClass.recall * tpPlusFn); const fn = tpPlusFn - tp; const tnPct = tn / tnPlusFp * 100; const fpPct = fp / tnPlusFp * 100; const fnPct = fn / tpPlusFn * 100; const tpPct = tp / tpPlusFn * 100; const rowStyle = { borderBottom: "1px solid rgba(148, 163, 184, 0.3)" }; const cellStyle = { padding: "0.5rem 0.125rem" }; const centerCellStyle = { textAlign: "center", padding: "0.5rem 0.125rem" }; return
{} {}
Precision Recall F1-Score
{negativeLabel} {negClass.precision.toFixed(2)} {negClass.recall.toFixed(2)} {negClass.f1.toFixed(2)}
{positiveLabel} {posClass.precision.toFixed(2)} {posClass.recall.toFixed(2)} {posClass.f1.toFixed(2)}
{}
; }; export const BooleanConfusionMatrix = ({actualNegativeLabel = "Not Advanced", actualPositiveLabel = "Advanced", predictedNegativeLabel = "Not Advanced", predictedPositiveLabel = "Advanced", tnCount, tnPct, fpCount, fpPct, fnCount, fnPct, tpCount, tpPct, matrix, maxWidth = 520, displayFormat = "percentage", fractionDigits = 3, percentageDigits = 1, titlePrefix = ""}) => { const parseNum = val => val !== undefined && val !== null ? Number(val) : undefined; const clampPct = pct => Math.max(0, Math.min(100, Number(pct) || 0)); const formatValue = pct => { const p = clampPct(pct); if (displayFormat === "fraction") { const digits = Number.isFinite(Number(fractionDigits)) ? Number(fractionDigits) : 3; return (p / 100).toFixed(digits); } const digits = Number.isFinite(Number(percentageDigits)) ? Number(percentageDigits) : 1; return `${p.toFixed(digits)}%`; }; const palette = ["#f8fafc", "#eff6ff", "#dbeafe", "#bfdbfe", "#93c5fd", "#60a5fa", "#3b82f6", "#2563eb", "#1d4ed8", "#1e40af"]; const getBg = pct => { const p = clampPct(pct); const idx = p === 100 ? 9 : Math.floor(p / 10); return palette[idx]; }; const getColor = pct => clampPct(pct) >= 60 ? "#ffffff" : "#1e3a8a"; const rawTn = parseNum(tnCount); const rawFp = parseNum(fpCount); const rawFn = parseNum(fnCount); const rawTp = parseNum(tpCount); const rawTnPct = parseNum(tnPct); const rawFpPct = parseNum(fpPct); const rawFnPct = parseNum(fnPct); const rawTpPct = parseNum(tpPct); const hasCounts = rawTn !== undefined && rawFp !== undefined && rawFn !== undefined && rawTp !== undefined; const hasPcts = rawTnPct !== undefined && rawFpPct !== undefined && rawFnPct !== undefined && rawTpPct !== undefined; let resolvedMatrix; let showCounts; if (matrix) { resolvedMatrix = matrix; showCounts = matrix.tn?.count !== undefined; } else if (hasCounts) { const actualNegTotal = rawTn + rawFp; const actualPosTotal = rawFn + rawTp; resolvedMatrix = { tn: { count: rawTn, pct: actualNegTotal > 0 ? rawTn / actualNegTotal * 100 : 0 }, fp: { count: rawFp, pct: actualNegTotal > 0 ? rawFp / actualNegTotal * 100 : 0 }, fn: { count: rawFn, pct: actualPosTotal > 0 ? rawFn / actualPosTotal * 100 : 0 }, tp: { count: rawTp, pct: actualPosTotal > 0 ? rawTp / actualPosTotal * 100 : 0 } }; showCounts = true; } else if (hasPcts) { resolvedMatrix = { tn: { pct: rawTnPct }, fp: { pct: rawFpPct }, fn: { pct: rawFnPct }, tp: { pct: rawTpPct } }; showCounts = false; } else { return
BooleanConfusionMatrix: Provide either all counts or all percentages
; } const cellStyle = pct => ({ background: getBg(pct), color: getColor(pct), padding: "1rem", textAlign: "center", borderRadius: "8px", aspectRatio: "1 / 1", width: "100%", display: "flex", flexDirection: "column", alignItems: "center", justifyContent: "center", border: "1px solid rgba(148, 163, 184, 0.35)" }); const displayPredictedLabels = { left: predictedPositiveLabel, right: predictedNegativeLabel }; const displayActualLabels = { top: actualPositiveLabel, bottom: actualNegativeLabel }; const displayMatrix = { tl: resolvedMatrix.tp, tr: resolvedMatrix.fn, bl: resolvedMatrix.fp, br: resolvedMatrix.tn }; return
{}
{titlePrefix}Confusion Matrix (Normalized)
{}
Predicted
{}
{displayPredictedLabels.left}
{displayPredictedLabels.right}
{}
Actual
{displayActualLabels.top}
{showCounts &&
{displayMatrix.tl.count}
}
{formatValue(displayMatrix.tl.pct)}
{showCounts &&
{displayMatrix.tr.count}
}
{formatValue(displayMatrix.tr.pct)}
{}
{displayActualLabels.bottom}
{showCounts &&
{displayMatrix.bl.count}
}
{formatValue(displayMatrix.bl.pct)}
{showCounts &&
{displayMatrix.br.count}
}
{formatValue(displayMatrix.br.pct)}
{}
{displayFormat === "fraction" ? "0.0" : "0%"}
{palette.map((color, idx) =>
)}
{displayFormat === "fraction" ? "1.0" : "100%"}
; }; export const DefinitionCard = ({children}) => { return
{children}
; }; export const Pill = ({label, color, backgroundColor}) => {label} ; Context Relevance measures whether your retrieved context, taken together, contains enough information to fully answer the user query. ## Context relevance Context Relevance asks whether your retrieved context, as a whole, contains enough information to fully answer the user query. High Context Relevance values indicate strong confidence that there is enough context to fully answer the question. Low Context Relevance values are a sign that you need to increase your Top K, modify your retrieval strategy, or use better embeddings. Context Relevance is differentiated from [Context Adherence](/concepts/metrics/rag/generation-quality/context-adherence): Context Relevance evaluates whether the retrieved context is relevant to a user's query whereas Context Adherence determines how well the response aligns to provided context. ### Chunk Relevance vs. Context Relevance * **Chunk Relevance** ([Chunk Relevance](/concepts/metrics/rag/retrieval-quality/chunk-relevance)) evaluates **each chunk individually**: does this chunk contain anything useful for answering the query? * **Context Relevance** evaluates **the retrieved context as a whole**: do all of these chunks, taken together, cover everything needed to answer the query end-to-end? Use **Chunk Relevance** when you're tuning chunking or reranking (which chunks should show up at all), and **Context Relevance** when you're deciding if retrieval "succeeded" for a given query and whether to adjust Top K, retriever configuration, or fallback behavior. ### Reading Context Relevance with Context Precision * **High Context Relevance & High Context Precision**: Retrieved context is both sufficient and mostly noise-free — focus next on generation quality and grounding. * **High Context Relevance & Low Context Precision**: The right information is present but mixed with a lot of irrelevant chunks — keep your recall but prune noise (better filters, reranking, or a lower Top K). * **Low Context Relevance & High Context Precision**: Most chunks are on-topic, but together they still miss pieces needed for a full answer — broaden retrieval (higher Top K, alternate retriever, or additional data sources). * **Low Context Relevance & Low Context Precision**: Retrieval is both incomplete and noisy — revisit embeddings, indexing, and query formulation end-to-end. ## Best practices Leverage Context Relevance when assessing the quality of your retrieval system's results and determining how accurately it adheres to queries. Use context relevance alongside context adherence, correctness, and completeness metrics for a comprehensive view of response quality. ## Performance Benchmarks We evaluated Context Relevance against human expert labels on an internal dataset of RAG samples using top frontier models. | Model | F1 (True) | | :---------------------- | :-------: | | GPT-4.1 | 0.82 | | GPT-4.1-mini (judges=3) | 0.85 | | Claude Sonnet 4.5 | 0.81 | | Gemini 3 Flash | 0.81 | ### GPT-4.1 Classification Report Benchmarks based on internal evaluation dataset. Performance may vary by use case. ## Related Resources If you would like to dive deeper or start implementing Context Relevance, check out the following resources: ### Examples * [Context Relevance Examples](https://app.galileo.ai) - Log in and explore the "Context Relevance" Log Stream in the "Preset Metric Examples" Project to see this metric in action. ### Related Concepts * [Context Adherence](/concepts/metrics/rag/generation-quality/context-adherence) * [Ground Truth Adherence](/concepts/metrics/response-quality/ground-truth-adherence) * [Correctness](/concepts/metrics/response-quality/correctness)